From 99087c38efcbe78a1b2ec9e46a80eea17991dd6c Mon Sep 17 00:00:00 2001 From: Kylen Solvik Date: Wed, 12 Jun 2024 08:38:12 -0600 Subject: [PATCH 1/3] Add sqgturb to observer example and add examples using location and time counts instead of probs --- .../observers/1-observers-example-usage.ipynb | 184 ++++++++++++++++-- 1 file changed, 167 insertions(+), 17 deletions(-) diff --git a/examples/observers/1-observers-example-usage.ipynb b/examples/observers/1-observers-example-usage.ipynb index c140ca4..c8e58cb 100644 --- a/examples/observers/1-observers-example-usage.ipynb +++ b/examples/observers/1-observers-example-usage.ipynb @@ -7,8 +7,7 @@ "metadata": {}, "outputs": [], "source": [ - "import dabench\n", - "from dabench import data, vector, observer\n", + "import dabench as dab\n", "import matplotlib.pyplot as plt\n", "import numpy as np" ] @@ -18,7 +17,7 @@ "id": "08132851", "metadata": {}, "source": [ - "# 1. Basic stationary observer with random sampling" + "# 1. Basic stationary observer with random sampling by *count*" ] }, { @@ -36,7 +35,7 @@ "metadata": {}, "outputs": [], "source": [ - "l63 = data.Lorenz63()\n", + "l63 = dab.data.Lorenz63()\n", "l63.generate(n_steps=50)" ] }, @@ -48,10 +47,10 @@ "outputs": [], "source": [ "# Now we can define the observer:\n", - "obs_l63 = observer.Observer(\n", + "obs_l63 = dab.observer.Observer(\n", " l63, # Data generator object\n", - " random_time_density = 0.5, # Probability of picking each time step for random sampling\n", - " random_location_density = 0.5, # Probability of picking each location in l63.system_dim for random sampling\n", + " random_time_count = 20, # Pick 20 timesteps for sampling\n", + " random_location_count = 1, # Pick one location in the system for sampling\n", " error_bias = 0.0, # Mean for observation error, Gaussian/Normal distribution\n", " error_sd = 0.7, # Standard deviation for observation error, Gaussian/Normal distribution\n", " random_seed=99 # We can specify a random seed. Default is 99\n", @@ -71,7 +70,6 @@ "# Let's examine that object\n", "print('Sampling times: ', obs_vec_l63.times)\n", "print('Number of observations: ', obs_vec_l63.num_obs)\n", - "# In this case, the entire system (3 values) was sampled at the specific timesteps\n", "print('Number of locations at each timestep: ', obs_vec_l63.obs_dims[0])\n", "print('Sampling location indices: ', obs_vec_l63.location_indices[0])\n", "print('Observation values: ', obs_vec_l63.values)" @@ -86,7 +84,7 @@ "source": [ "# Let's examine how error is added to observations\n", "fig, ax = plt.subplots()\n", - "ax.plot(l63.times, l63.values[:, 0], alpha=0.9)\n", + "ax.plot(l63.times, l63.values[:, 1], alpha=0.9)\n", "ax.plot(obs_vec_l63.times, obs_vec_l63.values[:, 0], '--', alpha=0.9)\n", "obs_values_minus_error = obs_vec_l63.values - obs_vec_l63.errors\n", "ax.plot(obs_vec_l63.times, obs_values_minus_error[:, 0], ':', alpha=0.9)\n", @@ -107,7 +105,7 @@ "id": "b98fc359", "metadata": {}, "source": [ - "Last time, we let the observer randomly select locations and times to sample. But the observer also allows us to specify the location and time indices we want to observe. Let's explore that using a Lorenz96 generator." + "Last time, we let the observer randomly select locations and times to sample. But the observer also allows us to specify the location and time indices we want to observe. You can use this to, for example, sample every other time step or every 5th element in the state vector. It allows for complete customization. Let's explore that using a Lorenz96 generator." ] }, { @@ -117,7 +115,7 @@ "metadata": {}, "outputs": [], "source": [ - "l96 = data.Lorenz96()\n", + "l96 = dab.data.Lorenz96()\n", "l96.generate(n_steps=100)\n", "print('Time dim: ', l96.time_dim)\n", "print('System dim: ', l96.system_dim)" @@ -130,7 +128,7 @@ "metadata": {}, "outputs": [], "source": [ - "# Let's sample 5 different points in the system every 5th timestep\n", + "# Let's sample 5 different locations in the system every 5th timestep\n", "time_inds_l96 = np.arange(0, 100, 5)\n", "print(time_inds_l96)\n", "sys_inds_l96 = [5, 10, 20, 25, 35]" @@ -144,7 +142,7 @@ "outputs": [], "source": [ "# Set up observer using our specified sampling times/locations\n", - "obs_l96 = observer.Observer(\n", + "obs_l96 = dab.observer.Observer(\n", " l96, \n", " time_indices = time_inds_l96, # Time indices to sample\n", " location_indices = sys_inds_l96, # Location indices to sample\n", @@ -179,7 +177,7 @@ "metadata": {}, "outputs": [], "source": [ - "# Plot it against the original values\n", + "# Plot observations against the original values\n", "fig, ax = plt.subplots()\n", "ax.plot(l96.times, l96.values[:, obs_vec_l96.location_indices[0, 0]], alpha=0.9)\n", "ax.plot(obs_vec_l96.times, obs_vec_l96.values[:, 0], '--', alpha=0.9)\n", @@ -267,7 +265,7 @@ "metadata": {}, "outputs": [], "source": [ - "aws = data.AWS()\n", + "aws = dab.data.AWS()\n", "aws.load()\n", "print('Time dim: ', aws.time_dim)\n", "print('System dim: ',aws.system_dim)\n", @@ -295,7 +293,7 @@ "outputs": [], "source": [ "# Set up observer using our specified sampling times/locations\n", - "obs_aws = observer.Observer(\n", + "obs_aws = dab.observer.Observer(\n", " aws, \n", " time_indices = time_inds_aws, # Time indices to sample\n", " location_indices = loc_inds_aws, # Location indices to sample\n", @@ -390,7 +388,7 @@ "outputs": [], "source": [ "# Set up observer using our specified sampling times/locations\n", - "obs_aws_ns = observer.Observer(\n", + "obs_aws_ns = dab.observer.Observer(\n", " aws, \n", " time_density = 0.002,\n", " location_density = 0.05,\n", @@ -416,6 +414,158 @@ "print('Sampling location indices at first timestep: ', obs_vec_aws_ns.location_indices[0])\n", "print('Sampling location indices at last timestep: ', obs_vec_aws_ns.location_indices[-1])\n" ] + }, + { + "cell_type": "markdown", + "id": "bc87936b-a6ef-4836-bedf-a43805417443", + "metadata": {}, + "source": [ + "# 6. Spectral Models" + ] + }, + { + "cell_type": "markdown", + "id": "4a8f5bc1-0ada-464e-9f6d-182d29d9d3e5", + "metadata": {}, + "source": [ + "SQGTurb is a data generator that operates in spectral space, and so their state vector stores complex numbers with real and imaginary components. Fortunately, you can transform the data back into real space using an inverse Fourier Transform. The observer will handle this operation for you automatically, and so SQGTurb can be used with the observer in the same way as the other data generators. The main difference is that location_indices will have multiple indices per timestep, since they're specified in the original gridded dimension instead of the flattened state vector." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d34e0d7d-aaf4-4030-9c16-3af85e640e5f", + "metadata": {}, + "outputs": [], + "source": [ + "sqgturb = dab.data.SQGTurb()\n", + "sqgturb.generate(n_steps=50)\n", + "print('Complex state vector length: ', sqgturb.system_dim)\n", + "print('Original gridded dimension in real space: ', sqgturb.original_dim)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94cd1356-9728-4b31-86c3-6ca5b9949a7f", + "metadata": {}, + "outputs": [], + "source": [ + "# Set up observer \n", + "obs_sqg = dab.observer.Observer(\n", + " sqgturb, \n", + " random_time_count = 50,\n", + " random_location_count = 5,\n", + " error_bias = 0.0,\n", + " error_sd = 100.,\n", + " stationary_observers=True\n", + ")\n", + "obs_vec_sqg = obs_sqg.observe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f9353d3-bd8e-4fde-bfa6-3f76f70a8646", + "metadata": {}, + "outputs": [], + "source": [ + "print('Sampling times: ', obs_vec_sqg.times)\n", + "print('Number of observations: ', obs_vec_sqg.num_obs)\n", + "print('Number of locations at each timestep: ', obs_vec_sqg.obs_dims[0])\n", + "print('Sampling location indices: ', obs_vec_sqg.location_indices[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2d126893-5832-4f58-beed-e1eccc395ab0", + "metadata": {}, + "outputs": [], + "source": [ + "# Let's get the indices of the second sampled location:\n", + "print(obs_vec_sqg.location_indices[0, 2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a85d3eac-1c96-4cf1-a2b9-00100e0124cd", + "metadata": {}, + "outputs": [], + "source": [ + "# Visualize\n", + "fig, ax = plt.subplots()\n", + "ax.plot(sqgturb.times, sqgturb.values_gridded[:, 1, 52, 79], alpha=0.9)\n", + "ax.plot(obs_vec_sqg.times, obs_vec_sqg.values[:, 2], '--', alpha=0.9)\n", + "ax.legend(labels=['Original System', 'Observations'])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a56b6fc5-19b6-40ce-bf46-e4f93c1f6b19", + "metadata": {}, + "source": [ + "# 7. Basic stationary observer with random sampling *by probability*" + ] + }, + { + "cell_type": "markdown", + "id": "107f509a-dc21-4c54-867a-5649a3389659", + "metadata": {}, + "source": [ + "If you'd prefer, you can also specify a probability that each timestep or location will be sampled using random_time_density and random_location_density. For example, if you specify random_time_density = 0.5, approximately 50% of time steps will be sampled (with the proability of each time step being selected for sampling following a Bernoulli distribution with p = random_time_density). All of the examples above can be modified to use this method instead, although the exact number of times and locations sampled will vary.\n", + "\n", + "NOTE: If used with stationary_observer=False, random_location_density will sample a DIFFERENT number of locations at each time step. For example, with system_dim=10 and random_location_density=0.5, it might sample 5 locations at the first timestep, 6 in the next, then 5 again, then 3, etc. It randomly selects locations at each timestep." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5117408a-b1a2-45c8-89b4-e44f9c447af1", + "metadata": {}, + "outputs": [], + "source": [ + "l63 = dab.data.Lorenz63()\n", + "l63.generate(n_steps=50)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2c6567f-12ce-4428-a07d-d46928020610", + "metadata": {}, + "outputs": [], + "source": [ + "obs_l63_p = dab.observer.Observer(\n", + " l63, \n", + " random_time_density = 0.5, # Probability of picking each time step for random sampling\n", + " random_location_density = 0.3, # Probability of picking each location in l63.system_dim for random sampling\n", + " error_bias = 0.1,\n", + " error_sd = 1.33\n", + ")\n", + "\n", + "# Making observations\n", + "obs_vec_l63_p = obs_l63_p.observe()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfec9e66-e7ba-4e8f-a78a-e6140fd4f66d", + "metadata": {}, + "outputs": [], + "source": [ + "# Let's examine that object\n", + "print('Sampling times: ', obs_vec_l63_p.times) # 28 out of 50 timesteps are sampled\n", + "print('Number of observations: ', obs_vec_l63_p.num_obs)\n", + "# In this case, 2 values (out of a total system_dim of 3) are observed at each timestep.\n", + "print('Number of locations at each timestep: ', obs_vec_l63_p.obs_dims[0])\n", + "print('Sampling location indices: ', obs_vec_l63_p.location_indices[0])\n", + "print('Observation values: ', obs_vec_l63_p.values)\n", + "print('Errors: ', obs_vec_l63_p.errors)" + ] } ], "metadata": { From ba3845f5cfe37888c95767ba5c0161ac4db33f90 Mon Sep 17 00:00:00 2001 From: Kylen Solvik Date: Wed, 12 Jun 2024 11:48:38 -0600 Subject: [PATCH 2/3] GCP working in observers example --- .../observers/1-observers-example-usage.ipynb | 540 ++++++++++++++---- 1 file changed, 441 insertions(+), 99 deletions(-) diff --git a/examples/observers/1-observers-example-usage.ipynb b/examples/observers/1-observers-example-usage.ipynb index c8e58cb..b5c10f2 100644 --- a/examples/observers/1-observers-example-usage.ipynb +++ b/examples/observers/1-observers-example-usage.ipynb @@ -2,10 +2,18 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "5ffe3f58", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":241: UserWarning: No pyfftw detected. Using numpy.fft\n" + ] + } + ], "source": [ "import dabench as dab\n", "import matplotlib.pyplot as plt\n", @@ -30,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "9a10e502", "metadata": {}, "outputs": [], @@ -41,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "9e3e807e", "metadata": {}, "outputs": [], @@ -62,10 +70,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "08b77969", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling times: [0.05 0.06 0.12 0.16 0.18 0.19 0.22 0.23 0.24 0.25 0.27 0.29 0.3 0.34\n", + " 0.36 0.37 0.43 0.44 0.45 0.46]\n", + "Number of observations: 20\n", + "Number of locations at each timestep: 1\n", + "Sampling location indices: [1]\n", + "Observation values: [[-15.51101746]\n", + " [-15.63084999]\n", + " [-11.9788614 ]\n", + " [ -7.43437412]\n", + " [ -4.94812204]\n", + " [ -5.31448538]\n", + " [ -2.64207745]\n", + " [ -1.85146711]\n", + " [ -2.03815694]\n", + " [ -0.90402463]\n", + " [ -1.24896995]\n", + " [ -0.3523532 ]\n", + " [ -0.69936886]\n", + " [ -0.64733011]\n", + " [ -2.22313773]\n", + " [ -1.87359053]\n", + " [ -1.15229503]\n", + " [ -2.13185187]\n", + " [ -2.48536021]\n", + " [ -1.93566991]]\n" + ] + } + ], "source": [ "# Let's examine that object\n", "print('Sampling times: ', obs_vec_l63.times)\n", @@ -77,10 +117,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "8bdd27b1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Let's examine how error is added to observations\n", "fig, ax = plt.subplots()\n", @@ -110,10 +161,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "af33c8d7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time dim: 100\n", + "System dim: 36\n" + ] + } + ], "source": [ "l96 = dab.data.Lorenz96()\n", "l96.generate(n_steps=100)\n", @@ -123,10 +183,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "cf117b6b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95]\n" + ] + } + ], "source": [ "# Let's sample 5 different locations in the system every 5th timestep\n", "time_inds_l96 = np.arange(0, 100, 5)\n", @@ -136,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "abfd11ea", "metadata": {}, "outputs": [], @@ -156,10 +224,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "8ad3f0d7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling times: [0. 0.25 0.5 0.75 1. 1.25 1.5 1.75 2. 2.25 2.5 2.75 3. 3.25\n", + " 3.5 3.75 4. 4.25 4.5 4.75]\n", + "Number of observations: 20\n", + "Number of locations at each timestep: 5\n", + "Sampling location indices: [ 5 10 20 25 35]\n", + "Observation values: [[-2.04938935 2.47725879 0.59325828 2.18193221 -3.03160065]\n", + " [-0.03638425 4.93167001 6.7015676 1.04932555 0.44471019]\n", + " [ 0.47293418 3.39324919 7.63980548 5.00867157 4.32050446]\n", + " [ 2.65925269 4.58264583 4.15880751 2.27910639 6.29407341]\n", + " [ 6.37575185 4.51183119 -1.11072222 -3.95222748 6.61628667]\n", + " [ 1.45459697 1.94398097 -1.32837318 1.35165833 1.82872983]\n", + " [-0.34286475 4.41978587 0.37919729 2.84734961 -0.09454621]\n", + " [ 1.62970512 5.98047862 3.64155235 1.92799158 2.38752044]\n", + " [ 5.14729121 -1.20996717 6.402633 5.81342484 3.82966525]\n", + " [ 6.59022196 -0.33427234 4.81476949 7.73738948 6.46179164]\n", + " [ 6.71402318 -0.08630652 0.26178953 4.66546028 6.85299783]\n", + " [ 1.72990425 -2.07068951 2.15502987 -4.87394136 4.88731928]\n", + " [ 0.66951335 -1.99361091 5.87205144 -0.63378297 3.82178376]\n", + " [ 1.13300442 -1.16871363 9.67599183 0.41748392 2.36017881]\n", + " [ 5.90362183 1.76771976 6.44743952 2.8919843 1.66692715]\n", + " [ 3.61954712 2.41498728 -2.68864732 3.18142715 -1.00888657]\n", + " [ 0.3028668 5.4184401 -1.75591661 -1.8027279 2.37284488]\n", + " [ 3.64382716 -2.03180057 2.58498241 0.19905976 5.51338893]\n", + " [ 0.75678514 -1.45820595 6.20408296 -1.53810727 3.04132346]\n", + " [ 9.93349046 4.72132568 7.70536207 -0.82432949 -1.68901767]]\n", + "Mean Error: 0.25386117355524973\n" + ] + } + ], "source": [ "# Let's examine that object\n", "print('Sampling times: ', obs_vec_l96.times)\n", @@ -172,10 +273,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "c3f99be4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot observations against the original values\n", "fig, ax = plt.subplots()\n", @@ -203,10 +315,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "800c40df", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Observation times: [1.25 1.5 1.75 2. 2.25 2.5 2.75]\n", + "New number of obs: 7\n" + ] + } + ], "source": [ "# Specify time interval, centered at 2 +/- 0.75\n", "time_start = 2 - 0.75\n", @@ -219,10 +340,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "a039a2cd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Visualize\n", "# Plot it against the original values\n", @@ -242,108 +374,190 @@ "# 4. Observer with locations in original coordinate dimensions" ] }, - { - "cell_type": "markdown", - "id": "0a574b53-685a-4fa7-abb9-4f5fa29e1d39", - "metadata": {}, - "source": [ - "NOTE: These are currently not working" - ] - }, { "cell_type": "markdown", "id": "76a5d514", "metadata": {}, "source": [ - "In the previous example, we specified locations to sample in the flattened, 1D space of the system's state vector. But for many data generators/loaders, the values originally exist in multi-dimensional space (e.g. latitudue, longitude, vertical level) before being flattened into a state vector. DataAssimBench's Observer class can take location indices in this original_dim instead. Let's create observations from some ERA5 data downloaded from Amazon Web Services. " + "In the previous example, we specified locations to sample in the flattened, 1D space of the system's state vector. But for many data generators/loaders, the values originally exist in multi-dimensional space (e.g. latitudue, longitude, vertical level) before being flattened into a state vector. DataAssimBench's Observer class can take location indices in this original_dim instead. Let's create observations from some ERA5 data downloaded from Google Cloud." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "5ffda9a2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time dim: 8784\n", + "System dim: 559\n", + "Original dim: (13, 43)\n" + ] + } + ], "source": [ - "aws = dab.data.AWS()\n", - "aws.load()\n", - "print('Time dim: ', aws.time_dim)\n", - "print('System dim: ',aws.system_dim)\n", - "print('Original dim: ', aws.original_dim)" + "gcp = dab.data.GCP()\n", + "gcp.load()\n", + "print('Time dim: ', gcp.time_dim)\n", + "print('System dim: ',gcp.system_dim)\n", + "print('Original dim: ', gcp.original_dim)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "40dba65d", "metadata": {}, "outputs": [], "source": [ "# Let's sample every 500 timesteps\n", - "time_inds_aws = np.arange(0, aws.time_dim, 500)\n", + "time_inds_gcp = np.arange(0, gcp.time_dim, 500)\n", "# Let's pick indices at the corners and roughly center of the system\n", - "loc_inds_aws= np.array([[0, 0], [12, 0], [12, 42], [0, 42], [6, 21]])" + "loc_inds_gcp= np.array([[0, 0], [12, 0], [12, 42], [0, 42], [6, 21]])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "fe830407", "metadata": {}, "outputs": [], "source": [ "# Set up observer using our specified sampling times/locations\n", - "obs_aws = dab.observer.Observer(\n", - " aws, \n", - " time_indices = time_inds_aws, # Time indices to sample\n", - " location_indices = loc_inds_aws, # Location indices to sample\n", + "obs_gcp = dab.observer.Observer(\n", + " gcp, \n", + " time_indices = time_inds_gcp, # Time indices to sample\n", + " location_indices = loc_inds_gcp, # Location indices to sample\n", " error_bias = 0.0, # No error this time\n", " error_sd = 0.0\n", ")\n", "\n", "# Making observations\n", - "obs_vec_aws = obs_aws.observe()" + "obs_vec_gcp = obs_gcp.observe()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "48ec47a8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling times: ['2020-01-01T00:00:00.000000000' '2020-01-21T20:00:00.000000000'\n", + " '2020-02-11T16:00:00.000000000' '2020-03-03T12:00:00.000000000'\n", + " '2020-03-24T08:00:00.000000000' '2020-04-14T04:00:00.000000000'\n", + " '2020-05-05T00:00:00.000000000' '2020-05-25T20:00:00.000000000'\n", + " '2020-06-15T16:00:00.000000000' '2020-07-06T12:00:00.000000000'\n", + " '2020-07-27T08:00:00.000000000' '2020-08-17T04:00:00.000000000'\n", + " '2020-09-07T00:00:00.000000000' '2020-09-27T20:00:00.000000000'\n", + " '2020-10-18T16:00:00.000000000' '2020-11-08T12:00:00.000000000'\n", + " '2020-11-29T08:00:00.000000000' '2020-12-20T04:00:00.000000000']\n", + "Number of observations: 18\n", + "Number of locations at each timestep: 5\n", + "Sampling location indices: [[ 0 0]\n", + " [12 0]\n", + " [12 42]\n", + " [ 0 42]\n", + " [ 6 21]]\n", + "Observation values: [[297.23501587 299.53863525 299.60635376 298.39529419 299.56481934]\n", + " [293.4972229 296.51568604 298.66275024 297.1550293 298.37826538]\n", + " [298.23049927 299.69537354 298.92877197 298.5039978 298.57818604]\n", + " [297.90866089 299.37078857 297.83895874 296.55648804 296.78570557]\n", + " [299.03088379 298.66619873 297.55090332 297.32962036 297.0994873 ]\n", + " [300.82321167 300.77740479 299.08557129 298.64144897 300.2663269 ]\n", + " [300.44546509 301.3611145 299.53311157 299.38739014 301.33627319]\n", + " [300.19708252 301.85693359 301.8951416 300.79223633 301.80780029]\n", + " [300.82681274 300.05966187 301.08444214 299.50622559 301.32681274]\n", + " [301.93634033 301.83963013 300.98519897 300.9465332 301.4598999 ]\n", + " [302.09408569 302.35028076 300.92572021 301.02856445 300.94512939]\n", + " [302.48748779 302.74679565 300.58584595 301.60620117 302.49124146]\n", + " [302.00979614 301.52264404 300.78738403 301.27090454 300.07928467]\n", + " [302.00424194 302.71188354 301.16174316 301.21835327 299.78479004]\n", + " [300.4196167 299.81497192 300.57574463 301.39801025 301.60894775]\n", + " [298.41833496 300.45272827 299.34237671 299.23269653 298.65423584]\n", + " [298.972229 298.11251831 298.41674805 297.80419922 297.37774658]\n", + " [299.05178833 299.69592285 298.02679443 297.21060181 296.76501465]]\n", + "Errors: [[0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]\n", + " [0. 0. 0. 0. 0.]]\n" + ] + } + ], "source": [ "# Let's examine that object\n", - "print('Sampling times: ', obs_vec_aws.times)\n", - "print('Number of observations: ', obs_vec_aws.num_obs)\n", - "print('Number of locations at each timestep: ', obs_vec_aws.obs_dims[0])\n", - "print('Sampling location indices: ', obs_vec_aws.location_indices[0])\n", - "print('Observation values: ', obs_vec_aws.values)\n", - "print('Errors: ', obs_vec_aws.errors)" + "print('Sampling times: ', obs_vec_gcp.times)\n", + "print('Number of observations: ', obs_vec_gcp.num_obs)\n", + "print('Number of locations at each timestep: ', obs_vec_gcp.obs_dims[0])\n", + "print('Sampling location indices: ', obs_vec_gcp.location_indices[0])\n", + "print('Observation values: ', obs_vec_gcp.values)\n", + "print('Errors: ', obs_vec_gcp.errors)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "7110130f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Visualize\n", "# Recall that there is no error, but our sampling is pretty infrequent compared to the actual system\n", "# Plot it against the original values\n", "fig, ax = plt.subplots()\n", - "ax.plot(aws.times, aws.values_gridded[:, 0, 0], alpha=0.7)\n", - "ax.plot(obs_vec_aws.times, obs_vec_aws.values[:, 0], '--', alpha=1.0)\n", + "ax.plot(gcp.times, gcp.values_gridded[:, 0, 0], alpha=0.7)\n", + "ax.plot(obs_vec_gcp.times, obs_vec_gcp.values[:, 0], '--', alpha=1.0)\n", "ax.legend(labels=['Original System', 'Observations'])\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "5c1d1db8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Observation times: ['2020-06-15T16:00:00.000000000' '2020-07-06T12:00:00.000000000'\n", + " '2020-07-27T08:00:00.000000000' '2020-08-17T04:00:00.000000000']\n", + "New number of obs: 4\n" + ] + } + ], "source": [ "# Even though these times are datetimes, we can filter our observations by time\n", "# by using np.datetime objects.\n", @@ -351,9 +565,9 @@ "time_start = np.datetime64('2020-06-01')\n", "time_end = np.datetime64('2020-09-01')\n", "# Run filter and save as new obs vec\n", - "obs_vec_aws_filt = obs_vec_aws.filter_times(start=time_start, end=time_end, inclusive=True)\n", - "print('Observation times: ', obs_vec_aws_filt.times)\n", - "print('New number of obs: ', obs_vec_aws_filt.num_obs)" + "obs_vec_gcp_filt = obs_vec_gcp.filter_times(start=time_start, end=time_end, inclusive=True)\n", + "print('Observation times: ', obs_vec_gcp_filt.times)\n", + "print('New number of obs: ', obs_vec_gcp_filt.num_obs)" ] }, { @@ -364,55 +578,68 @@ "# 5. Non-Stationary Observer" ] }, - { - "cell_type": "markdown", - "id": "0853a8c8-a750-4a6d-9130-144228fed77e", - "metadata": {}, - "source": [ - "NOTE: These are currently not working" - ] - }, { "cell_type": "markdown", "id": "93064283", "metadata": {}, "source": [ - "In most cases, it's simplest to assume the observers are stationary and that we are sampling at the same location at each timestep. However, Observer allows for non-stationary observers as well, sampling different locations over time. We'll create a new set of observations from the AWS data as an example." + "In most cases, it's simplest to assume the observers are stationary and that we are sampling at the same location at each timestep. However, Observer allows for non-stationary observers as well, sampling different locations over time. We'll create a new set of observations from the gcp data as an example." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "0253c7e0", "metadata": {}, "outputs": [], "source": [ "# Set up observer using our specified sampling times/locations\n", - "obs_aws_ns = dab.observer.Observer(\n", - " aws, \n", - " time_density = 0.002,\n", - " location_density = 0.05,\n", + "obs_gcp_ns = dab.observer.Observer(\n", + " gcp, \n", + " random_time_density = 0.002,\n", + " random_location_density = 0.05,\n", " error_bias = 0.0,\n", " error_sd = 3.0,\n", " stationary_observers=False\n", ")\n", "\n", "# Making observations\n", - "obs_vec_aws_ns = obs_aws_ns.observe()" + "obs_vec_gcp_ns = obs_gcp_ns.observe()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "6605f67f", "metadata": {}, - "outputs": [], - "source": [ - "print('Sampling times: ', obs_vec_aws_ns.times)\n", - "print('Number of observations: ', obs_vec_aws_ns.num_obs)\n", - "print('Number of locations at each timestep: ', obs_vec_aws_ns.obs_dims)\n", - "print('Sampling location indices at first timestep: ', obs_vec_aws_ns.location_indices[0])\n", - "print('Sampling location indices at last timestep: ', obs_vec_aws_ns.location_indices[-1])\n" + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling times: ['2020-01-05T19:00:00.000000000' '2020-01-20T03:00:00.000000000'\n", + " '2020-01-21T18:00:00.000000000' '2020-01-28T03:00:00.000000000'\n", + " '2020-02-11T08:00:00.000000000' '2020-03-15T02:00:00.000000000'\n", + " '2020-04-18T03:00:00.000000000' '2020-05-09T15:00:00.000000000'\n", + " '2020-05-24T20:00:00.000000000' '2020-05-27T16:00:00.000000000'\n", + " '2020-06-08T16:00:00.000000000' '2020-07-23T14:00:00.000000000'\n", + " '2020-10-10T06:00:00.000000000' '2020-10-31T00:00:00.000000000'\n", + " '2020-11-02T12:00:00.000000000' '2020-11-03T23:00:00.000000000']\n", + "Number of observations: 16\n", + "Number of locations at each timestep: [28 26 32 20 23 28 35 30 29 41 35 27 23 23 36 26]\n", + "Sampling location indices at first timestep: [ 17 22 30 35 52 63 88 106 123 128 154 176 184 212 224 243 286 306\n", + " 310 411 425 441 448 458 470 477 536 541]\n", + "Sampling location indices at last timestep: [ 47 62 69 105 108 126 151 157 167 186 208 216 241 247 292 293 320 347\n", + " 349 360 389 398 410 435 512 540]\n" + ] + } + ], + "source": [ + "print('Sampling times: ', obs_vec_gcp_ns.times)\n", + "print('Number of observations: ', obs_vec_gcp_ns.num_obs)\n", + "print('Number of locations at each timestep: ', obs_vec_gcp_ns.obs_dims)\n", + "print('Sampling location indices at first timestep: ', obs_vec_gcp_ns.location_indices[0])\n", + "print('Sampling location indices at last timestep: ', obs_vec_gcp_ns.location_indices[-1])\n" ] }, { @@ -433,10 +660,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "d34e0d7d-aaf4-4030-9c16-3af85e640e5f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Complex state vector length: 9408\n", + "Original gridded dimension in real space: (2, 96, 96)\n" + ] + } + ], "source": [ "sqgturb = dab.data.SQGTurb()\n", "sqgturb.generate(n_steps=50)\n", @@ -446,7 +682,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "94cd1356-9728-4b31-86c3-6ca5b9949a7f", "metadata": {}, "outputs": [], @@ -465,10 +701,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "0f9353d3-bd8e-4fde-bfa6-3f76f70a8646", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling times: [ 900. 1800. 2700. 3600. 4500. 5400. 6300. 7200. 8100. 9000.\n", + " 9900. 10800. 11700. 12600. 13500. 14400. 15300. 16200. 17100. 18000.\n", + " 18900. 19800. 20700. 21600. 22500. 23400. 24300. 25200. 26100. 27000.\n", + " 27900. 28800. 29700. 30600. 31500. 32400. 33300. 34200. 35100. 36000.\n", + " 36900. 37800. 38700. 39600. 40500. 41400. 42300. 43200. 44100. 45000.]\n", + "Number of observations: 50\n", + "Number of locations at each timestep: 5\n", + "Sampling location indices: [[ 1 2 28]\n", + " [ 1 67 59]\n", + " [ 1 52 79]\n", + " [ 0 37 56]\n", + " [ 0 71 56]]\n" + ] + } + ], "source": [ "print('Sampling times: ', obs_vec_sqg.times)\n", "print('Number of observations: ', obs_vec_sqg.num_obs)\n", @@ -478,10 +733,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "2d126893-5832-4f58-beed-e1eccc395ab0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 1 52 79]\n" + ] + } + ], "source": [ "# Let's get the indices of the second sampled location:\n", "print(obs_vec_sqg.location_indices[0, 2])" @@ -489,10 +752,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "a85d3eac-1c96-4cf1-a2b9-00100e0124cd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAGdCAYAAAAMm0nCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACEJElEQVR4nOzdeVxU9frA8c/MwLAPm6yCgKIogvuGVu6ikllZesvM9iy7N2392bVuu9265rVbtpfdm2VqtmmuuJSKuaK4ISIIKosb+z5zfn8cGSU3UOAw+Lxfr3nNcL7fOfOcGXEevqtOURQFIYQQQggbotc6ACGEEEKIupIERgghhBA2RxIYIYQQQtgcSWCEEEIIYXMkgRFCCCGEzZEERgghhBA2RxIYIYQQQtgcSWCEEEIIYXPstA6goVgsFo4fP46bmxs6nU7rcIQQQghRC4qiUFhYSGBgIHr9pdtZmm0Cc/z4cYKDg7UOQwghhBBXITMzk6CgoEuWN9sExs3NDVDfAJPJpHE0QgghhKiNgoICgoODrd/jl9JsE5jqbiOTySQJjBBCCGFjrjT8QwbxCiGEEMLmSAIjhBBCCJsjCYwQQgghbE6zHQNTG2azmcrKSq3DENcRg8GAnZ2dTO0XQohrdN0mMEVFRRw9ehRFUbQORVxnnJ2dCQgIwGg0ah2KEELYrOsygTGbzRw9ehRnZ2d8fHzkr2HRKBRFoaKighMnTpCWlkbbtm0vu0iTEEKIS7suE5jKykoURcHHxwcnJyetwxHXEScnJ+zt7Tly5AgVFRU4OjpqHZIQQtik6/rPP2l5EVqQVhchhLh28j+pEEIIIWyOJDDXkfT0dHQ6HYmJibV+zty5c/Hw8NA8DiGEEOJ8ksDYmMzMTB544AECAwMxGo2EhITw5JNPcurUqSs+Nzg4mKysLKKiomr9euPGjePgwYPXEvJVSUtL4+677yYwMBBHR0eCgoIYPXo0Bw4cqJfzDxgwgClTptTLuYQQQjQ+SWBsyOHDh+nRowcpKSl8++23HDp0iI8++oj4+HhiYmI4ffr0JZ9bUVGBwWDA398fO7vaj912cnLC19e3PsKvtcrKSoYOHUp+fj6LFy8mOTmZ7777jujoaPLy8ho1FiGEEE2U0kzl5+crgJKfn39BWWlpqbJv3z6ltLRUg8iu3vDhw5WgoCClpKSkxvGsrCzF2dlZmTRpkvVYSEiI8uqrryoTJkxQ3NzclIkTJyppaWkKoOzcudNa76efflLCw8MVBwcHZcCAAcrcuXMVQDlz5oyiKIry5ZdfKu7u7tb6//jHP5TOnTsr//3vf5WQkBDFZDIp48aNUwoKCqx1li1bpvTr109xd3dXvLy8lLi4OOXQoUPW8ovFcb6dO3cqgJKenn7J92LgwIHK5MmTaxzLzc1V7O3tldWrVyuKoigffPCB9dp8fX2VMWPGKIqiKBMnTlSAGre0tDRFURQlKSlJGT58uOLi4qL4+voq99xzj3LixAnra/Tv31954oknlCeffFLx8PBQfH19lU8++UQpKipS7rvvPsXV1VVp06aN8uuvv14ydlv99yeEEI3hct/f55MWGNT1OUorzJrclFoupHf69GlWrFjB448/fsHUb39/f8aPH893331X43z/+te/6Ny5Mzt37uTFF1+84JxpaWnccccd3HrrrezatYtHH32Uv//971eMJTU1lR9//JElS5awZMkS1q9fz1tvvWUtLy4u5qmnnmLbtm3Ex8ej1+u57bbbsFgstbpWHx8f9Ho9ixYtwmw2X7TOQw89xDfffEN5ebn12Ndff03Lli0ZNGgQ27Zt429/+xuvvvoqycnJLF++nJtuugmA2bNnExMTw8MPP0xWVhZZWVkEBweTl5fHoEGD6Nq1K9u2bWP58uXk5OQwduzYGq/91Vdf0aJFC7Zs2cJf//pXHnvsMe6880769u3Ljh07GDZsGBMmTKCkpKRW1yuEEJd0KhUO/Kp1FE3SdbkOzJ+VVVro/85aTV57/bMDcTIarlgvJSUFRVHo0KHDRcs7dOjAmTNnOHHihLXLZ9CgQTz99NPWOunp6TWe8/HHHxMREcE777wDQEREBHv27OGNN964bCwWi4W5c+fi5uYGwIQJE4iPj7c+b8yYMTXqf/HFF/j4+LBv375ajb9p2bIl7733Hs899xyvvPIKPXr0YODAgYwfP57WrVsDcPvtt/PEE0/w008/WROMuXPnct9996HT6cjIyMDFxYWbb74ZNzc3QkJC6Nq1KwDu7u4YjUacnZ3x9/e3vu77779P165defPNN2vEHhwczMGDB2nXrh0AnTt3Zvr06QBMmzaNt956ixYtWvDwww8D8NJLL/Hhhx+ye/du+vTpc8XrFUKIC1SVwx8fwZZPQacH/2jwCAaLGfRX/s64HkgLjI2pbYsNQI8ePS5bnpycTM+ePWsc69Wr1xXPGxoaak1eAAICAsjNzbX+nJKSwl133UXr1q0xmUyEhoYCkJGRUevYJ0+eTHZ2NvPmzSMmJoaFCxfSsWNHVq1aBYCjoyMTJkzgiy++AGDHjh3s2bOH++67D4ChQ4cSEhJC69atmTBhAvPmzbtii8iuXbtYu3Ytrq6u1lv79u0BtdWpWqdOnayPDQYD3t7eREdHW4/5+fkB1HhPhBCi1o4kwFejIGEOmCuhVR+oKoPlL8Cng6CyTOsImwRpgQEc7fWsf3agZq9dG+Hh4eh0Ovbv389tt912Qfn+/fvx9PTEx8fHeszFxaXe4jyfvb19jZ91Ol2N7qFRo0YREhLCp59+SmBgIBaLhaioKCoqKur0Om5ubowaNYpRo0bx+uuvExsby+uvv87QoUMBtRupS5cuHD16lC+//JJBgwYREhJife6OHTtYt24dK1eu5KWXXuLll19m69atl5wWXlRUxKhRo/jnP/95QVlAQMBlr//8Y9ULJNa2y0wIIQAoOQ3r3oJ9P6k/u/rAwOnQLhYUBTI2QWE2pK6B9iO1jbUJkBYY1C8cJ6NBk1ttVwP29vZm6NChzJkzh9LS0hpl1S0V48aNq9PqwhEREWzbtq3Gsa1bt9b6+Rdz6tQpkpOTmT59OoMHD7Z2bV0rnU5H+/btKS4uth6Ljo6mR48efPrpp3zzzTc88MADNZ5jZ2fHkCFDePvtt9m9ezfp6emsWbMGAKPReMH4mm7durF3715CQ0MJDw+vcWuoZFAIIQCoLIWvblGTF50Ouo6H+36FiOHqz3o9RN6q1t37g6ahNhWSwNiQ999/n/LycmJjY/ntt9/IzMxk+fLlDB06lJYtW15x7MqfPfrooxw4cIDnn3+egwcPsmDBAubOnQtc/TYLnp6eeHt788knn3Do0CHWrFnDU089VadzJCYmMnr0aBYtWsS+ffs4dOgQn3/+OV988QWjR4+uUfehhx7irbfeQlGUGi1TS5Ys4b333iMxMZEjR47w3//+F4vFQkREBKB2g/3xxx+kp6dz8uRJLBYLkydP5vTp09x1111s3bqV1NRUVqxYwf3333/JwcRCCFEv7J2g053g2x7u/g4GvwSOppp1Ot6q3qdvgCLpopYExoa0bduWbdu20bp1a8aOHUubNm145JFHGDhwIAkJCXh5edXpfGFhYSxatIjFixfTqVMnPvzwQ+ssJAcHh6uKUa/XM3/+fLZv305UVBRTp061DhKuraCgIEJDQ3nllVfo3bs33bp1Y/bs2bzyyisXzJK66667sLOz46677qqxMaKHhweLFy9m0KBBdOjQgY8++ohvv/2Wjh07AvDMM89gMBiIjIzEx8eHjIwMAgMD2bhxI2azmWHDhhEdHc2UKVPw8PCQ/YuEEA2vz+Mw/nsI6Hzxcs9QCOwKiuVcN9N1TKfUZVSoDSkoKMDd3Z38/HxMpppZbFlZGWlpaYSFhcluwH/yxhtv8NFHH5GZmal1KLWSnp5OmzZt2Lp1K926ddM6nFqRf39CCKvEb6BlD/BpV7v6u76DVS9Bi7Yw8Re1e6mZudz39/nkz8rr3Jw5c9i6dSuHDx/mf//7H++88w4TJ07UOqwrqqysJDs7m+nTp9OnTx+bSV6EEMIqLxPiX1NnHOXV8o/GiBFgZ4STKZCzt2Hja+JkFtJ1LiUlhddff53Tp0/TqlUrnn76aaZNm6Z1WFe0ceNGBg4cSLt27Vi0aJHW4QghrjfmSkhaBHo7dezK1dj5tdodFNJXXeOlNhxN0PVesHcE16vY5iX3ABQehzaD6v7cJkYSmOvcrFmzmDVrltZh1NmAAQPqtCaOEELUG0WBBffCsR3qz25+EHZT3c5RXghJC9XH3e+r23P7P1u3+tUKsmDR/dAqBoJ6gYPr1Z2niZAERgghhKgLnQ7ax8HxRLUFZf3b0KovGGp+pZ4sKmfN/lzSTxVTUWWh0myhwmyhvMpCz1O/MCI/j1y7QF5fY8T9j530b+fDgAgfWrhe3SSKy1IUiH9FXWum5BQYbX9pCElghBBCiMuxWGDP92AKgNAb1GOd71JbXb6+Qx2Psud76DyO4vIq1iWfYPnebLamncZykZZivWLmfvNPVCoW5jGAAznFQDF/HD7FOysO0DnIg8EdfBkY4Yuv6RID/asq4PBaOJ0GfSZd+RqSl0HqWjDYw6AXm8XgX0lghBBCiEs5kazO+jmeCO4t4b6l6potegN4tIKYyShr36Rk7UzeSQkl/nAx5ZXnVuGOaulOz1AvHO312Bv0GO30BJ/8nbaJeVQZvRgy/FFiHZxIPVHM2gO57DmWT2JmHomZecxceZDolu4MaO/LoPa+tPQ4byPfvAz4+W9nx+CMBefLLKNRlg9rz64T1vtR8AyB4lPg4t0w71kjkQRGCCHE9aW8UE0AdAY1EXHxAScPtayqAsry1K6h7XNhx3/VDRSNztB1AujPbRuSklPIjzndGVnqga85hxYFX1FuuJ1WXs4Mj/IntqM/wV7OF77+XmdI84OoMdwYqQ7e7dumBRP6hJBTUMbaA7nEH8hl99E8ko7lk3Qsn//Ep9A52IPnh0cQ7usGLcLBPwqy98D+X6D7ZWaPrn8bik+Cdxto0Q5mdwb/TnD3/Hp7S7UgCYwQQojrh7kS5t6s7ilUbeC0cwNps5Ng/t01n9MuFga+AG7q7vVVZgtfbkzni41pmC0KmdzB/Xa/0KJ9f77s25PIANPlVzPveCtEjATzhfvD+Zkc+UuvVvylVytOFJazLjmXtcm57DiSx67MPCZ+sZX7+4UysW8o9h1vUxOYvT9cOoHJ+EOdLQUw9DW19chihrwjtXu/mjBJYIQQQlw/TqaoyYveAE5eYKkC+/NbSRS1W8ZSBV5hMGAatO5vLT16poR//LSXpGP5AAyI8OH2rvcT3WoKXf+00etl2RnV22X4uDlwZ49g7uwRTG5hGW8vT+a3gyf45LfDrEs+wcvD+hNueAty96tdXT4RF57k2Hb1vvNfIKg7VJzdT67kNJQVXLhdgQ2RBKaZCg0NZcqUKUyZMkXrUOrFunXrGDhwIGfOnLnkbtJCCHFF2bvV++BecOfcC8uDesBTZxeIUxTrYFdFUViyO4uZK5MpqTDj6mjH88PbE9vR/8JznPe8Gopy1ddvPVBNoOrA182Rd+7oxMp9ObyzIpmDOYXcO+8gX3h1J6JwM7q9P8CA/7vwiTGPq9fa4uxKv0YXdZfrohNwJh0COtUpjqZEVuK1QZmZmTzwwAMEBgZiNBoJCQnhySef5NSpU1qHVi8GDBhwQeLVt29fsrKycHd31yYoIUTzkJ2k3vvX4ov7bBKSX1rJCz8k8dqSfZRUmOnayoN5D/W+MHmpLIXNH8IPk9Qk5s92fg0/ToZlz11V6DqdjtiO/nz3SB8GRvhSZVH4IDeavJIKypJ+BHPVxZ8Y1KNmS4tnqHp/Jv2q4mgqJIGxMYcPH6ZHjx6kpKTw7bffcujQIT766CPi4+OJiYnh9OnTmsRlNpuxWCxXrniVjEYj/v7+V71LthBCAJB/dsn+2iQwwNb009z96Wbi9+dip9fx+IA2zBnfnQB3pwsrl+bB5jlweB0ciq9ZVlkKu84Omm03/KrDB/B2deCtMdG8cVs0h1y6csriyo4zTvwvfisVVRZ1jMvaN9WByhfjEaLe2/g4GElgbMzkyZMxGo2sXLmS/v3706pVK0aMGMHq1as5duxYjd2aCwsLueuuu3BxcaFly5Z88MEH1jJFUXj55Zdp1aoVDg4OBAYG8re//c1aXl5ezjPPPEPLli1xcXGhd+/erFu3zlo+d+5cPDw8+Pnnn4mMjMTBwYHPPvsMR0dH8vLyasT85JNPMmiQumz1qVOnuOuuu2jZsiXOzs5ER0fz7bffWuved999rF+/ntmzZ6PT6dDpdKSnp7Nu3Tp0Ol2Nc3///fd07NgRBwcHQkNDmTlzZo3XDQ0N5c033+SBBx7Azc2NVq1a8cknn1jLKyoqeOKJJwgICMDR0ZGQkBBmzJhxVZ+LEMJG3PkVPLIWQmIuW62iysJ78SlMnreDE4XltPJy5rOJPbmvXxgG/SX+kDIFQPf71ce/va0OGK627yd1OrN7UL0s46/T6Rga6ce8R2/km8iPmGL4O//ZWsx9X24hb9OXsP0rdTBy1YUDha0tMKfTrjkOLUkCc76KkkvfqsprX7eyrHZ16+j06dOsWLGCxx9/HCenmtm/v78/48eP57vvvrMusf/OO+/QuXNndu7cyf/93//x5JNPsmrVKkD98p81axYff/wxKSkp/Pjjj0RHR1vP98QTT5CQkMD8+fPZvXs3d955J8OHDyclJcVap6SkhH/+85989tln7N27l/Hjx+Ph4cH3339vrWM2m/nuu+8YP348oO7E3L17d5YuXcqePXt45JFHmDBhAlu2bAFg9uzZxMTE8PDDD5OVlUVWVhbBwRfuEbJ9+3bGjh3LX/7yF5KSknj55Zd58cUXmTt3bo16M2fOpEePHuzcuZPHH3+cxx57jOTkZADee+89fv75ZxYsWEBycjLz5s0jNDS0zp+LEMKG6HRgCrzsSrQlFVVM+no7X29WWyhu69aS/z3Ym8jAWgx47fUIOHvDmSPqTtOgLoS3/Sv1cbcJdR7/cjleLkZeGtuPN2+LxtPZSEHOEUrW/ItKiwVinrj4QOGALtDhZnVLARsmg3jP917XS5e17g+3n/vrnQ9jLkxUqgX3hHFfn/v500FQeubCes8k1ym8lJQUFEWhQ4cOFy3v0KEDZ86c4cSJEwD069eP//s/dVBXu3bt2LhxI7NmzWLo0KFkZGTg7+/PkCFDsLe3p1WrVvTq1QuAjIwMvvzySzIyMggMDFRDfeYZli9fzpdffsmbb74JqDtCz5kzh86dO1tj+Mtf/sI333zDgw8+CEB8fDx5eXmMGTMGgJYtW/LMM89Y6//1r39lxYoVLFiwgF69euHu7o7RaMTZ2Rl//4sMjjvr3XffZfDgwbz44ovW69u3bx/vvPMO9913n7XeyJEjefzxxwF4/vnnmTVrFmvXriUiIoKMjAzatm3LDTfcgE6nIyQkpJafhBCiuTJbFKb/uIc9x/IxOdnz4s2R9G/nU/sTOLhCv7/Bqn9AwgfqlOnjiXD6sJo0RY1pkLiHRPrR2UdP/ifPYG8pI6G8HTqngdx4scrBPdWbjZMWGBtU200MY2JiLvh5//79ANx5552UlpbSunVrHn74YX744QeqqtQBYElJSZjNZtq1a4erq6v1tn79elJTU63nMxqNdOpUsx95/PjxrFu3juPHjwMwb9484uLirDOHzGYzr732GtHR0Xh5eeHq6sqKFSvIyLhEX+0l7N+/n379+tU41q9fP1JSUjCbzdZj58en0+nw9/cnNzcXULurEhMTiYiI4G9/+xsrV66sUwxCCBsT/xr88Ni5qcUX8V58ChtSTmK00zNrbJe6JS/Vou4A73C1y2jzh+qCeADRd4KD29XFfiWpa/H56gZaO+RhsDPyb90Enl20hwXbMhvm9ZoAaYE53992Xrrsz01+jyVcuq7uT3nhw2uuPqbzhIeHo9Pp2L9/P7fddtsF5fv378fT0xMfnyv/wgUHB5OcnMzq1atZtWoVjz/+OO+88w7r16+nqKgIg8HA9u3bMRhqXrer67ndS52cnC4YVNuzZ0/atGnD/Pnzeeyxx/jhhx9qdOu88847zJ49m3//+99ER0fj4uLClClTqKi4SD9tPbD/07oMOp3OOti4W7dupKWlsWzZMlavXs3YsWMZMmQIixYtapBYhBAaS1sPeZlqN85FfL/9KN9uUf+Y+seojkQHXeWsR4Md9H8OFj+idh25B6nfC5d43Xrhrw4B0KPDfcDjdM/vztHE4/xrRTLHzpTy5OC26M8fu2OugoJj6grEjrY5u1MSmPMZL7Lkc2PXvQxvb2+GDh3KnDlzmDp1ao1xMNnZ2cybN497773XmlRs3ry5xvM3b95co/vJycmJUaNGMWrUKCZPnkz79u1JSkqia9eumM1mcnNzufHGizZAXtb48eOZN28eQUFB6PV64uLirGUbN25k9OjR3HPPPQBYLBYOHjxIZGSktY7RaKzRinIxHTp0YOPGjTWObdy4kXbt2l2QdF2OyWRi3LhxjBs3jjvuuIPhw4dz+vRpvLwus6+IEML2lJxWkxcAv6gLijcfPsW/Vqrd+pP6t2FopN+1vV7YTdDvSXXXao9WaheSe9C1nfNyXFrA4JfgdCqGmMd5QW9HSw8n5qxL5dstGWTnl/HK6I442p/9//HHSZD2O8S+AdF3NFxcDUgSGBvz/vvv07dvX2JjY3n99dcJCwtj7969PPvss7Rs2ZI33njDWnfjxo28/fbb3HrrraxatYqFCxeydOlSQJ1FZDab6d27N87Oznz99dc4OTkREhKCt7c348eP595772XmzJl07dqVEydOEB8fT6dOnWokJBczfvx4Xn75Zd544w3uuOMOHBzObQ3ftm1bFi1axKZNm/D09OTdd98lJyenRgITGhrKH3/8QXp6Oq6urhdNJp5++ml69uzJa6+9xrhx40hISOD9999nzpw5tX4v3333XQICAujatSt6vZ6FCxfi7+8vC+UJ0Rzl7FHvPUMvWH328IkiXlichNmiMDI6gPv7hV776+l06iJy1bzbXPs5r6Tr+HMvD9zXL4wADyde/WUfa5NzOTGvnH/d2RkvF6OaVIFNrwUjY2BsTNu2bdm2bRutW7dm7NixtGnThkceeYSBAweSkJBQ48v+6aefZtu2bXTt2pXXX3+dd999l9jYWAA8PDz49NNP6devH506dWL16tX88ssveHuru5N++eWX3HvvvTz99NNERERw6623snXrVlq1anXFGMPDw+nVqxe7d++2zj6qNn36dLp160ZsbCwDBgzA39+fW2+9tUadZ555BoPBQGRkJD4+PhcdH9OtWzcWLFjA/PnziYqK4qWXXuLVV1+tMYD3Stzc3Hj77bfp0aMHPXv2JD09nV9//RW9Xn4thGh2rAvYRdc4fLq4gqkLdlFUXkWXYA9eGNmhWa03FdvRn/fv7oqbox17juXz4FdbOXKq+NxaMDacwOiU2o4ItTEFBQW4u7uTn5+PyVQz2y4rKyMtLY2wsDAcHR01ilBcr+TfnxAa+GESpK5VN2U8u/FheZWZx7/eQdKxfII8nfjivp54OF9+fyJbdeRUMU/OT+R4XilujnZ82LeIdhufBp92MPEXrcOr4XLf3+eTPzWFEEI0b4pyrgXm7N4/iqLw6i/7SDqWj6ujHbPGdWm2yQtAiLcLX9zXk6iW7hSWVfF/awspqzKrLTANuIp6Q5IERgghRPNWUQzuweo6LD7qRIZPfz/Mqn052Ol1vD2mEyHel17YrrnwcjEyZ3w3hkb6kWXxIq9Moai4BHNhttahXRVJYIQQQjRvDq5w93x4YivYO7J8Txaf/a4uo//8iPb0CL1+Zh062ht4/dYoHuzflmydD6WVZj5YvJqi8ktsBNmESQIjhBDi+qA3kFNQxutL1QU9J/QJYXSXlhoH1fh0Oh0P3dgah65jWWA3ijXH9Dz81TaO55VqHVqd1CmBefnll60b7FXf2rdvby0fMGDABeWTJk2qcY6MjAzi4uJwdnbG19eXZ5991roCbLV169bRrVs3HBwcCA8Pv2B/GyGEEKLWztvQ8MN1qVRUWegS7MHkgeEaBqW9Drc8xYAHXqfCLYTUE0Xc/+VWdmXmaR1WrdW5BaZjx47WTfaysrLYsGFDjfLzN+HLysri7bfftpaZzWbi4uKoqKhg06ZNfPXVV8ydO5eXXnrJWictLY24uDgGDhxIYmIiU6ZM4aGHHmLFihXXcJkX10wnYIkmTv7dCdGILBb4sC/MvZlDhw+zbE8WAE8O+dPKtNepjoHuzL2/JxH+bpwpqeDxeTtYujtL67Bqpc4L2dnZ2V12k73LbcK3cuVK9u3bx+rVq/Hz86NLly689tprPP/887z88ssYjUY++ugjwsLCmDlzJqCuuLphwwZmzZplXcPkWlWv1FpRUXHBrs5CNLSSEnUn8j9vcyCEaABn0qC8EMVSyexNp1AUGNbRj46Btrl8fr2yWKAwC9/CbD6Z0IOXf97L2uRcXvllL4dPFPFI/9Y42NXfztn1rc4JTEpKCoGBgTg6OhITE8OMGTNqLG42b948vv76a/z9/Rk1ahQvvvgizs7qUvoJCQlER0fj53duiebY2Fgee+wx9u7dS9euXUlISGDIkCE1XjM2NpYpU6ZcNq7y8nLKy8utPxcUFFyyrp2dHc7Ozpw4cQJ7e3tZuEw0CkVRKCkpITc3Fw8PjzpteSCEuEpZuwA47RLOH0fysTfoeXzA9d11ZFWUA58OAr0dTk/uYsbt0Xz0WypzN6bzv81HWLU/h8f6tyG2o3+TbK2qUwLTu3dv5s6dS0REBFlZWbzyyivceOON7NmzBzc3N+6++25CQkIIDAxk9+7dPP/88yQnJ7N48WJA3a/n/OQFsP6cnZ192ToFBQWUlpZessVkxowZvPLKK7W6Dp1OR0BAAGlpaRw5cqQub4EQ18zDw+OyrZhCiHqUswcFWJsfAMDYHsEEekjLOwCufmDnAFXlUHAMvWcIjw8Ip52vG7NWHyQ7v4x//LyXeX9k8LfBbekV1rRma9UpgRkxYoT1cadOnejduzchISEsWLCABx98kEceecRaHh0dTUBAAIMHDyY1NZU2bRp2H4hp06bx1FNPWX8uKCggODj4kvWNRiNt27ZtsF2QhbgYe3t7aXkRojFl7aa8yszmykDcnO24/4ZQrSNqOvR68AyBEwfVrjZPdXuBIZF+3NC2Bd9tzeSrTekczCnkiW920Lu1N38bFE5bPzeNA1dd02aOHh4etGvXjkOHDl20vHfv3gAcOnSINm3a4O/vz5YtW2rUycnJAbD+Rerv7289dn4dk8l02fEqDg4ONTYNrA29Xi9LuQshRHNlrsSSu5/icjMHDaE8cEMYJkcZe1aDZ+jZBKZmb4SjvYGJfUMZ3SWQLzak8f2OY/xx+BT3pJ1iRFQAk/q3wd9d2+/Paxr8UVRURGpqKgEBARctT0xMBLCWx8TEkJSURG5urrXOqlWrMJlM1t2IY2JiiI+Pr3GeVatWERMTcy2hCiGEuN6cOEBpWRn5ijN6j1bc2f3SrfLXrSts6ujhbOSpYRHMf6QPQyL9UBT4NSmLMR9u4j/xKRSWVTZerH9SpwTmmWeeYf369aSnp7Np0yZuu+02DAYDd911F6mpqbz22mts376d9PR0fv75Z+69915uuukmOnVS954YNmwYkZGRTJgwgV27drFixQqmT5/O5MmTra0nkyZN4vDhwzz33HMcOHCAOXPmsGDBAqZOnVr/Vy+EEKLZOlMOyy292aDvweRBbTHayYSNC3iFqfdX2JU62MuZN2+L5sv7e9KtlSeVZgv/23yETamnGj7GS6hTF9LRo0e56667OHXqFD4+Ptxwww1s3rwZHx8fysrKWL16Nf/+978pLi4mODiYMWPGMH36dOvzDQYDS5Ys4bHHHiMmJgYXFxcmTpzIq6++aq0TFhbG0qVLmTp1KrNnzyYoKIjPPvus3qZQCyGEuD58tM+OH3QP0DHYxBcdfLUOp2nyDFXvr5DAVOsY6M6H93Rjw6GTrNqXw9AOfld+UgPRKc10Va3abscthBCi+Uk7Wczdn27GbFH4eEJ3urby1Dqkpqk0D7Z9Dl6toeNtWkcD1P77+5oG8QohhBBN0Yer9xBsziSkXSdJXi7HyQNufFrrKK6KJDBCCCGale1HTnMqZSsfmP+FW14EUP9b0QjtyYgmIYQQzYbFojA7/hDtlHQc7Q04+rfTOqSmr+Q0HEmA3P21q19ZCk1g9IkkMEIIIZqNlftyOJBVQEf9EVyMBvDvpHVITV/iPFh4H+z8unb1V78MX46Aw+saMKgrky4kIYQQzUKl2cKH61MB6O18DL1FB/7RGkdlA66wFkwNVRVwaDWUF4FR2xV5pQVGCCFEs7Ap9RRZeaWEOJbSwnIKdDrw66h1WE1f9VTqvFrsDZj+u5q8uPpCYNcGDetKJIERQgjRLPy08xgA40Py0YE6Ndihaezb06RVJzBFJ9Tk5HKSl6n3ESPUvZQ0JAmMEEIIm5dbUGZdFba/e7Z6ULqPasfRBM5nd5rOy7h0vcoySD271U/EiEvXayQyBkYIIYTN+2V3FhZFoUuwB55Rw8DFAfyitA7LdniGqrORzqSDX+TF66T/DhUlYAqAgC6NGNzFSQIjhBDCplksCj/vOg7ArV1bQkAABMjsozrxDIVjOy4/kPfAUvU+YqQ6vkhjksAIIYSwaVvTT5OVV4qrox2D2sueR1clcjQEdoOW3S5dp9M4sHeC9nGNF9dlSAIjhBDCpv2YqLa+jIjyxzHvEORlQkBncPXRODIb0qqPeruckBj11kTIIF4hhBA260xxBb8dPAHA6C4tYe+P8NNk2DxH28BEg5MERgghhM36dU8WlWYL7QNMtPNzg+zdaoG/DOCts6PbYPdCKC+seby8CNa/A9lJTWILgWqSwAghhLBJiqLw086zg3e7BIK5EnL2qoWyhUDdLZkKK6fDqUM1jx9eC1s/g6VNa9dqSWCEEELYpN1H80k/VYyjvYFhHf0hfYO60aCzt7qInagbrzD1/s8zkayL1zWN2UfVJIERQghhk346O3h3SAc/XB3sYN9PakGHm0Fv0DAyG1W9Iu+Z87YUKCuAtN/Ux01g8brzSQIjhBDC5hSWVbJqv7ri7q1dA9Uv2kNnV4mNvFW7wGzZxTZ1TF2jds15t4EW7TQJ61IkgRFCCGFzVu7NobzSQmgLF6JbusOxbWCphBZtwbeD1uHZpot1IZ2/91ET6j4CWQdGCCGEDfoxUd248dYuLdHpdNBmEDy8Foqym9wXrc2wdiGlq7ONygvgyEb1WMRIraK6JElghBBC2JQD2QUkZxdib9AzMtr/XIEpQL2Jq+MeDDq9OhC6+AQUHAMHE7h4q11ITYwkMEIIIWzKz2cH7/aP8MHD2QhVFWBn1DiqZsBgDyP+CS4+auIS6AuP/gbFuVpHdlGSwAghhLAZZZVmlu89O3i3S0u1q+OrUeARDENeBvcgbQO0dZG31PzZYAemQG1iuQJJYIQQQtiM+P25FJVVEejhRI8QTzh+dgfl4lxw8tI6vOaj5DQ4eoC+6c71abqRCSGEEH/y09nBu7d0DkSv151b+6XdcDA6axhZM1GUC3u+hzkx8El/OLJJ64guSRIYIYQQNiH9ZDGJmXnodTpu7hwAVeVw4Fe1MHK0tsE1FyeSYfkL6uOi3CbdJScJjBBCCJvw8y518G7fcG983Rwhda268aCbPwT10ji6ZqJ6KjWAXyR4tNIslCuRBEYIIUSTV2m2sHR3FnB28C7Avh/V+8hbmvRYDZty/oDdlj20i6MW5BMXQgjR5O3MyONMSQWezkb6tvGG4lOQ9rtaKFsH1B+9AdoOBZcW0OthraO5LJmFJIQQoslbf1Bdi+TGti2wM+jB3hGG/AOyk5rkIms27Zb/gKVKXRemCZMERgghRJOmKArrkk8A6uJ1ABhdoNNY9Sbql07X5JMXkC4kIYQQTdz+rEJOFJbjZDTQK0zWehEqaYERQgjRpK07233Ut403DnYGSPwWFDO0jwMnT42jE1qRBEYIIUSTtr66+6idD1jMsHmOukaJiy+0G6ZxdEIr0oUkhBCiyco4VULayWLs9Dr6hbeAzD/U5MXRBK0HaB2e0JAkMEIIIZqs6tlH3UI8cXO0h70/qgXt42QH6uucJDBCCCGarHXndx9VFEPKCrVAtg647kkCI4QQokk6UVjOnuP5wNnp0ykrobIMPEMgoIu2wQnNSQIjhBCiSfo95QSKAh0DTereR9XdR5G3qmuViOuaJDBCCCGapPUHz599ZAFXX3Wp+8hbNI5MNAWSwAghhGhyisqr2JZ+BoABEb7qZo0j34FH1oF7kLbBiSZBEhghhBBNTkLqKSrNFkK8nQlt4XKuwNVXu6BEkyIJjBBCiCZnbbI6fbp/Ox/Y8z2cPqxxRKKpkQRGCCFEk1JRZSEh9RQAg1taYNU/4Ms4OJ2mcWSiKZEERgghRJOy7chpisuraOHqQPvM78BcCcE9wStM69BEE1KnBObll19Gp9PVuLVv395aXlZWxuTJk/H29sbV1ZUxY8aQk5NT4xwZGRnExcXh7OyMr68vzz77LFVVVTXqrFu3jm7duuHg4EB4eDhz5869+isUQghhU6r3PhoepkeXtFA92OdxDSMSTVGdW2A6duxIVlaW9bZhwwZr2dSpU/nll19YuHAh69ev5/jx49x+++3WcrPZTFxcHBUVFWzatImvvvqKuXPn8tJLL1nrpKWlERcXx8CBA0lMTGTKlCk89NBDrFix4hovVQghRFNnsSjW6dO3VS0HcwW07AbBvTWOTDQ1dd6N2s7ODn9//wuO5+fn8/nnn/PNN98waNAgAL788ks6dOjA5s2b6dOnDytXrmTfvn2sXr0aPz8/unTpwmuvvcbzzz/Pyy+/jNFo5KOPPiIsLIyZM2cC0KFDBzZs2MCsWbOIjY29xssVQgjRlO09XsDp4goCjSUEZfykHuzzuCxcJy5Q5xaYlJQUAgMDad26NePHjycjIwOA7du3U1lZyZAhQ6x127dvT6tWrUhISAAgISGB6Oho/Pz8rHViY2MpKChg79691jrnn6O6TvU5hBBCNF/rzs4+muz2G7qqcvCPgtAbNI5KNEV1aoHp3bs3c+fOJSIigqysLF555RVuvPFG9uzZQ3Z2NkajEQ8PjxrP8fPzIzs7G4Ds7OwayUt1eXXZ5eoUFBRQWlqKk5PTRWMrLy+nvLzc+nNBQUFdLk0IIYTGFEWxTp8OCgyCDJO0vohLqlMCM2LECOvjTp060bt3b0JCQliwYMElE4vGMmPGDF555RVNYxBCCHH10k4Wc/RMKfYGPa1inwAeAqPLFZ8nrk/XNI3aw8ODdu3acejQIfz9/amoqCAvL69GnZycHOuYGX9//wtmJVX/fKU6JpPpsknStGnTyM/Pt94yMzOv5dKEEEI0surBu73CvHBxsAMHV2l9EZd0TQlMUVERqampBAQE0L17d+zt7YmPj7eWJycnk5GRQUxMDAAxMTEkJSWRm5trrbNq1SpMJhORkZHWOuefo7pO9TkuxcHBAZPJVOMmhBDCdqxLPsEgSwJ3eKSAomgdjmji6pTAPPPMM6xfv5709HQ2bdrEbbfdhsFg4K677sLd3Z0HH3yQp556irVr17J9+3buv/9+YmJi6NOnDwDDhg0jMjKSCRMmsGvXLlasWMH06dOZPHkyDg4OAEyaNInDhw/z3HPPceDAAebMmcOCBQuYOnVq/V+9EEKIJiGnoIz04zk8ap5PzO6/Q+oarUMSTVydxsAcPXqUu+66i1OnTuHj48MNN9zA5s2b8fHxAWDWrFno9XrGjBlDeXk5sbGxzJkzx/p8g8HAkiVLeOyxx4iJicHFxYWJEyfy6quvWuuEhYWxdOlSpk6dyuzZswkKCuKzzz6TKdRCCNGMrT94gpGW9XgaStF7hUPrAVqHJJo4naI0z3a6goIC3N3dyc/Pl+4kIYRo4qb8L4HJqY/Q0qEU51H/hKgxWockNFLb72/ZC0kIIYSmCssq8T3yEx4UYvAIgg63aB2SsAGSwAghhNDUH4dyGVO1HINeh0Pfx8Bgr3VIwgZIAiOEEEJTKft24EUeOLhBx9u0DkfYCElghBBCaMZiUdifkcNBXSiWwG5gZ9Q6JGEj6ryZoxBCCFFfknMK2Vweym7nf7Dqrpu0DkfYEGmBEUIIoZmNh04C0DPUC3s7g8bRCFsiCYwQQgjNbD6Ui71SSb/wFlqHImyMJDBCCCE0kVdSQdGxfXxf9QTD9z6rdTjCxkgCI4QQQhObD5+mjZKBg96Co1GGZIq6kQRGCCGEJjalniRcOYLRTg9+UVqHI2yMJDBCCCEandmisPnwKdoqR7A36MGvo9YhCRsjCYwQQohGtz+rgMLiMtqQKQmMuCqSwAghhGh0m1JPEkwWLgYzOgdXcG+ldUjCxkgCI4QQotFtPHTq3PgX3w6gl68jUTcy7FsIIUSjOlVUzv6sAox4oUSMhJbRWockbJAkMEIIIRrV5sOnASgL7IXTbX/VOBphq6TNTgghRKPamKpuHyCr74prIQmMEEKIRlNltrD58ClclGIG+BSBxaJ1SMJGSQIjhBCi0ew9XkBRWRWD7ZOI+HUsLH5I65CEjZIERgghRKOp7j66wZSNDsA7XNN4hO2SBEYIIUSj2XToFACRukz1gCxgJ66SJDBCCCEaxYnCcg7mFGKHGe/SNPWg7IEkrpIkMEIIIRpFwmG19aW/TyEGcznYO4FnqLZBCZslCYwQQohGsemQOv5liKd6j28k6A0aRiRsmSQwQgghGlyl2cIfaeoCdp2MR9WDMv5FXANZiVcIIUSD2300j+LyKjydjXh3HQ3eLSC4t9ZhCRsmCYwQQogGVz37KKaNN/pWHaFVT40jErZOupCEEEI0uE2pagLTt423xpGI5kISGCGEEA0qO7+M1BNF6HU6YkynIHUtFJ/SOixh4ySBEUII0aA2nV19N6qlCbeUH+GHSfDHh9oGJWyeJDBCCCEa1MZD1d1HLSBnr3pQZiCJayQJjBBCiAZTUWVh2xF1+nS/1p6Qu08tkBV4xTWSBEYIIUSD2XbkNKUVZlq4OtDOeBIqS8HeEbxaax2asHGSwAghhGgw6w+eAOCmdj7ocs92H/l0kBV4xTWTBEYIIUSDsFgUfj+oDuC9qZ2MfxH1SxIYIYQQDWJfVgEni8pxcbCjR4iXJDCiXslKvEIIIRpEdfdRTBtvjHZ6GPoqZO2CkL4aRyaaA0lghBBCNIjqBKZ/Ox/1gHcb9SZEPZAuJCGEEPUu41QJ6SeLsTfoZfsA0SCkBUYIIUS9W38wF4CurTxwc7SHA0uh+CS07g+eodoGJ5oFSWCEEELUuwu6j3Z9C5lbwcFVEhhRL6QLSQghRL06VVRO0rF84GwCY7FAjqzAK+qXJDBCCCHq1YZDJ1EU6BBgwtfkCPkZUFEMdkbwkkG8on5IAiOEEKJenb/6LnBu/RefDmCQkQuifkgCI4QQot6UVFTxx2F188b+f05gZAE7UY8kgRFCCFFvNh8+RaXZQktPJ9r4uKgHc/ao95LAiHp0TQnMW2+9hU6nY8qUKdZjAwYMQKfT1bhNmjSpxvMyMjKIi4vD2dkZX19fnn32WaqqqmrUWbduHd26dcPBwYHw8HDmzp17LaEKIYRoBL+d3fuofzsfdDodKArkHlALJYER9eiqOyO3bt3Kxx9/TKdOnS4oe/jhh3n11VetPzs7O1sfm81m4uLi8Pf3Z9OmTWRlZXHvvfdib2/Pm2++CUBaWhpxcXFMmjSJefPmER8fz0MPPURAQACxsbFXG7IQQogGVGm28HuKOv5lUJCiHtTp4JG1ahLjHa5hdKK5uaoWmKKiIsaPH8+nn36Kp6fnBeXOzs74+/tbbyaTyVq2cuVK9u3bx9dff02XLl0YMWIEr732Gh988AEVFRUAfPTRR4SFhTFz5kw6dOjAE088wR133MGsWbOu8jKFEEI0tF0ZZ2hTspu3mE30stuhIEstMLpAUHcw2GsboGhWriqBmTx5MnFxcQwZMuSi5fPmzaNFixZERUUxbdo0SkpKrGUJCQlER0fj5+dnPRYbG0tBQQF79+611vnzuWNjY0lISLhkTOXl5RQUFNS4CSGEaATmStj3Ez4/juMN87v0ZB86iwUyN2sdmWjG6tyFNH/+fHbs2MHWrVsvWn733XcTEhJCYGAgu3fv5vnnnyc5OZnFixcDkJ2dXSN5Aaw/Z2dnX7ZOQUEBpaWlODk5XfC6M2bM4JVXXqnr5QghhLgWe76HjbNRCnNwK6mgBCMl7cbgNvQx8GildXSiGatTApOZmcmTTz7JqlWrcHR0vGidRx55xPo4OjqagIAABg8eTGpqKm3aNNwCRtOmTeOpp56y/lxQUEBwcHCDvZ4QQlz3ThyE5S8AUOHgyRclMcQ7DeKHW0eCvUHj4ERzV6cEZvv27eTm5tKtWzfrMbPZzG+//cb7779PeXk5BkPNf7S9e/cG4NChQ7Rp0wZ/f3+2bNlSo05OTg4A/v7+1vvqY+fXMZlMF219AXBwcMDBwaEulyOEEOJaeLWGO+dC5ma+rhrJgo2Z3NTaB0dJXkQjqNMYmMGDB5OUlERiYqL11qNHD8aPH09iYuIFyQtAYmIiAAEBAQDExMSQlJREbm6utc6qVaswmUxERkZa68THx9c4z6pVq4iJianTxQkhhGhABjsIiYEbprL2UB5w3uJ1QjSwOrXAuLm5ERVVcyMuFxcXvL29iYqKIjU1lW+++YaRI0fi7e3N7t27mTp1KjfddJN1uvWwYcOIjIxkwoQJvP3222RnZzN9+nQmT55sbUGZNGkS77//Ps899xwPPPAAa9asYcGCBSxdurSeLlsIIUR9OZ5XysGcQvQ6HTe2baF1OOI6Ua+bUhiNRlavXs2///1viouLCQ4OZsyYMUyfPt1ax2AwsGTJEh577DFiYmJwcXFh4sSJNdaNCQsLY+nSpUydOpXZs2cTFBTEZ599JmvACCFEU7HzazhzBKLv5Pd0dUxk52B3PJyNGgcmrhc6RVEUrYNoCAUFBbi7u5Ofn19jHRohhBD1YO7NcDIFRrzF44mt2JZ+hieHtGV87xCtIxM2rrbf37IXkhBCiLo5laomLwZ78lv2Z2dGHgA3tZXxL6LxSAIjhBCibpKXqfchfdmYWY7ZotDGx5VgL+fLP0+IeiQJjBBCiLpJWaHet4vlt4Pq3kf9I6T1RTQuSWCEEELU3unD6gJ2ejvKQgaScPgUINOnReOTBEYIIUTtJS9X70NiWJ1WRmmFmQB3R9r7u2kbl7juSAIjhBCi9uwdwdUH2g1n8Y5jANzWtSU6nU7jwMT1pl7XgRFCCNHM9XgAut3H/uNn2HNsJ/YGPbd0aal1VOI6JC0wQggh6kav5/tEdb+6ge198HKRxetE45MERgghRO0c3wnmKgrLKlmxLxuAMd2CNA5KXK+kC0mI61BReRUJqadYm5zLjiNnuKVLII/1byPjGMSlnTkC3/wFXH1Y1nku5ZUW2vi40iXYQ+vIxHVKEhghrhOniyv4PeUE65JPsCXtNJVmi7Vs7sZ0ThSW88LIDtgbpGFWXETKSgAU73AW7soFYEz3IEl6hWYkgRGiGcvKL2Vd8gnWJeeyKzMfy3lbn7XycmZAhA/uzkbmrD3E0t1Z5JVU8uZt0TgZDRpGLZqks6vvpnndwJGDJTgbDYyI8tc4KHE9kwRGiGZqye7jvLF0P2bLuaQlwt+NARG+DIzwIayFi/Wv51BvZ174IYmNh07yxDc7eHdsF9yd7bUKXTQ1eZmQsxd0er4+2Q6oYER0AC4O8hUitCP/+oRohnZknGHGrwcwWxSiW7ozJNKP/u18CPRwumj9G9v68MHd3Zj6XSJJx/J5+H/b+M9dXfEzOTZy5KJJOqguXlce0J1lhysBGNNNpk4LbUlntxDNzNEzJTy/aDeVZguDO/jx6b09uKtXq0smL9U6BXnwyb098HFzIP1kMQ9+tZW0k8WNFLVo0g6qex8lGHpgtih0DvYg3FdW3hXakgRGiGaksKySpxfsIr+0kvYBJv4xKhK9vvaDLNv4uPL5xJ6EeruQW1DOw//dRtLR/AaMWDR5BcchOwlFp+Oj4+EA3NFdpk4L7UkXkhDNRJXZwvQf95B2spgWrg78685OONobYPtXsPN/YK4ExQzmKrBUgaUSLGa4+zvw62g9j7+7I5/e24OpCxLZcyyfx7/ZzozbOnFD2xYaXp3QjFsA3LOIAzs3cniHI57ORgZG+GodlRDSAiNEc/HemkMkpJ7CwV7Pv+7sjK/b2fEr5QXqIMzCbCg6AaVnoLwQKsvUpMZcccG53J3t+eDubvRt4015pYVnF+1i7YHcRr4i0STodOAfzfunewFwS5dAjHby1SG0Jy0wQjQDP+w8yvwtGQC8PKojkQ4nAJNaGDUGQvqB3g4M9ur9+TeXsy0r5irIOwLebQBwMhp4587OvL5kH8v2ZPPOimT6hnvjYCdTrK83R04VszX9NDqdunGjEE2BJDBC2Lht6ad5Z3kyAI/2b8Ngx2SY+wh0GQ+DpoMpUL1dTnkRLJmqLhU/fgF4tQbA3qDn73GR7MjII6egjJ92Hmdsz+CGviTRVCQtgmPb+b20D+BCv/AWVxwMLkRjkXZAIWxY5ukSnv9+N1UWhWEd/XigqwmWT4PqBetqu0qqwV7taiovhMWPQslpa5HRTs99fUMBmLspnfIqcz1fhWiykhah7FnM8eStANwh+x6JJkQSGCFsVEFZJVO/S6SwrIqolu5MH9kB3crpUHwSvMPhpmdrfzI7Bxg9B9xbQl4G/PxXqDo3NmZU50D8TI6cLCrnp8TjDXA1oskpyILjOymvMrO2qjOBHk70ae2tdVRCWEkCI4QNqjRbmLY4iYzTJfiZHHn7jk447v8eUteorSlx/wL7Oi5C5+INt30CDq5wdBusnG5tyTHa6Zl4thXmK2mFuT7s+wmAJF0Ep3SejOnWsk5T8oVoaJLACGGDPt+Qxta00zjaG5g5tjMtKo7DujfVwhumgG+Hqztxi3AYNRv0BvULbPOH1qJbOgfia3LgRKG0wtRZZZnatbdrvtaR1I6iwN7FVFos/FDRC3uDnps7XWEclRCNTBIYIWzM/qwCvtqUDsD0uA6083GGX59RvyRb9YHuD1zbC4TeAINfUh9v/VSdek31WJgwQG2Fqag6u5t1eeG1vd714FQK7FkMq/4Bp1K1jubKju+EM0coNNuzQdedIR188XQxah2VEDVIAiOEDak0W3j1l32YLQqDO/gxrKO/2lrS40HwCIYR/wR9Pfxad/6L2pIz7mtw9bEevqVzIO1cS2ifv4HU+c/BV7fA+72sSY64BP9oaDNQffz7TG1jqY29izErCququlGmc+SO7jLzTDQ9Mo1aCBvy+YY0Uk8U4eFsz3OxEecK2o+EtsPAUI+/0n0eO/f42HbYvRDjsW18WpJOkbkKfaoOxcWIDiAnCVwH1d9rN0c3PQtpv8GheHWMUVAPrSO6pCrPcNIqvVlJDJ2CPIhqadI6JCEuIC0wQtiI87uOnottj6ehTJ1xVK0+k5c/yz8Ke3+AvEwcjXYctQvhJ91ANnaYDpN+hzaD4Ld/wRfD1WRHnFOYo6547N0Gou9Qj63/57mp7k3QzFN9GG95lSPOHXn91ih0tZ2OL0QjkgRGCBvw566jIZF+sOZ1+GoUpG9s+ACC+0DvR+D2T9BN3kLK8K/5yHA3bx0OpcLx7Eq+eUfgdBpkbm34eGzJyukwJwYOrYaYv4K9E2TthuRlWkd2Ucv3ZPH99qPo9DpevTUKf/c6zmYTopFIF5IQNuCCrqM936uzhHT6uk+XvhpufnDj09YfR3dx4atN6eQWlPPzruPq7sRBveDgSji6BZjU8DHZgtI8OLIJxVLFd4cMHNiXS4zLzfTN+Zb8X17nvweDwM5e7YbTgUGno3OwB0M7+GkyZfnIkTTW/7wAe6UT997Qjr5tZANP0XRJAiNEE3dB19GpnepsFoCYx6Fl90aPycHOwMS+ofxrRTJzN6VxS+dAjMHqZn8c26F2mRjsGz2uJufQaizmSg6YA3h3uxnIIl6J4QXzLhZbhrEr6cINMhdtP8r/Eo7w10Hh9K7rwnHmKji+A9J/h4DOED6k1k8tqahizaKPeKriO0abetLzxgV1e20hGpkkMEI0YRd0HfkVwTeT1QQhYgT0maxZbKO7BDJ3o9oK88uu44zp2hYc3aEsH3L2QmAXzWJrKoqSllBRWskyumJytWd871YY9Dpylf/QT1HoC1gUUM6Ohyksq+KXXcc5mFPIX7/dSa8wL/46qC0R/m6XfpHKUrUbMTVeXciwNE89bucAj6wDZ68rxqkoCm8s2cfYorXodTqi+t+JQRatE02cJDBCNGHndx09f5MPLB6vrrsS2LX+pkxfJQc7A/f1q26FSWdU50CMQT3OzrLZet0nMLtS0vFP+R29opDifQNf3N2TVt7OF1asKleTjbMe6BfGFxvTWLT9KFvSTjPh8z8YEeXPpAFtCHD/00aK8a+qGy5WlZ875mhSk5q7vq1V8gKwcPtRju7dRKCSi6ubCYfouKu5ZCEalQziFaKJ+nPXkceuT9TZQB7BcOucGl96WhndJZAWrg7kFJTxy67jENRTLTh6fQ/kXbk3m8ULvkKvmMl1DGPGA7dcmLxYzJAwBz7uD/nHrIfdne2ZOrQdCybFMKyjHwDL9mRzx4cJfLh8J/mllefOobdXkxf3ltDtXhj7X3gsAabuAb+OtYp1z7F8Zq9OYYiyERcHOxw6xoHR5ZrfAyEamiQwQjRBF511dNNz6jTc2z+p9V/WDa26FQbUnaorW/YEzxDwaq1tYBpRFIX/JqQz/cc99K36Awc7Pe1uGnvxVWx1esjcDKVnYMOsC4pbejjx+q3RfPVAL3qGeDKg8jfiNt/FS+99wtyNaRSWVULXe+Den+CheBj0d2jV+8Lp9CeSa063P09+SSUv/JCEvqqU4XY7cbI3QMfb6uOtEKLBSQIjRBN00QXr7B0h9o0mlxzUaIXJ8oAHV8KA/9M6rEZXZbbwz+XJvL/mEADHu0zBdeAU7CMv0R2j06lJKcD+XyB7z0WrdfCw8L7bXP5hnIebvpwby9czZ10qoz/YyIeJFZxxaa2e62ISv4X/3Q5r37ygyGJR+MfPe8jOL+Nml314GyvQuQdBy6a7wJ4Q55MERogm5vyuo5ntU/Dc8T5YLNoGdRnqjKQQAL7dkmEdkHo9Kamo4tlFu1m84yg6HTw9rB33jx6Gvt/fwKPVpZ/oHwUdRqmPf3v7wsXtjiTAV6PQpazEaHTAPfYFXG59l9AWLhSVVfHlxjRu+WAD765MJqeg7CLnjwbFAgeWQtrvNeL9+LfDbEo9hdFOz8NtC9Gjg463ajquSoi60CnN9H+bgoIC3N3dyc/Px2SSZbCFbSgqr+Lez//g6JlSHgzO4tGTM9SxEjfPUrcLaKKKy6uIe+93SirMfHhPN7oHmaDgKHiGah3atbOY1e6eS7RyFJdX8di8HRzIKsDBXs9ro6MYEOFb+/PnH1NXMDZXwG0fqXsmVVXAxtmw7XM1qfEKg5H/UhMe1NaT9Skn+HJjOgeyCgCwN+gZEeXPxL6hBHudG29jWfMGlm1fUeDgx6etZ7Mru4LDJ4qxnP2v/8WbIxnVORBOHwYHE7jI2i9CW7X9/pZZSEI0EYqi8Nay/Rw9U0p3lxM8lDdL/fKMvEWdMt2EuTjYERvlzw87jrE2YQvdc6eBzgCT/1A3m7RVZ47A12PUXb5HvXfR1olPfjvMgawCPJ2NzBzbmShPMyyZCu1GQNuhl+7eqVY9AHfrZ+p2DKE3Qvpv6s+gbqzZ/3kwnktK9HodAyN8GdDOhy1pp/lyYzo7Ms7w867jLNmdxaAOvgS6O7L3eAHpx7vybskiWpRk4rbzUw4ZxgDgZ3JkTLeWavICTa5rUogrkQRGiCbi513HWbk3By9dITPt5mAoK1Y3/Bv2xpW/BJuA27sG8cOOY/ycZmCqMxgqCuHkQfDtoHVoV2/fj+q09ZRVakLR+5EaxYdyC1mwLROAl2/pSFRLd9g1Hw78qiY/7YbV7nV6PwpJC9XtGHKS1AXouo6HkH4QPviST9PpdPRu7U3v1t7syszjq03pbDh0ktX7cs6rZeRzhwlMr3qfCXbx9Bg8gbAO3fFxc1Bbd0rzwMmjTm+LEE2BJDBCNAGpJ4r418pkAN5stR3n7Fx1Ns/o98HuIjNYmqAIfzciA03sO15AhmN7wip3QOYW205gYp5Q93dKXgYb/w1B3a0rHyuKwtvLkzFbFAa19yWmzdlVc6v3OKpLq5mjCUa+DZ5h6ucOMPilOoXaOdiDd8d14WBOId9vP4pFUYhq6U7HQBNhLQZj+CUVUlbT69Bs6PGt+qTjO2DBRHUczvAZdXo9IbQmo7WE0FhZpZkXFidRXmmhd5gXXcv+UAv6TQEnT01jq6vburYEYHVhCAqc3RfJhukN6vijDqPU7rwlT1lXul22J5vEzDwc7Q1MGdJOrV98Sk3aANoNr9trtR5wLnm5Bu383Jg2sgN/j4tkdJeWhPu6qavqDnoRXH2gfRxwdujjnsXqqs5C2CBJYITQ2L9WJJN2shhvVwdeG+iJrjBLbXVp3V/r0OpsWKQ/rg52/F4WRqXZAke3NekZVJdVHbdOB0NeVpOLwmxYPo3C0grei08B4MEbws7t2JyyUp314x+tLjjYlLj5w0Nr1PE2eoO6Wm91a1HH27WNTYirIAmMEBpaviebn3cdR6eDV0d3xCMgDB7bBLd/apOroToZDQyP8ieFEArN9mprxakUrcOqu8Js+KQ//PaOmsg4uMLN/1Y3qDyygYXL13C6uIIQb2fu7n3eNOmD1d1HdWx9aSznd0cm/woVxWqipcGGoEJcK0lghNBI5ukS3lq2H1D/iu8ZenZ1XUeTOuvFRt3WtSVmnR07q0LVqbq2uK3A3h+gKBeOJ56beeQXCcPfIn34V3yyX91p+9nY9tgbzpYXn4TMs9da1+6jxnYkAZa/oD6OvFXWfhE26Zr+1b711lvodDqmTJliPVZWVsbkyZPx9vbG1dWVMWPGkJOTU+N5GRkZxMXF4ezsjK+vL88++yxVVVU16qxbt45u3brh4OBAeHg4c+fOvZZQhWhSKqosvPBDEiUVZrq28uCBfmEXLmJmo9r6uRHV0p3luhvYFnQvBPfWOqS6sVhgz/fq46gxNYsi4nj9DzMWRWFIpB+9ws7b0qEoB3zaQUAncA9qxICvQuqac4873qpZGEJci6tOYLZu3crHH39Mp06dahyfOnUqv/zyCwsXLmT9+vUcP36c228/179qNpuJi4ujoqKCTZs28dVXXzF37lxeeunciPu0tDTi4uIYOHAgiYmJTJkyhYceeogVK1ZcbbhCNCnvxaeQnF2Iu5M9r90ahZ1BD1s+hXl3QvJyrcO7Zrd1bclv+l7MODMQi1e41uHUzdEtkJepduH9qSVlaVIWu4/m42Q08Ex0Kax761zi6ddR3ZfozrmNH3Nd3TBFnard+9Gmn2wJcQlXlcAUFRUxfvx4Pv30Uzw9z82SyM/P5/PPP+fdd99l0KBBdO/enS+//JJNmzaxefNmAFauXMm+ffv4+uuv6dKlCyNGjOC1117jgw8+oKKiAoCPPvqIsLAwZs6cSYcOHXjiiSe44447mDXrwg3PhLA165Jza6wd4ut2dgDoweWQtRvK8jWMrn4MjfTD1dGOY2dK2ZJ+Wutw6iZpkXrfPq7G4nEFZZX8Z406nmdyb0+8ljwE275U1285ny2MXTK6wK0fwI1PaR2JEFftqhKYyZMnExcXx5AhQ2oc3759O5WVlTWOt2/fnlatWpGQkABAQkIC0dHR+Pn5WevExsZSUFDA3r17rXX+fO7Y2FjrOS6mvLycgoKCGjchmprjeaW8umQfAPf0CaFf+Nll2/OPQs5edcn68CGXOYNtcLQ3MCLKH3elkAPrFqizkWxBWQGknG3pjb6jRtFH61LJK6kkrIULt/XrBH3/qhaseQ1SVkN5USMHK8T1rc4JzPz589mxYwczZly46FF2djZGoxEPD48ax/38/MjOzrbWOT95qS6vLrtcnYKCAkpLSy8a14wZM3B3d7fegoOb2BRGcd3LL6lkyvxEisqqiGrpzmMD2pwrTFmp3gd1BxdvbQKsZ7d1DSLOspa4jH9SuvW/WodTO/t/UfchatEW/M91j+/PKuD7HUcBeG54hDpwt8eDEHajWv+nyfBhDBxarVXkQlx36pTAZGZm8uSTTzJv3jwcHR0bKqarMm3aNPLz8623zMxMrUMSwqqs0sxTCxJJP1WMr8mBGbdHn5u9AupS9QBtY7UJsAGE+7pS6tcNgJLUzbYxSDm4t7qEf7eJ1u0bLBaFt5cfQFEgtqM/3UPODtzV62HE2+ricKAmMr4dNQpciOtPnRKY7du3k5ubS7du3bCzs8POzo7169fz3nvvYWdnh5+fHxUVFeTl5dV4Xk5ODv7+/gD4+/tfMCup+ucr1TGZTDg5OV00NgcHB0wmU42bEE1BlVmdcZR0LB9XRztm/6Urfqbz/gAoyoXjO9XHbYdqE2QD6dJrAFUY0JWcwHw6XetwrqxFuLqEf6c7rYd+2X2cvccLcHGw42+D29as7+wFI2eC4ezCg6aARg5YiOtXnRKYwYMHk5SURGJiovXWo0cPxo8fb31sb29PfHy89TnJyclkZGQQExMDQExMDElJSeTm5lrrrFq1CpPJRGRkpLXO+eeorlN9DiFshbrD9AE2pJzEaKdn1tgutPFxrVkpZZXaOhHQWV0ttRkZGBVMql0bzBaF1B1rtQ6nzvJLK3l/zSEAHr6xtboB4p+16g2TfoPRHzRydEJc3+q0maObmxtRUVE1jrm4uODt7W09/uCDD/LUU0/h5eWFyWTir3/9KzExMfTpoy7MNWzYMCIjI5kwYQJvv/022dnZTJ8+ncmTJ+PgoP7nMGnSJN5//32ee+45HnjgAdasWcOCBQtYunRpfVyzEI3mk98O8/Ou4+h1Ot64LZrOwR4XVvJqre5abGvrpdSCo70BS8uecOQguft/p93QB7QO6eKqymHN69DhFnUH8LPdR/9LSCe/tJI2Pq6M7XGZ6cY2tmeVEM1Bve9GPWvWLPR6PWPGjKG8vJzY2FjmzJljLTcYDCxZsoTHHnuMmJgYXFxcmDhxIq+++qq1TlhYGEuXLmXq1KnMnj2boKAgPvvsM2Jjm8/4ANH8Ldp+lM83pAHwfyPa07+dz8UrhsSot2YqvPtgODKPFmcSyS0oxdd08W5gTR1aDbsXQNpv8PAa0Bk4WVTOd2enuz8+sI26Vo8QosnQKYotjKyru4KCAtzd3cnPz5fxMKLRrTmQw7TFSSgKPHJTax66sbXWIWmnooTT/+yM2VzJ6n7fcNfQvlpHdKGF96nL68c8Dv2eBGDmymS+25pJVEt3Pp/YA93ZVhkhRMOq7fe3/EkhRD3bfuQML/64F0WB27q15MEbwi5d+cCvcDqt8YLTgtGZQ33/yX12/+SbAxbMlib2N1P+UchQF9qk420AZOeXsXjHMQAeG9BGkhchmiBJYISoR4dyC3l20S4qzRYGRPjwXGz7S3/5lRfCsufgi+FwJr1R42xsnfuPpsLZn5yCMjalntQ6nJr2/qAOom7VBzzUnaU/33CYSrOF7iGe9AiR8S1CNEWSwAhRT7LPFPHxf7+mvLSULsEevHZrFAb9Zf5yP7wOzJXqIF7P0MYKUxMOdgbiOqlTjBdtP6pxNOexmM9t3Hh25d3M0yUs2Z0FSOuLEE1ZvQ/iFeJ6VFhWyaovXua5okVkOLSj7ej5ONgZLv+kg2eXrG83rOEDbALuNa6jrXkpHxwaz8GccNr5uWkdEmQkQEEWOLhBuLoGz6e/H8ZsUegX3oJOQR7axieEuCRpgRHiGlWaLUxfuIUbCn9Fr9PRxS4d0y8Pg7nqMk8qVWe8QLNaffdyvDJXcaM+iU5KMnM3pWsdjqqyDDyCIfIWsHck9UQRK/aqW5o82v86HngthA2QBEaIa6AoCm8s3Y93+lLcdCW4tAjC4NICoseC4TINnGm/q2uPuLcE3w6NF7CWgnrhbLSjh5LEmv25ZJ4u0ToiaDsEHlgJNz4NwCfrD6MoMKi9L+39ZfaiEE2ZJDBCXINPfz/M8t1Hud2yEpOjPY59J8EDy6HzuMs/sXrH47ax1kXTmr02g7DT6xiq38ZN5s38NyFd64hUej0YXdifVcDa5Fx0Onj4Jml9EaKpkwRGiKv0y67jfPZ7GjFKIuEOeRhdvSDqdnA87y/3ktOw+FHIyzh3zGKBzD/Ux9fJ+BdA3Wm718M4Gw1MMc/l4K4EcgvLtInFYlHHIFVVWA99vD4VgOEd/S/c7kEI0eTIIF4hrsKWtNPM+HU/AO373oxji1BQzGD/p1VmV7+szjbK3Qdjv1JnHOn18OBqyNgE/p0bO3Rt3TAV+5MpOO9dxbSK//DD7x15dGSfxo8jIwF+/ps6bfqBFew6VsCm1FMY9Lrre9FBIWyItMAIUUeHcgv5v+93U2VRiO3ozyODItUuoy53X1h50HTwDld3nJ5/D5xIVo/bO0KbQWoycz3RG2DkO+i8W+NOIcm7N5NfUtn4cez6Rr0PuxFFp+PDdWrry6jOgQR7OTd+PEKIOrvO/vcU4trkFpYx5btEisqr6NbKkxfjOlx+nRBXXxj3P/BtDyWn4LsJkJ3UeAE3RY4mTH/5lA98X2aDOYoFZ/cbajSF2XBojfq4891sTT/Djowz2Bv0l181WQjRpEgCI0QtFZdX8dR3u8gtKCfU24V3hpowfn0LJC26/BOdvWDsfyGgM5Tlw9d3wKb/NE7QTZTOK4z+A9TxP99ty6SktLTxXnz3AlAsENwTxbsNH50d+3J7t5b4mRwbLw4hxDWRBEaIWqgyW3jhhyQO5hTi5WJk1l+64Jb0NZw6pO5kfCWO7nDHFxDUQ/25uIktp6+BQe19CfJ0okVJKsUfx6qbKTY0c6WawAB0vpsNh06y51g+jvYG7usb2vCvL4SoN5LACFELn/6eRkLqKRzs9cwc25mW9iWwd7Fa2OPB2p3EwRXGfA6j34ebnmm4YG2EQa9jYt9Q4ixr0ednovzyZM3ZWg3h0GooPgEuLbC0GWJtfRnXMxhvV4eGfW0hRL2SBMbWKQpUFGsdRbN2+EQRX28+AsBLN3ekY6C7Ogi0qgL8o8+1qtSGvSO0HaouXS8YERXAItN9HCCE8qLT8OPjUF7UcC+YtUu9j76Tn/bkkpJThKuDHff0CWm41xRCNAhJYGzdqhfhP93h+E6tI2mWFEXhn8sPUGm2cEPbFgzp4KtuA7BznlqhxwPXz0J0DcBop2dsTDivGyZzvMoN5WQKLHteXaelIQz4P7hvCcfDbuffq1MAddE6dyf7hnk9IUSDkQTGlqWuhd0L1VaY/b9oHU2ztGR3Fjsz8nC0N/BsbIQ642jvj1B6Rt0GoO11tBBdA7mta0sqnX15mUmUWfRqN8/mDxrs9cxe4bwcn0tphZlurTwZ1yO4wV5LCNFwJIGxZeUF5x6fTNEujmYqr6SC9+LP/pV+YxgB7k5gMcP2L9UK3e+7/H5HolacjXaM6xHMAV0bPnO8HwUg4QM4sqn+XqSyDIpPATB/awaJmXk4Gw28OCoSvV5a0ISwRZLA2LLI0XDbR+rjnD3ql6uoN+/FHyK/tJJwX1f+0quVelCnhyGvQLtYiBqjbYDNyNgewTgZDfyvsBvHW90CYTfV7yaX+3+BT/pzetkbzFmrDtydMqQdLT2crvBEIURTJQmMrQu7CYzOUFECp1K1jqbZ2JFxhiW7jwPwfyPaY284+6ui00FIDNzyHhhdNIyweXF3tue2ri0BeL10DNz6ETh51s/JFQUS56GYK/npYBmVZgt923gzuktg/ZxfCKEJSWBsTWUZfP/QuTUz9Abwi1IfZ+/WLq5mpNJs4a1lBwB1fEanIA9tA7pO3N27FfYGPduPFrHr2NnuUUWB44nXduKsXZC7n6IqHV8XdsfN0Y6/x0VefgVlIUSTJwmMrUl4H9J+h2XPQVW5euyGqTB+AXS4RdvYmomvNx8h/WQxns5GJg8KP1ew/AVY/w4UndAuuGbM182RkdH+APxrZTKFpeWw4gX4ZhwcXHn1J971LZUWC79WdqNQ58pzw9vj4yZrvghh6ySBsSU5e2HbF+rjIS+D3dn/hFt2U5eptzNqFlpzcfRMCZ9vSANgypC2mBzPTq89c0RduG7rZ1CWp12Azdz9/cJwd7InObuQKd/tpsLepBasmKZ+BnVVegblwFIKy6pYohvA4A5+DIv0q9eYhRDakARGK3Vd58Jcqf41ajFDxAgIH9wwcV3HFEXhnRXJVFRZ6BnqxfAotTWAkylqt52iqGOOWrTVNtBmLNDDiQ/Gd8PN0Y6kY/n87ehAqgK6qIvb/fI3tQu1LvZ8T3FpKQeVYE64RPD88AjpOhKimZAERgtnjsAXw2DP9+qXIqib/J1HURQWbT/K/32/m6NnStSWl9wD6p46g1688JzJy2HVS2orjbgq8ftzSUg9hb1Bz3PVX3Qpq+CbseoS96YAGDhN6zCbvXZ+brx/dzdcHe3YcbSIv1c+hMXJU/33v/b12p9IUSjcvpDSCjNL9AP5+82ReDhLK6UQzYUkMFrYOBvyMiF5mTqr5cRB+Li/ukNxVQV5JRU8vXAXby8/wJoDubzxv6WYN57dvXjQ38HF+8JzHvgFdn0HGZsb91qaicKySt5ddRCA+/qGEuLpBBvfg5+eUGd4BfeCexaDV2uNI70+dAgw8d5fuuLqYMfaYzr+7TAJBZ26cOPeH2p1jpJKM49XTeVz/Z04dxrNjW19GjhqIURjkgSmseXuhwNL1cc3Pq3eH/hFXZ5+0/sUfhrHPz78mg0pJ7E36Gnh6kCHvPUUFBVTEXLDpQfqBnRR72Um0lX5aH0qJ4vKCfZy5t6+IVByCnZ9qxZ2u1fdSdrZS9sgrzNRLd3591+64Gw0MD8niB+dblUXuYt/VV0J+Qreiz9Ecr4dm7xG87fhnRo8XiFE45JlRBvb7zPV+w43n1uo64anMHtHkLf0H1hyUvg7r7HBZSid/vIKjq7uPPyVwpHClugKuvB6lQVHe8OF5/WPVu+rN6sTtbbveAGLth8F4Pnh7XGwM4CrD4x6D/IzZME6DXUK8mDWuC48OT+Rf54ZiI9bFr3jHsLeyVPdTPPEfjXZLD4FJacoOpPN8WOZ5J3KhvJIMMTy4s2RuDrIf3VCNDfyW92YMv5Qp0Dr7aDv36yHswvKeXGbP6nlL/GQfgGjDJu5Tbce3dKxMPQV/nN3Tx75n4Wi7CpeWJzEP+/odG5htWp+UWp3VEGWOs3XVZrLa+vzDWkoCjzeKoNeZh1wdoB0cE/1JjTVtZUn747tzNQFiTxVNIGbdpiYEWrBvvQ0zBuLRVEor7JQXmWh0mzBE/AE2hhMTOrfhp6h0nImRHMkXUiNRVHOtb50HgeeIQCsTc5l/Geb2ZWZh+LojveYmbjd8zU6j1ZQlAun0wj3dePdsV1wsNez4dBJXl+yD4tFqXl+B1fwPrtmiXQj1drRMyVsTMnhL+Yl3JP9T/j1GTidpnVY4k96hHox884u2Bv0/HbwBC/+uIcVaZVkVrnzR0kgaysiWabEsFA/ghU+93Oo5ysMn/gCD9wQpnXoQogGIi0wjeX4TrV7x94Rej9GWaWZ9+JTrF0XHQNNvHZrFEGezoA/TPwFdn8HXcYD0CXYgxm3deLZRbtYticbk5M9Tw1tV3NKqH8ndcpv1i6ZZl1L328/xkjLOh7U/Yydzh4ibwX3IK3DEhfRK8yLd+7sxLMLd7PmQC5rDuQCb4IdRPi7MayjP2Mi/fAzOWodqhCiEUgC01hadoO7voEz6eDqw+s/JrFybw4AE/qEMGlAm5rdQvaO0H1ijVPc0LYFL90cyT9+3st3WzPxcDby4Pl/YQZ0VqdmF2Y1wgXZvpKKKn7adYx/WLbg5GiAmMeh35NahyUuo2+bFrw1JprpP+7B28XI8Ch/hkX6E9pC9qUS4nojCUxjatkdWnYn83QJq/apycu7Y7twQ9sWtT7FiOgACsoqmbnyIB+vT8XDyZ4x3c+2GESMgLZDZbZMLS1LysZSWkhHXRr2BjvoeLvWIYlauLGtD/FP9ceg18midEJcx2QMTEOrKofCnBqHvtmSgaLADeEt6pS8VBvXs5W1b//tFQesyRCOJkleaklRFBZsy6STcgAXex06zxDwCNY6LFFLdga9JC9CXOckgWloO/8Hnw+x7mGUV1LBkt3HARjfp9VVn/bRm1pze7cgFAVe/nkvB7IL6iXc68W2I2dIO1lMH/0+HOz1EHqD1iEJIYSoA0lgGlJZAfzxsbpehaM7AIu2H6W80kKEvxvdWnle9al1Oh3PxkZwQ9sWVJotzN+SqRak/QYLJqq7JotLsr5f7WLRd7kb2sZqG5AQQog6kQSmIW39TE1ivMMh8lbKq8zWWUf39Am55iZwg17H/X3VrqT4AzkUllVCRbG6nUDGpmsOv7k6llfKhkMnAOg7cJS6s3er3toGJYQQok4kgWkoRbmwfa76+MapoDewfE82p4sr8DM5Mqi9b728TFRLE2EtXCivtKizmgI6qwUnDtZ9597rxKJtR1EU6N3aW2avCCGEjZIEpqFsnqMO4A3sAm0GY7EozNucAcBfegVfuJLuVdLpdIzu0hKAn3cdB7cAcGkBlirI3Vcvr9GclFaY+WnXMQAe990DR7eDuVLjqIQQQtSVJDAN4cwRdddcgBufAZ2OTamnSD9VjKuDnTXhqC8jo/2xN+jZn1VASm6RuqAdyL5IF7FsTxZFZVWEeNjTfs9MmH83nDqkdVhCCCHqSBKYhpCdBHo9tO5v3Utn3h9HALi1a8t631jOw9nITe3U6dg/JR6HgLMJjGwpUIOiKHy3VR28+0ibPHSVpWprVYsIjSMTQghRV5LANIQON8ODq2Dg3wHYn1XA9iNnsNPrGNezYdYauaWz2qqzbE8WFb7VO1NLAnO+6qnTTkYDNxkPqAdD+qnJphBCCJsi/3M3FDd/64aN1a0vQxpwn5ZeYV74mRwpLKvitwJ/ddq2Z4g6hVsAWFtfbu4UgMPRs7O0ZP0XIYSwSZLANLDs/DLi9+cCML53SIO9jkGvY1TnAAB+2FsAk/+AO74AO2ODvaYtOZZXyu8p6tTpcZHOkHteC4wQQgibIwlMA5u/NQOzRaFnqBcR/m4N+lo3dwpEp4Ot6ac5li9TqM93/tTpVgU71IO+HcDFW9vAhBBCXBVJYBpQYVmlOqgWGN/76rcNqK1ADyd6hqp7If2yS31dyosa/HWbuvOnTo/rEQxHt6oF0n0khBA2q04JzIcffkinTp0wmUyYTCZiYmJYtmyZtXzAgAHodLoat0mTJtU4R0ZGBnFxcTg7O+Pr68uzzz5LVVVVjTrr1q2jW7duODg4EB4ezty5c6/+CjX0Y+JxisurCGvhQkybxvlLv3qK9h87E1E+HQyfDgRFaZTXbqqqp04HeTrRt403DH0Vxi+ATmO1Dk0IIcRVqtN83qCgIN566y3atm2Loih89dVXjB49mp07d9KxY0cAHn74YV599VXrc5ydna2PzWYzcXFx+Pv7s2nTJrKysrj33nuxt7fnzTffBCAtLY24uDgmTZrEvHnziI+P56GHHiIgIIDYWNvZr6bSbOG7rerCdePrYduA2urfzgeTkz0Hilwor8zCUWeGvCPgGdoor9/UVO86DXBnj2D0eh1gOLdisRBCCJtUpxaYUaNGMXLkSNq2bUu7du144403cHV1ZfPmzdY6zs7O+Pv7W28mk8latnLlSvbt28fXX39Nly5dGDFiBK+99hoffPABFRXqbJmPPvqIsLAwZs6cSYcOHXjiiSe44447mDVrVj1dcuOI359DbkE5Xi5Ghnf0b7TXNdrpGRnlj1lnx2H92UHD1/GCdtuOnOHwCXXq9M2dArQORwghRD256jEwZrOZ+fPnU1xcTExMjPX4vHnzaNGiBVFRUUybNo2SkhJrWUJCAtHR0fj5+VmPxcbGUlBQwN69e611hgwZUuO1YmNjSUhIuGw85eXlFBQU1LhpRVEUvj67bcDYHsEY7Rp3qNEtXQIB2FzSEouiXNcJzE+J6tiXkdEBuDnaw9JnYMXf1dWShRBC2Kw6LwmblJRETEwMZWVluLq68sMPPxAZGQnA3XffTUhICIGBgezevZvnn3+e5ORkFi9eDEB2dnaN5AWw/pydnX3ZOgUFBZSWluLk5HTRuGbMmMErr7xS18tpENuOnOFgTiGO9gbGdAtq9NcP93WjY6CJ/UfDKKtah3N2UqPH0BSUVpj57eBJAOKiA9Sdug8uV/c+6vWIxtEJIYS4FnVOYCIiIkhMTCQ/P59FixYxceJE1q9fT2RkJI88cu5LITo6moCAAAYPHkxqaipt2rSp18D/bNq0aTz11FPWnwsKCggObphVb6/k2y1q68uozgG4O9trEsMtXQL58lgYZZVmnHL3oauquO7WhNlw6CRllWYCPZzoGGiCw2vV5MUj2LrIoBBCCNtU574No9FIeHg43bt3Z8aMGXTu3JnZs2dftG7v3r0BOHRI3SzP39+fnJycGnWqf/b3979sHZPJdMnWFwAHBwfr7KjqmxbySyrZnHoKgDu6a5NAAQyN9CfP3p8zFheqKiuuy52pV+5VW/WGRvqpg6jTN6gFMn1aCCFs3jUPzrBYLJSXl1+0LDExEYCAAHXwZExMDElJSeTm5lrrrFq1CpPJZO2GiomJIT4+vsZ5Vq1aVWOcTVMWfyCHKotCOz83wlq4aBaHq4MdQyL9WaPvwxZTLBhdNYtFC4VllWw6m0jGdjzbJZn2u3ovCYwQQti8OnUhTZs2jREjRtCqVSsKCwv55ptvWLduHStWrCA1NZVvvvmGkSNH4u3tze7du5k6dSo33XQTnTqpuyMPGzaMyMhIJkyYwNtvv012djbTp09n8uTJODg4ADBp0iTef/99nnvuOR544AHWrFnDggULWLp0af1ffQNYcfavfuuXpoZu6RLII7v/glOhgV/dQtEunWp865JPUGm2ENbChTY+rpCXod70dhDcW+vwhBBCXKM6tcDk5uZy7733EhERweDBg9m6dSsrVqxg6NChGI1GVq9ezbBhw2jfvj1PP/00Y8aM4ZdffrE+32AwsGTJEgwGAzExMdxzzz3ce++9NdaNCQsLY+nSpaxatYrOnTszc+ZMPvvsM5tYAya3oIzEzDxA7cLRWucgd0K8nSmtMLN6f86Vn9CMrNqnXu+wjv5nu482qgWBXcChYbd0EEII0fDq1ALz+eefX7IsODiY9evXX/EcISEh/Prrr5etM2DAAHbu3FmX0JqElftyUBToHOyBv3vD7DpdFzqdjls6B/JR/H52/bGO0ZG3grH5t8OcKa5ga/ppAIZFnm0JszOCV2sIvVHDyIQQQtSXOs9CEpe2svqv/kjtu4+qjYwOoOPKuwnOOs6xvS1o2bXpt2Rdq/gDuZgtCu0DTAR7nV0JOmqMerOYtQ1OCCFEvZDNHOtJxqkSDmQVYNDrGNKh6SQw3q4OFHmqA6Rzdi67Qu3mYdU+dRzSRRNJvaGRoxFCCNEQJIGpJ9WDd3uFeeHp0rTWW3GIGgWA7/F4dR2UZqzmOKSzCUxeJlRVaBeUEEKIeicJTD1QFIWV1r/6tR+8+2cd+sRyRueOQ1UhubtXaR1Og1q1/9w4JD/T2XFIS6bABz3PDeQVQghh8ySBqQcHc4o4cqoEo52e/hE+WodzAZOzIyleAwDI2/69tsE0sFV/HodUchpy9kJlGbRoq2FkQggh6pMkMPWgesXXG9u2wNWhaY6LNnQcDYBX9u9Qpt1Glw0p83QJ+44XoNfpGFw9DunIJlAU8GkHrr7aBiiEEKLeSAJzjSwWhRVNuPuoWtfuMRzRBaJUVVBwYK3W4TSI6taXHqGeeLkYoaoc/vhILQy7ScPIhBBC1Lem2VxgQ3YdzSO3oBxXBzv6hntrHc4l+bk78anvQ+w+pedupQe3ah1QA6hOYGI7nk0kN86Gkyng7A3dH9AwMiGEEPVNWmCuUfXaL/0jfHCwa9pTdAOjB5KuC2L9wRNah1LvDuUWkXqiCHuDngERPpC5BbZ9oRYOew1cmm5yKYQQou4kgbkGlWYL8fv/9Fd/Ezbg7ADjLWmnKS5rXtOpq1tf+rT2xs3RHgqzwWCE6DsgfLDG0QkhhKhv0oV0DbamnSavpBIvFyM9Qjy1DueKwlq4EO1eRuzpryn5ajYuj/wIOp3WYV0zRVGsi9dZN9GMvAX8o8BFBu4KIURzJC0w16C6+2hwB1/sDE3/rdTpdPRs25IbLNtwOJEEJw5oHVK92JdVwNEzpTjaG7gxvMW5Aq/W4OCqXWBCCCEaTNP/1m2iyirNrEvOBZr27KM/69sxjM36LlSYLZj3/Kh1OPXCuvZLmB1Oi+6Go9s1jkgIIURDkwTmKm08dJKSCjMB7o5Et3TXOpxaiwp0Z5vTDSgKlCX9ZPObG1osiprAKAoPlXwBWbtgzatgsWgdmhBCiAYkCcxVqt77aGikH3q97Ywj0et1uHcYTCEuWIpOQEaC1iFdk8SjeZwoLGeUXQJ+JzaBwR6G/xP08k9bCCGaM/lf/ioUllWy8dApwDZmH/3Zje0DWK/vRUWVBWXfT1qHc01W7cvBTznB48p36AD6PQm+7bUOSwghRAOTBOYqrEs+QaXZQmgLF8J9bW+QaI9QLxKMfbEoChUHVkBFidYhXZVKs4W1+47ztPkL3PQV0LI79JAF64QQ4nogCcxVWHnehoE6G5yGbLTT06Jdb7bpotnicydYqrQO6apsSz/DwKJfieYQ9k6uMOIt0DftxQSFEELUD1kHpo5OFZWzLf00YJvdR9X6R/jy4v4nCS124UZHk9bhXJWVe7PopKRhtNOjG/ACeLTSOiQhhBCNRBKYOoo/kIvZohAZaCLYy1nrcK5a3zbe2Bv0pJ8qJv1kMaEtXLQOqU7KKs2sO3iSpYZJRA2uwC16pNYhCSGEaETShVRHK/c2/Z2na8PN0Z7uIZ44KOWkbVwAqWu0DqlONqWepLi8Cj93J9r0GtksVhQWQghRe9ICUwcWi0KXYA9OFFUwNNJP63CuWf92PrQ4tJCuu+dDYVdoM0jrkGptbdIRHJRyhkWG2NQ0diGEEPVDWmDqQK/X8cSgtvz4eF983By0Duea3dTOh991PSk3gzkrCU6lah1SrRSWVaI7uJyFVX9jfNEXWocjhBBCA5LAXAVbnHl0MT5uDgQHBbFdF0VFlQX2/6x1SLWy/uAJIs37MeoteHr5aB2OEEIIDUgCc50bEOFDvD7mbALzi00swb9iTzadlWQc7PTogntrHY4QQggNSAJznevfzoctuk7kW4xY8o/C8R1ah3RZp4rKOZqeTAvlNA4ODhDYVeuQhBBCaEASmOtciLcLAS282KzrorbCHF6ndUiXFX8gl47mA9gZdNgFdgaj7U5lF0IIcfUkgRH0j/AhUddBTWAKjmkdzmWt3JtNJ+UADnYGkO4jIYS4bkkCI+jfzoeNum7c6zCLiuEztQ7nko7nlbI7M49OZ8e/SAIjhBDXL0lgBJEBJlzcPDhe4WLdJqEpWrUvBwMWtvrcgSEiFgK7aB2SEEIIjUgCI9DrdQxsr05HXr43GxRF44gubsXebMw6A6a+98Mt/wF7J61DEkIIoRFJYAQAI6ICCFWO0n/381R9d6/W4VzgUG4Rh3KLsDfoGdjeV+twhBBCaEwSGAFAx0ATnp6edDLvpfLIFigv1DqkGlbuU1uGHmmxG1Pp8SbbSiSEEKJxSAIjAHV14T5dOpGta0F5RSUcazrrwSiKwsq9OQSSw7iT78PcODBXaB2WEEIIDUkCI6xGRAWQpIug0myh8NBGrcOx2nOsgON5pfTUH1SnTwd2ATvb34tKCCHE1ZMERlj5uztS4tsDgLzkDRpHc87KfdkADHU7gg5k+rQQQghJYERNoV0HAOB85gBKWYGmsQBUmS2s2pcDikJH8wH1oCQwQghx3ZMERtTQt2s0OXpfLBYLabt+1zocdmTkcbq4gvaOJ3GuygM7IwR01josIYQQGpMERtTgbLTjlG8MO3Qd2XikSOtwWLFX7T4a63tM7T4K7CrjX4QQQkgCIy7kPPwfvGg3lS8z/dT9kRpCyWnYveCyVSqqLKxNzgWgt32qelC6j4QQQgB2Wgcgmp5urTzxNTmQW1DO7yknGNzBr35foLwIvhwJpWfAIwRaXTwp2ZR6kqKyKnzcHPAe/SYc3w7e4fUbixBCCJskLTDiAga9jhFRAXgpeazfubd+T34qFQxGiBih/rzuTbCYL1p1xd4cAIZF+qN39oTwIeAZWr/xCCGEsEmSwIiLuqt8Ef+reoag1AWcLq6nReMsZlj0AHx8k5qMOLhB7gHY+8MFVYvLq/g95QQAsVH13AIkhBDC5kkCIy7Kq1UkdgYdHS0HWHl2IO01O7IJCrNBMUNQD4h5XD2+YdYFWxesP3iCiioLrbyciUidCxtnQ15m/cQhhBDC5kkCIy4uuBeOdgbClSPE7zpUP+dMWqjeR45WZxJ1nQAeraD4JPzxsbWaoijM36omK7GRvugSv4GEOVB8on7iEEIIYfPqlMB8+OGHdOrUCZPJhMlkIiYmhmXLllnLy8rKmDx5Mt7e3ri6ujJmzBhycnJqnCMjI4O4uDicnZ3x9fXl2WefpaqqqkaddevW0a1bNxwcHAgPD2fu3LlXf4Xi6rj5Y+8digEFY/ZODuVe4+aOxacgdY36OPpO9d5gDwP+T328fa61hWXDoZMcyCrA0d7A2LAydbCvvSP4R19bDEIIIZqNOiUwQUFBvPXWW2zfvp1t27YxaNAgRo8ezd696kDPqVOn8ssvv7Bw4ULWr1/P8ePHuf32263PN5vNxMXFUVFRwaZNm/jqq6+YO3cuL730krVOWloacXFxDBw4kMTERKZMmcJDDz3EihUr6umSRW3ZhfbBaKcnWjnIr0nX2I2070cwV6pJiE/EueNtBkFoP4gaA0YXFEXh09/TALizexDuJ3eq9Vp2VxMeIYQQAkC5Rp6enspnn32m5OXlKfb29srChQutZfv371cAJSEhQVEURfn1118VvV6vZGdnW+t8+OGHislkUsrLyxVFUZTnnntO6dixY43XGDdunBIbG1unuPLz8xVAyc/Pv9pLE/t+VsreClc2vtxfGf7v35TKKvPVncdiUZTPhyvKO+0UJXH+heXmKuvD3w7mKj1fX6Xc+M81yumickX58XH1eZs/usqLEEIIYUtq+/191WNgzGYz8+fPp7i4mJiYGLZv305lZSVDhgyx1mnfvj2tWrUiISEBgISEBKKjo/HzOzerJDY2loKCAmsrTkJCQo1zVNepPsellJeXU1BQUOMmrlFQL4wGPW3JoKzwDFvTz1zdeU4cgNOH1W6g9iMvLNcbAHXsy2e/p4GicGf3IDyd7CBzq1onuNdVXoQQQojmqM4JTFJSEq6urjg4ODBp0iR++OEHIiMjyc7Oxmg04uHhUaO+n58f2dlq90N2dnaN5KW6vLrscnUKCgooLS29ZFwzZszA3d3degsODq7rpYk/c/ND1/sRNrR7nioMLE06fnXn8e0A9y2B2DfVqdOXsH3HNu7KfJWR+s3c0ycETh6EsnywdwK/qKu8CCGEEM1RnROYiIgIEhMT+eOPP3jssceYOHEi+/bta4jY6mTatGnk5+dbb5mZMuW2Xtz4NO36/4VynQPrkk9QVF515edcTIu20D7uksWKorBnw890V/Yw2f5nPO0qoOCYmvAE9ZDxL0IIIWqocwJjNBoJDw+ne/fuzJgxg86dOzN79mz8/f2pqKggLy+vRv2cnBz8/f0B8Pf3v2BWUvXPV6pjMplwcnK6ZFwODg7W2VHVN1E/IgNMhLZwoaLKQvz+nCs/4XyW2u2ltPHQKT4u7EeO3hdv8mHLJxA+GCb/ASPevoqohRBCNGfXvA6MxWKhvLyc7t27Y29vT3x8vLUsOTmZjIwMYmJiAIiJiSEpKYnc3FxrnVWrVmEymYiMjLTWOf8c1XWqzyEany5rF0+7r8NFKeHXpKy6PXnBBFgyFfKPXrKKoih8+vthzDo7UiOfQK/TwbYv1efoDeDsdY1XIIQQormpUwIzbdo0fvvtN9LT00lKSmLatGmsW7eO8ePH4+7uzoMPPshTTz3F2rVr2b59O/fffz8xMTH06dMHgGHDhhEZGcmECRPYtWsXK1asYPr06UyePBkHBwcAJk2axOHDh3nuuec4cOAAc+bMYcGCBUydOrX+r17UzrLn6ZH5JVGksDMjj2N5lx6LVMOJZDi6DVJWgd2lW882HjrF/rPrvtw4fBy06gPmCvjtX/V0AUIIIZqbOiUwubm53HvvvURERDB48GC2bt3KihUrGDp0KACzZs3i5ptvZsyYMdx00034+/uzePFi6/MNBgNLlizBYDAQExPDPffcw7333surr75qrRMWFsbSpUtZtWoVnTt3ZubMmXz22WfExsbW0yWLOgvuhUGnY7h7BgDvrU5BUZQrP6965d02g8DF+6JVqltfQF33xcvVAQa+oBYmL4O1M645fCGEEM2PTqnVN5HtKSgowN3dnfz8fBkPc60OLIUlT1Hk0Y7Yk1OpNFt4elg7xvVsdennVJXDRzdAWQGM+QzCbrxotY2HTjL1u0Qc7Q38OLkfXi5GtSD+Vdg5D4a9Dp3ubICLEkII0RTV9vtb9kISVxbUEwDX/BSeulGd4v5e/CH2HMu/9HNSVqnJiykAQvpetMoFrS/VyQvAwOkw8WeIvqN+rkEIIUSzIgmMuDJXX/AKA0Xhdr9sBkb4Umm28Pcfkigoq7z4c6q7j6LGWBeq+7NNqafYd1wd+zK+T0jNQr1e3XJAp6vHCxFCCNFcSAIjaufsSri6zC1Mv7kDLT2dyMov45Wf9104HubMEcjYrCYfHW+/yMlqtr7c8efWFyGEEOIKJIERtRPcW73PSsTN0Z4Zt0djb9Dze8oJ5v2RUbOukwf0fxY6jQP3lhc9XXXri4O9Xl11VwghhKgDSWBE7YTeCHd9A+O+BqC9v4mpQ9sBMGftIXYfzTtX19Edej4EQ1+56Klqjn0JltYXIYQQdWandQDCRjiaoGV39fGRTbD+n4yxd6KtSyVp+ZD+tRPturTG0ckNIkaA/8X3LjJbFBbvOCqtL0IIIa6JJDCi7opPQu4BdEA0CsG6SsxlCuXbNuHgaI/Op90FCUxphZlfdh/n2y0ZHDujLoQ3VlpfhBBCXCVJYETdteqjru1SWYK+soTKU6f5+vcD2JnL6O/nQhfvttaqJwrLWbg9k++3H6WwTN0I0uRkz53dg3jghjCtrkAIIYSNkwRG1J2rr3o7yw8INx3jjaX7+TZTx5zyANxPFPHNHxks35NNpVnd0DHI04m7e4dwc6cAHO0vPrVaCCGEqA1JYES9uKVzIDsz8vg1KYsp8xMpqzRbyzoFuTO+Twg3tfXBoJd1XYQQQlw7SWBEvdDpdDw/vD37sgpIP1mMTgcDI3wZ3zuE6CB3rcMTQgjRzEgCI+qNk9HA+3d1ZdX+HG5q60Owl7PWIQkhhGimJIER9crX5Mj43jI1WgghRMOSheyEEEIIYXMkgRFCCCGEzZEERgghhBA2RxIYIYQQQtgcSWCEEEIIYXMkgRFCCCGEzZEERgghhBA2RxIYIYQQQtgcSWCEEEIIYXMkgRFCCCGEzZEERgghhBA2RxIYIYQQQtgcSWCEEEIIYXOa7W7UiqIAUFBQoHEkQgghhKit6u/t6u/xS2m2CUxhYSEAwcHBGkcihBBCiLoqLCzE3d39kuU65Uopjo2yWCwcP34cNzc3dDpdvZ23oKCA4OBgMjMzMZlM9XZecXXk82h65DNpWuTzaFrk87gyRVEoLCwkMDAQvf7SI12abQuMXq8nKCiowc5vMpnkH18TIp9H0yOfSdMin0fTIp/H5V2u5aWaDOIVQgghhM2RBEYIIYQQNkcSmDpycHDgH//4Bw4ODlqHIpDPoymSz6Rpkc+jaZHPo/4020G8QgghhGi+pAVGCCGEEDZHEhghhBBC2BxJYIQQQghhcySBEUIIIYTNkQSmjj744ANCQ0NxdHSkd+/ebNmyReuQbM5vv/3GqFGjCAwMRKfT8eOPP9YoVxSFl156iYCAAJycnBgyZAgpKSk16pw+fZrx48djMpnw8PDgwQcfpKioqEad3bt3c+ONN+Lo6EhwcDBvv/32BbEsXLiQ9u3b4+joSHR0NL/++mu9X29TN2PGDHr27Imbmxu+vr7ceuutJCcn16hTVlbG5MmT8fb2xtXVlTFjxpCTk1OjTkZGBnFxcTg7O+Pr68uzzz5LVVVVjTrr1q2jW7duODg4EB4ezty5cy+I53r/Hfvwww/p1KmTdaGzmJgYli1bZi2Xz0Jbb731FjqdjilTpliPyWeiEUXU2vz58xWj0ah88cUXyt69e5WHH35Y8fDwUHJycrQOzab8+uuvyt///ndl8eLFCqD88MMPNcrfeustxd3dXfnxxx+VXbt2KbfccosSFhamlJaWWusMHz5c6dy5s7J582bl999/V8LDw5W77rrLWp6fn6/4+fkp48ePV/bs2aN8++23ipOTk/Lxxx9b62zcuFExGAzK22+/rezbt0+ZPn26Ym9vryQlJTX4e9CUxMbGKl9++aWyZ88eJTExURk5cqTSqlUrpaioyFpn0qRJSnBwsBIfH69s27ZN6dOnj9K3b19reVVVlRIVFaUMGTJE2blzp/Lrr78qLVq0UKZNm2atc/jwYcXZ2Vl56qmnlH379in/+c9/FIPBoCxfvtxaR37HFOXnn39Wli5dqhw8eFBJTk5WXnjhBcXe3l7Zs2ePoijyWWhpy5YtSmhoqNKpUyflySeftB6Xz0QbksDUQa9evZTJkydbfzabzUpgYKAyY8YMDaOybX9OYCwWi+Lv76+888471mN5eXmKg4OD8u233yqKoij79u1TAGXr1q3WOsuWLVN0Op1y7NgxRVEUZc6cOYqnp6dSXl5urfP8888rERER1p/Hjh2rxMXF1Yind+/eyqOPPlqv12hrcnNzFUBZv369oijq+29vb68sXLjQWmf//v0KoCQkJCiKoialer1eyc7Ottb58MMPFZPJZP0MnnvuOaVjx441XmvcuHFKbGys9Wf5Hbs4T09P5bPPPpPPQkOFhYVK27ZtlVWrVin9+/e3JjDymWhHupBqqaKigu3btzNkyBDrMb1ez5AhQ0hISNAwsuYlLS2N7OzsGu+zu7s7vXv3tr7PCQkJeHh40KNHD2udIUOGoNfr+eOPP6x1brrpJoxGo7VObGwsycnJnDlzxlrn/NeprnO9f575+fkAeHl5AbB9+3YqKytrvFft27enVatWNT6T6Oho/Pz8rHViY2MpKChg79691jqXe7/ld+xCZrOZ+fPnU1xcTExMjHwWGpo8eTJxcXEXvG/ymWin2W7mWN9OnjyJ2Wyu8Q8QwM/PjwMHDmgUVfOTnZ0NcNH3ubosOzsbX1/fGuV2dnZ4eXnVqBMWFnbBOarLPD09yc7OvuzrXI8sFgtTpkyhX79+REVFAer7ZTQa8fDwqFH3z5/Jxd7L6rLL1SkoKKC0tJQzZ87I79hZSUlJxMTEUFZWhqurKz/88AORkZEkJibKZ6GB+fPns2PHDrZu3XpBmfx+aEcSGCGE1eTJk9mzZw8bNmzQOpTrWkREBImJieTn57No0SImTpzI+vXrtQ7rupSZmcmTTz7JqlWrcHR01DoccR7pQqqlFi1aYDAYLhhZnpOTg7+/v0ZRNT/V7+Xl3md/f39yc3NrlFdVVXH69OkadS52jvNf41J1rtfP84knnmDJkiWsXbuWoKAg63F/f38qKirIy8urUf/Pn8nVvt8mkwknJyf5HTuP0WgkPDyc7t27M2PGDDp37szs2bPls9DA9u3byc3NpVu3btjZ2WFnZ8f69et57733sLOzw8/PTz4TjUgCU0tGo5Hu3bsTHx9vPWaxWIiPjycmJkbDyJqXsLAw/P39a7zPBQUF/PHHH9b3OSYmhry8PLZv326ts2bNGiwWC71797bW+e2336isrLTWWbVqFREREXh6elrrnP861XWut89TURSeeOIJfvjhB9asWXNB11v37t2xt7ev8V4lJyeTkZFR4zNJSkqqkViuWrUKk8lEZGSktc7l3m/5Hbs0i8VCeXm5fBYaGDx4MElJSSQmJlpvPXr0YPz48dbH8ploROtRxLZk/vz5ioODgzJ37lxl3759yiOPPKJ4eHjUGFkurqywsFDZuXOnsnPnTgVQ3n33/9u3f5DUwjiM4wpyRJE0UBwEA6GWFlsCwU0QnMLRQcQmbY3AJVod5C7S3CptDYI4pIJDQpCJIE3Z5CQIQQ0OT0Mk16vLvXCxl74feKfzcv7w48DD4Ty/9PDwoJeXF0mfNWqfz6ebmxsNBgMdHR2trVEfHByo1+up2+1qd3d3qUY9m80UDAaVzWY1HA5Vq9XkdrtXatQOh0OVSkWj0UgXFxc/skZdLBbl9XrVbrc1mUwW6+3tbbGnUCgoHA7r9vZW9/f3isViisVii+NfNdFkMql+v69Go6FAILC2Jnp2dqbRaKTLy8u1NdGf/o6VSiV1Oh09Pz9rMBioVCrJbrer2WxKYhbfwe8tJImZbAoB5i9Vq1WFw2FZlqXDw0Pd3d1t+paM02q1ZLPZVlYul5P0WaU+Pz9XMBiU0+lUIpHQ09PT0jmm06kymYw8Ho+2traUz+f1+vq6tOfx8VHxeFxOp1OhUEjlcnnlXq6vr7W3tyfLsrS/v696vf7fnvu7WjcLm82mq6urxZ7393ednJxoe3tbbrdb6XRak8lk6Tzj8VipVEoul0t+v1+np6eaz+dLe1qtlqLRqCzLUiQSWbrGl5/+jh0fH2tnZ0eWZSkQCCiRSCzCi8QsvoM/Awwz2Qy7JG3m2w8AAMC/4R8YAABgHAIMAAAwDgEGAAAYhwADAACMQ4ABAADGIcAAAADjEGAAAIBxCDAAAMA4BBgAAGAcAgwAADAOAQYAABiHAAMAAIzzAbM/ZXsFnkrwAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Visualize\n", "fig, ax = plt.subplots()\n", @@ -522,7 +796,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "5117408a-b1a2-45c8-89b4-e44f9c447af1", "metadata": {}, "outputs": [], @@ -533,7 +807,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "e2c6567f-12ce-4428-a07d-d46928020610", "metadata": {}, "outputs": [], @@ -552,10 +826,78 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "dfec9e66-e7ba-4e8f-a78a-e6140fd4f66d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampling times: [0. 0.01 0.02 0.03 0.04 0.05 0.07 0.09 0.1 0.16 0.18 0.21 0.23 0.25\n", + " 0.26 0.27 0.28 0.29 0.36 0.38 0.39 0.42 0.43 0.44 0.45 0.47 0.48 0.49]\n", + "Number of observations: 28\n", + "Number of locations at each timestep: 2\n", + "Sampling location indices: [1 2]\n", + "Observation values: [[-15.45142174 22.03606281]\n", + " [-14.4686044 21.99438985]\n", + " [-15.32430972 22.68675841]\n", + " [-16.77319336 22.06791687]\n", + " [-17.81345853 24.96373146]\n", + " [-16.13824323 29.16772615]\n", + " [-15.50613068 29.88428784]\n", + " [-14.31334733 30.36502765]\n", + " [-13.93197312 32.16670006]\n", + " [ -8.32738498 39.13311118]\n", + " [ -3.0457868 37.35421371]\n", + " [ -2.37955399 35.25509374]\n", + " [ -3.30238542 31.5764011 ]\n", + " [ -0.86401254 31.18756508]\n", + " [ -2.10580353 30.92742188]\n", + " [ -0.99884478 30.53835263]\n", + " [ -1.77255489 29.56852812]\n", + " [ -2.37159018 30.44662647]\n", + " [ 0.9597602 22.67620324]\n", + " [ -0.72211118 22.67191287]\n", + " [ -1.26576014 22.48505748]\n", + " [ -0.25174667 21.54320443]\n", + " [ -3.1486213 20.41526382]\n", + " [ -2.17987056 18.76455319]\n", + " [ -2.05666771 19.32987016]\n", + " [ -0.8952854 18.22832462]\n", + " [ -2.32176499 15.07322177]\n", + " [ -5.35836951 18.10055608]]\n", + "Errors: [[-0.45142174 0.73606357]\n", + " [ 1.01576454 -0.28790248]\n", + " [ 0.56009434 -0.67390748]\n", + " [-0.59306149 -2.45704052]\n", + " [-1.46147618 -0.79633185]\n", + " [ 0.24388307 2.12203889]\n", + " [ 0.45782526 0.22151008]\n", + " [ 0.56270844 -1.76397961]\n", + " [ 0.16434548 -1.05459161]\n", + " [-0.66304837 2.80828049]\n", + " [ 2.55700582 1.39961255]\n", + " [ 0.82219988 0.76978617]\n", + " [-1.18360809 -1.56974966]\n", + " [ 0.54517751 -0.49476701]\n", + " [-0.93303725 -0.00682879]\n", + " [ 0.00361078 0.35166705]\n", + " [-0.88366757 0.12301952]\n", + " [-1.54827906 1.73168695]\n", + " [ 2.1205409 -1.36885064]\n", + " [ 0.66831873 -0.19389598]\n", + " [ 0.25124152 0.18359375]\n", + " [ 1.68680731 0.83585131]\n", + " [-1.05512813 0.20664139]\n", + " [ 0.07664173 -0.96164471]\n", + " [ 0.3717697 0.06969017]\n", + " [ 1.90783444 -0.1498703 ]\n", + " [ 0.68652057 -2.88966756]\n", + " [-2.1312222 0.5352165 ]]\n" + ] + } + ], "source": [ "# Let's examine that object\n", "print('Sampling times: ', obs_vec_l63_p.times) # 28 out of 50 timesteps are sampled\n", From 33f72b39eba1139f875df28792eb23ac38658360 Mon Sep 17 00:00:00 2001 From: Kylen Solvik Date: Wed, 12 Jun 2024 11:49:04 -0600 Subject: [PATCH 3/3] Workin GCP example for era5 data download --- .../4-era5-data-download.ipynb | 293 +++--------------- 1 file changed, 38 insertions(+), 255 deletions(-) diff --git a/examples/data_generators/4-era5-data-download.ipynb b/examples/data_generators/4-era5-data-download.ipynb index fd869d7..fbb2a07 100644 --- a/examples/data_generators/4-era5-data-download.ipynb +++ b/examples/data_generators/4-era5-data-download.ipynb @@ -1,23 +1,15 @@ { "cells": [ - { - "cell_type": "markdown", - "id": "bbec98e7-540d-4f73-9c2a-6eb1e31ab4b2", - "metadata": {}, - "source": [ - "NOTE: AWS deprecated ERA5 data, and so this notebook no longer works. " - ] - }, { "cell_type": "markdown", "id": "d6e78334", "metadata": {}, "source": [ - "# 4. Example: Download era5 from cloud provider\n", + "# 4. Example: Download era5 from Google Cloud\n", "\n", - "DataAssimBench provides interfaces to ECWMF ERA5 data hosted on Google Cloud, Amazon Web Services, and Microsoft Azure.\n", + "DataAssimBench provides interfaces to ECWMF ERA5 data hosted on Google Cloud.\n", "\n", - "In this example, we'll walk through loading data from Amazon Web Services (AWS) into a dabench data object." + "In this example, we'll walk through loading data from Google Cloud into a dabench data object." ] }, { @@ -38,219 +30,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + ":241: UserWarning: No pyfftw detected. Using numpy.fft\n" ] } ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "from dabench import data" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e2c7a6ac", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on class AWS in module dabench.data.aws:\n", - "\n", - "class AWS(dabench.data._data.Data)\n", - " | AWS(variables=['air_temperature_at_2_metres'], months=['01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12'], years=[2020], min_lat=19.8554808619, max_lat=23.1886107447, min_lon=-84.9749110583, max_lon=-74.1780248685, system_dim=None, time_dim=None, store_as_jax=False, **kwargs)\n", - " | \n", - " | Class for loading ERA5 data from AWS Open Data\n", - " | \n", - " | Notes:\n", - " | Source: https://registry.opendata.aws/ecmwf-era5/\n", - " | Data is HRES sub-daily.\n", - " | \n", - " | Attributes:\n", - " | system_dim (int): System dimension\n", - " | time_dim (int): Total time steps\n", - " | variables (list of strings): Names of ERA5 variables to load.\n", - " | For list of variables, see:\n", - " | https://github.com/planet-os/notebooks/blob/master/aws/era5-pds.md\n", - " | NOTE: Do NOT include .nc extension in variable name.\n", - " | Default is ['air_temperature_at_2_metres']\n", - " | months (list of strings): List of months to include in '01', '02', etc.\n", - " | format.\n", - " | years (list of integers): List of years to include. Data is available\n", - " | from 1979 to present.\n", - " | min_lat (float): Minimum latitude for bounding box. If None, loads\n", - " | global data (which can be VERY large). Bounding box default covers\n", - " | Cuba.\n", - " | max_lat (float): Max latitude for bounding box (see min_lat for info).\n", - " | min_lon (float): Min latitude for bounding box (see min_lat for info).\n", - " | max_lon (float): Max latitude for bounding box (see min_lat for info).\n", - " | store_as_jax (bool): Store values as jax array instead of numpy array.\n", - " | Default is False (store as numpy).\n", - " | \n", - " | Method resolution order:\n", - " | AWS\n", - " | dabench.data._data.Data\n", - " | builtins.object\n", - " | \n", - " | Methods defined here:\n", - " | \n", - " | __init__(self, variables=['air_temperature_at_2_metres'], months=['01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12'], years=[2020], min_lat=19.8554808619, max_lat=23.1886107447, min_lon=-84.9749110583, max_lon=-74.1780248685, system_dim=None, time_dim=None, store_as_jax=False, **kwargs)\n", - " | Initializes the base data object\n", - " | \n", - " | generate(self)\n", - " | Alias for _load_aws_era5\n", - " | \n", - " | load(self)\n", - " | Alias for _load_aws_era5\n", - " | \n", - " | ----------------------------------------------------------------------\n", - " | Methods inherited from dabench.data._data.Data:\n", - " | \n", - " | calc_lyapunov_exponents_final(self, total_time=None, rescale_time=1, convergence=0.05, x0=None)\n", - " | Computes the final Lyapunov Exponents\n", - " | \n", - " | Notes:\n", - " | See self.calc_lyapunov_exponents_series for full info\n", - " | \n", - " | Args:\n", - " | total_time (float) : Time to integrate over to compute LEs.\n", - " | Usually there's a tradeoff between accuracy and computation\n", - " | time (more total_time leads to higher accuracy but more\n", - " | computation time). Default depends on model type and are based\n", - " | roughly on how long it takes for satisfactory convergence:\n", - " | For Lorenz63: n_steps=15000 (total_time=150 for delta_t=0.01)\n", - " | For Lorenz96: n_steps=50000 (total_time=500 for delta_t=0.01)\n", - " | rescale_time (float) : Time for when the algorithm rescales the\n", - " | propagator to reduce the exponential growth in errors.\n", - " | Default is 1 (i.e. 100 timesteps when delta_t = 0.01).\n", - " | convergence (float) : Prints warning if LE convergence is below\n", - " | this number. Default is 0.01.\n", - " | x0 (array) : initial condition to start computing LE. Needs\n", - " | to be on the attractor (i.e., remove transients). Default is\n", - " | None, which will fallback to use the x0 set during model object\n", - " | initialization.\n", - " | \n", - " | Returns:\n", - " | Lyapunov exponents array of size (system_dim)\n", - " | \n", - " | calc_lyapunov_exponents_series(self, total_time=None, rescale_time=1, convergence=0.01, x0=None)\n", - " | Computes the spectrum of Lyapunov Exponents.\n", - " | \n", - " | Notes:\n", - " | Lyapunov exponents help describe the degree of \"chaos\" in the\n", - " | model. Make sure to plot the output to check that the algorithm\n", - " | converges. There are three ways to make the estimate more accurate:\n", - " | 1. Decrease the delta_t of the model\n", - " | 2. Increase total_time\n", - " | 3. Decrease rescale time (try increasing total_time first)\n", - " | Algorithm: Eckmann 85,\n", - " | https://www.ihes.fr/~ruelle/PUBLICATIONS/%5B81%5D.pdf pg 651\n", - " | This method computes the full time series of Lyapunov Exponents,\n", - " | which is useful for plotting for debugging. To get only the final\n", - " | Lyapunov Exponent, use self.calc_lyapunov_exponents.\n", - " | \n", - " | Args:\n", - " | total_time (float) : Time to integrate over to compute LEs.\n", - " | Usually there's a tradeoff between accuracy and computation\n", - " | time (more total_time leads to higher accuracy but more\n", - " | computation time). Default depends on model type and are based\n", - " | roughly on how long it takes for satisfactory convergence:\n", - " | For Lorenz63: n_steps=15000 (total_time=150 for delta_t=0.01)\n", - " | For Lorenz96: n_steps=50000 (total_time=500 for delta_t=0.01)\n", - " | rescale_time (float) : Time for when the algorithm rescales the\n", - " | propagator to reduce the exponential growth in errors.\n", - " | Default is 1 (i.e. 100 timesteps when delta_t = 0.01).\n", - " | convergence (float) : Prints warning if LE convergence is below\n", - " | this number. Default is 0.01.\n", - " | x0 (array) : initial condition to start computing LE. Needs\n", - " | to be on the attractor (i.e., remove transients). Default is\n", - " | None, which will fallback to use the x0 set during model object\n", - " | initialization.\n", - " | \n", - " | Returns:\n", - " | Lyapunov exponents for all timesteps, array of size\n", - " | (total_time/rescale_time - 1, system_dim)\n", - " | \n", - " | load_netcdf(self, filepath=None, include_vars=None, exclude_vars=None, years_select=None, dates_select=None, lat_sorting='descending')\n", - " | Loads values from netCDF file, saves them in values attribute\n", - " | \n", - " | Args:\n", - " | filepath (str): Path to netCDF file to load. If not given,\n", - " | defaults to loading ERA5 ECMWF SLP data over Japan\n", - " | from 2018 to 2021.\n", - " | include_vars (list-like): Data variables to load from NetCDF. If\n", - " | None (default), loads all variables. Can be used to exclude bad\n", - " | variables.\n", - " | exclude_vars (list-like): Data variabes to exclude from NetCDF\n", - " | loading. If None (default), loads all vars (or only those\n", - " | specified in include_vars). It's recommended to only specify\n", - " | include_vars OR exclude_vars (unless you want to do extra\n", - " | typing).\n", - " | years_select (list-like): Years to load (ints). If None, loads all\n", - " | timesteps.\n", - " | dates_select (list-like): Dates to load. Elements must be\n", - " | datetime date or datetime objects, depending on type of time\n", - " | indices in NetCDF. If both years_select and dates_select\n", - " | are specified, time_stamps overwrites \"years\" argument. If\n", - " | None, loads all timesteps.\n", - " | lat_sorting (str): Orient data by latitude:\n", - " | descending (default), ascending, or None (uses orientation\n", - " | from data file).\n", - " | \n", - " | rhs_aux(self, x, t)\n", - " | The auxiliary model used to compute the TLM.\n", - " | \n", - " | Args:\n", - " | x (ndarray): State vector with size (system_dim)\n", - " | t (ndarray): Array of times with size (time_dim)\n", - " | \n", - " | Returns:\n", - " | dxaux (ndarray): State vector [size: (system_dim,)]\n", - " | \n", - " | sample_cells(self, targets)\n", - " | Samples values at a list of multidimensional array indices.\n", - " | \n", - " | Args:\n", - " | targets (ndarray): Array of target indices in shape:\n", - " | (num_of_target_indices, time_dim + original_dim). E.g.\n", - " | [[0,0], [0,1]] samples the first and second cell values in the\n", - " | first timestep (in this case original_dim = 1).\n", - " | \n", - " | save_netcdf(self, filename)\n", - " | Saves values in values attribute to netCDF file\n", - " | \n", - " | Args:\n", - " | filepath (str): Path to netCDF file to save\n", - " | \n", - " | ----------------------------------------------------------------------\n", - " | Readonly properties inherited from dabench.data._data.Data:\n", - " | \n", - " | values_gridded\n", - " | \n", - " | x0_gridded\n", - " | \n", - " | ----------------------------------------------------------------------\n", - " | Data descriptors inherited from dabench.data._data.Data:\n", - " | \n", - " | __dict__\n", - " | dictionary for instance variables (if defined)\n", - " | \n", - " | __weakref__\n", - " | list of weak references to the object (if defined)\n", - " | \n", - " | values\n", - " | \n", - " | x0\n", - "\n" - ] - } - ], - "source": [ - "# We can find info the options for the AWS data loader by running help()\n", - "help(data.AWS)" + "import dabench as dab" ] }, { @@ -265,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "a401e5d4", "metadata": {}, "outputs": [], @@ -273,26 +60,24 @@ "# The model object is defined in the same way as the model data generators (e.g. Lorenz63).\n", "# But the options vary a bit. In this case we can specify which variables and years to load\n", "# and set a bounding box\n", - "aws_loader = data.AWS(variables = ['air_temperature_at_2_metres'], \n", - " years = [2020, 2021],\n", + "gcp_loader = dab.data.GCP(variables = ['2m_temperature'], \n", " min_lat = 36.992426, max_lat = 41.003444, \n", - " min_lon = -109.060253, max_lon = -102.041524\n", + " min_lon = -109.060253, max_lon = -102.041524,\n", + " date_start='2020-01-01', date_end='2021-12-31'\n", " )" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "f607cb3e", "metadata": {}, "outputs": [], "source": [ - "# To download the data, we can use aws_loader.generate() \n", - "# OR aws_loader.load()\n", - "aws_loader.load()\n", - "# Also works, but .generate() shows a warning because it \n", - "# is a simple alias for .load()\n", - "# aws_loader.generate()" + "# To download the data, we can use gcp_loader.load()\n", + "# gcp_loader.generate() also works, but is just a wrapper around load()\n", + "# Depending on your connection, this may take a minute\n", + "gcp_loader.load()" ] }, { @@ -307,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "4f02f4f8", "metadata": {}, "outputs": [ @@ -316,25 +101,25 @@ "output_type": "stream", "text": [ "(17544, 476)\n", - "[[260.75 258.5625 258.125 ... 275.6875 275.9375 276.0625]\n", - " [260.5 258.5 258.0625 ... 274.375 274.8125 275.25 ]\n", - " [260.875 259.75 259.3125 ... 273.0625 273.4375 273.8125]\n", + "[[260.73407 258.55048 258.115 ... 275.66376 275.90997 276.0577 ]\n", + " [260.51556 258.48276 258.04727 ... 274.365 274.842 275.22058]\n", + " [260.9018 259.77383 259.3291 ... 273.0616 273.45862 273.7941 ]\n", " ...\n", - " [266. 266. 266.5625 ... 286. 286.375 286.8125]\n", - " [264.375 264.4375 265.0625 ... 284.0625 284.6875 285.25 ]\n", - " [264.25 264.4375 264.625 ... 282.625 283. 283.4375]]\n" + " [266.0227 266.0227 266.54797 ... 286.0066 286.40204 286.81412]\n", + " [264.37903 264.4379 265.0869 ... 284.09274 284.71005 285.22476]\n", + " [264.27338 264.46204 264.64166 ... 282.63773 283.0045 283.41653]]\n" ] } ], "source": [ "# In this case, we have 17544 timesteps (24 hours for 731 days, 2020 was a leap year)\n", - "print(aws_loader.values.shape)\n", - "print(aws_loader.values)" + "print(gcp_loader.values.shape)\n", + "print(gcp_loader.values)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "24f9868c", "metadata": {}, "outputs": [ @@ -350,12 +135,12 @@ ], "source": [ "# We can access those timesteps directly:\n", - "print(aws_loader.times)" + "print(gcp_loader.times)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "8dae1030", "metadata": {}, "outputs": [ @@ -369,18 +154,18 @@ ], "source": [ "# Convert each timestep back to 2D\n", - "print(aws_loader.values_gridded.shape)" + "print(gcp_loader.values_gridded.shape)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "01764c83", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -393,11 +178,11 @@ "# Now let's compare air temp in January vs June over Colorado\n", "fig, ax = plt.subplots(1, 2)\n", "fig.suptitle('Air Temp at 2 Metres (K), Colorado')\n", - "ax[0].imshow(aws_loader.values_gridded[12], vmin=250, vmax=300)\n", - "ax[0].set_title(np.datetime_as_string(aws_loader.times[12], unit='h')); ax[0].set_xlabel('Longitude'); ax[0].set_ylabel('Latitude')\n", + "ax[0].imshow(gcp_loader.values_gridded[12], vmin=250, vmax=300)\n", + "ax[0].set_title(np.datetime_as_string(gcp_loader.times[12], unit='h')); ax[0].set_xlabel('Longitude'); ax[0].set_ylabel('Latitude')\n", "ax[0].set_yticks(ticks=[0, 5, 10, 15], labels=[40.75, 39.5, 38.25, 37]); ax[0].set_xticks(ticks=[0, 10, 20], labels=[-109, -106.5, -104])\n", - "ax[1].imshow(aws_loader.values_gridded[3660], vmin=250, vmax=300)\n", - "ax[1].set_title(np.datetime_as_string(aws_loader.times[3660], unit='h')); ax[1].set_xlabel('Longitude'); ax[1].set_ylabel('Latitude')\n", + "ax[1].imshow(gcp_loader.values_gridded[3660], vmin=250, vmax=300)\n", + "ax[1].set_title(np.datetime_as_string(gcp_loader.times[3660], unit='h')); ax[1].set_xlabel('Longitude'); ax[1].set_ylabel('Latitude')\n", "ax[1].set_yticks(ticks=[0, 5, 10, 15], labels=[40.75, 39.5, 38.25, 37]); ax[1].set_xticks(ticks=[0, 10, 20], labels=[-109, -106.5, -104])\n", "fig.tight_layout()\n", "fig.subplots_adjust(top=1.4)\n", @@ -413,11 +198,9 @@ "\n", "This interface is highly flexible. ERA5 offers many different variables that can be used. Multiple variables can be loaded at the same time.\n", "\n", - "You can find the full list of variables here: https://github.com/planet-os/notebooks/blob/master/aws/era5-pds.md#variables\n", - "\n", - "Note that you cannot load forecast variables (denoted by \"fc\" in the table) and analysis variables (\"an\") into the same data object. You can load one or more forecast variables OR one or more analysis variables, but not both.\n", + "You can find the full list of variables here: https://github.com/google-research/arco-era5?tab=readme-ov-file#full_37-1h-0p25deg-chunk-1zarr-v3\n", "\n", - "Let's load air pressure and sea surface temperature data over Cuba (the default bounding box) for 1983. Note that you should not included the \".nc\" extension in your variable list." + "Let's load air pressure and sea surface temperature data over Cuba (the default bounding box) for 1979." ] }, { @@ -428,8 +211,8 @@ "outputs": [], "source": [ "# Cuba is the default bounding box so we don't need to specify that\n", - "cuba_loader = data.AWS(variables = ['air_pressure_at_mean_sea_level', 'sea_surface_temperature'], \n", - " years = [1979]\n", + "cuba_loader = dab.data.GCP(variables = ['mean_sea_level_pressure', 'sea_surface_temperature'], \n", + " date_start='1979-01-01', date_end='1979-12-31'\n", " )\n", "cuba_loader.load()" ] @@ -456,7 +239,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ]