From dda40c050a4eed192b901f203dc97d8d07ad1f6d Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 13 Sep 2024 20:01:25 +0000 Subject: [PATCH 01/32] Bump aiohttp from 3.9.5 to 3.10.2 Bumps [aiohttp](https://github.com/aio-libs/aiohttp) from 3.9.5 to 3.10.2. - [Release notes](https://github.com/aio-libs/aiohttp/releases) - [Changelog](https://github.com/aio-libs/aiohttp/blob/master/CHANGES.rst) - [Commits](https://github.com/aio-libs/aiohttp/compare/v3.9.5...v3.10.2) --- updated-dependencies: - dependency-name: aiohttp dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 768ae44..6e9fc2d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,7 +28,7 @@ keywords = [ "PV", ] dependencies = [ - "aiohttp==3.9.5", + "aiohttp==3.10.2", "numpy==1.26.4", "pvlib==0.10.3", "scipy<1.14.0", From 1b113c388303b588a556eca72cfb9a07e86c2459 Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Sun, 15 Sep 2024 13:14:37 -0600 Subject: [PATCH 02/32] Sparse Interpolation QoL --- pvdeg/geospatial.py | 51 ++++++++++++++++++++++++++++++++++++++------- pvdeg/utilities.py | 46 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 89 insertions(+), 8 deletions(-) diff --git a/pvdeg/geospatial.py b/pvdeg/geospatial.py index d54877e..fbbc234 100644 --- a/pvdeg/geospatial.py +++ b/pvdeg/geospatial.py @@ -927,7 +927,7 @@ def elevation_stochastic_downselect( def interpolate_analysis( - result: xr.Dataset, data_var: str, method="nearest" + result: xr.Dataset, data_var: str, method="nearest", resolution=100j, ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """ Interpolate sparse spatial result data against DataArray coordinates. @@ -935,6 +935,9 @@ def interpolate_analysis( Parameters: ----------- + resolution: complex + Change the amount the input is interpolated. + For more interpolation set higher (200j is more than 100j) Result: ------- @@ -951,8 +954,8 @@ def interpolate_analysis( ) # probably a nicer way to do this grid_lat, grid_lon = np.mgrid[ - df["latitude"].min() : df["latitude"].max() : 100j, - df["longitude"].min() : df["longitude"].max() : 100j, + df["latitude"].min() : df["latitude"].max() : resolution, + df["longitude"].min() : df["longitude"].max() : resolution, ] grid_z = griddata(data[:, 0:2], data[:, 2], xi=(grid_lat, grid_lon), method=method) @@ -960,12 +963,42 @@ def interpolate_analysis( return grid_z, grid_lat, grid_lon -def plot_sparse_analysis(result: xr.Dataset, data_var: str, method="nearest") -> None: +# api could be updated to match that of plot_USA +def plot_sparse_analysis( + result: xr.Dataset, + data_var: str, + method="nearest", + resolution:complex=100j, + figsize:tuple=(10,8), +) -> None: + """ + Plot the output of a sparse geospatial analysis using interpolation. + + Parameters + ----------- + result: xr.Dataset + xarray dataset in memory containing coordinates['longitude', 'latitude'] and at least one datavariable. + data_var: str + name of datavariable to plot from result + method: str + interpolation method. + Options: `'nearest', 'linear', 'cubic'` + See [`scipy.interpolate.griddata`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html) + resolution: complex + Change the amount the input is interpolated. + For more interpolation set higher (200j is more than 100j) + + Returns + ------- + fig, ax: tuple + matplotlib figure and axes of plot + """ + grid_values, lat, lon = interpolate_analysis( - result=result, data_var=data_var, method=method + result=result, data_var=data_var, method=method, resolution=resolution ) - fig = plt.figure() + fig = plt.figure(figsize=figsize) ax = fig.add_axes([0, 0, 1, 1], projection=ccrs.LambertConformal(), frameon=False) ax.patch.set_visible(False) @@ -977,7 +1010,7 @@ def plot_sparse_analysis(result: xr.Dataset, data_var: str, method="nearest") -> origin="lower", cmap="viridis", transform=ccrs.PlateCarree(), - ) # should this be trnsposed + ) shapename = "admin_1_states_provinces_lakes" states_shp = shpreader.natural_earth( @@ -994,7 +1027,9 @@ def plot_sparse_analysis(result: xr.Dataset, data_var: str, method="nearest") -> cbar = plt.colorbar(img, ax=ax, orientation="vertical", fraction=0.02, pad=0.04) cbar.set_label("Value") - plt.title("Interpolated Heatmap") + plt.title(f"Interpolated Sparse Analysis, {data_var}") plt.xlabel("Longitude") plt.ylabel("Latitude") plt.show() + + return fig, ax \ No newline at end of file diff --git a/pvdeg/utilities.py b/pvdeg/utilities.py index 2374df9..d7ca654 100644 --- a/pvdeg/utilities.py +++ b/pvdeg/utilities.py @@ -1262,3 +1262,49 @@ def compare_templates( return False return True + +def merge_sparse(files: list[str])->xr.Dataset: + """ + Merge an arbitrary number of geospatial analysis results. + Creates monotonically increasing indicies. + + Uses `engine='h5netcdf'` for reliability, use h5netcdf to save your results to netcdf files. + + Parameters + ----------- + files: list[str] + A list of strings representing filepaths to netcdf (.nc) files. + Each file must have the same coordinates, `['latitude','longitude']` and identical datavariables. + + Returns + ------- + merged_ds: xr.Dataset + Dataset (in memory) with `coordinates = ['latitude','longitude']` and datavariables matching files in + filepaths list. + """ + + datasets = [xr.open_dataset(fp, engine='h5netcdf').compute() for fp in files] + + latitudes = np.concatenate([ds.latitude.values for ds in datasets]) + longitudes = np.concatenate([ds.longitude.values for ds in datasets]) + unique_latitudes = np.sort(np.unique(latitudes)) + unique_longitudes = np.sort(np.unique(longitudes)) + + data_vars = datasets[0].data_vars + + merged_ds = xr.Dataset( + {var: (['latitude', 'longitude'], np.full((len(unique_latitudes), len(unique_longitudes)), np.nan)) for var in data_vars}, + coords={ + 'latitude': unique_latitudes, + 'longitude': unique_longitudes + } + ) + + for ds in datasets: + lat_inds = np.searchsorted(unique_latitudes, ds.latitude.values) + lon_inds = np.searchsorted(unique_longitudes, ds.longitude.values) + + for var in ds.data_vars: + merged_ds[var].values[np.ix_(lat_inds, lon_inds)] = ds[var].values + + return merged_ds \ No newline at end of file From adf61a673793d327f27d5be48281f8e16631b10b Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Sun, 15 Sep 2024 19:16:42 -0600 Subject: [PATCH 03/32] DuraMAT pref maps --- pvdeg/geospatial.py | 71 +++++++++++++++++++++++++++++++++++++++++++-- pvdeg/scenario.py | 17 ++++++++++- pvdeg/utilities.py | 27 ++++++++--------- 3 files changed, 98 insertions(+), 17 deletions(-) diff --git a/pvdeg/geospatial.py b/pvdeg/geospatial.py index fbbc234..a43f73e 100644 --- a/pvdeg/geospatial.py +++ b/pvdeg/geospatial.py @@ -970,6 +970,7 @@ def plot_sparse_analysis( method="nearest", resolution:complex=100j, figsize:tuple=(10,8), + show_plot:bool=False, ) -> None: """ Plot the output of a sparse geospatial analysis using interpolation. @@ -999,7 +1000,7 @@ def plot_sparse_analysis( ) fig = plt.figure(figsize=figsize) - ax = fig.add_axes([0, 0, 1, 1], projection=ccrs.LambertConformal(), frameon=False) + ax = fig.add_axes([0, 0, 1, 1], projection=ccrs.LambertConformal(), frameon=False) # these should be the same ccrs ax.patch.set_visible(False) extent = [lon.min(), lon.max(), lat.min(), lat.max()] @@ -1009,7 +1010,7 @@ def plot_sparse_analysis( extent=extent, origin="lower", cmap="viridis", - transform=ccrs.PlateCarree(), + transform=ccrs.PlateCarree(), # why are ccrs different ) shapename = "admin_1_states_provinces_lakes" @@ -1030,6 +1031,70 @@ def plot_sparse_analysis( plt.title(f"Interpolated Sparse Analysis, {data_var}") plt.xlabel("Longitude") plt.ylabel("Latitude") - plt.show() + + if show_plot: + plt.show() + + return fig, ax + +def plot_sparse_analysis_land( + result: xr.Dataset, + data_var: str, + method="nearest", + resolution:complex=100j, + figsize:tuple=(10,8), + show_plot:bool=False, + proj=ccrs.PlateCarree(), +): + + import matplotlib.path as mpath + from cartopy.mpl.patch import geos_to_path + + grid_values, lat, lon = interpolate_analysis( + result=result, data_var=data_var, method=method, resolution=resolution + ) + + fig = plt.figure(figsize=figsize) + ax = fig.add_axes([0, 0, 1, 1], projection=proj, frameon=False) + ax.patch.set_visible(False) + + extent = [lon.min(), lon.max(), lat.min(), lat.max()] + ax.set_extent(extent, crs=proj) + + mesh = ax.pcolormesh(lon, lat, grid_values, transform=proj, cmap='viridis') + + land_path = geos_to_path(list(cfeature.LAND.geometries())) + land_path = mpath.Path.make_compound_path(*land_path) + plate_carre_data_transform = proj._as_mpl_transform(ax) + mesh.set_clip_path(land_path, plate_carre_data_transform) + + shapename = "admin_1_states_provinces_lakes" + states_shp = shpreader.natural_earth( + resolution="110m", category="cultural", name=shapename + ) + + ax.add_geometries( + shpreader.Reader(states_shp).geometries(), + proj, + facecolor="none", + edgecolor="black", + linestyle=':' + ) + + cbar = plt.colorbar(mesh, ax=ax, orientation="vertical", fraction=0.02, pad=0.04) + cbar.set_label("Value") + + utilities._add_cartopy_features( + ax=ax, + features = [ + cfeature.BORDERS, + cfeature.COASTLINE, + cfeature.LAND, + cfeature.OCEAN, + ], + ) + + if show_plot: + plt.show() return fig, ax \ No newline at end of file diff --git a/pvdeg/scenario.py b/pvdeg/scenario.py index 1e4d1e7..2f1df3b 100644 --- a/pvdeg/scenario.py +++ b/pvdeg/scenario.py @@ -1767,7 +1767,7 @@ def plot_coords( coord_2: Optional[tuple[float]] = None, coords: Optional[np.ndarray[float]] = None, size: Union[int, float] = 1, - ) -> None: + ): """ Plot lat-long coordinate pairs on blank map. Quickly view geospatial datapoints before your analysis. @@ -1789,6 +1789,11 @@ def plot_coords( size : float matplotlib scatter point size. Without any downsampling NSRDB points will siginficantly overlap. + + Returns: + -------- + fig, ax + matplotlib figure and axis """ fig = plt.figure(figsize=(15, 10)) ax = plt.axes(projection=ccrs.PlateCarree()) @@ -1811,6 +1816,9 @@ def plot_coords( plt.title(f"Coordinate Pairs from '{self.name}' Meta Data") plt.show() + return fig, ax + + def plot_meta_classification( self, col_name: str = None, @@ -1844,6 +1852,11 @@ def plot_meta_classification( size : float matplotlib scatter point size. Without any downsampling NSRDB points will siginficantly overlap. + + Returns: + -------- + fig, ax + matplotlib figure and axis """ if not col_name: raise ValueError("col_name cannot be none") @@ -1892,6 +1905,8 @@ def plot_meta_classification( plt.legend() plt.show() + return fig, ax + def plot_world( self, data_variable: str, diff --git a/pvdeg/utilities.py b/pvdeg/utilities.py index d7ca654..b4a8c82 100644 --- a/pvdeg/utilities.py +++ b/pvdeg/utilities.py @@ -11,7 +11,7 @@ from collections import OrderedDict import xarray as xr from subprocess import run - +import cartopy.feature as cfeature def gid_downsampling(meta, n): """ @@ -1012,7 +1012,7 @@ def _find_bbox_corners(coord_1=None, coord_2=None, coords=None): min and max latitude and longitudes. Minimum latitude at lats[0]. Maximum latitude at lats[1]. Same pattern for longs. """ - if coord_1 and coord_2: + if coord_1 is not None and coord_2 is not None: lats = [coord_1[0], coord_2[0]] longs = [coord_1[1], coord_2[1]] elif coords.any(): @@ -1043,20 +1043,21 @@ def _plot_bbox_corners(ax, coord_1=None, coord_2=None, coords=None): return -def _add_cartopy_features(ax): +def _add_cartopy_features( + ax, + features = [ + cfeature.BORDERS, + cfeature.COASTLINE, + cfeature.LAND, + cfeature.OCEAN, + cfeature.LAKES, + cfeature.RIVERS, + ], + ): """ Add cartopy features to an existing matplotlib.pyplot axis. """ - import cartopy.feature as cfeature - - features = [ - cfeature.BORDERS, - cfeature.COASTLINE, - cfeature.LAND, - cfeature.OCEAN, - cfeature.LAKES, - cfeature.RIVERS, - ] + for i in features: if i == cfeature.BORDERS: From a1f17ee193a7fad8f848aff43169f661b8d0c682 Mon Sep 17 00:00:00 2001 From: Kempe Date: Tue, 17 Sep 2024 14:50:26 -0600 Subject: [PATCH 04/32] Update O2permeation.json Updated the PO measurement parameters. --- pvdeg/data/O2permeation.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pvdeg/data/O2permeation.json b/pvdeg/data/O2permeation.json index 9ecc24d..18eedd3 100644 --- a/pvdeg/data/O2permeation.json +++ b/pvdeg/data/O2permeation.json @@ -36,10 +36,10 @@ "Fickian": true, "Ead": 29.43112031, "Do": 0.129061678, - "Eas": 32.3137806, - "So": 87.81142774, - "Eap": 61.7449009, - "Po": 97917899126 + "Eas": 16.6314948252219, + "So": 0.136034525059804, + "Eap": 49.1083457348515, + "Po": 528718258.338532 }, "OX004": { "name": "AAA polyamide backsheet", From 13de54d822fd2cbd6511f385ed9b0c5fe2990a63 Mon Sep 17 00:00:00 2001 From: Kempe Date: Tue, 17 Sep 2024 14:51:30 -0600 Subject: [PATCH 05/32] Update diffusion.py Improved the plotting and the calculations at the interface. --- pvdeg/diffusion.py | 40 +++++++++++++++++++++++----------------- 1 file changed, 23 insertions(+), 17 deletions(-) diff --git a/pvdeg/diffusion.py b/pvdeg/diffusion.py index c299def..ef1f6bc 100644 --- a/pvdeg/diffusion.py +++ b/pvdeg/diffusion.py @@ -187,10 +187,9 @@ def esdiffusion( ) # Cs edge seal/Ce encapsulant r1 = so * np.exp(-eas / (met_data[row][0] + dtemp * mid_point)) - r2 = ( - dod * np.exp(-ead / (met_data[row][0] + dtemp * mid_point)) - * r1 * encapsulant_width / edge_seal_width - ) # Ds/De*Cs/Ce*We/Ws + r2 = dod * np.exp(-ead / (met_data[row][0] + dtemp * mid_point) + )* r1 * encapsulant_width / edge_seal_width + # Ds/De*Cs/Ce*We/Ws # Calculates the edge seal nodes. Adjusted to not calculate ends and to have the first node be temperature. for node in range(2, seal_nodes): perm[row + 1 + rp_row][node] = perm_mid[node] + fos * ( @@ -201,34 +200,41 @@ def esdiffusion( perm[row + 1 + rp_row][node] = perm_mid[node] + foe * ( perm_mid[node - 1] + perm_mid[node + 1] - 2 * perm_mid[node] ) - # Calculates the center encapsulant node. Accounts for temperature and two interfade nodes. + # Calculates the center encapsulant node. Accounts for temperature and two interface nodes. perm[row + 1 + rp_row][encapsulant_nodes + seal_nodes + 2] = perm_mid[ - encapsulant_nodes + seal_nodes + 2 - ] + 2 * foe * (perm_mid[encapsulant_nodes + seal_nodes + 1] - perm_mid[encapsulant_nodes + seal_nodes + 2]) + encapsulant_nodes + seal_nodes + 2] + 2 * foe * ( + perm_mid[encapsulant_nodes + seal_nodes + 1] - + perm_mid[encapsulant_nodes + seal_nodes + 2]) + # Calculated edge seal node adjacent to the first encapsulant node. Node numbers shifted. perm[row + 1 + rp_row][seal_nodes] = perm_mid[seal_nodes] + fos * ( perm_mid[seal_nodes - 1] + perm_mid[seal_nodes + 3] * r1 * 2 / (1 + r2) - - perm_mid[seal_nodes] * (1 + 2 / (1 + r2)) - ) + - perm_mid[seal_nodes] * (1 + 2 / (1 + r2))) + # Calculated encapsulant node adjacent to the last edge seal node. Node numbers shifted. perm[row + 1 + rp_row][seal_nodes + 3] = perm_mid[seal_nodes + 3] + foe * ( perm_mid[seal_nodes] / r1 * 2 / (1 + 1 / r2) + perm_mid[seal_nodes + 4] - - perm_mid[seal_nodes + 3] * (1 + 2 / (1 + 1 / r2)) - ) + - perm_mid[seal_nodes + 3] * (1 + 2 / (1 + 1 / r2))) + # sets the concentration at the edge seal to air interface. perm[row + 1 + rp_row][1] = Sos * np.exp( -Eass / (met_data[row + 1][0] + dtemp * mid_point) ) perm_mid = perm[row + 1 + rp_row] - # calculate edge seal at interface to encapsulant. - perm[row + 1 + rp_row][seal_nodes + 1] = ( - perm_mid[seal_nodes + 3] / r2 * r1 + perm_mid[seal_nodes] - ) / (1 / r2 + 1) - # calculate encapsulant at interface to the edge seal. - perm[row + 1 + rp_row][seal_nodes + 2] = perm[row + 1 + rp_row][seal_nodes + 1] / r1 + # Calculate edge seal at interface to encapsulant. + # Blocked out code did weird things and was based on equal flxes. Actually using a simple averaging. This looks better and is not used in the diffusion calculations. + #perm[row + 1 + rp_row][seal_nodes + 1] = (perm_mid[seal_nodes + 3]*r1 + # + perm_mid[seal_nodes]*r2) / (1+r2) + perm[row + 1 + rp_row][seal_nodes + 1] = perm_mid[seal_nodes ]+(perm_mid[seal_nodes]-perm_mid[seal_nodes-1])/2 + + # Calculate encapsulant at interface to the edge seal. + #perm[row + 1 + rp_row][seal_nodes + 2] = perm[row + 1 + rp_row][seal_nodes + 1] / r1 + perm[row + 1 + rp_row][seal_nodes + 2] = perm_mid[seal_nodes + 3]-(perm_mid[seal_nodes + 4]-perm_mid[seal_nodes+3])/2 + + # Puts in the time for the first column. perm[row + 1 + rp_row][0] = rp_time + met_data[row + 1][1] # Because it is cycling around, it needs to start with the last temperature. From d9147f0d0cbc45b5581165abd863eaadddaa88ea Mon Sep 17 00:00:00 2001 From: Kempe Date: Tue, 17 Sep 2024 14:52:11 -0600 Subject: [PATCH 06/32] Update Tools-Edge Seal Oxygen Ingress.ipynb Added in better plotting and some data output functions. --- .../Tools-Edge Seal Oxygen Ingress.ipynb | 136 +++++++++--------- 1 file changed, 65 insertions(+), 71 deletions(-) diff --git a/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb b/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb index 555c9d4..9c74dc5 100644 --- a/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb +++ b/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb @@ -26,17 +26,17 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# if running on google colab, uncomment the next line and execute this cell to install the dependencies and prevent \"ModuleNotFoundError\" in later cells:\n", - "# !pip install pvdeg==0.3.3" + "# !pip install pvdeg==0.4.2" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -86,14 +86,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'latitude': 33.4152, 'longitude': -111.8315, 'altitude': 381.0, 'wind_height': 10, 'Source': 'PVGIS'}\n" + "{'Source': 'NSRDB', 'Location ID': '77855', 'City': '-', 'State': '-', 'Country': '-', 'Dew Point Units': 'c', 'DHI Units': 'w/m2', 'DNI Units': 'w/m2', 'GHI Units': 'w/m2', 'Temperature Units': 'c', 'Pressure Units': 'mbar', 'Wind Direction Units': 'Degrees', 'Wind Speed Units': 'm/s', 'Surface Albedo Units': 'N/A', 'Version': '3.2.0', 'latitude': 33.41, 'longitude': -111.82, 'altitude': 381, 'tz': -7, 'wind_height': 2}\n" ] } ], @@ -111,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -152,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -171,20 +171,20 @@ "source": [ "## 3. Run the Calculations\n", "\n", - "This runs the calculations for diffusion using a simple 1-D finite difference calculation. The first set of calculations is just for diffusion, then the next two include some consumption of oxygen. In typical PV applications, it is common for oxygen ingress distance to be limited by its consumption rate in the encapsulant." + "This runs the calculations for diffusion using a simple 1-D finite difference calculation. The first set of calculations is just for diffusion, then the next two (when written) will include some consumption of oxygen. In typical PV applications, it is common for oxygen ingress distance to be limited by its consumption rate in the encapsulant." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The edge seal is None .\n", - "The encapsulant is None .\n" + "The edge seal is Helioseal_101_dry .\n", + "The encapsulant is EVA .\n" ] } ], @@ -204,12 +204,34 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[WinError 183] Cannot create a file when that file already exists: 'c:\\\\Users\\\\mkempe\\\\Documents\\\\GitHub\\\\PVDegradationTools\\\\TEMP\\\\results'\n" + ] + } + ], + "source": [ + "#This sets up an a variable with the output folder information.\n", + "output_folder = os.path.join(os.path.dirname(os.path.dirname(os.getcwd())), 'TEMP', 'results')\n", + "try:\n", + " os.makedirs(output_folder)\n", + "except OSError as error:\n", + " print(error)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmAAAAGyCAYAAABDdXhpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAADlZ0lEQVR4nOzdd5xU1fn48c+durO9z2wvSEfaIghIsQCiIpZvwOBPrESiERGNEU3sweBX0fi1R4SYGCWKPURZpReV3pbOsr33nd2dnXJ/fww7uO6CM7CN5Xm/XvNa9s659zx3JJmHc859jqKqqooQQgghhOgwms4OQAghhBDifCMJmBBCCCFEB5METAghhBCig0kCJoQQQgjRwSQBE0IIIYToYJKACSGEEEJ0MEnAhBBCCCE6mCRgQgghhBAdTBIwIYQQQogOpuvsAM53LpeL/Px8goKCUBSls8MRQgghhBdUVaWmpobY2Fg0mjMYz1I72WuvvaYmJyerRqNRHTp0qLpu3brTtl+zZo06dOhQ1Wg0qikpKeobb7zRos3HH3+s9u3bVzUYDGrfvn3VTz75xOd+XS6X+sQTT6gxMTGqn5+fOm7cOHXv3r3N2owbN04Fmr2mT5/u0/3n5OS0uIa85CUveclLXvI6N145OTk+fe836dQRsGXLljF37lxef/11Ro8ezVtvvcXkyZPJyMggMTGxRfvMzEyuuuoqZs2axT//+U82btzIPffcQ1RUFDfeeCMAmzdvZvr06TzzzDNcf/31fPrpp0ybNo0NGzYwYsQIr/t9/vnnWbRoEUuXLqVXr148++yzTJgwgYMHDxIUFOSJadasWTz99NOe300mk0+fQdO1cnJyCA4O9u0DFEIIIUSnqK6uJiEhoVlO4AtFVTtvM+4RI0YwdOhQ3njjDc+xvn37ct111/Hcc8+1aP+HP/yBL774gv3793uOzZ49m127drF582YApk+fTnV1Nf/97389ba688krCwsL44IMPvOpXVVViY2OZO3cuf/jDHwCw2WyYzWYWLlzI3XffDcD48eMZPHgwL7/88hl/BtXV1YSEhFBVVSUJmBBCCHGOONvv705bhN/Y2Mi2bduYOHFis+MTJ05k06ZNrZ6zefPmFu0nTZrE1q1bsdvtp23TdE1v+s3MzKSwsLBZG6PRyLhx41rE9v777xMZGUn//v156KGHqKmpOe1922w2qqurm72EEEIIcX7ptCnI0tJSnE4nZrO52XGz2UxhYWGr5xQWFrba3uFwUFpaSkxMzCnbNF3Tm36bfrbWJisry/P7zTffTEpKChaLhb179zJ//nx27dpFenr6Ke/7ueee46mnnjrl+0IIIYTo/jr9KcifP/mnquppnwZsrf3Pj3tzzbZoM2vWLM+fBwwYQM+ePRk2bBjbt29n6NChrcY/f/585s2b5/m9aQ5ZCCGEEOePTkvAIiMj0Wq1LUa7iouLW4w8NbFYLK221+l0REREnLZN0zW96ddisQDukbCYmBivYgMYOnQoer2ew4cPnzIBMxqNGI3GU15DCCGE8IbT6fQsvxFtT6/Xo9Vq2+36nZaAGQwG0tLSSE9P5/rrr/ccT09PZ+rUqa2eM3LkSL788stmx1auXMmwYcPQ6/WeNunp6TzwwAPN2owaNcrrfpumFdPT0xkyZAjgXju2du1aFi5ceMp72rdvH3a7vVnSJoQQQrQlVVUpLCyksrKys0Pp9kJDQ7FYLO1Sp7NTpyDnzZvHLbfcwrBhwxg5ciRvv/022dnZzJ49G3BP1+Xl5fHee+8B7iceX331VebNm8esWbPYvHkzixcv9jzdCHD//fczduxYFi5cyNSpU/n888/59ttv2bBhg9f9KorC3LlzWbBgAT179qRnz54sWLAAf39/ZsyYAcDRo0d5//33ueqqq4iMjCQjI4MHH3yQIUOGMHr06I76CIUQQpxnmpKv6Oho/P39pYh3O1BVlbq6OoqLiwHaZ2DljKqHtaHXXntNTUpKUg0Ggzp06FB17dq1nvduvfVWddy4cc3ar1mzRh0yZIhqMBjU5OTkVguxfvTRR2rv3r1VvV6v9unTR12+fLlP/arqyUKsFotFNRqN6tixY9U9e/Z43s/OzlbHjh2rhoeHqwaDQe3Ro4c6Z84ctayszKf7r6qqUgG1qqrKp/OEEEKcfxwOh5qRkaGWlpZ2dijnhdLSUjUjI0N1OBwt3jvb7+9OrQMmpA6YEEII7zU0NJCZmUlycrLPhb+F7+rr6zl+/DgpKSn4+fk1e++crQMmhBBCiDMj044doz0/Z0nAhBBCCCE6mCRgQgghxHniySefZPDgwR3e75o1a1AUBUVRuO666zq8/9Y8+eSTnpjOZkvBMyUJmBBCCNENNCUTp3rddtttPPTQQ3z33XedFuPBgwdZunRpp/X/Uw899BAFBQXEx8d3Sv+dXglftI8Kq438qgbC/Q3EhMpCTSGE6O4KCgo8f162bBmPP/44Bw8e9BwzmUwEBgYSGBjYGeEBEB0dTWhoaKf1D+4CtoqieD6L9iy2ejoyAtZNzVp1kMsPZvLKluzODkUIIUQHsFgsnldISAiKorQ49vMpyNtuu43rrruOBQsWYDabCQ0N5amnnsLhcPD73/+e8PBw4uPjeffdd5v1lZeXx/Tp0wkLCyMiIoKpU6dy/Phxn+J97733iIiIwGazNTt+4403MnPmTM/vX375JWlpafj5+ZGamuqJr8miRYu48MILCQgIICEhgXvuuYfa2lrP+0uXLiU0NJSvvvqKfv36YTQam+3r3FkkAeumgjXu/7SVP/lLKoQQQvzcqlWryM/PZ926dSxatIgnn3ySa665hrCwMH744Qdmz57N7NmzycnJAaCuro5LL72UwMBA1q1bx4YNGwgMDOTKK6+ksbHR635/9atf4XQ6+eKLLzzHSktL+eqrr7j99tsB+Oabb/h//+//MWfOHDIyMnjrrbdYunQpf/7znz3naDQaXnnlFfbu3cvf//53Vq1axcMPP9ysr7q6Op577jneeecd9u3bR3R09Nl8ZG1CErBuKvTEkGq109XJkQghhOjKwsPDeeWVV+jduzd33HEHvXv3pq6ujkcffZSePXsyf/58DAYDGzduBODDDz9Eo9HwzjvvcOGFF9K3b1+WLFlCdnY2a9as8bpfk8nEjBkzWLJkiefY+++/T3x8POPHjwfgz3/+M4888gi33norqampTJgwgWeeeYa33nrLc87cuXO59NJLSUlJ4bLLLuOZZ57h3//+d7O+7HY7r7/+OqNGjaJ3794EBASc+QfWRmQNWDcVqj+RgLkkARNCCHFq/fv3R6M5OR5jNpsZMGCA53etVktERIRnW55t27Zx5MgRgoKCml2noaGBo0eP+tT3rFmzuOiii8jLyyMuLo4lS5Zw2223eepvbdu2jS1btjQb8XI6nTQ0NFBXV4e/vz+rV69mwYIFZGRkUF1djcPhoKGhAavV6km0DAYDAwcO9O2DaWeSgHVToUYd2KEW2ehACCHEqen1+ma/K4rS6jHXiX/Qu1wu0tLSeP/991tcKyoqyqe+hwwZwqBBg3jvvfeYNGkSe/bs4csvv/S873K5eOqpp7jhhhtanOvn50dWVhZXXXUVs2fP5plnniE8PJwNGzZw5513YrfbPW1NJlOXK14rCVg3FW7UuxMwRUbAhBBCtJ2hQ4eybNkyoqOj22QLvbvuuouXXnqJvLw8rrjiChISEpr1dfDgQS644IJWz926dSsOh4MXX3zRM4r38+nHrkrWgHVTESb3v17qOufpWiGEEN3UzTffTGRkJFOnTmX9+vVkZmaydu1a7r//fnJzc8/oenl5efztb3/jjjvuaPbe448/znvvvceTTz7Jvn372L9/P8uWLeOPf/wjAD169MDhcPB///d/HDt2jH/84x+8+eabbXKf7U0SsG4qwt8AQJ22aw25CiGEOLf5+/uzbt06EhMTueGGG+jbty933HEH9fX1ZzQiFhwczI033khgYGCLKvmTJk3iq6++Ij09nYsuuoiLL76YRYsWkZSUBMDgwYNZtGgRCxcuZMCAAbz//vs899xzbXGb7U5RVVUWCXWis91N/VQyi2sZue8IqCp54weh1UiuLYQQ57qGhgYyMzNJSUnBz8+vs8Px2po1a7j00kupqKhotRDrhAkT6Nu3L6+88kqHx5acnMzcuXOZO3dui/dO93mf7fe3fCt3U5GB7hEwFIXyOvvpGwshhBAdID4+nl//+tee38vLy/nwww9ZtWoV9957b4fGsmDBAgIDA8nO7pyC5bIIv5sKNOnROVQcOoWSWhtRgcbODkkIIcR5asSIERw+fBig2VZIQ4cOpaKigoULF9K7d+8OjWn27NlMmzYN8P3pzbYgCVg3pSgKJodKjU6h1Op9ZWIhhBCirZlMplafZPR1+6K2FB4eTnh4eKf1L1OQ3Zj/iV2IymQKUgghhOhSJAHrpioOriOQGgDKGiQBE0IIIboSScC6qaM/Pk1IwCEAKmySgAkhhBBdiSRg3VRRjYsAagGosDk7ORohhBBC/JQkYN1UjVXjScCqHJKACSGEEF2JJGDdlKoGEoAVgCqnJGBCCCFEVyIJWHelCfWMgNW4ZENuIYQQoiuRBKyb0hijPCNgNaokYEIIIc4dr7/+umf7n7S0NNavX3/Ktp988gkTJkwgKiqK4OBgRo4cyTfffNOB0Z4ZScC6KX1gnGcErFaR7T6FEEKcG5YtW8bcuXN57LHH2LFjB2PGjGHy5Mmn3DJo3bp1TJgwgRUrVrBt2zYuvfRSpkyZwo4dOzo4ct9IAtZNRWlPrgGzaiQBE0IIcW5YtGgRd955J3fddRd9+/bl5ZdfJiEhgTfeeKPV9i+//DIPP/wwF110ET179mTBggX07NmTL7/8soMj941sRdRNJWWrZMa7R8Dq5L+yEEKc91RVpd7e8Q9lmfRaFEXxqm1jYyPbtm3jkUceaXZ84sSJbNq0yatruFwuampqOnWbIW/IV3M3ZQjUEWR3gQEadAouVUXj5f8AhBBCdD/1dif9Hu/4tVEZT0/C3+BdulFaWorT6cRsNjc7bjabKSws9OoaL774Ilar1bPRdlclU5DdlDZAR3Cj+z+vqihUSjV8IYQQ54ifj5ipqurVKNoHH3zAk08+ybJly4iOjm6v8NqEjIB1U/ogA352IwbVRqNipKS2kXA/Q2eHJYQQopOY9Foynp7UKf16KzIyEq1W22K0q7i4uMWo2M8tW7aMO++8k48++ogrrrjijGLtSJKAdVOGYH+0NUEEUEsjRkqsjfSO7OyohBBCdBZFUbyeCuwsBoOBtLQ00tPTuf766z3H09PTmTp16inP++CDD7jjjjv44IMPuPrqqzsi1LPWtf9LiDOWp7HRaDcQgJUKIiira+zskIQQQohfNG/ePG655RaGDRvGyJEjefvtt8nOzmb27NkAzJ8/n7y8PN577z3AnXzNnDmTv/71r1x88cWe0TOTyURISEin3ccvkQSsm1p2cCcJYbWeWmDl9Y5OjkgIIYT4ZdOnT6esrIynn36agoICBgwYwIoVK0hKSgKgoKCgWU2wt956C4fDwb333su9997rOX7rrbeydOnSjg7fa5KAdVNafx0Ou/FkAtYgi/CFEEKcG+655x7uueeeVt/7eVK1Zs2a9g+oHchTkN2UMcgfu93oKcZaYZcRMCGEEKKrkASsmwoMCsHuODkCViUJmBBCCNFlSALWTQUHheCw+3lGwKocsiG3EEII0VVIAtZNhQWFYbcbTo6AuTp++wkhhBBCtE4SsG4qPDgc+09GwGpcMgUphBBCdBWSgHVT0SHROBwnR8BqkARMCCGE6CokAeumzCFmVFWDn9MGgFUra8CEEEKIrkISsG7KT+8HiorB7q6AX6+V/9RCCCFEVyHfyt2YqrgwOtxTjw06PS5V7eSIhBBCCAGSgHVvWhf6RvfTj6qiSC0wIYQQoouQBKw70zlR7FqMagMAZbIfpBBCiHPA66+/TkpKCn5+fqSlpbF+/Xqvztu4cSM6nY7Bgwe3b4BtQBKwbkwxgN1uxP9EKYrSWlsnRySEEEKc3rJly5g7dy6PPfYYO3bsYMyYMUyePLnZBtytqaqqYubMmVx++eUdFOnZkQSsG9P5a5ptR1RqbezkiIQQQojTW7RoEXfeeSd33XUXffv25eWXXyYhIYE33njjtOfdfffdzJgxg5EjR3ZQpGdH19kBiPZjDPTDUXtyQ+6yensnRySEEKLTqCrY6zq+X70/KIpXTRsbG9m2bRuPPPJIs+MTJ05k06ZNpzxvyZIlHD16lH/+8588++yzZxVuR5EErBsLDAzGXnFyBKzcJgmYEEKct+x1sCC24/t9NB8MAV41LS0txel0Yjabmx03m80UFha2es7hw4d55JFHWL9+PTrduZPWyBRkNxYUEnFiCtI9AiYJmBBCiHOB8rMRM1VVWxwDcDqdzJgxg6eeeopevXp1VHht4txJFYXPwoIjKLAbCacMgOMNDZ0ckRBCiE6j93ePRnVGv16KjIxEq9W2GO0qLi5uMSoGUFNTw9atW9mxYwe/+93vAHC5XKiqik6nY+XKlVx22WVnF387kQSsG4sMjsRu9+MCDgGwT5URMCGEOG8pitdTgZ3FYDCQlpZGeno6119/ved4eno6U6dObdE+ODiYPXv2NDv2+uuvs2rVKj7++GNSUlLaPeYzJQlYNxYZEondbqTfiQQsX6+h3O4gXC//2YUQQnRN8+bN45ZbbmHYsGGMHDmSt99+m+zsbGbPng3A/PnzycvL47333kOj0TBgwIBm50dHR+Pn59fieFcj38TdWHRwNKqqwd9ZT4w2jwIljm1VViZEhnR2aEIIIUSrpk+fTllZGU8//TQFBQUMGDCAFStWkJSUBEBBQcEv1gQ7F8gi/G4s0BAIiordbqQXBwDYVFzdyVEJIYQQp3fPPfdw/PhxbDYb27ZtY+zYsZ73li5dypo1a0557pNPPsnOnTvbP8izJAlYN6YoCi7Fid1upCcHAfihrLaToxJCCCGEJGDdnKpx4nCcTMD22W3YXWonRyWEEEKc3yQB6+ZcOgd2u5FY8jA56rApkGGt7+ywhBBCiPNapydgvu54vnbtWtLS0vDz8yM1NZU333yzRZvly5fTr18/jEYj/fr149NPP/W5X1VVefLJJ4mNjcVkMjF+/Hj27dvXakyqqjJ58mQUReGzzz7z/uY7gKpzYm/0Q4NKct1RALZUyjSkEEII0Zk6NQHzdcfzzMxMrrrqKsaMGcOOHTt49NFHmTNnDsuXL/e02bx5M9OnT+eWW25h165d3HLLLUybNo0ffvjBp36ff/55Fi1axKuvvsqWLVuwWCxMmDCBmpqaFnG9/PLLrVbo7QoUI9TWRgDQS3FPQ24ubXkPQgghhOhAaicaPny4Onv27GbH+vTpoz7yyCOttn/44YfVPn36NDt29913qxdffLHn92nTpqlXXnllszaTJk1Sb7rpJq/7dblcqsViUf/yl7943m9oaFBDQkLUN998s9l5O3fuVOPj49WCggIVUD/99NNfuOvmqqqqVECtqqry6TxvPfnOQ+pzzz2gfvtdqvrSyqmqedUOdeDq3e3SlxBCiPZVX1+vZmRkqPX19Z0dynnhdJ/32X5/d9oIWNOO5xMnTmx2/HQ7nm/evLlF+0mTJrF161bsdvtp2zRd05t+MzMzKSwsbNbGaDQybty4ZrHV1dXx61//mldffRWLxeLVfdtsNqqrq5u92lNAQCANDUE47X701B5GUV0UqU7yGxrbtV8hhBBCnFqnJWBnsuN5YWFhq+0dDgelpaWnbdN0TW/6bfr5S7E98MADjBo1qtXtEU7lueeeIyQkxPNKSEjw+twzERYaDijUVUfjRwMx1lwAtlbXtWu/QgghhDi1Tl+E7+2O56dr//Pj3lzzbNt88cUXrFq1ipdffvmUsbZm/vz5VFVVeV45OTk+ne+ryHB3EllTEwlAD8dhAH6QhfhCCCFEp+m0BMzXHc8BLBZLq+11Oh0RERGnbdN0TW/6bZpOPF2bVatWcfToUUJDQ9HpdOh07l2dbrzxRsaPH3/K+zYajQQHBzd7taeI0BgAKqrDARio3wnA2lKpiC+EEEJ0lk5LwH664/lPpaenM2rUqFbPGTlyZIv2K1euZNiwYej1+tO2abqmN/2mpKRgsViatWlsbGTt2rWeNo888gi7d+9m586dnhfASy+9xJIlS3z5KNpVVGg0AFU17gR1oP9uUFWO2BoptNk7MzQhhBCiVb6WqLLZbDz22GMkJSVhNBrp0aMH7777bgdFe2Y6dTNuX3Y8B5g9ezavvvoq8+bNY9asWWzevJnFixfzwQcfeK55//33M3bsWBYuXMjUqVP5/PPP+fbbb9mwYYPX/SqKwty5c1mwYAE9e/akZ8+eLFiwAH9/f2bMmAG4R8laW3ifmJhISkpKu31mvooIjEBFxek0oKkOJzC4nLiqXPJCE1hfUcOvLOGdHaIQQgjh0VQq6vXXX2f06NG89dZbTJ48mYyMDBITE1s9Z9q0aRQVFbF48WIuuOACiouLcTgcHRy5j87i6cw28dprr6lJSUmqwWBQhw4dqq5du9bz3q233qqOGzeuWfs1a9aoQ4YMUQ0Gg5qcnKy+8cYbLa750Ucfqb1791b1er3ap08fdfny5T71q6ruUhRPPPGEarFYVKPRqI4dO1bds2fPae+FLliGwu60q/OfekR94okn1HXvTVO//S5V/fX7C1Tzqh3q7zKOt0ufQggh2sf5UIbC1xJV//3vf9WQkBC1rKyszWNpzzIUiqqqsjFgJ6quriYkJISqqqp2Ww82789zCbaHcnlUHY19l/ND8XBeMf8Bs0HHzlH9u2wRWSGEEM01NDSQmZnpmZ7zhaqq1Ds6fis6k87k9fdMY2Mj/v7+fPTRR1x//fWe4/fffz87d+5k7dq1Lc655557OHToEMOGDeMf//gHAQEBXHvttTzzzDOYTKaziv10n/fZfn97NQV5ww03+HzhN998k+joaJ/PE23PqXGv9XJUxQEwMGQ3WoeTIuBInY2eAb79j1gIIcS5p95Rz4h/jejwfn+Y8QP+en+v2p5Jiapjx46xYcMG/Pz8+PTTTyktLeWee+6hvLy8S68D82oR/meffYbBYGhWv+p0r//85z/U1kqZg65C1brnwW114Sh2HSZjA4llWQCsq5BtiYQQQnQtvpSocrlcKIrC+++/z/Dhw7nqqqtYtGgRS5cupb6+40f8vOX1IvxXXnnF6xGtjz/++IwDEu1A7/5La8VOUFUiDZHH6FW7h0xzKusrargzPqqTAxRCCNHeTDoTP8z44ZcbtkO/3jqTElUxMTHExcUREhLiOda3b19UVSU3N5eePXueWeDtzKsRsNWrVxMe7v3Tcv/973+Ji4s746BE21KD3Hl2saYK/5o+APRnNwAbK2pxuGQZoBBCdHeKouCv9+/wly/rjM+kRNXo0aPJz89vNvN26NAhNBoN8fHxZ/ZhdQCvErBx48Z5Co1645JLLsFoNJ5xUKJtBZrdI5clSjWGylQA+oQcwGizUeN0sbtGtiUSQgjRNcybN4933nmHd999l/379/PAAw+0KFE1c+ZMT/sZM2YQERHB7bffTkZGBuvWreP3v/89d9xxx1kvwm9PXhdiPXToEO+++y7Z2dnMmzePjIyM9oxLtKEBKRdi09hwKSoN1e7aZf7hDSQVHAVgrawDE0II0UVMnz6dl19+maeffprBgwezbt06VqxYQVJSEgAFBQVkZ2d72gcGBpKenk5lZSXDhg3j5ptvZsqUKbzyyiuddQte8XpYa86cOaxdu5aFCxdiMpm466672LRpU3vGJtrIxXGDWGf8mpj6GEocKqbaUByBlfSs3sch+rG+opYHkjs7SiGEEMLtnnvu4Z577mn1vaVLl7Y41qdPnxbTll2d1yNgTqeT/v37M2fOHP785z+3Z0yijaWEJlNlLAfc68BM1b0BGHBiHdjWKit1TlenxSeEEEKcb7xOwIKCgnj00Uc9vzftvSi6Po2ioVHnBKBIU4Gpyv1ESFJIFkG1tTSqKluqrJ0ZohBCCHFe8ToB+9Of/uQpyGqz2fj1r3/dbkGJtqeYIlFRsSqNUOmeRw8w15OUewiQemBCCCFER/I6ARsyZIjnz0aj0fM0gjg3hAYPospQBUBFXSCKQ4/O6KJHxUEA1ksCJoQQQnQY72tL/MSPP/7ImjVrKC4uxuVqvnZo0aJFbRKYaFs9QvtzwPgDoY2hlCi1xFSnUh9+kH6uvXwO7Kmpp8LuIEx/Rn8lhBBCCOEDn79tFyxYwB//+Ed69+6N2WxuVmBNNnXuuvpGpvKDoRxIpUhTRmrlBdSHHyQmrICIijLKwiLYWFHLNdGhnR2qEEII0e35nID99a9/5d133+W2225rh3BEe4kNCcCuNABQqrFirOoBgP+JdWBlYSNZX1EjCZgQQgjRAbxeA+Y5QaNh9OjR7RGLaEcxISbs9iB3QVagrsq9p5YpvJGUwsMArK+QDdSFEEKIjuBzAvbAAw/w2muvtUcsoh1FBxupbkil/EQ9sBKHHb3VnYT1dmWgqC6O1dvIa2jszDCFEEKI84LPU5APPfQQV199NT169KBfv34t6oF98sknbRacaDt+ei2NXEiJ6Qti6mPI0xczqKoH9oAiIiIqiCnOJ98cz/qKGm6KiejscIUQQohuzecRsPvuu4/Vq1fTq1cvIiIiCAkJafYSXZfFP5lSv0IA8pUaz8bcAeYGEnOPADINKYQQovO9/vrrpKSk4OfnR1paGuvXrz9t+/fff59Bgwbh7+9PTEwMt99+O2VlZR0U7ZnxeQTsvffeY/ny5Vx99dXtEY9oR7EhAeQ12KjV1RLoCKSqKho4kYDtPMr3aePZUFGDqqryRKsQQohOsWzZMubOncvrr7/O6NGjeeutt5g8eTIZGRkkJia2aL9hwwZmzpzJSy+9xJQpU8jLy2P27NncddddfPrpp51wB97xeQQsPDycHj16tEcsop1ZQvzws0VS4F8AQG6tHY3dhEbv4ILGw2idDooaHRyps3VypEIIIc5XixYt4s477+Suu+6ib9++vPzyyyQkJPDGG2+02v77778nOTmZOXPmkJKSwiWXXMLdd9/N1q1bOzhy3/icgD355JM88cQT1NXVtUc8oh1Zgv2os/ak0N89DZmjr8avyj0NGRxVTVxBNgAbKmUaUgghuhtVVXHV1XX4S1VVr2NsbGxk27ZtTJw4sdnxiRMnsmnTplbPGTVqFLm5uaxYsQJVVSkqKuLjjz/u8jN1Pk9BvvLKKxw9ehSz2UxycnKLRfjbt29vs+BE27KE+JFrvQhd7Drsih00etSqRIjcR6DFSWL+UbLjU9lQUcPtcZGdHa4QQog2pNbXc3BoWof323v7NhR/f6/alpaW4nQ6MZvNzY6bzWYKCwtbPWfUqFG8//77TJ8+nYaGBhwOB9deey3/93//d9axtyefE7DrrruuHcIQHSEmxESdM5J+dhdFpiLi6+IprwrDBATF2kjcdwyAjRW1uFQVjawDE0II0Ql+vg75dGuTMzIymDNnDo8//jiTJk2ioKCA3//+98yePZvFixd3RLhnxOcE7IknnmiPOEQHsIT4ARBbH0yBfwHxdfFkVWnooyroAmpIqD2OobGRSgzsq63nwiDv/sUihBCi61NMJnpv39Yp/XorMjISrVbbYrSruLi4xahYk+eee47Ro0fz+9//HoCBAwcSEBDAmDFjePbZZ4mJiTnz4NuRzwnYli1bcLlcjBgxotnxH374Aa1Wy7Bhw9osONG2mhIwrIkUmY+golKiVbiwJg57cC5B0XXEFxzjWFIf1lfUSgImhBDdiKIoXk8FdhaDwUBaWhrp6elcf/31nuPp6elMnTq11XPq6urQ6ZqnM1qtFsCn9WcdzedF+Pfeey85OTktjufl5XHvvfe2SVCifQQadQQZdZRYB2HT2jxV8Rur4wAIitGQmOeehtxQUdNpcQohhDh/zZs3j3feeYd3332X/fv388ADD5Cdnc3s2bMBmD9/PjNnzvS0nzJlCp988glvvPEGx44dY+PGjcyZM4fhw4cTGxvbWbfxi3weAcvIyGDo0KEtjg8ZMoSMjIw2CUq0H0uIHweLe9O/sZEC/wIibBGUVQYTGQ+hcXaSVrkTsO+rrNhdKnqNrAMTQgjRcaZPn05ZWRlPP/00BQUFDBgwgBUrVpCUlARAQUEB2dnZnva33XYbNTU1vPrqqzz44IOEhoZy2WWXsXDhws66Ba/4nIAZjUaKiopITU1tdrygoKDFEKDoeiwhfhwuNjLIaSLdVMSAigHk1AQQCehCi4muDMHUUEednz87qq0MDw3s7JCFEEKcZ+655x7uueeeVt9bunRpi2P33Xcf9913XztH1bZ8noKcMGEC8+fPp6qqynOssrKSRx99lAkTJrRpcKLtxZxYB5akSaDSUIlDY6PWHohiCwKNk4AoOwknpiFlWyIhhBCifficgL344ovk5OSQlJTEpZdeyqWXXkpKSgqFhYW8+OKL7RGjaEMxIe6nUYxciIJKvqkIUGiscq8DC40zedaBbZSCrEIIIUS78HnOMC4ujt27d/P++++za9cuTCYTt99+O7/+9a9bFGUVXU9cmDsBO+DoRR/sFJmKSLQmUlYZgiUawuJsJK09CsDWKiv1Thcmrc95uhBCCCFOw+sE7NFHH+W6665j+PDhBAQE8Jvf/KY94xLtJD7UnYB9b43hCmMjHwYWAVBQG4EF0EflElatJbC2mtrAYLZUWRkbHtSJEQshhBDdj9dDGwUFBVxzzTXExMTwm9/8hv/85z/YbLJp87kmPsxdAyazysVQv2hsWht2TTW1tWHgMKLq6gmI1JGY5x4Fk3IUQgghRNvzOgFbsmQJRUVF/Pvf/yY0NJQHH3yQyMhIbrjhBpYuXUppaWl7xinaiCXED0UBm8NFv7CBAGQG5AMaGird9VKiEwNJaqoHJuvAhBBCiDbn0+IeRVEYM2YMzz//PAcOHODHH3/k4osv5m9/+xtxcXGMHTuWF154gby8vPaKV5wlg06DOcj9JKQ9ZBA9GxspCHBPQ5ZUhQEQHFvjWYi/s7qOaoezc4IVQgghuqmzWl3dt29fHn74YTZu3EhOTg633nor69ev54MPPmir+EQ7aFqIn2XoRVqDjTK/MjQuJ2XV0QBoI48TbK0krLIUF/C9jIIJIYQQbarNHm+Ljo7mzjvv5PPPP+ehhx5qq8uKdhDf9CSkK540mx1VUYEKamsjUJ16VIOVwKiQn2xLJAmYEEII0ZZ8LkNx/fXXoygtt6dRFAU/Pz969uzJjBkz6NWrV5sEKNpe3IknIbNrXFwbmAxUc8yUQ7ItkvrKaPwj8rAk+pOYf4xd/YfLQnwhhBCijfk8AhYSEsKqVavYvn27JxHbsWMHq1atwuFw8OGHHzJw4EA2btzY5sGKttE0BZlXUU907FAS7XYORhQCUFIdCUBQTIVnBCzD2kBpo6NzghVCCHFeWbduHVOmTCE2NhZFUfjss89+8Zy1a9eSlpaGn58fqampvPnmm+0f6FnyOQGzWCzMmDGDY8eOsXz5cj755BOOHj3K//t//48ePXqwf/9+br31Vv7whz+0R7yiDTSNgOVV1kPsENIabNQa6zA11lNZZQZAiTyGf0MDUaUFAGyslFEwIYQQ7c9qtTJo0CBeffVVr9pnZmZy1VVXMWbMGHbs2MGjjz7KnDlzWL58eTtHenZ8noJcvHgxGzduRKM5mbtpNBruu+8+Ro0axYIFC/jd737HmDFj2jRQ0XbifzICpsYMZmiDjU+DAlFcFdTUmFGdWlzGasKjY0jMP0ZJZAwbKmqZGh3WyZELIYQ4U6qq4mh0dXi/OoOm1aVLpzJ58mQmT57sdfs333yTxMREXn75ZcD9gODWrVt54YUXuPHGG30Nt8P4nIA5HA4OHDjQYo3XgQMHcDrd5Qr8/Px8+rBFx4oLdRdjrbE5qA7qRVqj+7/bcUM20Wos1uooAsMKMScYSMo9yraBo1kv68CEEOKc5mh08fb9azu839/8dRx6o7bdrr9582YmTpzY7NikSZNYvHgxdru9y26T6PMU5C233MKdd97JSy+9xIYNG9i4cSMvvfQSd955JzNnzgTcc7H9+/dv82BF2zAZtEQEGADIrXUSH9GLaIeDveYiFJfLU44iwFJMQsFxNC4nx+sbya6XnQ+EEEJ0LYWFhZjN5mbHzGYzDoejSxeJ93kE7KWXXsJsNvP8889TVOQu4Gk2m3nggQc8674mTpzIlVde2baRijYVF2aizNpIXkU9/WOGkJbzFf8N1BF6pIqqSgsk7UaNOoTRnkpMUS55MUlsqKhlhsnY2aELIYQ4AzqDht/8dVyn9Nvefj7rpqpqq8e7Ep8TMK1Wy2OPPcZjjz1GdXU1AMHBwc3aJCYmtk10ot3EhZrYnVt1ciH+4eX8NzAAvbOSkupEXE4dGKuJiU0iMe8oeTFJrK+oYUZsRGeHLoQQ4gwoitKuU4GdxWKxUFhY2OxYcXExOp2OiIiu+511VmlpcHBwi+RLnBuaFuLnVtRD7GCGNLinF3MMOaiqlpqqKAAiE5wk57o35l5XUYvrxL8qhBBCiK5g5MiRpKenNzu2cuVKhg0b1mXXf4GXCdjQoUOpqKjw+qKXXHKJ7AfZxXlKUVTUQ3Q/LnBCkNPFvsgS9I2NlFdZAPCz5BJTnIve3kiZ3cEBa0Nnhi2EEKKbq62tZefOnezcuRNwl5nYuXMn2dnZAMyfP9+z5hxg9uzZZGVlMW/ePPbv38+7777L4sWLu/yuPF5NQe7cuZNdu3YRHh7u1UV37tyJzSYLtruyuDD3k5B5lfWgM6Ix92eILY+N0X5cc6yUynALpIAj4hAmzSDiCzLJTOzN+ooa+gWaOjl6IYQQ3dXWrVu59NJLPb/PmzcPgFtvvZWlS5dSUFDgScYAUlJSWLFiBQ888ACvvfYasbGxvPLKK126BAX4sAbs8ssv9yxq+yVdedGbcGtWjBXc05BHjrHO34S/vYr82t44HQbQ1xEXH0dS7jEyE3uzrryWuxOiOzFyIYQQ3dn48eNPm28sXbq0xbFx48axffv2doyq7XmVgGVmZvp84fj4eJ/PER2naTuicmsjdY0O/GOHMHTvBwAUG/KBvlRWRhMRmUt4fB1J+8sA2FxVi92lotdIki2EEEKcKa8SsKSkpPaOQ3SwEJOeID8dNQ0O8irq6Rk7hAE2GwZVZU9kOf1qa6mstBARmYs+OouoDSqmeit1pgC2V1sZERrY2bcghBBCnLPavziH6LKapiFzK+shqi8GrZEBNhsH4xXMhUVUVsYAYAs/TIgpjqS8pqchpSq+EEIIcTYkATuP/XRPSHQGMPdnaIONGn+FkIZK6upCsDeaULWNxMVHkNRUjqK8tjPDFkIIIc55koCdx+JPPAmZW9G0EH+Ipx5YmakMxaVSUene3iEortKTgG2vsVLtcHZ8wEIIIUQ3IQnYeexkMdY694HYIQy22VBU2BlVRVh5BZWV7npgmugjhNVWE1ZZilOFjTINKYQQQpyxM07AGhsbyc3NJTs7u9lLnDuaRsByfjICFuxS6elwciBewVJYSGVFLAANIceIDr2A5JzDAKwplwRMCCGEOFM+J2CHDx9mzJgxmEwmkpKSSElJISUlheTkZFJSUtojRtFOPCNg5SdGwKL6gM6PIfV1FIRDRHUZNlsADXXBoHERnWAkOfcIAGtlBEwIIYQ4Yz5vxn3bbbeh0+n46quviImJkaKr57CEcPcIWFlTLTCDDiwXMrRiH8uCg6gKqkNnt1NeaSHWvxr/2CISD1Sicbk4Xt9IVr2NJJOxk+9CCCGEOPf4PAK2c+dO3nrrLSZPnszgwYMZNGhQs5evXn/9dVJSUvDz8yMtLY3169eftv3atWtJS0vDz8+P1NRU3nzzzRZtli9fTr9+/TAajfTr149PP/3U535VVeXJJ58kNjYWk8nE+PHj2bdvX7M2d999Nz169MBkMhEVFcXUqVM5cOCAz59BZwkx6Qn2c+fgP12IP/TEQvzt0bVEFxVTWeEuR+GMOkigU0NsoXuqea1MQwohhGhj69atY8qUKcTGxqIoCp999tlp23/yySdMmDCBqKgogoODGTlyJN98803HBHsWfE7A+vXrR2lpaZt0vmzZMubOnctjjz3Gjh07GDNmDJMnTz7lWrLMzEyuuuoqxowZw44dO3j00UeZM2cOy5cv97TZvHkz06dP55ZbbmHXrl3ccsstTJs2jR9++MGnfp9//nkWLVrEq6++ypYtW7BYLEyYMIGampNJR1paGkuWLGH//v188803qKrKxIkTcTrPnScEm0bBcspPLsS3OJ3EqloOxONeB1ZpQVUV7AGFxFlSZRpSCCFEu7FarQwaNIhXX33Vq/br1q1jwoQJrFixgm3btnHppZcyZcoUduzY0c6RniXVR9999506cuRIdfXq1WppaalaVVXV7OWL4cOHq7Nnz252rE+fPuojjzzSavuHH35Y7dOnT7Njd999t3rxxRd7fp82bZp65ZVXNmszadIk9aabbvK6X5fLpVosFvUvf/mL5/2GhgY1JCREffPNN095P7t27VIB9ciRI6ds83NVVVUq4PNn11Z+894WNekPX6lLNhxzHyjKUNUngtVHXu+pDn6nv7rp4hHqE088oX7yyQj12+9S1dUvPKjO+93dqnnVDrXXut2q3enqlLiFEOJ8VF9fr2ZkZKj19fWdHUqHANRPP/3U5/P69eunPvXUU2fd/+k+77P9/vZ5BOyKK67g+++/5/LLLyc6OpqwsDDCwsIIDQ0lLCzM6+s0Njaybds2Jk6c2Oz4xIkT2bRpU6vnbN68uUX7SZMmsXXrVux2+2nbNF3Tm34zMzMpLCxs1sZoNDJu3LhTxma1WlmyZAkpKSkkJCT80u13GQk/fxIyshfo/RlaV4tDp1AT6iKgtpaKE1XxDeZcLCV5+DU2UOVwsqumrrNCF0II4QNVVbE3NHT4Sz3NxtrtweVyUVNTQ3h4eIf26yufF+GvXr26TTouLS3F6XRiNpubHTebzRQWFrZ6TmFhYavtHQ4HpaWlxMTEnLJN0zW96bfpZ2ttsrKymh17/fXXefjhh7FarfTp04f09HQMBsMp79tms2Gz2Ty/V1dXn7JtR2iagvTUAtNowTKQoYVbAdhlacBcWERpbAxJSbtpjDxAsO5CEnOOcKjHAFaX15AWEtBZ4QshhPCSw2bjlVv/p8P7nfP3j9H7+XVYfy+++CJWq5Vp06Z1WJ9nwucEbNy4cW0awM+folRV9bRPVrbW/ufHvblmW7W5+eabmTBhAgUFBbzwwgtMmzaNjRs34neKv2zPPfccTz311Klur8MlhLtLUeSU1588GDuE1JzvCVX07IuzMej7QjJrUnA69GCoISEpjuRcdwK2tryGh1IsnRS9EEIIcdIHH3zAk08+yeeff050dHRnh3NaPidgAJWVlSxevJj9+/ejKAr9+vXjjjvuICQkxOtrREZGotVqW4x2FRcXtxh5amKxWFptr9PpiIiIOG2bpmt606/F4k4oCgsLiYmJOW1sISEhhISE0LNnTy6++GLCwsL49NNP+fWvf93qPcyfP5958+Z5fq+uru7UKcuTU5A/mUqMHYICDHZq2BKvEF1cBE6orDITEZFLcIyVlO05AGyrtlJhdxCmP6O/SkIIITqIzmhkzt8/7pR+O8KyZcu48847+eijj7jiiis6pM+z4fMasK1bt9KjRw9eeuklysvLKS0tZdGiRfTo0YPt27d7fR2DwUBaWhrp6enNjqenpzNq1KhWzxk5cmSL9itXrmTYsGHo9frTtmm6pjf9pqSkYLFYmrVpbGxk7dq1p4ytiaqqzaYYf85oNBIcHNzs1ZniThRjrWlwUFVnP3FwKABp1WVYTQq1kUbCy8s95SgU8zFCrDVEV5XiAtbJ05BCCNHlKYqC3s+vw18dUS/0gw8+4LbbbuNf//oXV199dbv31xZ8HrZ44IEHuPbaa/nb3/6GTuc+3eFwcNdddzF37lzWrVvn9bXmzZvHLbfcwrBhwxg5ciRvv/022dnZzJ49G3CPFuXl5fHee+8BMHv2bF599VXmzZvHrFmz2Lx5M4sXL+aDDz7wXPP+++9n7NixLFy4kKlTp/L555/z7bffsmHDBq/7VRSFuXPnsmDBAnr27EnPnj1ZsGAB/v7+zJgxA4Bjx46xbNkyJk6cSFRUFHl5eSxcuBCTycRVV13l68faafwNOiIDDZTWNpJTUUeIfwiE9wBDEEPqaiE0kN1xDiyFhRw7MVJnCztCZNBYEjMPUDz4ElaX1TA12vsHMIQQQohTqa2t5ciRI57fMzMz2blzJ+Hh4SQmJrbIDT744ANmzpzJX//6Vy6++GLPDJfJZPJpZq7D+frYpJ+fn7p///4Wx/ft26eaTCafH8N87bXX1KSkJNVgMKhDhw5V165d63nv1ltvVceNG9es/Zo1a9QhQ4aoBoNBTU5OVt94440W1/zoo4/U3r17q3q9Xu3Tp4+6fPlyn/pVVXcpiieeeEK1WCyq0WhUx44dq+7Zs8fzfl5enjp58mQ1Ojpa1ev1anx8vDpjxgz1wIEDPt1/Z5ehUFVVnfrqBjXpD1+p/92Tf/LgkqvVxieC1WF/H6z+5uF+6trRl6hPPPG4+p//DFS//S5V/fbZh9TfPTBHNa/aoQ7csEd1uaQchRBCtLfzoQzF6tWrVaDF69Zbb1VVtWVuMG7cuNO2PxvtWYZCUVXfng81m8384x//aFHG4ZtvvmHmzJkUFRWddVJ4PqmuriYkJISqqqpOm46874MdfLkrn8eu6sussanugyv/BJte4Y6egzhSUc4br7n47PrrSeq/jZiYw/hljmXDt+W8dtfjNGq0fHdRb/oHmjolfiGEOF80NDSQmZnp2clFtK/Tfd5n+/3t8xqw6dOnc+edd7Js2TJycnLIzc3lww8/5K677jrlwnPRtTVtyv3zhfgAQxvqqQhSsEaYiC4uosKzLdFhTKqW5ILjAKwq69xyGkIIIcS5xOc1YC+88AKKojBz5kwcDgcAer2e3/72t/zlL39p8wBF+/M8CVn+kwTsxEL8oWV5YI5gf7yCpbCQnRUD3dsSBRZgibqQhGMZHIrrwaryau5Lav3pVSGEEEI05/MImMFg4K9//SsVFRXs3LmTHTt2UF5ezksvvYSxgx41FW2rqRaYZ0NugNAkMIUzqL4ODQrbY+qxFBbidBqoqY4EwJyqIzX7EABbqqzUOM6dPTCFEEKIzuRzAtbE39+fCy+8kIEDB+Lv79+WMYkO1jQClltRf3LLCEWB2CEEqCp9/KLYn6AQWGt1b0t0YhpSF11IaE0F0TYrDhU2SDkKIYQQwiteTUHecMMNLF26lODgYG644YbTtv3kk0/aJDDRcWJDTSgK1NudlNY2EhV0YiQzdggc/Y6hqp5/hkNDsB+WgkKKY2JJSnZvS2TS9Sf5+AGKe6fxXVkNk6NCO/VehBBCiHOBVyNgISEhnkJqwcHBnurvrb3Euceg02AJdj/d0dpC/LSqMlAUjiTqsBQWUlMTgcNuwKWvIz4xjMQjewH4rry6wzddFUIIIc5FXo2ALVmyxPPnpUuXtlcsohMlhPlTUNVATnkdQxNPFFU9sRB/SPExSIxli6WOmw/aUFSFikoLUVHZhCXZSVhXgFF1UWCzs6+2ngFBMiUthBBCnI7Pa8Auu+wyKisrWxyvrq7msssua4uYRCeIb20hflAMBJqJcDpI9rewP0HBYLcTUVFBRUUsAEpUNjqngz5VxQCkSzkKIYQQ4hf5nICtWbOGxsbGFscbGhpYv359mwQlOl6rpSgUBWJPlKPQh5EVDXZ/A5a8PE8CZgs9RnhgKPEHdgLwrSRgQgghxC/yug7Y7t27PX/OyMjw7LUE4HQ6+frrr4mLi2vb6ESHSQx3J2DZP03AwL0O7NB/GdrQyCcahePJJsyFRey1XUidNRT/gEpiUowkHN4FF1/J9uo6ShsdRBp8LjEnhBBCnDe8HgEbPHgwQ4YMQVEULrvsMgYPHux5paWl8eyzz/L444+3Z6yiHSVFnCIBayrIWpoNwBaLlfDycgwuF+UnylEEJtYSZK2hh8uGCqwql1EwIYQQZ2bdunVMmTKF2NhYFEXhs88+8/rcjRs3otPpGDx4cLvF11a8TsAyMzM5evQoqqry448/kpmZ6Xnl5eVRXV3NHXfc0Z6xinbUNAKWX1mP3ek6+caJKcj40qNEmyLZG6+iUVXMRcVUlLunIR2RR9CgofeJbYnSSyUBE0IIcWasViuDBg3i1Vdf9em8qqoqZs6cyeWXX95OkbUtr+eJkpKSAHC5XL/QUpyLooKMGHUabA4XeRX1JEcGuN8IiIDQJJTKLIYGJJJuKcFp1GPOySE3digupw78KrFY+lG0czPE9WZNeTV2l4peo3TuTQkhhDjnTJ48mcmTJ/t83t13382MGTPQarU+jZp1ljNeqJORkUF2dnaLBfnXXnvtWQclOp6iKCSG+3O4uJbs8rqTCRi4pyErsxiq6vlaq5CbHIAlpxBV1VJZaSY8Io+oVJXITUcJ00CF08UPVbVcEhbUeTckhBCiGVVVUe0dP4ii6DWeWqLtZcmSJRw9epR//vOfPPvss+3aV1vxOQE7duwY119/PXv27EFRFE/hzaYP1+mU/QDPVUkRJxOwZmKHwr5PGVpdDsDWmHpuPGgjxOmkoiKG8Ig8jLGlKOgY0lDNKkMw6WXVkoAJIUQXotpd5D++qcP7jX16FIpB227XP3z4MI888gjr169Hpzt3HgDzuQzF/fffT0pKCkVFRfj7+7Nv3z7WrVvHsGHDWLNmTTuEKDpKQngrpSjAsxC/Z+EBggxB7Ip3AGDOy6eiwv3ka2PYMYwGHanH9wOwsrRKquILIYRoV06nkxkzZvDUU0/Rq1evzg7HJz6nips3b2bVqlVERUWh0WjQaDRccsklPPfcc8yZM4cdO3a0R5yiAzQtxM8q+1kCFjMYFA2a6jyG9B/F5rrvcem1mI9ncihxDLb6IIymGmKT/Gn4YQ3G3heTWd/IoTobvQP8Ov5GhBBCtKDoNcQ+PapT+m0vNTU1bN26lR07dvC73/0OcK9VV1UVnU7HypUru2yReJ8TMKfTSWBgIACRkZHk5+fTu3dvkpKSOHjwYJsHKDrOKWuBGQMhsjeU7GeoPpx1OoXC5CCiMkvQoFBeEUOMqYawZBvKYRsXGRQ22FS+LqmSBEwIIboIRVHadSqwMwQHB7Nnz55mx15//XVWrVrFxx9/TEpKSidF9st8TsAGDBjA7t27SU1NZcSIETz//PMYDAbefvttUlNT2yNG0UGaaoHllNehqmrzRZNxQ6FkP2k290MX22NsXHPYgdnppLwilpjYQyiWXCCSC8vz2RBg4evSKu5PNnfCnQghhDhX1dbWcuTIEc/vmZmZ7Ny5k/DwcBITE5k/fz55eXm89957aDQaBgwY0Oz86Oho/Pz8WhzvanweF/zjH//oKUXx7LPPkpWVxZgxY1ixYgWvvPJKmwcoOk78ie2IamwOKuvszd+MHQJA/5IsjFoj2+MaAIjOyqKq0oLq0uD0LyUk3EDc3i0A7Kipo9D2s+sIIYQQp7F161aGDBnCkCHu75158+YxZMgQT7H3goICsrOzOzPENuHzCNikSZM8f05NTSUjI4Py8nLCwsLa/TFT0b789FrMwUaKqm1kldcRFmA4+WZcGgD6gh1cOOhSdjdswaXTEn34CM7UVKqrzISEFWBJ0XB09w6GXjGN7TX1rCytYmZcZCfdkRBCiHPN+PHjT/sQ19KlS097/pNPPsmTTz7ZtkG1A59GwBwOBzqdjr179zY7Hh4eLslXN3HKdWDmAaA1QH0FQ4NTadQrlCaFEFZRgZ9WS9mJbYkCEqpx2BsZpdoA+Lq0qkPjF0IIIc4FPiVgOp2OpKQkqfXVjZ2yFIXO4E7CgDTVPTK2M96BAsTZGqkod5ejUCNzULQueuW4H8jYUFFLrUP+vgghhBA/dUZrwObPn095eXl7xCM6WVK4uwJ+9s9LUYCnHtjg6nK0ipYfLbUARB89Ql1dCPaGQFStHXOiDtfubaSajDSqKqvKazosfiGEEOJc4HMC9sorr7B+/XpiY2Pp3bs3Q4cObfYS57bECBMAWeXWlm+eWAfmX7CbPuF9OBivoGo0RB44CCiUllsAiEhyUHj4ABPC3MmcTEMKIYQQzfm8CH/q1Kmy3qsbS/RMQda3fPNEAkbBTob2v599ZfsoTw4l4lgZ4UY/KiriiIk9gjGuFKcjmmHWct4C0kursLlcGDXtV4xPCCGEOJf4nICdC08WiDPXtAYsv6qeRocLg+4nSVNETzAEQWMNaX5m/gHsSVAZfwzi6qxkONzlKFyBZRiDwwk5tBtLQhqFjXbWldcwITKkc25KCCGE6GJ8HpJITU2lrKysxfHKykopxNoNRAUaMem1qCrkVvxsHZhGA3HuuixDGtx1wDaZK93nHTiI02mgtspdeNWSoiF3326uinInXf8pkWlIIYQQoonPCdjx48dbfQrSZrORm5vbJkGJzqMoyqlLUYBnGjK8aD+pIakn1oEphGVkoNVoKD1RjiIk0UrhkUNMCnZvRfRNaRV2l2zOLYQQQoAPU5BffPGF58/ffPMNISEnp5OcTiffffddl95zSXgvIdyfg0U1LUtRwMl1YHnbSBs8iY+qjlGVFEFoZilxAQGUlseSkrodjbkQlADi8o8TofejzO5gU2Ut48KDOvZmhBBCiC7I6wTsuuuuA9wjJLfeemuz9/R6PcnJybz44ottGpzoHE0jYFmtlqI4kYAVZzA0Yh4f8REZiQqjMiGmspJsbSiOhiB0fjWExNnIy9jNVRdN4B/5ZfynpFISMCGEEAIfpiBdLhcul4vExESKi4s9v7tcLmw2GwcPHuSaa65pz1hFB0mOPJGAtTYCFhwLQTGguhimGgHYYK4AIHLvXtzlKNzTkFEpKjn7dnP1iXVgK0qqcJ5mewkhhBBi3bp1TJkyhdjYWBRF4bPPPvvFc2w2G4899hhJSUkYjUZ69OjBu+++2/7BngWf14BlZmYSGSl7+3VnSRHu+l1ZZa3UAgPPKJilLJPYgFj2xamoGoWA/QfwN5ooK48FwD++guLMo6TpFEJ1WkrtDn6sOsU1hRBCCMBqtTJo0CBeffVVr8+ZNm0a3333HYsXL+bgwYN88MEH9OnTpx2jPHs+l6EA+O677/juu+88I2E/1dUzTvHLkiNOTkG6XCoazc/qvsUNhQNfudeBWdL40ppPTXIUwceKSQowcbDSgurSogRWYwhuoOjgPiZGxvDvwgq+Kq5kZGhgJ9yVEEKIc8HkyZOZPHmy1+2//vpr1q5dy7FjxwgPDwcgOTm5naJrOz6PgD311FNMnDiR7777jtLSUioqKpq9xLkvLtSETqNgc7goqmlopcHJhfhDze7dDw4kaQGIKS3F5dJjrXRPQ4Yl2cjet4trokIB+KqkUqYhhRCiE6iqSmNjY4e/1Hb+//wvvviCYcOG8fzzzxMXF0evXr146KGHqK9vpaB4F+LzCNibb77J0qVLueWWW9ojHtEF6LQa4sNMHC+r43hpHTEhpuYNYt21wKjMZmig+8nXddHlDAfCt22Diy6iqMJCYHgu4cmN5Ozcw69nziJEp6Wo0cH3lbWMDpPF+EII0ZHsdjsLFizo8H4fffRRDAZDu13/2LFjbNiwAT8/Pz799FNKS0u55557KC8v79Kzcj6PgDU2NjJq1Kj2iEV0IaddB+YXApG9AEipKSHcL5w9sQ5UjYL26DGiQiOoKI8DwGAuozz/GI7aGk9R1s+LKzvkHoQQQnR/LpcLRVF4//33GT58OFdddRWLFi1i6dKlXXoUzOcRsLvuuot//etf/OlPf2qPeEQXkRzhz1rgeGulKMA9DVl6CCVvG0Ojh/Jtw7fUpkQTdLSIJKOerZVBOOpC0flXEhhnJWffHq7rPYgPCsr5qqSSBT3j0f18bZkQQoh2o9frefTRRzul3/YUExNDXFxcs/qkffv2RVVVcnNz6dmzZ7v2f6Z8TsAaGhp4++23+fbbbxk4cGCLD3bRokVtFpzoPE0jYNnlp3kSctcH7oX4aTfwbfa3HEo2kHYUYvLzQKulrDwWs38l4ck2cvbtZvyI0UTodZTZHWyorGF8eHAH3pEQQpzfFEVp16nAzjJ69Gg++ugjamtrCQx0P+R16NAhNBoN8fHxnRzdqfk8Bbl7924GDx6MRqNh79697Nixw/PauXNnO4QoOkNTLbDjpacZAQN3AhbtXoi/PqocgMAtW9BpdZRUWAAITqwle98udBqFa2QaUgghxGnU1tayc+dOT06RmZnJzp07yc7OBmD+/PnMnDnT037GjBlERERw++23k5GRwbp16/j973/PHXfcgclkaq2LLsHnEbDVq1e3Rxyii/npGjBVVVGUn00XmgeA1ggNlfRStQTqA9kRUwMaDa7jWcTf8CuyCmyoTj0a/3oabEepLS9janQYf88vY0VJFQt7uTBofP43gBBCiG5s69atXHrppZ7f582bB8Ctt97K0qVLKSgo8CRjAIGBgaSnp3PfffcxbNgwIiIimDZtGs8++2yHx+6LM6oDBnDkyBGOHj3K2LFjMZlMrX9Ji3NWfJgJjQLWRieltY1EBRmbN9AZIGYQ5P6INn8Hg6MHs8G+AWtqNAFHCkjRwnFVS11FPAGRmQQn1pKzbzcjLhmPxaCnsNHOmvIaJkaGtB6AEEKI89L48eNPW7pi6dKlLY716dOH9PT0doyq7fk8/FBWVsbll19Or169uOqqqygoKADci/MffPDBNg9QdA6jTktsqHvo9pQV8eOHuX/mbiXN7J6SPJLiB0BUZiYABeVmAMKSGsjetwetojAlWqYhhRBCnN98TsAeeOAB9Ho92dnZ+Pv7e45Pnz6dr7/+uk2DE50r+cQ05GmfhATIO5mArY92rwPT//AjAaYgz7ZExuga8g5vAeD66DAA/ltahdXpbK/whRBCiC7L5wRs5cqVLFy4sMWTBT179iQrK6vNAhOdL8mzJdEvjIAV7qV/cA+MWiNbzLWg1eDIySE1LpbGxgAcNdEoCmA6TlVxEUOC/Uk2GahzuvimtLpjbkYIIYToQnxOwKxWa7ORryalpaUYjcZWzhDnql8cAQtNAv9IcNkxlBxgYNRA6o0KdT3co15JDhsAZSeKsjatA1MUxTMKtrxQtq8SQghx/vE5ARs7dizvvfee53dFUXC5XPzv//5vs6cWxLnvF0fAFOXkKNiJgqwAx1Lda8ciDh5CQfGsAwtJqCN73w4AbrS4E7A1FdWUNjra6xaEEEKILsnnBOx///d/eeutt5g8eTKNjY08/PDDDBgwgHXr1rFw4cL2iFF0kuRI9whYZqn11E+kxLVciL/BXAmA84cfiIqwUFMTgdroj8booKRoE6qqcoG/HwODTDhV+KJYRsGEEEKcX3xOwPr168fu3bsZPnw4EyZMwGq1csMNN7Bjxw569OjRHjGKTpIY7h4Bq2lwUFlnb71R/MmF+IOiBqFTdGyMLAetFnt+Pj3jLYCGuvIkAAzheVQW5gNwo9k9CvZJkSRgQgghzi9nVAfMYrHw1FNPtXUsoovx02uJCfGjoKqB42VWwgJa2cIi1j3tSMVx/Bvr6BvRlz2le6jvGYfpQBbxte5F9vnlZnpa9hOc6N4XMiwmjuuiw3jqSD5bq+vIqreRZJI1hEIIIc4PPo+ALVmyhI8++qjF8Y8++oi///3vbRKU6DpOrgM7xUJ8UyhE9nL/OW+bZxoys4f7vMA9e9BrDZRUmMGlwS/MRs7h9QCYjXouCXPv2yWjYEIIIc4nPidgf/nLX4iMjGxxPDo6mgULFrRJUKLrOPkk5CkW4kOr68A2WtwjXw0//EhCfBJOpwFHZSIA1dbNnjVlN5yYhlxeVHHaysdCCCFEd+JzApaVlUVKSkqL40lJSc32ZhLdQ9OekMdLT5OAeZ6E3MqQ6CEoKKwNKwSdDkdREb1jowAoL3fXjjOZSyjPywXg6qhQ/DQKR+ps7Kypb78bEUIIcU5Yt24dU6ZMITY2FkVR+Oyzz37xnPfff59Bgwbh7+9PTEwMt99+O2VlZe0f7FnwOQGLjo5m9+7dLY7v2rWLiIiINglKdB0pP3kS8pTiL3L/zN1GiD6InmE9adQrNPRxL7yPKS0BILvMPXIaGFNH1r7vAQjSabnyxH6Qy4vK2+MWhBBCnEOsViuDBg3i1Vdf9ar9hg0bmDlzJnfeeSf79u3jo48+YsuWLdx1113tHOnZ8TkBu+mmm5gzZw6rV6/G6XTidDpZtWoV999/PzfddFN7xCg6UWqUOwE7drpSFNH9QO8PtiooPeSZhjzew32udtt2gvxDqbcFQW00igYK8k5uW9X0NOSnRZXYXTINKYQQ57PJkyfz7LPPcsMNN3jV/vvvvyc5OZk5c+aQkpLCJZdcwt13383WrVvbOdKz43MC9uyzzzJixAguv/xyTCYTJpOJiRMnctlll8kasG4oKcIfRXGXoiizNrbeSKs7+TRk7pYW68CsP/5IjwvcJUqsZe7paxt7UF0uAMaHBxOh11Fmd7CmXLYmEkKI9qCqKk5nXYe/2nt976hRo8jNzWXFihWoqkpRUREff/wxV199dbv2e7Z8LkNhMBhYtmwZzzzzDLt27cJkMnHhhReSlJTUHvGJTmbUaYkPM5FTXs+xEiuRgacoFRE/DLI2uBOwvo8DsCo4lzuNRpylpfSMCGYnkFseRe8kCIipoCT7KNHJPdFrFK43h/JObinLiyqYcGJKUgghRNtxuepZs/bCDu93/Lg9aLUttzBsK6NGjeL9999n+vTpNDQ04HA4uPbaa/m///u/duuzLfg8AtakV69e/OpXv+Kaa66R5KubS4l0l4rILK09dSPPOrCtRJoiSQ5Oxq6Dxn7uEa/I7Gw0aCiuCUFpDEBndJF54AvP6f9jDgfg69IqahzO9rkRIYQQ3U5GRgZz5szh8ccfZ9u2bXz99ddkZmYye/bszg7ttHweAXM6nSxdupTvvvuO4uJiXCemkZqsWrWqzYITXUNqZADrDpVwzJuF+MUZYKshzZzG8erjZF4QSO8dYP9xC9F9BlJYkouzrCeamJ2UV6wFHgRgUJCJnv5GDtfZ+Kqkkl/HyAMdQgjRljQaE+PH7emUftvTc889x+jRo/n9738PwMCBAwkICGDMmDE8++yzxMTEtGv/Z8rnEbD777+f+++/H6fTyYABAxg0aFCzl69ef/11UlJS8PPzIy0tjfXr15+2/dq1a0lLS8PPz4/U1FTefPPNFm2WL19Ov379MBqN9OvXj08//dTnflVV5cknnyQ2NhaTycT48ePZt2+f5/3y8nLuu+8+evfujb+/P4mJicyZM4eqqiqfP4OuzvMkZMlpErAgM4QmAirkbfesA9sUUwNA3Y8/0refu2BrSVmc+xz/I7ic7tEuRVE8i/GXF0pRViGEaGuKoqDV+nf4S1GUdr2vuro6NJrm6YxWqwXo0vUlfU7APvzwQ/7973+zbNkyXn75ZV566aVmL18sW7aMuXPn8thjj7Fjxw7GjBnD5MmTT1lPLDMzk6uuuooxY8awY8cOHn30UebMmcPy5cs9bTZv3sz06dO55ZZb2LVrF7fccgvTpk3jhx9+8Knf559/nkWLFvHqq6+yZcsWLBYLEyZMoKbGnVDk5+eTn5/PCy+8wJ49e1i6dClff/01d955p0+fwbmgKQE77QgY/GQa8uRC/FWm4yj+/jirqkjx0wOQWRECTh2GIBu5R9d4Tm8qyrqxspYC2ykW/AshhOjWamtr2blzJzt37gTc3/07d+70fEfPnz+fmTNnetpPmTKFTz75hDfeeINjx46xceNG5syZw/Dhw4mNje2MW/CO6qOYmBj14MGDvp7WquHDh6uzZ89udqxPnz7qI4880mr7hx9+WO3Tp0+zY3fffbd68cUXe36fNm2aeuWVVzZrM2nSJPWmm27yul+Xy6VaLBb1L3/5i+f9hoYGNSQkRH3zzTdPeT///ve/VYPBoNrt9lO2+bmqqioVUKuqqrw+p6PllFvVpD98pV7w6H9Uh9N16oabX1fVJ4JV9f3pqqqq6oSPJqgDlg5Qd82cpmb07qOWLH5XXfDMX9QnnnhCXf3hNeq336WqG76+t9klpmw7pJpX7VBfzypqz1sSQohzUn19vZqRkaHW19d3dijtZvXq1SrQ4nXrrbeqqqqqt956qzpu3Lhm57zyyitqv379VJPJpMbExKg333yzmpube9axnO7zPtvvb59HwB588EH++te/nvWwXmNjI9u2bWPixInNjk+cOJFNmza1es7mzZtbtJ80aRJbt27Fbreftk3TNb3pNzMzk8LCwmZtjEYj48aNO2VsAFVVVQQHB6PTnXppnc1mo7q6utmrq4sNMWHQabA7VfIqTlOt3jMC9iOo6sl6YBe4F/HX//gjyUnuRfk1pe6f1sYfm12iaRRM9oYUQojz0/jx41FVtcVr6dKlACxdupQ1a9Y0O+e+++5j37591NXVkZ+fzz//+U/i4uI6Pngf+JyAbdiwgffff58ePXowZcoUbrjhhmYvb5WWluJ0OjGbzc2Om81mCgsLWz2nsLCw1fYOh4PS0tLTtmm6pjf9Nv30JbaysjKeeeYZ7r777lPeM7gXC4aEhHheCQkJp23fFWg0CikRTdOQp3kS0nIhaA1QVwYVmS3qgdVt2UK/Ae51YFnlkaCCNqCMurpczyWmRIWiU2BPbT2HrA3tdEdCCCFE5/I5AQsNDeX6669n3LhxREZGNksmQkJ8r9/088V5qqqedsFea+1/ftyba7ZVG4Dq6mquvvpq+vXrxxNPPHHK2ME9d11VVeV55eTknLZ9V+HVlkQ6I8SceBAjdyvDzO49Ir8zHEUTHIzLaiXB7l7bVep0oatIBuD44X97LhFh0HFpeDAgo2BCCCG6L5/LUCxZsqRNOo6MjESr1bYYUSouLm4x8tTEYrG02l6n03n2oTxVm6ZretOvxWIB3CNhP318tbXYampquPLKKwkMDOTTTz9Fr9ef9r6NRiNG4ymKmXZhKU1bEp3uSUhwT0PmboGcH0m68FdE+EVQ1lBG46D+6NZvxbVjJ2FBkVTUlOIo6wvhxykuXkk/5nkucaM5jPSyaj4pquAPKZZ2f4JGCCGE6GhnXIi1pKSEDRs2sHHjRkpKSnw+32AwkJaWRnp6erPj6enpjBo1qtVzRo4c2aL9ypUrGTZsmCfxOVWbpmt6029KSgoWi6VZm8bGRtauXdssturqaiZOnIjBYOCLL77Az8/Pl4/gnJLqzQgYNHsSUlGUFuvA6n74nt593NOQhaXu+XmH5gh2+8nyHRMjQ/DXashuaGRrdV1b3oYQQgjRJficgFmtVu644w5iYmIYO3YsY8aMITY2ljvvvJO6Ot++LOfNm8c777zDu+++y/79+3nggQfIzs72VK/9+aOms2fPJisri3nz5rF//37effddFi9ezEMPPeRpc//997Ny5UoWLlzIgQMHWLhwId9++y1z5871ul9FUZg7dy4LFizg008/Ze/evdx22234+/szY8YMwD3yNXHiRKxWK4sXL6a6uprCwkIKCwtxOrtfJfemTbl/MQFLGO7+WbgHGq0Ms7inIT3rwLZtp0/vVACyG10oVZEoikpJybeeS/hrNVx1Yjui5TINKYQQohvyeQpy3rx5rF27li+//JLRo0cD7oX5c+bM4cEHH+SNN97w+lrTp0+nrKyMp59+moKCAgYMGMCKFSs8WxsVFBQ0q82VkpLCihUreOCBB3jttdeIjY3llVde4cYbb/S0GTVqFB9++CF//OMf+dOf/kSPHj1YtmwZI0aM8LpfgIcffpj6+nruueceKioqGDFiBCtXriQoKAiAbdu2eWqLXXDBBc3uKzMzk+TkZK8/h3NB03ZEeZX1NNid+Om1rTcMiYegWKjJh/wdJ+uBaQ9xR1QUzpISwotL0Ck6bNjRlgzEEbKKvOzPiY09+d/xBnMYHxdV8FVxJc9eEIdOI9OQQgghug9F9bGeRGRkJB9//DHjx49vdnz16tVMmzbtjKYjz2fV1dWEhIR4Slh0VaqqMvjpdKrq7fz3/jH0jTlNrP++FTI+g8ufwHXJXMYuG0uVrYoPt16MJn0DEb+dzQpTGMfzjzHM6I9pxFug6hg3bhs6nTvRs7tUBm3aS7ndyUeDejAmPKhjblQIIbqwhoYGMjMzPTu5iPZ1us/7bL+/fZ6CrKura3WRfHR0tM9TkOLcoSiKd09CwslpyJwf0SgahkYPdZ/X051E1W3+nn6D+rqb1OtwVQeB4qC09OQ+onqNwlWRoQB8XlzZdjcihBBCdAE+J2AjR47kiSeeoKHhZI2m+vp6nnrqKUaOHNmmwYmuxet1YPEnErATBVmbylFssFQCUL9nDz3i3dtDFCs1aPP7A1BU/J9ml7k2OhSAFaWV2F1ddz8vIYQQwlc+rwH761//ypVXXkl8fDyDBg1CURR27tyJn58f33zzTXvEKLqIpichjxafphgrQMxA0BrdBVnLj5Fmca8DW+c4wF0JCdhzcjAcOkSQMZgaWzVqeRrwPWVla3E4atDp3CNlo0IDidDrKLM72FBRw6URXXeKVgghhPCFzyNgAwYM4PDhwzz33HMMHjyYgQMH8pe//IXDhw/Tv3//9ohRdBEXRLvXZx0p+YUETGeE2MHuP+f8SO+w3gToA6ix12Af2geAuu+/p0dP98MLxQ0BNFaaUFV7s2lInUbhmij305BflFS26b0IIYToep577jkuuugigoKCiI6O5rrrruPgwYO/eN7atWtJS0vDz8+P1NRU3nzzzQ6I9uycUR0wk8nErFmzePHFF1m0aBF33XUXJpOprWMTXUxTAna0uPaX9wL9yb6QOo2OIdFDADh2oh6YdfP39D+xDixXWw657mSsqHhFs8t4piFLqmh0udriNoQQQnRRa9eu5d577+X7778nPT0dh8PhKfl0KpmZmVx11VWMGTOGHTt28OijjzJnzhyWL1/egZH7zusEbNu2bVx66aWtbh5dVVXFpZdeyq5du9o0ONG1JEUEoNMoWBudFFT9wj6NnoX4WwA85SjWmysBsB06RHxQEBo0WBUb+hL3+03TkE0uDg0k2qCjyuFkbfnJ40IIIbqfr7/+mttuu43+/fszaNAglixZQnZ2Ntu2bTvlOW+++SaJiYm8/PLL9O3bl7vuuos77riDF154oQMj953XCdiLL77IZZdd1uqjliEhIUyYMIH//d//bdPgRNei12pIivAH4MgvrQNrWohfvA9sNZ6F+Bvr9mDs0xsA+/btWMLc2z41OBJoqDCgqvZmRVm1isKUqFBAnoYUQoizoaoqVqezw18+VrtqpqrKvUtKeHj4Kdts3ryZiRMnNjs2adIktm7dit1uP+O+25vXi/B/+OEHHnnkkVO+P2XKFN555502CUp0XT2jgzhaYuVwcS1je0WdumFwDIQkQlU25G2jf/JoTDoTlbZKGoeMhgMHsW7eTN8rJpG/Op9CXTVhx2PwC8uiqPgrYmKu91zq2uhQFueV8k1pFQ1OF37aM95BSwghzlt1Lhc91u3p8H6Pjr2QAO0pinefhqqqzJs3j0suuYQBAwacsl1hYWGL8lhmsxmHw0FpaWmzPZ27Eq+/yfLy8jxV4FsTGBhIQUFBmwQlui7PQvxfGgEDSDixDixnC3qNnkFRg9zn9nCPolk3f0/vvu59IQs0lRjy3OvEysrWYbMVeS5zUUgAMUY9NU4XaytkGlIIIc4Hv/vd79i9ezcffPDBL7ZVlOa7pTSNuv38eFfi9QhYVFQUBw8eJCUlpdX3Dxw4QGRkZJsFJrqmny7E/0UJI2Dvcshxb9k0zDyM7wu+Z31kGT30euy5uYTU1+OvNVHnrEejXEBdcSD+0bUUFH5GctLdAGhOTEO+nVvC58WVTDqxT6QQQgjv+Ws0HB17Yaf066v77ruPL774gnXr1hEfH3/athaLhcLCwmbHiouL0el0RERE+Nx3R/H6U7niiiv485//3Op7qqqyYMECrrjiijYLTHRNXpeigJML8XN/BJfLsxD/+6qdmAa5R8PqNn9PcoI7qa/101KW4V5jWFDwUbN1A1NPPA35TWkV9U55GlIIIXylKAoBWm2Hv3wZhVJVld/97nd88sknrFq16pSDPj81cuRI0tPTmx1buXIlw4YNQ6/X+/w5dRSvE7A//vGP7NmzhxEjRvDvf/+bXbt2sXv3bs9G13v27OGxxx5rz1hFF9AjKhBFgXJrI2W1ttM3Nl8Ien9oqILSg1wYdSEGjYHyhnLsae4SFNZNm+g/zF0/Ll9biZLbE1QDdXWZVFWdfOplaLA/cUY9VqeLVeUtn8QVQghx7rv33nv55z//yb/+9S+CgoIoLCyksLCQ+vp6T5v58+czc+ZMz++zZ88mKyuLefPmsX//ft59910WL17MQw891Bm34DWvE7AePXrw7bffYrVauemmmxg6dChDhgzh17/+NXV1daSnp3PBBRe0Z6yiCzAZtMSFumu+/eI6MK0O4tyjXmR/j1FrZGDUQAAO9nBvamr94QdSU5JRUKjS1BFsTMFRkQxAfsHHnkspiuKpCSZPQwohRPf0xhtvUFVVxfjx44mJifG8li1b5mlTUFBAdna25/eUlBRWrFjBmjVrGDx4MM888wyvvPIKN954Y2fcgtd82opo2LBh7N27l507d3L48GFUVaVXr14MHjy4ncITXdEF0YHkVtRzpKSWEam/ML+eeDEcX+9eBzbsdoZZhrG1aCsbggroGRSEq6oKjh0j2j+SoroSXIHhFOwwkHA5FBevoFfPP6HTubdAmhodxhs5JaSXVmN1Os/oqRohhBBdlzclK5YuXdri2Lhx49i+fXs7RNR+zuh5/sGDB/OrX/2KadOmSfJ1HrogypcnIS92//zJQnyALaXb8R/uXiNm3biJXieehqwyuqg4omLUx+F0Wiku+a/nUoOCTCT5Gah3ufi2TKYhhRBCnLukoJLwWU+zDwlY/DBAgfJjUFvMwKiB6DQ6iuuKT64D27yZPkP7AVCgrSTcLxad3Z2o5eV96LnUT6ch388vO6vifkIIIURnkgRM+MynWmCmUIh2J1rk/IBJZ+LCSPdj0BmpBgDqt2/HEhaGUTFgV5yYghOoOBSORmOgunoHlT9ZjD89Jhy9orCuopbFeaVtel9CCCFER5EETPjsgih3Qd6CqgZqbY5fPsGzL2TzacjN2kx0MTGodjv127aTFOmu9WIPCCJ3zzEs5usAyM4+ucPCBf5+PHFBLABPHclnR3VdW9ySEEII0aEkARM+C/HXExloBLwtyHpiHVh28wRsa9E2AkaNBNzlKPoMco+UlRkasZaVEx7k3o6opCSdurpMz+XujIvk6qgQ7KrKb/Ydp8ruRRIohBBCdCE+PQXZpLKykh9//JHi4mJcruZFMX9am0N0Xz2jAymttXG4uJZBCaGnb5w4wv2zYCfYGxgcPRidoiPfmk/jkD6wHKwbN9Lr3nvg2/9Qrqkl2RRPeaaVyIjLKC1bRXbOu/Tp/QzgXgv2Up9E9tYcJKuhkQcO5LB4QHKX3nJCCCHakqyB7Rjt+Tn7nIB9+eWX3HzzzVitVoKCgpp96SmKIgnYeeKC6EA2Hyvzbh1YWAoERIG1BAp24p94Mf0i+7G7ZDd7UrRcoCjYDh3CaK0jQhdKmaMSXUgMOfv3ctGv7qK0bBUFBctJTZmLweAuexGs0/L2gGSmbDvMitIqFueVclf8aTYHF0KIbqCpsntdXR0mk6mTo+n+6urcy1zao6K+zwnYgw8+yB133MGCBQvw9/dv84DEuaHpScjDRV5sjq0o7n0hD3wF2d9D4sVcZL6I3SW7+bFhPwMGDKBhzx6sGzfSIzGFsmM7aPA3kb13DxNm/Y6goAupqdlDbu4/SU2933PZQUH+PHFBLI8dzuOpI/lMiAgmyWRsr1sWQohOp9VqCQ0Npbi4GAB/f38Z/W8HqqpSV1dHcXExoaGhaNuh7qTPCVheXh5z5syR5Os819vsXoh/oNCLBAyaJ2DAMMswFu9dzJbCLdx3yWR3ArZhPX3u+C0/HttBqb4ev+JS6qurSEq8i7377icv/18kJ/8WjcbguewdcZH8I7+MA9YGDlgbJAETQnR7FosFwJOEifYTGhrq+bzbms8J2KRJk9i6dSupqantEY84R/SxuDfNzqusp7rBTrDfLwzPJroX25PzA7hcDIkeglbRklebh62pHtjGTaT+5S/o0dGg2IkOTiL3wD4uuGgSBkM0jY3FlJSsxGy+xnNZ9+ay8iyJEOL8oSgKMTExREdHY7fbOzucbkuv17fLyFcTnxOwq6++mt///vdkZGRw4YUXtpgXvfbaa9ssONF1hfjrsQT7UVjdwKHCGoYlh5/+hJhBoDNBfTmUHSYgqjf9Ivqxp3QPO6Pr6BUUhLOqCvv+/cQFmDluzYOgKLL37qHXiNHExd5E5vFXyM39Z7METAghzldarbZdEwTRvnxOwGbNmgXA008/3eI9RVFwOp1nH5U4J/S2BFFY3cABbxIwncFdFf/4esjeDFG9GWYexp7SPWwt3cGQiy+mJj2d2g0b6NWjH8d352E16Ti+axcAsXHTOZ71GpVVW6itPUhgYO8OuEMhhBCiffg8d+NyuU75kuTr/NInxr0O7KC368ASm+qBnVwHBrClcAsBl1wCgHXDRnoP7w9Aubae2rIyGqy1+BktREVOBCA37/22ugUhhBCiU5zV4pmGhoa2ikOcg/pYzjQB2wzA0OihaBQNOTU51KW5N+Ou37WL0CAjoQSgKir+oUnkH9wPQFz8zQAUFn6Gw+Fln0IIIUQX5HMC5nQ6eeaZZ4iLiyMwMJBjx44B8Kc//YnFixe3eYCi6+ptdi/EP1BY7V2xuvjhoGig4jhUFxBoCKRvuHsB/g5NLobUVHC5sG7+nuQI97ZErsBQjm7fCUBY6MX4+1+A02mloPCzdrgjIYQQomP4nID9+c9/ZunSpTz//PMYDCfLAVx44YW88847pzlTdDc9ogPQahSqGxwUVnsxGuoXDGb39CI5J6Yhm7YlKtxKwCWjAajdsJ4LevcEoMoIx3fvAdxrDONPjIJlZb2J3V7dlrcjhBBCdBifE7D33nuPt99+m5tvvrnZ0xcDBw7kwIEDbRqc6NqMOi2pkQGAD/XAmspRnFgHdpHlIgC2Fm0lcMxYAKxr15E6rA8aVaFeY6euqhy7zZ3gxcb8CpMpCZutkEOHn2rDuxFCCCE6js8JWF5eHhdccEGL4y6XS+qRnId6n1gHdqDgzNaBDTEPQaNoyKrOorZ/Ioq/P46SEpT8LMzaMACMwfHkHXCvA9NqTfTv9wKgobDwM4pLvmnT+xFCCCE6gs8JWP/+/Vm/fn2L4x999BFDhgxpk6DEuePkQnwvpwObRsAK90BDNcGGYPqE9wFgW+UeAkePAqB2zRqSzYkAOAKCOLBpu+cSISFDSUr6DQAHDvwRVXW0xa0IIYQQHcbnBOyJJ57gd7/7HQsXLsTlcvHJJ58wa9YsFixYwOOPP94eMYourKkivtdTkMGxEJoEqgtytwBwkdk9DbmlcAuB48cD7gTsgr5N68CcZGfsbXaZ1JQ5BAb0xm4vp74+pw3uRAghhOg4PidgU6ZMYdmyZaxYsQJFUXj88cfZv38/X375JRMmTGiPGEUX1jQFebSkFrvT5d1Jp1sHNm4cAA179xKbEIpB1WFXXNRbq3A6Tk5xazRG+vV7AUXRY7dXts3NCCGEEB3kjOqATZo0ibVr11JbW0tdXR0bNmxg4sSJbR2bOAfEh5kINOqwO1UyS63enfTzemDmoZ51YGUmJ34DBwLQsHUTsfpIAHTBFrL2NH/IIyioH6kpczy/2+1SG0wIIcS5QXYxFmdFURR6mQMBH6Yhk9zrvMjdAo5GggxBnnpgW4u2EnTpeABqV68hJTYJALu/P/s3bGlxqcTE36DRGAGoqz925jcihBBCdCCfE7CwsDDCw8NbvCIiIoiLi2PcuHEsWbKkPWIVXVTvE+vAvF6IH9kL/CPA0QD5O4CT05A/XQdm3byZHr1SAKjWO8k5sK/FpTQaHYpyYktTL2rBCiGEEF2BzwnY448/jkaj4eqrr+app57iySef5Oqrr0aj0XDvvffSq1cvfvvb3/K3v/2tPeIVXVDfE3tCZuR7mYApyk/WgW0Cmq8DM/bpg85iQa2vJ6i+kADVD5eiUt9Yg9MuTzwKIYQ49+l8PWHDhg08++yzzJ49u9nxt956i5UrV7J8+XIGDhzIK6+8wqxZs9osUNF19Y8NAWCvtwkYQNJoOPAVZG2CSx5gSPTJemDFdcUEjh9H5YfLqNu4hgRjIgcas9EHRXHoh730vWRw+9yIEEII0UF8HgH75ptvuOKKK1ocv/zyy/nmG3dRzKuuusqzR6To/vrFBKNRoKTGRrE3WxIBJDWNgP0ALmfLdWCXXQZA7XerSIl31wNrMJk4sHlbm8cvhBBCdDSfE7Dw8HC+/PLLFse//PJLwsPDAbBarQQFBZ19dOKcYDJouSDavRB/b36VdyeZLwRDENiqoMi9tuun68D8L74YTWAgjpIS4oPdi+xrdQ7yjrRcByaEEEKca3yegvzTn/7Eb3/7W1avXs3w4cNRFIUff/yRFStW8OabbwKQnp7OuBP1nMT5YUBsCIeKatmbV81lfcy/fIJWBwnD4eh37mnImIFcZLmIpfuWsqVwCxqDgcBLL6X6yy/R7v+BEJc/VZo67God9VYbpgBj+9+UEEII0U58HgGbNWsWa9euJSAggE8++YSPP/4Yf39/1q5dy5133gnAgw8+yLJly9o8WNF19Y9zrwPbk+flCBicLEdxYiF+0zqw7JpsCq2FBE9y15arTf8vcaYoALSBEexft7vtAhdCCCE6gc8jYACjR49m9OjRbR2LOIcNiHWXoth3JglY1iZQVYIMQfQL78fesr1sKdzC1ZdMQPH3x56fT0JwGBklWTSa/Di0ZTtDJ1/UDnchhBBCdAyfR8DGjx/Pe++9R319fXvEI85RTSNg+VUNlNXavDspdihojWAtgbKjQPNyFBo/PwLHjgXAXFkCQK3OSVHWQVRVin4JIYQ4d/mcgKWlpfHwww9jsViYNWsW33//fXvEJc4xgUYdqZEBAOzzthyF3g/i0tx/ztoInEzAfiz4EYDgie79RV0bvyLU5Q8KOLVWygtq2zB6IYQQomP5nIC9+OKL5OXl8d5771FSUsLYsWPp168fL7zwAkVFRe0RozhHnNU6sKyT68C0ipbc2lwKagsIGDsOxWjEfuwQsXr3U7a6wAj2r9/TprELIYQQHemM9oLUarVMnTqVzz77jLy8PGbMmMGf/vQnEhISuO6661i1alVbxynOAZ51YN6WooCfJGDuEbBAQyD9IvoB7mlIbWAAAZdcAkCsy/3X1Wby4+j2HW0UtRBCCNHxzmoz7h9//JHHH3+cF154gejoaObPn090dDRTpkzhoYceaqsYxTliwIkRsL15PlTETxgBihaqcqAiC/jJNGRh82nI8CMZAFh1LkoLDlNd5vs6RJfLgd1ehcNh9flcIYQQoq34/BRkcXEx//jHP1iyZAmHDx9mypQpfPjhh0yaNAlFUQCYNm0a1113HS+88EKbByy6rgEntiTKLq+jqs5OiL/+l08yBkLsEMjb6h4FC0viIstFvLv3XbYUbgFwb86t1aLZtZbQlF9RqalDNdayZ/VRRv/PAM+lKio2ceDgdzgdtTictSd/Oq04HLU4HLW4XCeTNpMpkcDAfgQF9iUoqD+BQX0xGsyev8dCCCFEe/E5AYuPj6dHjx7ccccd3HbbbURFRbVoM3z4cC66SMoEnG9C/PUkhJvIKa9nX0EVo3pEendi8mh3AnZ8IwyewdDooWgVLXm1eeTX5hMbEov/8Iuo2/w9sUoIldShD4piz6o1jLy+H4riHsitqt5BXvXWFpdXgUYM1OFPHeHU4Y8Glcj6YoLrv6ak5GtPW70+nKDAfgQG9sbfP+XEKxWDIUoSMyGEEG3G5wTsu+++Y8yYMadtExwczOrVq884KHHuGhAbQk55PXvzfEjAki6BjX+FrA0A+Ov96R/Zn90lu9lSuIWpF0wl6PIrqNv8PZaaejKCoSrIiF/VAbL2luHnFwNW+FZ/B5u5lVqXAauqP/HSUYcOl9L6bLsRBxZNFdEUEenKJNJeSHRFEdEV3xBNMQYaAdBqA/H3T3YnZKYUTKZE/PxiMBpj8POzoNFIZX4hhBDe8zkBa9rvsTVff/01V1555VkFJM5tA+JC+O/eQnbn+rAQP/FiUDRQcRyq8iAkjuGW4ewu2c2PhT+eSMAuo+jZZzHv2kb8qOHkasuoiw1l89c/4BgWDRoDux2tbIH0k0ErRVUxOOwYHHZcGg1Wgx82RUeWK4IsIoB+zdoDRFBBtJqP2VlAdE0h5poizOzFTCH+nJzO1Osj8POL/UlSFut+Gd0/DYZIz0idEEII4XMCNmzYMJ5//nnuu+8+zzGbzcaDDz7I4sWLpUDreW5wQigAO3MqvT/JLxhiBkH+Dvc6sIHTuMh8Ee/seYdtRdsA0MfE4Ne/Pw37d3GFejsrXDsp1lZzuGYraRlmjEFhGBWFEJ2W4BOvMKOBMKOBCJMfEf4mIvxNBAREYjKZaGho4GhWNjvzCjhQXkmpoqXaFECNnz/VfgFUmwJo1OkpI4wyJYz99G8RdjC1mMnHouZhthe6XzVHsbCBAOqatVUUPX7GGIx+MZj84vDzi8dkSsRkSsBkSjqRoMkUpxBCnC98TsDef/99fvOb37BixQqWLFlCYWEhM2bMAGDjxo1tHqA4twyMD0FRILeinuKaBqKD/Lw7MWm0OwE7vgEGTmNw9ODm68ACYwm8/DIa9u1DW7OPiabBfKH/kWpdA6ayIi4qK+Kmm26iT58+XscaHx/POMDlclFaWkpWVhbZ2dlkHTlIVXU1DToD1aYAqkwBNIZG4IiMpsY/kCI0lNqdVBNINb04rPRqce0gpYEYpZxo8olyHidaLcDcUIC54SAh/PDzgTa0Wn9MfgknkrJETCemOwP8UzEYoiU5E0KIbsbnBOyGG27g4osv5tZbb2XAgAFYrVZuv/12XnzxRUwmU3vEKM4hQX56epuDOFBYw/asSq4cYPHuxORLYPOrnnpg/np/+kf0Z3fpbrYWbeXawGsJuvwKSl/5P6zr/kHQ1Je4uiGNj9T1OHRnN7Wn0WiIjo4mOjqaiy66CFVVKS0t5ciRIxw5coTjx4/jLM6FQyfbRyYk4peciivKQo1/IFk2B8frbWTW2yhqdFCj+lGjxnKIWFCGNevPpDiJ0dYQTQmRai7hjmNEOYuIthYRZV2L8cS6syZabcCJ9Wep7pcpmYCAC/D3T0Wr9TLBFUII0aWc0WbcTqeTxsZGnE4nTqcTi8WC0SiLkIXbkMQwDhTWsCOnwvsELHEkoEDZEagphCALaZY0dwJWuJVre1yLsVdP9AkJ2HNy0FtsBBz347L63qwMOgyAv79/m8SvKApRUVFERUUxcuRIGhsbycrK4siRIxw+fJjy8nKKs45D1nHAXZh4UHw8U5OTSUlJIdRiId+hkllv43h9I8frbZ7kLK/BTr2q5ZgjlGOEAj1BubRZ/+GaBqKVCiLVAsKc2UQ6i4iqKSaqZjsRfPOTBE3Bzy+egIAeBPj3cCdlAT0I8L8AvT6kTT4LIYQQ7cPnBOzDDz/kt7/9LWPGjOHQoUPs3LmT22+/nW+++YZ//OMfpKamtkec4hwyJDGUD37MZkdWpfcnmULBMgAK97hHwQbcyEXmi1iydwlbi9ylJRRFIejyyylfupTGY9+hGq4kkURScneg9BlPQkJCu9yPwWCgZ8+e9OzZk8mTJ1NeXk5mZibHjx8nMzOT2tpasrKyyMrKYu3ateh0OuLi4khISOCKhAQSEhI8yaHN5SKnoZGs+kay6m1kNzSSXd9IdoP79xqni3KXH+XEADGgDG0RT6hiJUItIlwtIrKhlIiGEiLL9hLJaiIoJYhqjIZoAgIuICCgp+dnYEBP9PrQdvmMhBBC+MbnBOzOO+/khRde4Le//S0AEyZMYM+ePdx9990MHjyY6mofqqADr7/+Ov/7v/9LQUEB/fv35+WXXz5tmYu1a9cyb9489u3bR2xsLA8//DCzZ89u1mb58uX86U9/4ujRo/To0YM///nPXH/99T71q6oqTz31FG+//TYVFRWMGDGC1157jf79Ty7Gfvvtt/nXv/7F9u3bqampoaKigtDQUJ/uvzsamhgGwO68SuxOF3qtl1OEyWPcCdhxdwI2JHoIGkVDTk0OhdZCLAEWgiZOoHzpUmq//Zrox2dS930xgwKHsX5/HrUVNoLC239KLjw8nPDwcNLS0lBVlbKyMo4fP+5JyKxWqychaxIZGUnCiWQsISGByyIjUZTgZtdVVZVKh5Os+kZyGhrJbWj+M6ehkVqni0o1gEpSOaq0/o8dg2ojorGU8MYyIitKiGAPEawhghIseieJAeFEBCYTENBLEjMhhOgkPidg27dvp3fv3s2OhYWF8e9//5t//OMfPl1r2bJlzJ07l9dff53Ro0fz1ltvMXnyZDIyMkhMTGzRPjMzk6uuuopZs2bxz3/+k40bN3LPPfcQFRXFjTfeCMDmzZuZPn06zzzzDNdffz2ffvop06ZNY8OGDYwYMcLrfp9//nkWLVrE0qVL6dWrF88++ywTJkzg4MGDBAUFAVBXV8eVV17JlVdeyfz58339KLut1MgAQkx6qurtHCio4cJ4L6fDkkbD96+7F+Lj3heyb3hf9pXtY2vRVq5JvQbTkCEYkpNpPH4c6vfhUiKI9IsjrOYIpbm1HZKA/ZSiKERGRhIZGcmwYcM868dycnLIzs4mJyeHsrIySktLKS0tZccO9x6Wfn5+xMfHEx8fT1xcHHFxcfj7+xOm1xGm1zE4uOV0qqqqVDmc5DQ0ktdgJ9fWSF5DI3k2O7kN7j8XNTpoVIwUEEcBcS0DdgBVEFhZQwQlRLCTcL4lWttAnJ+BBP8QUoJiSA5NJiywFzpdUDt/gkIIcX5SVFVVz+TE0tJSFEUhIiLijDsfMWIEQ4cO5Y033vAc69u3L9dddx3PPfdci/Z/+MMf+OKLL9i/f7/n2OzZs9m1axebN28GYPr06VRXV/Pf//7X0+bKK68kLCyMDz74wKt+VVUlNjaWuXPn8oc//AFwl9owm80sXLiQu+++u1lca9as4dJLLz2jEbDq6mpCQkKoqqoiODj4l084R9z67o+sPVTCU9f259ZRyd6dVFcOz6cCKjx4CILMvLDlBf6e8Xdu7HkjT456EoDSv/2NkhcXYRoyBOM1v8e5p5bC+iwCbxpFn5FdbwrcarWSm5tLTk4OOTk55OXl4XA4WrSLiIholpSZzWa0Wq1PfdlcLgpsdk9iltfQSL4nQbOR19CI1fXL11FUFyFUEqWpwqyzE2vUEW8KIjkwipSQeBL9Q4gy6NDI05lCiPPU2X5/+zQCVllZyWOPPcayZcuoqKgA3KNfN910E88++6xPyUdjYyPbtm3jkUceaXZ84sSJbNq0qdVzNm/ezMSJE5sdmzRpEosXL8Zut6PX69m8eTMPPPBAizYvv/yy1/1mZmZSWFjYrC+j0ci4cePYtGlTiwTMFzabDZvN5vnd1ynbc8XQxDDWHiphe3aF9wmYf/jJdWDH18OF/8NFlov4e8bfPevAAEKmTqXk5b9Sv2MH0Y/4U7q7GospiYIjmdAFE7CAgAB69+7tGTl2OBwUFRWRl5dHbm4uubm5lJeXU1ZWRllZGbt27QJAp9MRExNDXFycJykLDQ09bUkKo0ZDsslIsqn1h2JUVaXa4STfZifPZie/oZGceivZ1gry6usoaFQpchpxKDoqCadSDeewHbADtUAJQC6Qiw4nUVobMQaFOJOJpIAw4k0BxBr1xPsZiDXqCdFppYSGEEK0wusErLy8nJEjR5KXl8fNN99M3759UVWV/fv3s3TpUr777js2bdpEWFiYV9crLS3F6XRiNjevXm42myksLGz1nMLCwlbbOxwOSktLiYmJOWWbpmt602/Tz9ba/HRdz5l47rnneOqpp87qGueCoUmhAOzIrvTtxOSxzRKwIeYhKChkVWdRUldClH8U+uhoAseOpXb1amq++YJKxwWE6yPRNpzRYG6Ha1qkHxcXx/DhwwH3KNlPE7K8vDxsNptn1KxJQECA59y4uDhiY2N9evpTURRC9DpC9Dr6BjaVjYkEkjxtXKpKmd1BVm0lmTXZZNWUklNfS4HNQaFDR4krlEpCcShaCpz+FNTD9nqgvAKoaNafvwbi/QzE+RmJMxqI9dMTZzQQd+JnjFGPn7drBIUQohvxOgF7+umnMRgMHD16tEVi8vTTTzNx4kSefvppXnrpJZ8C+Pm/jlVVPe2/mFtr//Pj3lyzrdr4av78+cybN8/ze3V1dbs9vdeZBiWEoiiQXV5Haa2NyEAvy5SkjIHvX4PM9QAEG4LpE96H/eX72Vq0lckpkwEI/Z8bqV29mqrPP4cR7s9Ta1dwlNajAqiqexfuEz9VtfkxjZ8ObYRflxmdCQgIoFevXvTq5S7q6nK5KC8v9yRjeXl5FBYWYrVaOXToEIcOHfKcGxYW1iwps1gsGAyGM45FoyhEGfREhUcxLDyqxft2eyWVtUfIqjrE8ZoisuuqyG+wUew0UUok5URSRgQ1Sgh1LjhU18ihusZWenKL1OuI9dMT3yxBMxBv1BPnZ5CpTiFEt+R1AvbZZ5/x1ltvtUi+ACwWC88//zyzZ8/2OgGLjIxEq9W2GO0qLi5utY+mflprr9PpPGvRTtWm6Zre9GuxuGtXFRYWEhMT41Vs3jIajedFzbRgPz09owM5VFTL9qwKJvb3oR6YooHyo1CdD8GxpJnT3AlY4ckELHDsWLSRkThLSz2nRmQbKHxh66mu3IImUI8xKRhDSgjGlBD0MQEomq7xRa/RaDyL+wcPHgyA3W6nsLDQk5Dl5eVRXl5ORUUFFRUV7N27F3D/wyE6OprY2FjPy2w2o9OdUdm/FvT6UKLChhEVNoyflpi12yuorT2M1XoYa91qymqPk22toMiuofREUlZGFGVEUkYk5URgU/wotTsotTvYXdP6NmZ6RSHGqPeMmjVNb8b5uUfS4o0GAnW+rZUTQojO5vX/IzeVaziVAQMGnHLqsDUGg4G0tDTS09OblYhIT09n6tSprZ4zcuRIvvzyy2bHVq5cybBhw9Dr9Z426enpzdaBrVy5klGjRnndb0pKChaLhfT0dIYMGQK4146tXbuWhQsXen2P57uhiWHuBCy70vsEzBQKloFQsNOzLdEwyzD+uf+fzdaBKXo9IVOvpXzxu+RaMwnSBaPVGdDqdSc21FZQNLj/rCien8qJ95zWRly1dur3lVG/r8x9TaMWQ1IwxuRgjKkhGOKDUM6yyn5b0uv1njIWTerr68nPz2+WlNXW1lJUVERRUZHnqUutVovZbCY2Npa4uDhiYmKIioryeZH/6eMLIyxsOGFhwz3HRuEeMbNaj7gTM+sRrNbvsNYdpcFWSK0a6EnITr6iKFfMlCvRlKlB2FWNu15aQyNgbbXvYJ3GM3IW15ScnfgZa9QTYzSg7yLJtRBCgA8JWGRkJMePHyc+Pr7V9zMzM31+InLevHnccsstDBs2jJEjR/L222+TnZ3tqes1f/588vLyeO+99wD3E4+vvvoq8+bNY9asWWzevJnFixd7nm4EuP/++xk7diwLFy5k6tSpfP7553z77bds2LDB634VRWHu3LksWLDAU4BzwYIF+Pv7e/a9BPcIWWFhIUeOHAFgz549BAUFkZiYSHh4uE+fRXc0NDGMD7fksPV4uW8npoxxJ2CZ62DgNNKi0wA4VnWM8oZywv3cn23ojf9D+eJ3OVy5k/2Vq7n4f+Yw+lcTT3Phk1SHi8bcGmyZ1TQer8J2vBrV5sR2qALbIfc6JkWvwZASgl+PEIw9QtHHBnaZEbImJpOJHj160KNHD+DEIvvqavLz8z2JWX5+Pg0NDZ5jW7e6E1mdTudJymJjY9slKQP3iFlo6DBCQ5tvyeRw1JxIyI5irWtKztb8//bOO86uqtz7v91Pb1PO9JaEhCSUhADSlS7CFbxcEJXy4lW5gBK4KlwVBZWmV65XaWKBawWVIigIQRAFQjEhGEif9EyfOf2c3df7x9pnzznTJ0xmMsn65vN8nmc9e+191uwp+5e11l4LqrrbGSoGLPBIIDYozrg6pKUWDHB16CdRdNs+pC0eadNG2lSxPqeO2AYOQI0ioV6RUDdEpNGyjAqJvTDAYDCmjwkLsLPPPhtf/epXsWLFimHzSzRNw80334yzzz57Uh9+8cUXo7+/H9/85jfR2dmJxYsX45lnnkFzM50Q3NnZiZ07d7r1W1tb8cwzz+D666/Hvffei7q6OvzgBz9w1wADgOOPPx6PPPIIvva1r+Hmm2/GnDlz8Oijj7prgE3kcwHgy1/+MgqFAq6++mp3Idbnn3/eXQMMAB544IGyCfUnn3wyAOChhx7CFVdcMal7cSDygTYqyN/ZnUReN+GTJ/jj1nIy8NoP6UR8ABFPBHMjc7EluQVvd7+N05pPAwAoba3wLl0KWJNvGyfyUFrCUFrCABpBbAKjKwdtWwr69jS0rUnYObNckHlEKG2Dgkys9u13gozjOITDYYTDYRx66KEAqChLJBJlgqyzsxO6rru9ZkVKRVltba0ryqZq+LIUUQwiHF6CcHhJWd6yCsjntzrCjAq0fL4d+fwbIMTAkK0yocKDflQhIy9AWjoESaER/VwVeu0Quk0ZHZoFnRB0agY6NQNI50dsj4fnUKfQHrPSuWh1JWKNDXUyGIypYsLrgO3evRvLli2Doii45pprsGDBAgDAunXrcN9990HTNPzjH/84ICeU70sO1HXAAPrgP/Gul7AnWcAvPn0MTpo3fEL3iKhp4K4WgFjA8neBSCO+/fq38ejGR/GpQz+FG4+50a2afOxx/N9vn4CJxKR6wMZtu01g9uShbklCa09C25oC0cqVHucRobSEILeEoLSGIdcH9qshy7EoTvLv7Ox0e8aKomwoxc3Ki4KstrYW8Xj8fU3037s2GygUdiGfb0cuvxX5nOPzW2CamVHP44UQDO9iZJVDkRTbkODr0E9i6La86NAsdGh0AduJEBJ5V6QVxVmd81ZnnfNWp5e91clgHBRM2zpgDQ0NWLlyJa6++mr813/9V9nbh2eccQbuueceJr4YZXAch2PbYnh89R6sbO+fuADzhIC6I4E9q+g8sCMvwdLqpXh046NY3bO6rGro7LPA/e5JgABmd8/UtZ3nINX4IdX4ETyxHsQiMDqyUNupINN3pEFUE+qGAagbnCFWkYfcGIDSEqairDEI3idNWZumktJJ/ocddhiAclFWaqqqusPtxTllxUWYa2pqXKutrYXf79+HbZbg97fB729D6U8SIQS60e8IsnbkXXG2Daq6G7aVhpB9DeHsawijdMENDh5PHXz+NoiVbchK85AUmjHAVaPX9qNDM7FHNdCh0cVsU6blDnVuGGWoEwBikuCKtNqyeWg0rpHZ0hsMBmOSC7G2trbi2WefRSKRwObNmwEAc+fOZfOdGKNyXFsFFWBb+yd3YstJjgD7OxVgcbop9YaBDcjqWQTkAACA9/vpW5MEsAsjv0U3FXACB7kxCLkxCHywkQqyzmzZHDI7Z0Dfloa+bXBxXbHaC7kpBKUpBLk5CLFq/xu2LDKSKCOEIJlMDhNluVzO3V6p+PYlAASDQVeQxeNx1NTUIBaLgef3neDgOA6KXAlFrkQ0emzZMctSUSjscHvM8vltyBe2IZ/fCtPMQFX3QFX3AKDD3TKAGgC1nIxjvU3w+VrgizbD52uFrbQgyTegl4TQqZnYo+noUOmwZodGdx7IWzYGDAsDRgHvZkf/eayQRFeU1Tq9aLUeCbWy5Ho/G+5kMA5o9mpiRzQadReQZDDGojgP7J+7U8hpJvzKBH/kWk8CXv0+nYhPCGr8NWgINGB3djfW9K7BifUn7rtGTwBO4CA3BCE3BIGT6kEIgdlXoPPHtqWg78zA7CvA7KGW/0c3Pc8jQm4KQmkKQm4KQW4I7Le9ZAAVN9FoFNFoFAsXLnTzmUzG7RUrWn9/PzKZDDKZjPsfNIC+vVldXe0KspqaGlRXV8Pj2ff7dgqCB4HAfAQC5fvXEkJgGP3I57dTUZanoiyX34ZCYScI0ZHPb0E+v2XYNXneg7neZhzma4bX2wxfqAVeXzO8niaoQhU6dbrTQIezDVSHI9Q6NAOdmo6CTRe67TdMrB1DpIVEHrWK7IqyGpmKtRpl0FdIbI00BmO2MvUzaxmMEhpjPjREvdidKOCt7QP44PzqiZ3YdBzAS0BqF5DYBsTasDS+FLuzu7G6e/WMC7ChcBwHqcoHqcoH/9F0yQ0rq0PfmYG+MwNtRxrG7gyIWj6xHwDEKtpLJjfRHjYp7gcn7N8P1WAwiGAwiHnz5rk5TdPQ3d3tCrLiUhiGYQyb7A8AkUgE8Xi8zPZ1b1kRjuMgy5WQ5cphb2cSYkFVO5EvUHFWyG93Y1XdDdtWkc1tRDa3cdh1eV6B19uEKm8TmrzN8Hqb4As3wettgsfTDI4TkTQtp9eMCrJiL1qxJ61TM5C1bHe4c+MYw50SxyGuiKiVZVeYxRUJNbKIeFGosd40BmO/hAkwxj7nuLYK/G7Vbqzc2j9xASb7gYajgZ2v0V6wWBuWxZfhqfansKp71b5t8BQhBGR4F1bAu5D2AhLLhtGVh74jDX1nGtquDKx+FWZvAWZvAflVTi+ZzEOqD1JB1kC9EJL3+yUSFEVBU1MTmpqa3FxxXlmpKOvq6kImk0EymUQymcTGjYNCRhRFVFVVIR6Po7q62u05CwQC0/b1c5wAr7cBXm8DKmLlQt+2DajqHuQL21HI70C+sAOFwnbk8zsccaY5651tHvG6ilIHn7cJHm8j5nqbcJi3Ed7KRni9zZCkwUm8GUekdTmirMsRbF2OdeoG+nQTBiHYrRrYrRpjfk0BgUeNIiEuU4EWl8UhZZpjQo3BmD6YAGPscz7gCLDXt052PbCTBwXYUVfgqDhdD2xt31polgZFKN9RYP17L6Hzaxsge32QPV5IHg9kr9eJvWWxPxJBVXMblEnso/h+4QQecn0Acn0AOL4OgNNLtitDbSf1RLOgb0tB35Zyz+WDsjsHTW4MQG4Igvfs/7++pfPKFi9e7Obz+Tx6enrcXrLu7m709PTAMAx3nlkpXq+3TJBVVVWhuroaXq936Efu469HovPCfC3AkGUPbduEqu5BobAThcIOFAo7HYG2A4XCLti2ClXdBVXdNXTLTACAKIbh9TbC62mEx9sAn6cRi7wNWBZugsdTB54v/3k3bIJu3RFk2qDvcXJdjs9aNrKWjS15DVvy2phfX0DgUS1LqHZ60KplEdWOSKuWRcRlCVWyhJgksKFPBuN9MuFlKBj7hgN5GYoiHckCjr/zRQg8hzVfPwNBzwTnPG1/FXj4HMBfBXxxMwiAU393KvoKfXjorIewrIYOHd37yS9ANbfuVduitXWobp2LeNtcxFvnorq1DR5/YK+uNRUQm8DszVMxtpuKMqM7B9jD64pVXsj1AUgNztBlrR+8PHt7MGzbRiKRcMVYUaANDAxgtD9TwWDQFWOlfjrml00GQgh0vcfpKduFfGEn1MIuKtbUXdD1vnGuwEFR4vB4GuD1NMDjrafeUw+PpwEeTy14fuRlQbKmhW6dirNuzUC3bjqeCrQe3USXTl8gmCgCR/fwrJYlVDkirVoW6R6isohKJ66URESZWGMcoLzf5zcTYDPMwSDAAOCU776EHf15/OyKZTh1wQT30zQ14M5mwCwA/7ESiC/EF1/+Ip7b/hyuPfJafO6IzwEAfvnpXyHBcThikY7aE+fDKBSgFwrQ1QIMtQBdVQfLhTx0VUW6tweZ/t4RPzYSr0V121zUzpmHmrmHIN46F9IMPtBt3YLRkR3sKduVgZUYoSeDB6S4H1I97SGT6wN0f8tZsjbZaBiGgb6+PleQ9fb2oqenB6lUatRzQqEQqqqqhtl095hNFNPMQVV3O4JsNwqFXU6ZessaefHYQYoCrb7E6uAtiQVh7N7erGmhSzfQo5no0WlPWrfuxJqJbic3YExu5WORo299FsVZhUQFWmXRO0Kt0jnG1lFjzBambR0wBuP98IHWCuzoz2Nle//EBZioAM3HAe0v0mHI+EIcFT8Kz21/Dm90veEKMI7jwYtxVFYC844+bsJtyqdT6Nm6Bd3b2tHt+HRvN5LdnUh2d2LTyr+7169obELNnHmomXMIaubMQ2VTC4R9sDr8SPCyULJqP8XK6tD3ZGHsykDfnYW+OwM7a8DozMHozLlvXYLnINX4INcHqTCbhaJMkiR3AdhSVFVFb2+vK8iKls1mkU6nkU6n0d7eXnZOIBBAVVWVOyxajIPB4IzOsRNF/4hvawLFNzYHUFB3014zdQ9UdTfUwm43tm0NmtYFTetCKjXyHElJisLjqYNHqYPiqYPHUwuPUgePpw6KpxZ+uQpzfR7MHWdU3nDe4qQijfpeR7T1GiZ6nflpvbqJpGnBJKC9bhNc7NYn8KiQxEGThZKY+phrAkIi62FjzE5YD9gMc7D0gP1hzR5c98gaLKgJ4s/LT574ia/8D/DCLcD8jwCX/Bq7MrtwzuPngAOHZz72DBqCDfjVv/8GSTGOo5t7MfeswyCH/JAiQcihALhJrtZeyKSpIGvfjK72Tehq34zswPA1zARJQnVzG+Jz5qJmziGIt81FrL4BPD8zQ4CEEFhpfVCQ7cnA2JOFnR/hocdzkOI+SHUByHW0x0yq9YOf6BIh+zmFQgF9fX2uOCvaWD1miqK4oqzUotHoPtmGaSopLkSrFnZTYabuQUHtgKZ2OPEeWFZ23OtwnAhFiUNRauFRaqB4HK/UwuOphaLUQJYrwXETF++6baPfoGKsVzfRp5voM0z06YbjTfTrJnqd2NiLx5HAAVFxUJBFnWHPqCQiKgqIlZadXFgSoEzD27aMAxs2BDnLOVgEWCKn46hvr4BNgNduOhV1kQkOBe1ZBfz4VEAJAzduA3gBn33+s1jZuRKfOewz+MLSL+BX//4IkuLwtys5YoG3DQi2CR4WBM6CwNkQeQJZBmI1PlTMr0V8SRtiDWFIysjiKTvQj672zY5tQlf7Jmi53LB6kuJBdesc1MyZi3jbPMTb5iFaUwtuhv7QE0JgJTUYe7LQ99BeslFFGQeIFV5IdX6nl4yKMiE4vdsN7Us0TUNvb68rzoo+kUiMOseM4zjEYjFUVFS4oqyiogIVFRXw+/37/ZupRQwjTRed1TqgqZ1Q1Q6oWgdUtROa2gFN7wYh4w8tcpwIWa5yhFkNFWyeGihyfLCsxCEIkx+yJ4QgY9no1013nbRi3OfEA4bpLHRL4+wk5q0NxSfwiIoCIpKAiCgiIgkIi9QiooiwJCDilMNOnZAoICTykJl4Y4AJsFnPwSLAAOBf738Nq3YkcNsFi/HJY5vHPwEAbAu4qxXQUsBnXgTqj8KKHStww19vQKW3Es9f+DzWPPBXrFmjwYIIixPpyvh7gU9QEYlJqGyLoeKQWsTq/IjV+iEPeduQEIJkd6fTS7aZDl9u3QJDG75ek+z1obq1zRFkc1HTNheR+H4gyjqy0DtyMDqyMPZkYaWH7wEJAHxQglQbgFzrh1Tnh1QbgFjp3W9X898bTNPEwMCAK8pKzTBGX97B4/G4YqzUYrEYFEUZ9bz9Eds2oeu9jkCjQ5mq1kkFmtYFTe2EpvcAmNjjQhRDVIzJ1ZCVajdWlDhkuRKKUg1Zrt4roVaKZttIOIKsXzcxYJpIGBYShunmE4aFhGkiYZhIGhaSpjXBr2J0vDzniDEq0IKOD4kCAgIVaUGnTHM8Qk49v8AjKAhQeG7WCHjGyDABNss5mATYPS9uxn8/vwmnHxrHTy5fNv4JRX7zCWDjn4DTbwFOvB6GbeCM352BfrUfd3/wbpzRfIZblRAC2yTQCxqMVBZ6Mgs9nYeRycPIFmDkVBg5FdnuFBIdOaTyArJKFQx59Hvv81iIxb2oaKtERWMIsdoAorW+MmFm2xYSHXvcXrLurVvQu30bTGO4sJG9PsRb56C6tQ3VrXNR3dKGWF0DeGHm3mC0sjqMjhx0R5AZnTmY/YURn7ecxEOM++hembV+d89Mwb//rui/NxBCkMlkygRZf38/+vv7kUwmxzw3EAi4PWelPhaLTfsm5lOFbRvQ9V5oWjdUZ76ZpnU7Nli27bGXuihFFIOQ5WoochUVanKVu0CuLFdBVpyyFAXHTc3vh00I0qaFlGkhYVhImlSYDRgm0iYVaCnTQsooxvR4yrTeV4/bUEQOCAoC/CIVZAFBQEDk4RN4BAQq1AICD79Txy/QYz6eer8g0HJJnom66YUJsFnOwSTA3utI4SM/eAVeScDbXz8DHmmCf1BffwD4841A24eAy54EAPzv6v/FT9b+BMfXHY8fnfGjvW4TsW3oO3YguWotet/Zjv7tA0imgJy3GjlfLXQlPOq5fh+hw5htFaioDyJW50e0xu8OZdqWhf7dO50J/lvQ3b4FvTtGFmWirKCqqQXVRWHW3IaKpmZI8sz1pNi6BaMrB6MjB6Mz607wJ8bIDyEhJEMsFWVxujMAJx14wzWGYWBgYMAVZKWWz4/9xmIwGHTFWDQadeNYLLbfLZ8xWQghMM0MNL0butbjiLMeaDoVarrWA03vg673TEqoATxkOeaIsUrIcgUkucIpV0CWqUlSBWQ5BkHYN2+7WoQg4wi09Ag+Y9rImBYyVknZspBxjmctG7kpFHFD4QF4BR5enofXEWY05uDhaewReHh4WvbwPDwCR/OOgJOdYwrPQSnxsnNM4XhIPAeF5yBxHGSeh8xxEA+gXvGJwgTYLOdgEmCEEHzgjr+gO63h51ceg5MPqZrYid3rgPuPA0QvcNMOQFSwO7MbH378wwCAZz72DBqDjVPXTl2H1t4OdcNGZN7bjL72XiS6VWT4CHL+WuT8tdBH7TEjCPgIonEvKlorUNEYRrTWj2gN7TGzTBMDe3ahe1s7era3o2dbO3q2b4OhDt8TkON4ROvqUdXciqrmVlQ73h+Nzdj/colNYPYXqDDrzMHoysPoysEaGGW7HN6ZW1YUZDV+iHEfxIoDaxizlEKh4IqzoV5VR99WCKALzhaFWdGK5WAwOC3bNE0HRaGm6z3QtB7as6b3QNf7oGt91Ou90PReGEYCEx36LMLzXshyDJIUo+JMikEqlqUoJNdikKQIJCk8ZT1s42ETgpxFhVrWspE1LWQsG1nLQs4p5xyhlrMGRVvWtJC3bORtGwXLRt7J5y0b+n7wGOcAyDwHkaPCTHIEWjEWOWoCBzcuzQklnkdJzAECqOcdDwA8x4EHwHP0szlw4Eoaw5W0iwOHj1SFcVTYP6VfMxNgs5yDSYABwE2P/ROPvLULVxzfglv+ZdHETiIE+O9DgFwPcMWfgBa6PcznVnwOr3W8hk8v/jSWH7V83zUazgOjuxvqhg3QNmxEZvMO9O9OI5m0kZWrkPNRYWbIwVGv4ffYiFYpqGiNIdYcRTTuQ7TWD8UrINHViZ5tW9CzfSu6t7Wjd/tWFDLpEa/jDYVR1dSMysYWVDQ2o6qpBRWNTZA9M7fGla2aMLrzjigrWh5EHWXpAZGDVOmjQ5mOiXE/xJjngBVmAN0BYGBgAAMDA0gkEm48MDCA3AgvdpQiCAIikQii0eiI3uv1HpDDT7ZtwjAGoOu90PV+akYfdL0fht5PxZrh5PUBEDLyfMax4RwhFoEoRlxRJklRSKLjpQhEMQxJCpf44LQJt7EwbeIKs0LRO2It74g01bah2gRqSVywbadMoNs2NJtAdbzmepozCM3pNnHi2SUdvju/AZfWVU7pNZkAm+UcbALsz+924apfrkJzhQ9//eIHJ/7A+P2ngXd/D5z8ZeDUrwIAXtjxAq7/6/WIeWJ44cIXIAnTPweJ2DaMjk7oW9uhtW9FZstO9O9MITFgIstHkPPVID9mjxmgyDYilQoqmqOI1ocQrfUjUu0Fx+XRv2s7enZsQ69jiY49IGTkIYxwdRyVTS2obGxGRUMTKhqaEKtrgDhDc44IIbAzuttLZnTnYXTnYHbnRx3GhEg3NRerfZCqvNRX++jE/1m0dtneoGkaEomEK8yKcSKRQDKZhG2PPXSlKAoikYhr4XC4rHygCrRSCCGwrCx0fYCKNmMAhl70/TCMBHQjAcNIwDAGYBgJmGbmfXwiB1EMOKItBFEcNEkMQRSDEKWwkwtCFILUiwGIYhCCEADP79/LnIwGIQQmoUuNaITAdISZQQiMEWKLEJjOOaZdjGneIAQ2ASwQWIQO9dqOt0B7DYnjbQA2AWwQEAKnTGVMUcwQ0P+305gG51ZFWA8Yo5yDTYBlNRNLvvk8DIvgxf88BW1VE9z2Z/XPgac+DzQeC3z6eQCAYRs48/dnoq9At3E5oe4ERDwRRJQIwkoYESWCqBIdjD009or7vqeIEAKrvx9a+1boW9uR3rgDAzsHkOgzkbH9yPviyPlqoHlio16D5wnCFTKi9WFEavyIxn0IxERYRi8yvXvQt2s7+nbtRN/O7cglR9hcEHQYM1JTg1h9EyoaGgeFWW39jK3uT2wCK6FSQdaTh1n0PWMIMx4QY16IVV4qyKp8NK7ygvcdWJP/R8K2baTTaQwMDCCZTLqirOiz2fHX+ZJlGeFw2BVmxbhowWAQwgy+CDJT2LYBw0w5Ai0Fw0zANFKOSHO8mYJhJGGaKRhGCqaZmsDuBBNDEHwQhSAEMQBRDEAQ/EN8AKIQgCD6IQo+CEIAguCDIPpoHcFPy4IPPO854EX2/gQTYLOcg02AAcAnf/I6Xt3Sj6995FD8+0ltEzspsQP438MBXgRu3A4odKjvB6t/gB+v/fGkPl8RFNT6a3F0zdE4pvYYHFNzDGJjCKGpxkqnoW1ph7Z5M3Ib29G/tRfJ7gKyJICcvwZ5Xxx5bxUIP7qw8PhFROI+RKp9CMd98AYsEKsPaqYLA507MbBnF/p37YSaG/3BHKqqRqyugVp90TfCF47MyB/xUmFm9uZh9BRg9lBxRrTR16ji/ZIjxqgoE6u8ECu9dDjzINnWxjAMV5ClUikkk8kyG294E6BrngWDQYTDYYRCoRH9bFr7bF9j2zpMMw3DSMM0k44wy8A00zTveNPMwDSc2Mo4dbKw7bHnA+4dHATBC573OqLMS80p84IHAu8BL3iHeCfPK+AFx/OKk5PdMo1pmeNk8Lw0qYV5DzSYAJvlHIwC7Cd/34pv/2k9PtAWwyOfnfjWQfjfI4DEduATvwUOOQsAyibjn9N6DhZWLERSSyKhJpDSUkhqyTIz7ZHnJM2LzsOxNcfi2NpjcVT8KATHmMu1rzD7+6Ft3gxt0yYUNm5CcnMHEt155KUY8t44cr5q5H1x6EpkzOv4Iwoi1V6EqrzwBg3wJAFD60U+1YVE527079456vwyAFB8fkRr6xCtradW5/jauhmZZ+YOZfbkYfYUYPTmYfZScTba+mUAAJ6DGPNQMVZZIswqvRCC8gE912wohmG4wiyVSo1o4w1xAnQeWjAYRCgUQigUKouL5YO1J22yUAGXpYLMEWaWmYNl5WCaWVhWlh63crCK3srBsvLUzJyTy8O2h7/EM11wnOQKM44TwXMSOF5yyhJ4TgTHS84xERwvguMkcJwwmONEOpeO452Yp8cxWAbHg0PRc0PKAJ15Pzj1niudhs9xiEWPH3Grr/cDE2CznINRgO0ayOOk77wEjgPe+MppqA5OcCjsqS8Aq/8P+MA1wNm3u+nrXrwOL+9+GU+f/zQaQ6O/DUkIQd7MI6EmsCW5BW90voE3u97EpsSmsno8x2NxxWIcX388Tqg7AYsrF0OcoXkaxLKg79gJbdNGqBs3Qtu4CbmNW5FOmch7q5H3VaPgrULeW42CrxqGNPaQbiCqIFzthT9MIEgpwEpAL/Qil+xGsms3Ut3do84xo+fHEK2tR6S2DpF4LRVqNXUI19TOyJIZtmZSMdZXoALNic2+wujDmaBrmQlFcVbhhVjpcfzBJ84AOsSZzWaRSqWQTqdH9BMZ5izi9/tdMTaSBQIB+P1+JtSmCEIsWFbBsTwsuwDbypflbFuFZRUcrzp1VFi26hzXhpllqSVlHbat7+VLDjPPgvnfRn39JVN6TSbAZjkHowADgPPvfRVrdiVx678swuXHt0zspHcfA35/JRBfDPzHq27atE1olga/tHcTLAfUAbzV9ZYryHakd5QdD8pBfKD2Azi+jgqy2kDtKFeaPqx0GtrGjVA3bIS6YT20DRuhbd4M3RYdMeaIMm8VFWn+OEx+bKHrjygIVUhQfDkIYhq2OQC90Id8sgfJ7g4U0qPvpQgAgYpKROO1rjiLxGsQqalDJF4D2TvODs9TDLEJrIxeJshcG1DpLN7REHnac1bhcbwXQjGOeg74lwFGwzTNso3Oi5bJZMriifSkFSkKtUAg4PqiOCvGgUAAiqKwoc/9BEJs2LYBQvQyYWYTA8Q2RvWEmLCJCUJMENsEIRYIMUCIBZuYALGcnE3rwHbKlrNNFgEIAYENENvxpeWSKfjurzdx83W1/4ZY7PgpvRdMgM1yDlYBVhyGPLolit9dNcFfilwf8N05NP7iFiAwwXXEJklXrgsrO1bi1Y5XsbJjJdJ6+XBda7gVx9cdj6Nrjsay+DKEx1isdTohpgl9+3ao6zdA27gB6voNUDdsgNXfDwLAkPwoeKuR91ah4K2CGm6AGq5DTozAsMfu4fMGJQSioOKMT4FYSWiFPhTSvUj1dI64N2bZ+aFwmSALV9cgHK9BpLpm2tc1I5YNK6HB7HcEWb9K4351fHHGAUJYgRjz0B40x4ox75cOaqFg2zYKhYIrxkotnU4jm80ik8kgl8uNuv/mSIii6Ioyv99fZqU5n88Hn8/HetYY0wITYLOcg1WAdaYKOO6OFwEAr//XaagJT3AY8v4TgO53gQt/Biz+133YQoplW3i3/128tuc1vNrxKtb2rYVdMkTHgcOC2AIcXXM0jq09FkurlyIgT/DNzmnC7O0d7ClzRJm+fTtQ0lNhiD4UvFUoBGqg1c+HFm1EXqlAzlQwztqhkDwCgjHA48tBENIgdhKGOoBCpg+Zvq4x55sBgCjJCMdrEK6OU1/lxI5NZ+8ZsQispOqIsaI4owLNGlDHHNYEAE7mIURpT5kQVdxeM5pTwHnFg1qgFbFtG7lczhVkpcIsm82Wma5PfsjL4/G4gmyo93q9rlArGuthY+wNTIDNcg5WAQYAF97/Gv6xI4Gbz12IT5/YOrGT/vwV4PV7gaWXA//yg33bwBFIaSm80fmGO1y5Pb297LjACVhYsRDL4suwpHoJjqw+ElFPdNrbOR52oQBtyxa6sOz6DXR+2YYNsEfoyTIFD/T6Q2C0LIZW1YqCrxo54kcmS5BLjv1wFCQegSgHrz8PUc6CIymYegJqrh+5RA8yfX1jzjkDAG8whHB1HKFqR5hVxRGuqkaoOo5QZfW0rXNGXwYwYCZoT5nVT4czzYQKa0ClLwSM89eUUwSIUQVCxBFojhciCsSo04N2kM0/Gw9d111hlsvlymxobrxtoEaD53lXmHm93jIrzXk8njKvKMoBszsBY/IwATbLOZgF2MOvbsMtT6/DkqYInrj6hImdtHkF8KsLgWAdcP17wAz/8evJ9+CtrrfwVtdbeLPrTezK7BpWpy3chiXVS7CkegmWVi9FQ7Bhv/zfNrFtGHv2UFG2cRMdxtywEcau4V8TAHCyDGHufFhzDodWMw9qqBZ5IYxMxkaqt4DMgAYyxnAexwH+qAR/SIek5MDzadhmEoaaQCHdh3RfD9Ts+Itk+qMxhKqqEa6KD/rKKoSq4whWVk3bywHEtKkYS2iOd4SaU7azxvgXETmIYQVCmIqyookRD43DCniFDa+NRnEItCjGhvpSKxQKyOfzMIwJfF/GwOPxlAmzoimKUlYu5opWLIvi7FyIlcEE2KznYBZgPWkVx97xFxACvHLjh9AQncBQk6kB35kD6Bng0y8AjUfv+4ZOgq5cF97sehOru1fj7Z63sTW1dVidSm8ljqw6EkdUHYEjqo/AwoqFUISZ23R7PKxsFtqmza4g0zZsgLZ5M+xRehuEigooh8yDPG8+zMb5UKONKCgxpFMW0r0FpHoLSPcWYI4znOcJSAjGOCi+AiQpB5A0TCMBLTeAXLIP6Z5uGNr4ayn5whGEqqoRqqx2fBVCVdUIVlDv8U/PkLGtW7CSGhVmSY0KsyQVaFZyYj1oAMB5RAhhGaIjyISQPCjYnDLvYQ/1iWIYRpkoG2pD86qqolAowDRH2WZrkgiCUCbMFEWBLMtlvhiPZZIkQZZliCIb5p4umACb5RzMAgwALv7RSryxbQBfOWcBPnvynImdVNyW6LhrgbNu27cNfJ8k1STW9K7B6p7VeLv7bbzb/+6wtchEXsTC2EIcXnU4jqg+AkdWHYkaf80MtXhiFHvLtI2Dy2NoGzdC37lzcA+QUjgOUmMjlEPmwXPIIZDnzoNV1wrVU4l0wkCqKMz6qFfH6S0SJB7BmIJAFJA9eQhCFoSkYaoJqLkBZPt7kertGXGT86HIXl+ZKAtWViFU6fiKKvijMQjT0EtBLBtWSoeV1GCmHFGW1Gg5qcFKaSDq6AvSlsLJAoSwTMVZyBFmJWU+JEMISAfNQrX7AtM0ywSZqqquaZpWVi7NF21v5rZNlKIYkySpLBZF0c2NFIuiOKoJgjCqL9rBJvyYAJvlHOwC7Bev78DNT76LBTVBPHvdSRP7BV73FPDbS4FIE3DdP0sW39v/UU0V7/W/hzU9a/BO7zt4p/cdDKgDw+pVe6txWNVhOKzyMBxedTgWVSyCT5repRz2Bjufh9beDm3TJmibNkHdtAnaps2w+vtHPkGSoLS0QJk3D8oh86ifOxekogbphE57zPpoj1lRnI03tAkAvpCMYIUCf5gKNF7IgVgpGFoSanYAmb5epHt7xn1BAKDbOfljMQQrKhFyBFqwotIxGk/X7gG2asJKaVSopagoM5MarLRTTmpj7hpQBkd3EXBFWlCmwiwo0TgoQ3DsYF16Y19i23aZIBsqzkbyhmFA1/URbap65N4PPM+XCbKiFfM8zw+zYp7juDI/NDeeFRktPvTQQ9HQ0DClXy8TYLOcg12ApfIGjrn9BWimjSeuPh5LmiYwYV3P0+UojDzw2ZeBuiP3eTv3FYQQ7M7upmKshwqyTYlNsEj5Q5TneMyNzHUF2eLKxZgTngOBnx3zgcz+/kFRtnkz9M1bxhzG5BQF8pw2KHPmQpk7F8q8uVDmzIHU0AACDtmENkSYqUj30VjLj/0g4gUOwZgHoSovAmEekqcAns+C2BmYWhKFjCPQ+nuR7e+DNYEHmyCKCAwRZcFYJc3FKhCsrII3GJoekaZZsNKOSEuXiLO0Diutw07rsDL62MttDIH3ieADVJzxQRlCMQ7QnrRijvdL4ITZ8x+iAwnLsmCaJnRdh2EYrlgrxqVmmuaw2DTNUc0wDPf6pX42yYdzzz0Xy5Ytm9JrMgE2yznYBRgAXP/oGjzx9h5cvKwRd114+MROevRSYP1TwIk3AKd/Y982cJrJG3ms61+HtX1rsbZvLf7Z+09057uH1fOKXhwaOxSLKxe71hDYPyf4jwQhBGZHB9TNm+kislu2QN20GfrWrSCaNuI5nKJAbmuDMmcOlLlzaDx3LuTGRnAS3TtTzRnI9KvukGbRUn0qsv0q7HGEh+QREKrwIFjhRTAmw+M3wQs5gGRg6Snk0wPI9Pci09+HTH8f3Qh9An9GBUlCIFZBhVmswokrnNjJRWPgp2ENK2IT2HmDirKMI8rSjmDLGLAzNG9ldMCaxCOCA3ivOCjMAhLtZQvI4AMSBH9Jzi+B84jsrc9ZjGVZo5pt28PKQ21onhBS5ktjgP7NGM2Kx4sMlTYLFy5EY+PoO6XsDUyAzXKYAAPe3DaAi360Ej5ZwBtfOQ1Bz+ibULus/T3w2KeBirnAtf+YVcOQe0NPvgdre9fin33/xD97/4l1/euQN4f3HkWUCBZVLMLCioVYVLkIiyoWIe6LzxpRBtDtl4zdu6Ft2QJt8xY6pLlly5jCDJIEubkJStsc2nPWNgdyWyuUlhbw/sEdEmzLRjapIdOnIt1fQLqv2HNGy/nU+PNyFJ+IYIUHoQovghUe+CMiJFkFx2Vhm2kUMglkB/odkdaP7IAj0iYCx8EfjrgCLRCNIRCtoEOgUZrzxyrg8Qem5XtKCAEpmFSMpXVYWUecuV6HnTWoiMsZE3qJoAwerhjjS83n5HyiW+aLZXl29PoyDnyYAJvlMAFG/8iffvfLaO/N4bYLFuOTxzaPf5KWoW9DWhrwHyuB+MJ939D9CMu2sD29He/2vYu1fWvxXt972JjYCMMePnk95olhYcVCKsoccTbbRBlQIsza26G1t0Pf0g5t61Zo7e0gY6z/JNbWQmltdXrO2iC3tkJubYVYXT3sHpi6hcyAinSfikz/oDDL9NOcmht/yQLFJyIQ89BetJjHFWmCUACQhZ5PITvQh2yi3xFo/cgmqLetic3fEiQJ/kjMEWgx+GMxt+yPxhCIROGPxuAJBKft+1zsVbOzBhVoWUeo5RyBVoxz1E94rtpQRB6CT6SizCc6Jg2WvWKJl8B7RboArsTPup95xv4NE2CzHCbAKD/+21bc9sx6HFYfxtOfP3FiJ/3648CmZ4EP/hfwwZv2bQNnAbqlY1NiE97texfr+tfhvf730J5sHzafDKCi7NDYoVgQW4BDKw7FobFD0RBsAM/NvsnWhBCYXV3QtrRDa98Cfes26Fu3Qtu2bfTJ/wB4nw9yS4sryOTWFirUWlrA+0Z+4UFXTWT6VSrI+qlIG4wnJtBEmafCLOZBwPH0jU4ZgqSD2FnkU4kSYTaAbKIfuYF+ZBIDUCfw4kARQRThi0QRiMTgj0bhj8Tgj0Thj0Thi0Thj0RoHI5ClCbQ8zyFEMOG5Qg2O1cizvJOOW8OyZmTmrc2DJGjoszjiDNHmJWWeY8IzivQnEcE5xEG8+xFBMYQmACb5TABRunPavjAHX+BYRH88fMnYnH9BPZXXPMb4MmrgOqFwNUr930jZyGqqWJjYiMVZH3vYd3AOmxNbh1RlAWkAObH5rvCbH5sPuaE50ASpvfBPJWYiQT0bduhb9sKbetW6O1boW/bBn33bmCM3iaxupqKs5YWyM3NkFuduKEB3Bgr7+uqicyA6oq0zIBaVs6nJ7D0AAf4QzICMQ8C0aI4Kwo2Bd6AANvMIpcaQDYxgOzAAHKJfhonBpBLDCCXTExoEdtSPP4AfOGiIIvAF4nAH44O+nDEtekWa4AzHKpZVJjljZF9wYkLxZj69yXciog8eA8VZ5wigPcI4BSxLMcpAnhFAOehQ6WD9Zy87Bib93ZAwATYLIcJsEGu/fVq/PGfnfjEsU24/YLDxj+hkAC+OxewTeDaVUDl3H3fyAOAglnA5sRmbBjYgPUD67G+fz02JzZDt4eLA5EX0RZuw4LYAhwSPYQKs+h8RDyR6W/4FEJ0Hfru3VSMbdsGbds2R6htg5UYY74Wz0Oqq6OirLkJcnMzpKYmyM0tkBvqxxRnAGAZNjIJFdmiMBvQkBkYLGcHNFjm2AvUAgAvcghEqDALRBXHPK73RxRIClBIJ6koSw4gl0hQn0oil0wgn0wgl6SxbU1uCQPF54cvHIY3FIE/HHFjXzgMX4iaNxSGLxyBJxAAP4Nv6xJCQHRrUKAVTJCiQFMHc3bBBFEt2KoJopqwC068t0OlY8BJPBVssuAKNU7mB8syD04aIScL9FxpsA4v8YP1JR4QODbUOk0wATbLYQJskJXt/bjkx6/DI/F49cZTURGYwOrwv/gY0P4X4LSvAyf9575v5AGKYRvYmtyKDQMbsGFgAzYmNmLDwAZk9JF7Uaq91ZgXnYdDooe4vjXcClmYnn0Z9yVWMgl9xw5q27dD374d2vbtMLbvGHXZDACD4qypEVJjk+MbqVhraCh7GWA0CCEoZAxkE4OCrCjYsgkq1vITXDGfFzj4I444iyjwRz3UuybDH1bACxzUXNYRZAnkUknkk0nkU1Sg5VNOzrGJzlNz4Th4gyFHlIXgC1LvDYbgDYXLfTAEbyg0bdtHTQRiOz1vjhizVRO2alGRplmDok2znLIJW7dKyo7XTWB8bf3+4QBO5KlQK3qJByQBnMjRXKk59SBy4AQnFor1huSEYj0OHF9yjsDR43zRF+tzAO/ki/4AggmwWQ4TYIMQQvAv97yKtXtS+MJp83DDGYeMf9Kqh4GnrwNqjwQ+9/K+buJBBSEEXbkuV5BtHNiIjYmNI+53CQAiJ6Il3IJ5kXmYG52LuZG5mBeZh/pg/aycWzYUQgjM3l4YO3ZA37kT+o6dVKTtpH6sFwEAQKishNzYCKmxAXKDI84aGyA1NkKsqqIPrQlgmTZyKQ3ZhIZcwhFoTpxNqMgmtQmLNADwBqUSUabAH1bgD1Nx5o8o8IVleIMyeJ4DIQRaLodcKoFCKoV8OumIsxTyqQQK6TTy6RTy6RQK6dSkh0GLiLICbzAETzAIbyDoxCF4nbInEIQnGITHH4Q3GIQnGILi881oT9t4EEIAk7jijOhFYVYi1gwLRLfpMccT3QIxSnKGU3ZyRT/pN1BnAg4AzwFcqShzcjxHX2bnSmKeo+cUF1vl4JbhaDmuJHYS5Z/nEDy5Ad6FFVP65TABNsthAqycP/2zE9f8ejUiPgmv3XQqfPI4W8Dk+oD/ngcQG7juHSDaMi3tPJjJGTlsTmzG5uRmbBrYRH1i06i9ZR7Bg7ZIG+ZG5ro2JzIHNf6aA0KYAfThavX1OYJsF/RdO2Hs2Al91y4YO3fCSqXGPJ+TZUj19Y44a6BxveMb6iFEJrfSvmXZyKd0ZB1RlktqTqwhn9KQTWrIpTTY5sT+/HM8B58j1HxhBb6QDJ8j0nwhx4dl+EIyhJLJ6pZpQs1mqChLJVHIpKmlUyhk0sin01AzKeTTxVxm0sOhg43k4PH54QkEofgD8AQC8PgDVKw5sRIIwOMLQPEHoPj9NOf3Q/H6JiyA90cIIYBFQEx7UJwVhVppzqQGk7ixm7eG5J3roTS2yWBsEXqO44kFwKZ1YZP9ThBGLpiLwLG1U3pNJsBmOUyAlWPZBKd+76/Y0Z/HN85biP93Quv4Jz1wItC1FpCDwLGfpVsURZqBaDMQagDE2T8str9DCEF3vhubEpuwKbEJ7cl2bEluwdbk1hHnlgF0Idm2cBvmROa4fk54DuoCdbNmhf+JYqXT0HfugrFzB/Tde2Ds2gV99y4Yu/fA6OgY84UAgL6xKRWFWV0dtfp6SPU0FmKxSc/7IYRAzRqDvWlJx9I68kkNuZSOXEpDIa1PZJ1ZF8UvwhdyRFqphWX4gjK8Ieo9QQnCkL0oCSHQCwWo2TQK6TQK2QwKmTTUonDLZKBmMyhkqS+aXhh/z8+x4Dgeis8H2eengszng+ILUO/3Q/FRk70+Gnu9tK7PD9nnheLzQ1I8bO5VCcSmQozYjjh0ym6uzIMuZuwIN1KMbScmjqBzfg6JWy7PD1YoaYcTy3V+iBXeKf0amQCb5TABNpxfvr4DX3vyXdRHvPjrlz4IabwNg397GbDuDyMf43ggWEfFWFGURZroAq41hwHS1P5CMsqxbAu7MrvQnmzH5uRmbEluQXuyHdvT24dtSl5E5mU0h5vRGmpFa7gVbeE2tIZb0RxqnhX7YU4WYpowurqoKNu1C8aeDhi7d8PYswf6nt2wevvGvQbn8UCqrR0UZ3W1EGtrIdXSWIrHx31BYDRsy6bz0pK09yyf1pFL6cinNNfn0zryKX3cXQaG4vFLjiCj3huksSfgiLWgBK/jZa84qsCxTANqNutYBmqOei2XRSGbhVYs53O0Ti4LLZ+Dls3CNKZmU2yO4yF7vZC8XiheH2SPF7LP8V4fZK+XHlc81HtoWVY8kLw+yB4PJMUDyeOYrMzqXrmDASbAZjlMgA1HNSyceNeL6Mvq+P7FR+L8JfVjn6DngM0rgOROILkDSOygPrkTMNXRz+NFuoRF/VGDVjUfOMB6X/ZHDNvA7sxubE1uRXuqHe3JdmxNbcW21DZo1iir3QOo9deiJdSC5lAzWsItblzrrz3ges2K2KoKo6MDxp49VJh1dFCR1kHN7OkZ/yIcB7GykoqymhqINXFINbWQauIQi766Gpw4zpD/GBCbQM0bVIw5gqyQoZ7mNOTTBvIZHWpmcr1qAH2pwBOQ4A3I1AcleP0SPEEZ3oAET9H8Ei37JYgTWDXf1HVXmGn5HPR8Dmo+Bz2fh5rLQi/koeZoXsvnoBcKjs9Dy+eh5XMg9r6ZXS8qChVligeSorjCTPJ4IMoKJEWB6BwTZQWiLDuxTI/LxVh2jwuSDFGWIErFWAYvCKz3bi9gAmyWwwTYyNz70hZ897mNmFPlx3PLT4Y4Xi/YSBACZHtKRNn2QXHWsx7I9Q4/R/IDdUuA+iVA3VIaR1sO+K2O9hcs20JnrtMVY0Xbnt6OAXVg1PNkXkZTqAnNoWbqg9Q3BZtQ7Ru+4v2BhK3rMDs7XUFmdHbB6Oxwcp0wOjtH38KpFJ6nIi0edwRZnMbxaojxGojxakjx+KiL1E4GYhOoOSrWChkd+YyOQok4y2cMqFnHZ3To6t4tBSFKfJkw8/glKH4JHr9IY59zzCdC8UtQfCI8PgmCNPG/N4QQmLoGLZ+HXijAUAs0VgvQCzRX9IZaoHlVhVHIQ1dV6KqTLxRgaBoMTZ3Q3qJTCcfxECQJgiRCECUIkgRRktx40IvgRRGiKIEXnbpOThAF8IIIXhAco7EgimVljudp2fGcIIDnaZnjOHC8U4fnAZ6jeZ4Hxzk7GTgT8l3jedBXP4tfS/F3nRv8s81x8IXCUHzjv4k8GZgAm+UwATYyadXAKd95CYm8gTs/dhg+fkzT1H4AIUBqN7BnFbWOt6np2eF1vTFHlDmCrG4pEJrayZyM8UmqSWxLb8P21HZsT2/HjvQObE9tx87MzhG3YCriFb1oDDaiKdjkirLGYCMag42o9lUfsD1nRQghsBIJR4x1wOzqhtndRYVadxfMzi4YPT2AMf4q/gDABwIQq6sdq4Lkxo5VVkKsqgLvnbrhfdOwUMgYULMGClm9LKbeQCGjQ82ZUHMGtKwx6eHQUkSJh1IiyhQfFWmyT4TipWXZK9Jj3sG87BUhewTwe/MfRoeioDM0DYZagKGqVLBp6mBeU2FqxVijeVWFqeswdQ2moTt5p6xpMA0DlqHTnKHDmuD3+0DhjM9ci8NPP3tKr8kE2CyHCbDR+ekr2/CtP65DPKTgr1/8ELz7ehNe2wL6NjmibDXQsRroehcY6eEeiNM5ZK4dDsTa2PDlDFDsNdue3u4Ksp3pndiZ2YmObMeIq/4XkXgJ9YF6V5A1BhvREGxAfaAe9YH6A3LO2UgQ24bV3w+jqxtmTzeMri6Y3T0wu7thdHe7frylNkrhAwFXjIlV1AuVlRArqyBWVkCsqKDlWOx9DX2O+PUQAl21oGYNqDlj0OcMaDljUKjlnWN5E1rOgFYwp+TtPVERoHgEKshcYSZC9gqQFRGSV6BlD/VS0SsCJI8ASaFlUd53+1cS24ZlmjAdUWYZBizTgGUYrkCzDNPNWaYByzRhmSZsx1um4cQGLMuCbZqwLQu2ZcIyqbeLeduCbVkgtg3btp16FmzbArEsEEJg2zaIY7ZtA8QezBHiTM636bx7J4diHnB7DglI+YR9AB+6/DNY/KEzpvQeMgE2y2ECbHQ008Kp//0y9iQL+NJZ83HNh2ZgpXtTA7rfo2Ks421gz9tA73q67MVQJB8QX0QFWXwRUL0IqD4U8EamvdkMimEZ6Mh1YEd6B3amd2JHegd2ZXdhd2Y39mT3jPoiQJGYJ4aGQAPqg/XUB+pRH6xHvb8eNf6aWb1N02QhhMDO5WD29JSZ0dMDs6cXZnc3zL4+mL29IOoYcy+HwnEQIhGIlZUQKisgxiogVMQGfUUFxFgMQkUFhGgMvN+3D0UJgVYwoeVNaHnD8YNiTS9Y0Aom9Lzh1tOL9QsmLGOK54JxgCQPijJJEWhZESCWlEVFgCTzEIvHnJgaD0kWIEg8RMnJS7xbfj+9dQc7TIDNcpgAG5sn3t6N6x99B0FFxMtf/hBi/v1gSQk9B3SvA7r+SZe/6FpLRZo5yqvwoXoqxKoPHRRlVfPZG5gzjGVb6Mp3YVdml2u7M7upZXePuq5ZEQ4cqnxVqA/Uo9Zfi/pAPeoCdaj116I2UIsaX81B04NWCiEEdjYLs5eKMbOvl/reXlh9/VSk9VNvDQwAk5zAzskyhFgMQiwKMRqjcTRCRVo0BiESoeVolMaRCLhp2rvSMm3oKhVlesGi4qxgDuZUC4Zq0bJqDsYFC4ZmwVBN6BqNp2sdLZ7nIMi8K8oE0YnFQZEmiNR4JycI3GBZdGKBAy/QMi/QsiAMxryzUj4vcOCLXuBpzlkln+NpezhuSLmY4wYXXi2PS+aAFb8wjv6OurHzOVMJE2CzHCbAxsa2CT7yw1ewvjON/3dCC75x3qKZbtLI2BbQ3+6Isn/SSf7d64D07lFO4OiSGJXzgapDgKoFg7FnAhuRM/Y5KS2FPdk91DJ7sDtLhVlnthMd2Q6o1vi9PBElQgWZI8pq/bWI++Oo8dWgxl+DSm8lRH5qh99mE8SyYCUSVJD19sEa6IfZPzDo+/thDji+v39iLxOMAB8MumJMCIcHfTGO0JgPhWguFIIQCu310h3vFzoPzIahUYFGxZkFQ7dgatQXy4ZWzNmwdKeObsPUac7ULcdsmIYNy7AntN/ogcYHPzkfi04a5436ScIE2CyHCbDx+dumXlz2szch8ByeuvYELKqbRQJFTQE9G4Ce96go61lPe8sKo7/Rh2AtUDkPqJhH1yurnAdUzKHrmLE5ZvsFhBAMqAPozHViT3YPOrId1HId6Mx1ojPbiawxwgsdQ+A5HpXeStT4a1Djq0HcH0fcR63aV+3agbDH5vuFEAKSz8NMJGAlErAGBmAOUG8lnDiZpMeKPpV6X28Ucl4vFWOOKONDIQjBYIkPQgiGwAcD9HggCCHgBx8MUpshATcexCYwTRuWbsM0qDizTGquSDOc2BwUbZZpw7bIYK4YO3nbsmGbZDC2CCyreIwuvGrbxC3bzsr6tmXTNVidxVmJTYaVCfC+egWZAGMMgwmwiXH1r1bhmbVdOKIxgsf/43gIs3lTV0LoFkp9G4HeDUDvJur7NgGZztHPE2Qg2koFWayt3EL1AFu0cb8io2fQmetEV64LHVlHmOU60Z3rRleuCz35HphkYtvuRJUo4n4qyqq8VajyVaHKW1VWjnliB3Vv2kgQy4KVTjuCLAkrlYSVTDk+CSuVgp1KwUomYSaTsFNpWOk07Mze7WE5FE6SHDEWgOAPgPf7wQeK3k+93w+hmPP5Bn3RnDLn9R70C7MWV8AnxBFkzkr5ZMiEe1oocxCd4dOphAmwWQ4TYBOjO63itO+9jKxm4psfXYTLjmuZ6SbtGwpJoG8z0L/Z8VscawfGWKCUirOWQUEWbSlZ+b8ZkA++uUj7Ozax0V/oR1euC935btd357vRnetGT74HPfmeUbdyGgrP8Yh5Yqj0Vo5pMU8MASlwQK+N9n4hlgU7k6HiLZWGlU7BTqdhZTJOPgM7k4aVzsDKpGEXfTYHO5OBncvtk3ZxXi/4ovm84Ly+8rLHC97jAef1gPd4wXs94BSP6zmPAl5RaM6jgFOo8YoCzuMBJ8u0106S2M/HBGACbJbDBNjE+fnK7fj6H95DQBHxl/88BfGQZ6abNH3YNpDaNSjIBrYOWmLHyEtllOKvHr4dU7gBCDueCbT9EkIIUloK3flBQdZT6EFfvg89hR705nvRW+hFf6F/zOU2hqIICmKeGCo8FajwOuapQMwTo+aNIapEUeGtQESJsJ61SUJsG3aOijErm4WdzbrCzMrlqFDL5Wg+l4Ody8LK5UByedh5x3I5N57uhVkBUHEmy46XwEsyLUsStWGxCIgiOFECJ4o0L4pD8gIgCOAEcXjMC+AEnvbk8zw4QSj3Th4c70yqd2Jngr676mqZH5yELzc2QqysnNJ7xATYLIcJsIlj2QQfu/81vLMriTMWxvHgpUex/6UBgGXSyf4D20pE2XZnB4CdgJYa/xq+CiDcCEQaqQ/VA6E6Ks5CdUCgBhDYQ3h/xbItJLQEevI96C/0o6/QN6rlzYmv5VUkrIQR81BRFvVEEVEiiHliiCgRt1z0ESUCv+Rnv5tTBCEERFWpGCsUYOfzIIWCExdgF5xyvgBbU0EKKmxVBVELsAsqbLUAki/A1jQQTaN11GKs0Wtr2oQX4p2t1Nx6K6IXXzSl12QCbJbDBNjkWNeRxkfvfQWGRfCtjy7CpQfqUORUUkgMbsGU2E7j1G7ao5bcBYyz3AIA+j/NQA0VY6E6+qJA0CkHawbLSoht27SfUzAL6C/0o1/tL/eFfgyoA0hoCQwUqE+oCZC9mPksciLCShgRJYKwEnbjiBJBSAnRnBymsRx26/jEfbfGF2NsiG2D6Do1TQPRddiaDmI4ZcOgpuvDY10HMUwQ06Rl0wAxTcA0QXQaE8sELAvEtGhs0kVZYZn0XNsCLLr4KrFsWtcu8cVFWB0PQmhdmwwuZVKyICsZMgms6rovIPyRj0zpPWMCbJbDBNjk+cnft+Lbf1oPWeTx5NUnYGEdu297DSGAmqSCLLmLirLULiDdQS21B8h0AOMsWOoi+eguAYE4EKguj4M11PurAX8lICr79EtjvH8s20JKTyGhJjCgDmBAHUBSTbriLKEl3PKAOoCUlhpzM/XxEDgBQTmIkBwq90rIjYNSEAE5QGM5iIA0GDMBx5hOmACb5TABNnkIIfj3//sH/rKhB21Vfjx97YnwK2x4bJ9h23Tj8vQexzqATJdjxbiTLrkxGZQwFWL+qhLvxL6K4SYdRHP+ZjEFs4CUlkJKSyGpJZHUkm5czKf0FNJaGmk97eYm+rLBWPAcD7/oR0AOwC/5EZSD8Et+BKQAzYl++CU/fJIPfsk/zHyiDz7JB5/og1f0MjHHGBMmwGY5TIDtHQM5HR/+37+hO63hX5c24HsXHTHTTWLoeSDrCLNsj2PdjvUM+lzPxHvUSpH8jhiL0g3SvVHA5/hi2bUI4InQRW2ZcNvvIYRAtVSktTQyegZpfdC7pqWRNbLI6Blk9SzSenl5okt6TBQOnCvGSkWZV/IOxo4Vyx7RU+6FwbJH9MAjeKCICryCFyIvMoE3y2ECbJbDBNje8/rWfnzix6/DJsD/XHwELljSMNNNYkyE4rBnrs8RZL2O9Q3GhQSQ7x+0vRFsRUQPFWOloswTovPVPCFaVhzvCQNKsNzkIHsBYT+HEIKCWUDOyCFrZJEzcsjomWHlvJF3y3kjj5yZQ1bPIm/m3dzevKSwN/AcD0VQ4BW9UAQFiqDAI3ogC7JbVgQFsiDDI9B88ZjMl8ROvpiTeAmSIEHmZde7eeeYxEsQedH1PHdwry+2tzABNsthAuz98f0XNuH7L2wGAPzsimVorQzArwgIKCK8ksD+h3kgQAigpakQy/XTXQQKCUekFeOBwbKapOupqSlM2YZ6ks8RYwFACVBRpgQA2U9zbj5Al/SQA/ScsthPTfJRY6Juv8QmNlRTRd7Mu4Isb1CBVjALKJgF5M28GxeMwZxmacibeaim6lrBLEC1qNcsDTbZ/7YBEjkRIj+CleQlXoLACRB4wT0m8MJgjqNCrpjjOd4Vd8Vy0RdN4Ojf6KLnQfMcx9E6oDEHbnTvxEWKMYeSHDgsiS9BW7htSu/brBdg9913H7773e+is7MTixYtwve//32cdNJJo9Z/+eWXccMNN+C9995DXV0dvvzlL+Oqq64qq/PYY4/h5ptvRnt7O+bMmYPbbrsNF1xwwaQ+lxCCW2+9FQ8++CASiQSOPfZY3HvvvVi0aHAvQk3T8MUvfhG/+c1vUCgUcNppp+G+++5DQ8PEe2KYAHt/WDbByd95CXuSwzfC5jnAL4vwKyJ8jigrlgOKgICHxkGlmHPMyftlET5ZoOfLAhSRZ4JuNmHb9A3PQrJElCUBNU3FmZamseaUizktM2jm+Ps97jW8RAWa5KMbs0t+x3toTvQ4ZS8gOnnXewaPiwrNi4qTV0rMQxfpLebZVlYzCiEEhm1AtVRopkZFmqVCszQUzAJ0S4dmaYNmamVl3dahW0PMpucYlgHd1l2vWzoM2xjMO7FhG3v1Zuts5+vHfR3/dsi/Tek13+/ze0b/C/boo49i+fLluO+++3DCCSfgRz/6ET784Q9j3bp1aGpqGlZ/27ZtOOecc/CZz3wGv/zlL/Hqq6/i6quvRlVVFf71X/8VALBy5UpcfPHF+Na3voULLrgATzzxBC666CK88sorOPbYYyf8ud/5zndw99134+GHH8YhhxyCb3/72zjjjDOwceNGBINBAMDy5cvx9NNP45FHHkFFRQX+8z//E+eeey5WrVoFQWB/6KYDgefwpbPm456XtiCjGshrFrK6Sd9YJkBGM5HRpmZuSFHQ+RQBPlmERxLglXh4ZQFeSXDKArwyjRWRd70ytCzykIteECA7ZVnkIQuDXhI4CDzHhN/ewPODw4po3rtrmDqgZ0tEWRrQczTWc86xLPXF2Mg5x/LUl5aNHFDsAbGNQeE3XfAiFWSCTAWZoACiTL0gOTmZxsV6rkkleYkKSEGmPXmC7JRFx0slZbH8GC86x4XBY7xYUrfUBIAThpRn7+8Cx3HukCFmcJtIy7aoICuaZcAkJky73AzboDExYdlWWWwRWi56m9huuRjbxHbr28SmBhu2bcMiFgiIe4yAlHmb0CUnbNAYBCDFf2S4L1IqLkvjOn/dtN7jiTCjPWDHHnssli5divvvv9/NHXrooTj//PNxxx13DKt/44034qmnnsL69evd3FVXXYV33nkHK1euBABcfPHFSKfTePbZZ906Z599NqLRKH7zm99M6HMJIairq8Py5ctx4403AqC9XfF4HHfddRc+97nPIZVKoaqqCr/4xS9w8cUXAwA6OjrQ2NiIZ555BmedddaE7gHrAZt6CCEoGBaymomcZiGnmU5surmsZiBbPKaayOrUF+tkNRMF3UJON6EaMztkwHGAJPCQeA6SyLuxKPAQBQ4iz0HkqVgTBZ6WBQ4CT2OB51zvGkfr8Bwt89xgHd45znMAz5fX4Tm4gpDn4OY4tw6coQHnGA9niICWXe98XaV1i4tZF+tzpfWKOYCugl1S5rjS2KmAwed0sc5gXMyX1yvGZUMXQ46Vnjfs+Ai58iMACAFva+DMAjizAN7IgzdVcEYevFkAZzplSwVnqk5OpTkn5ixtiKd1OVMDb6mApYOz9ME6++GQ1/uBcDzACSAl4qyYc2PnGOHoKuqEKxFvxTxHV1InvACguMq64Fxr0MrqDjlGc/Sa4HgAnFOHc8tl9UrK5XU52ganTvk1UHIeB4Kh9TG46nvxuFuHK7n+YN0R62DItdz7XVoHo9Qb6bhzfll9lNcp/d0Y9oszpDyu8B77uK9uAfyVjeNcY3LM2h4wXdexatUq3HTTTWX5M888E6+99tqI56xcuRJnnnlmWe6ss87CT3/6UxiGAUmSsHLlSlx//fXD6nz/+9+f8Odu27YNXV1dZZ+lKApOOeUUvPbaa/jc5z6HVatWwTCMsjp1dXVYvHgxXnvttVEFmKZp0LTBdXLS6fSI9Rh7D8dx8MkifLIIBN//9SybIK+byOsW8joVbQXDQkG3UDAsqCVxMa+ZNjTDgmrY0Mxyr5oWdNOmZtnQDOpLc6UQApoHAH3i280wZiM+x6YOARYUGJBhUM8ZkGE65sRuzoAECxJMSBytI7lmQebocbFYx8mLnAkFJgT3mAURJiSOlou54nERFgTOdmM3BxsCLMjc6D/nHKGLdXLjbb/FYJTwxqKv49h/+8+ZbkYZMybA+vr6YFkW4vF4WT4ej6Orq2vEc7q6ukasb5om+vr6UFtbO2qd4jUn8rlFP1KdHTt2uHVkWUY0Gp1w+wHgjjvuwK233jrqccb+h8BzCHokBD3StHweIQSGRWBYNgyLCjKztGwSmLYNwyIwLRuWTWDYNDYsesyyCSybwCz1lg2zJGfbBBYhbl2LODkbsAmB7RyzCYFtY/A4Ic4Q76CnRttu2bTjv1gurVN6HnG+1mJduLFzvKQOvS/OEMSQczG0PKRusYzSa2FIHmRIufw4hhwvz5Z/74YeKz1n6IDDsOGHccYjxhuuGHlAQwAgwwAw3kpbUz4eUvq1D239OJ/FwYboCDIq3GzwoKKt3NM6PGxHwFHjR4g51xP3GMfRmCc0zw+pw4OUnce7Vl6H5waPo6QOPZ+45wMoy3Nl16M3ppgrvZ7TN+bmS3Occ83S8wePEfdzh+dpDK54HCX1BnPFuKQ/a9g1y3Pl3+TB8zGs7tC4/Pzy64zG0PNHwlT2vxGmGX8NZ+jcFkLImPNdRqo/ND+Ra05VnaGMV+e//uu/cMMNN7jldDqNxsap7RZlzG44joMscpBF9mo4g8FgTAWHzHQDRmDG/sJXVlZCEIRhvUU9PT3Dep6K1NTUjFhfFEVUVFSMWad4zYl8bk1NDQCMW0fXdSQSiQm3H6BDmaFQqMwYDAaDwWAcXMyYAJNlGUcddRRWrFhRll+xYgWOP/74Ec857rjjhtV//vnnsWzZMkiSNGad4jUn8rmtra2oqakpq6PrOl5++WW3zlFHHQVJksrqdHZ24t133x21/QwGg8FgMBgAADKDPPLII0SSJPLTn/6UrFu3jixfvpz4/X6yfft2QgghN910E7n00kvd+lu3biU+n49cf/31ZN26deSnP/0pkSSJ/P73v3frvPrqq0QQBHLnnXeS9evXkzvvvJOIokhef/31CX8uIYTceeedJBwOk8cff5ysXbuWXHLJJaS2tpak02m3zlVXXUUaGhrICy+8QFavXk1OPfVUcsQRRxDTNCd8D1KpFAFAUqnUXt1DBoPBYDAY08/7fX7PqAAjhJB7772XNDc3E1mWydKlS8nLL7/sHrv88svJKaecUlb/r3/9K1myZAmRZZm0tLSQ+++/f9g1f/e735H58+cTSZLIggULyGOPPTapzyWEENu2yTe+8Q1SU1NDFEUhJ598Mlm7dm1ZnUKhQK699loSi8WI1+sl5557Ltm5c+ekvn4mwBgMBoPBmH283+f3jK+Ef7DD1gFjMBgMBmP28X6f3+w1KwaDwWAwGIxphgkwBoPBYDAYjGmGCTAGg8FgMBiMaYYJMAaDwWAwGIxphgkwBoPBYDAYjGmGCTAGg8FgMBiMaYYJMAaDwWAwGIxphgkwBoPBYDAYjGmGCTAGg8FgMBiMaUac6QYc7BQ3Ikin0zPcEgaDwWAwGBOl+Nze2w2FmACbYTKZDACgsbFxhlvCYDAYDAZjsmQyGYTD4Umfx/aCnGFs20ZHRweCwSA4jpuy66bTaTQ2NmLXrl1sj8lJwu7d3sHu297D7t3ewe7b3sPu3d5Ret+CwSAymQzq6urA85Of0cV6wGYYnufR0NCwz64fCoXYL9dewu7d3sHu297D7t3ewe7b3sPu3d5RvG970/NVhE3CZzAYDAaDwZhmmABjMBgMBoPBmGaYADtAURQF3/jGN6Aoykw3ZdbB7t3ewe7b3sPu3d7B7tvew+7d3jGV941NwmcwGAwGg8GYZlgPGIPBYDAYDMY0wwQYg8FgMBgMxjTDBBiDwWAwGAzGNMMEGIPBYDAYDMY0wwTYAcp9992H1tZWeDweHHXUUfj73/8+003ar7njjjtw9NFHIxgMorq6Gueffz42btw4082aldxxxx3gOA7Lly+f6abs9+zZswef+tSnUFFRAZ/PhyOPPBKrVq2a6Wbt95imia997WtobW2F1+tFW1sbvvnNb8K27Zlu2n7F3/72N5x33nmoq6sDx3F48skny44TQnDLLbegrq4OXq8XH/zgB/Hee+/NTGP3M8a6d4Zh4MYbb8Rhhx0Gv9+Puro6XHbZZejo6JjUZzABdgDy6KOPYvny5fjqV7+Kt99+GyeddBI+/OEPY+fOnTPdtP2Wl19+Gddccw1ef/11rFixAqZp4swzz0Qul5vpps0q3nrrLTz44IM4/PDDZ7op+z2JRAInnHACJEnCs88+i3Xr1uF73/seIpHITDdtv+euu+7CAw88gHvuuQfr16/Hd77zHXz3u9/FD3/4w5lu2n5FLpfDEUccgXvuuWfE49/5zndw991345577sFbb72FmpoanHHGGe4exQczY927fD6P1atX4+abb8bq1avx+OOPY9OmTfiXf/mXyX0IYRxwHHPMMeSqq64qyy1YsIDcdNNNM9Si2UdPTw8BQF5++eWZbsqsIZPJkHnz5pEVK1aQU045hVx33XUz3aT9mhtvvJGceOKJM92MWclHPvIRcuWVV5blPvaxj5FPfepTM9Si/R8A5IknnnDLtm2Tmpoacuedd7o5VVVJOBwmDzzwwAy0cP9l6L0biTfffJMAIDt27JjwdVkP2AGGrutYtWoVzjzzzLL8mWeeiddee22GWjX7SKVSAIBYLDbDLZk9XHPNNfjIRz6C008/faabMit46qmnsGzZMvzbv/0bqqursWTJEvz4xz+e6WbNCk488UT85S9/waZNmwAA77zzDl555RWcc845M9yy2cO2bdvQ1dVV9qxQFAWnnHIKe1bsBalUChzHTaoHm23GfYDR19cHy7IQj8fL8vF4HF1dXTPUqtkFIQQ33HADTjzxRCxevHimmzMreOSRR7B69Wq89dZbM92UWcPWrVtx//3344YbbsBXvvIVvPnmm/jCF74ARVFw2WWXzXTz9mtuvPFGpFIpLFiwAIIgwLIs3HbbbbjkkktmummzhuLzYKRnxY4dO2aiSbMWVVVx00034ROf+MSkNjZnAuwAheO4sjIhZFiOMTLXXnst/vnPf+KVV16Z6abMCnbt2oXrrrsOzz//PDwez0w3Z9Zg2zaWLVuG22+/HQCwZMkSvPfee7j//vuZABuHRx99FL/85S/x61//GosWLcKaNWuwfPly1NXV4fLLL5/p5s0q2LPi/WEYBj7+8Y/Dtm3cd999kzqXCbADjMrKSgiCMKy3q6enZ9j/dBjD+fznP4+nnnoKf/vb39DQ0DDTzZkVrFq1Cj09PTjqqKPcnGVZ+Nvf/oZ77rkHmqZBEIQZbOH+SW1tLRYuXFiWO/TQQ/HYY4/NUItmD1/60pdw00034eMf/zgA4LDDDsOOHTtwxx13MAE2QWpqagDQnrDa2lo3z54VE8cwDFx00UXYtm0bXnzxxUn1fgHsLcgDDlmWcdRRR2HFihVl+RUrVuD444+foVbt/xBCcO211+Lxxx/Hiy++iNbW1plu0qzhtNNOw9q1a7FmzRrXli1bhk9+8pNYs2YNE1+jcMIJJwxb6mTTpk1obm6eoRbNHvL5PHi+/PElCAJbhmIStLa2oqampuxZoes6Xn75ZfasmABF8bV582a88MILqKiomPQ1WA/YAcgNN9yASy+9FMuWLcNxxx2HBx98EDt37sRVV101003bb7nmmmvw61//Gn/4wx8QDAbdHsRwOAyv1zvDrdu/CQaDw+bK+f1+VFRUsDl0Y3D99dfj+OOPx+23346LLroIb775Jh588EE8+OCDM920/Z7zzjsPt912G5qamrBo0SK8/fbbuPvuu3HllVfOdNP2K7LZLLZs2eKWt23bhjVr1iAWi6GpqQnLly/H7bffjnnz5mHevHm4/fbb4fP58IlPfGIGW71/MNa9q6urw4UXXojVq1fjj3/8IyzLcp8ZsVgMsixP7EPex5uZjP2Ye++9lzQ3NxNZlsnSpUvZcgrjAGBEe+ihh2a6abMStgzFxHj66afJ4sWLiaIoZMGCBeTBBx+c6SbNCtLpNLnuuutIU1MT8Xg8pK2tjXz1q18lmqbNdNP2K1566aUR/65dfvnlhBC6FMU3vvENUlNTQxRFISeffDJZu3btzDZ6P2Gse7dt27ZRnxkvvfTShD+DI4SQ96cTGQwGg8FgMBiTgc0BYzAYDAaDwZhmmABjMBgMBoPBmGaYAGMwGAwGg8GYZpgAYzAYDAaDwZhmmABjMBgMBoPBmGaYAGMwGAwGg8GYZpgAYzAYDAaDwZhmmABjMBiTguM4PPnkkzPdDMYEmI7v1cMPPwyO48BxHJYvX75PP+uKK65wP4v9DDJmO0yAMRiMsgebJEmIx+M444wz8LOf/WzY/nqdnZ348Ic/PKHrzqYH5S233OLeg1J74YUXZrppZd+fUjv77LNnumkAgFAohM7OTnzrW9/ap5/zv//7v+js7Nynn8FgTBdsL0gGgwEAOPvss/HQQw/Bsix0d3fjz3/+M6677jr8/ve/x1NPPQVRpH8uampqZril+45FixYNE1yxWGxYPV3XJ77f2xRR/P6UoijKtLZhNDiOm5afi3A4jHA4vM8/h8GYDlgPGIPBAEAf5jU1Naivr8fSpUvxla98BX/4wx/w7LPP4uGHH3brlfZq6bqOa6+9FrW1tfB4PGhpacEdd9wBAGhpaQEAXHDBBeA4zi23t7fjox/9KOLxOAKBAI4++uhhoqelpQW33347rrzySgSDQTQ1NQ3bpHr37t34+Mc/jlgsBr/fj2XLluGNN95wjz/99NM46qij4PF40NbWhltvvRWmaY55D0RRRE1NTZnJsowrrrgC559/Pu644w7U1dXhkEMOAQCsXbsWp556KrxeLyoqKvDZz34W2WzWvV7xvNtvvx3xeByRSMRtx5e+9CXEYjE0NDTgZz/72YS/P6UWjUbd45s3b8bJJ58Mj8eDhQsXYsWKFcOu8dprr+HII4+Ex+PBsmXL8OSTT4LjOKxZs8ats27dOpxzzjkIBAKIx+O49NJL0dfXN277hqJpGr785S+jsbERiqJg3rx5+OlPfwoA+Otf/wqO4/Dcc89hyZIl8Hq9OPXUU9HT04Nnn30Whx56KEKhEC655BLk8/lJfzaDMRtgAozBYIzKqaeeiiOOOAKPP/74iMd/8IMf4KmnnsJvf/tbbNy4Eb/85S9dofXWW28BAB566CF0dna65Ww2i3POOQcvvPAC3n77bZx11lk477zzsHPnzrJrf+9738OyZcvw9ttv4+qrr8Z//Md/YMOGDe41TjnlFHR0dOCpp57CO++8gy9/+cvucOlzzz2HT33qU/jCF76AdevW4Uc/+hEefvhh3HbbbXt9L/7yl79g/fr1WLFiBf74xz8in8/j7LPPRjQaxVtvvYXf/e53eOGFF3DttdeWnffiiy+io6MDf/vb33D33XfjlltuwbnnnotoNIo33ngDV111Fa666irs2rVrr9tm2zY+9rGPQRAEvP7663jggQdw4403ltXJZDI477zzcNhhh2H16tX41re+NaxOZ2cnTjnlFBx55JH4xz/+gT//+c/o7u7GRRddNOk2XXbZZXjkkUfwgx/8AOvXr8cDDzyAQCBQVueWW27BPffcg9deew27du3CRRddhO9///v49a9/jT/96U9YsWIFfvjDH07+hjAYs4F9tZM4g8GYPVx++eXkox/96IjHLr74YnLooYe6ZQDkiSeeIIQQ8vnPf56ceuqpxLbtEc8trTsWCxcuJD/84Q/dcnNzM/nUpz7llm3bJtXV1eT+++8nhBDyox/9iASDQdLf3z/i9U466SRy++23l+V+8YtfkNra2lHb8I1vfIPwPE/8fr9rRx99NCGE3p94PE40TXPrP/jggyQajZJsNuvm/vSnPxGe50lXV5d7XnNzM7Esy60zf/58ctJJJ7ll0zSJ3+8nv/nNb0Zt2+WXX04EQShrm9/vJ9/85jcJIYQ899xzRBAEsmvXLvecZ599tuz+33///aSiooIUCgW3zo9//GMCgLz99tuEEEJuvvlmcuaZZ5Z99q5duwgAsnHjxhHb9tBDD5FwOFyW27hxIwFAVqxYMeI5L730EgFAXnjhBTd3xx13EACkvb3dzX3uc58jZ5111rDzJ/pzxWDsz7A5YAwGY0wIIeA4bsRjV1xxBc444wzMnz8fZ599Ns4991yceeaZY14vl8vh1ltvxR//+Ed0dHTANE0UCoVhPWCHH364GxfnGPX09AAA1qxZgyVLlow4PwsAVq1ahbfeequsx8uyLKiqinw+D5/PN+J58+fPx1NPPeWWS+dYHXbYYWXzvtavX48jjjgCfr/fzZ1wwgmwbRsbN25EPB4HQOeV8fzgYEM8HsfixYvdsiAIqKiocL+20fjQhz6E+++/vyxX/PrXr1+PpqYmNDQ0uMeOO+64srobN27E4YcfDo/H4+aOOeaYsjqrVq3CSy+9NKynCqBDx8Wh1/FYs2YNBEHAKaecMma90u9xPB6Hz+dDW1tbWe7NN9+c0GcyGLMNJsAYDMaYrF+/Hq2trSMeW7p0KbZt24Znn30WL7zwAi666CKcfvrp+P3vfz/q9b70pS/hueeew3//939j7ty58Hq9uPDCC6Hrelk9SZLKyhzHuUOMXq93zDbbto1bb70VH/vYx4YdKxUgQ5FlGXPnzh3xWKnQAsYWpqX5kb6Osb620fD7/aO2jRAyZhtGa+/Q82zbxnnnnYe77rpr2PVqa2vHbF8p431/ipTeh729LwzGbIUJMAaDMSovvvgi1q5di+uvv37UOqFQCBdffDEuvvhiXHjhhTj77LMxMDCAWCwGSZJgWVZZ/b///e+44oorcMEFFwCg87m2b98+qXYdfvjh+MlPfuJ+zlCWLl2KjRs3jipYpoKFCxfi//7v/5DL5Vxx9uqrr4Ln+Qn3FE1lW3bu3ImOjg7U1dUBAFauXFlWZ8GCBfjVr34FTdPcnr1//OMfZXWWLl2Kxx57DC0tLe5br3vDYYcdBtu28fLLL+P000/f6+swGAcybBI+g8EAQN9a6+rqwp49e7B69Wrcfvvt+OhHP4pzzz0Xl1122Yjn/M///A8eeeQRbNiwAZs2bcLvfvc71NTUIBKJAKBvM/7lL39BV1cXEokEAGDu3Ll4/PHHsWbNGrzzzjv4xCc+MelejksuuQQ1NTU4//zz8eqrr2Lr1q147LHHXNHx9a9/HT//+c9xyy234L333sP69evx6KOP4mtf+9re36AhfPKTn4TH48Hll1+Od999Fy+99BI+//nP49JLL3WHH6eS4ven1IpvJ55++umYP38+LrvsMrzzzjv4+9//jq9+9atl5xfv82c/+1msX7/e7YUEBnvLrrnmGgwMDOCSSy7Bm2++ia1bt+L555/HlVdeOUxIj0VLSwsuv/xyXHnllXjyySexbds2/PWvf8Vvf/vbKbobDMbshwkwBoMBAPjzn/+M2tpatLS04Oyzz8ZLL72EH/zgB/jDH/4AQRBGPCcQCOCuu+7CsmXLcPTRR2P79u145pln3DlP3/ve97BixQo0NjZiyZIlAKhoi0ajOP7443HeeefhrLPOwtKlSyfVVlmW8fzzz6O6uhrnnHMODjvsMNx5551uO8866yz88Y9/xIoVK3D00UfjAx/4AO6++240Nze/jztUjs/nw3PPPYeBgQEcffTRuPDCC3HaaafhnnvumbLPKKX4/Sm1E088EQDA8zyeeOIJaJqGY445Bv/+7/8+7I3PUCiEp59+GmvWrMGRRx6Jr371q/j6178OYHBYtq6uDq+++iosy8JZZ52FxYsX47rrrkM4HC6bxzYR7r//flx44YW4+uqrsWDBAnzmM59BLpebgjvBYBwYcGSkyQMMBoPBOOD51a9+hf/3//4fUqnUhOdtDeXhhx/G8uXLkUwmp7ZxY8BxHJ544gmcf/750/aZDMZUw3rAGAwG4yDh5z//OV555RVs27YNTz75JG688UZcdNFFey2+iqRSKQQCgWHrik01V1111YhvaDIYsxHWA8ZgMBgHCd/5zndw3333oaurC7W1tTj//PNx2223jbosx0TIZDLo7u4GAEQiEVRWVk5Vc4fR09ODdDoNgL6VOfTNVAZjNsEEGIPBYDAYDMY0w4YgGQwGg8FgMKYZJsAYDAaDwWAwphkmwBgMBoPBYDCmGSbAGAwGg8FgMKYZJsAYDAaDwWAwphkmwBgMBoPBYDCmGSbAGAwGg8FgMKYZJsAYDAaDwWAwphkmwBgMBoPBYDCmmf8PMP1ou0jUT0cAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -220,82 +242,54 @@ ], "source": [ "n_lines=10\n", - "for index in range(1,n_lines):\n", - " plt.plot(oxygen_profile.iloc[int(np.trunc(index*(len(oxygen_profile)-1)/n_lines))], label=np.round(index*((len(oxygen_profile)-1)/n_lines)/8760,3))\n", + "times=oxygen_profile.index.tolist()\n", + "for index in range(n_lines):\n", + " plt.plot(oxygen_profile.iloc[int(np.trunc((index+1)*(len(oxygen_profile)-1)/n_lines))], \n", + " label=np.round(times[int(np.trunc((index+1)*((len(oxygen_profile)-1)/n_lines)))]/365.25/24,2)) \n", "plt.legend(title='Time [year]')\n", "plt.ylabel('Oxygen Concentration [g/cm³]')\n", "plt.xlabel('Distance From Edge [cm]')\n", "plt.ticklabel_format(axis='y', style='plain')\n", + "\n", + "plt.savefig(os.path.join(output_folder, 'Edge_Seal_O2_ingress.png'), bbox_inches='tight') #Creates an image file of the standoff plot\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Save data outputs.\n", + "\n", + "This cell contains a number of pre-scripted commands for exporting and saving data. The code to save plots is located after the plot creation. First check that the output folder exists." + ] + }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " 0.000000 0.076923 0.153846 0.230769 0.307692 \\\n", - "0.0 0.000048 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "1.0 0.000048 4.025938e-07 0.000000e+00 0.000000e+00 0.000000e+00 \n", - "2.0 0.000048 7.914468e-07 3.295784e-09 0.000000e+00 0.000000e+00 \n", - "3.0 0.000048 1.165328e-06 9.571569e-09 2.635343e-11 0.000000e+00 \n", - "4.0 0.000049 1.525385e-06 1.852325e-08 1.006938e-10 2.058149e-13 \n", - "... ... ... ... ... ... \n", - "17514.0 0.000042 4.267309e-05 4.035455e-05 3.816304e-05 3.614315e-05 \n", - "17515.0 0.000043 4.255340e-05 4.035980e-05 3.817013e-05 3.614761e-05 \n", - "17516.0 0.000043 4.247354e-05 4.035994e-05 3.817617e-05 3.615158e-05 \n", - "17517.0 0.000045 4.244049e-05 4.035799e-05 3.818062e-05 3.615468e-05 \n", - "17518.0 0.000047 4.244476e-05 4.035617e-05 3.818351e-05 3.615683e-05 \n", - "\n", - " 0.384615 0.461538 0.538462 0.615385 0.692308 ... \\\n", - "0.0 0.000000 0.000000 0.000000 0.000000 0.000000 ... \n", - "1.0 0.000000 0.000000 0.000000 0.000000 0.000000 ... \n", - "2.0 0.000000 0.000000 0.000000 0.000000 0.000000 ... \n", - "3.0 0.000000 0.000000 0.000000 0.000000 0.000000 ... \n", - "4.0 0.000000 0.000000 0.000000 0.000000 0.000000 ... \n", - "... ... ... ... ... ... ... \n", - "17514.0 0.000034 0.000032 0.000031 0.000029 0.000027 ... \n", - "17515.0 0.000034 0.000032 0.000031 0.000029 0.000027 ... \n", - "17516.0 0.000034 0.000032 0.000031 0.000029 0.000027 ... \n", - "17517.0 0.000034 0.000032 0.000031 0.000029 0.000027 ... \n", - "17518.0 0.000034 0.000032 0.000031 0.000029 0.000027 ... \n", - "\n", - " 9.681818 9.883838 10.085859 10.287879 10.489899 10.691919 \\\n", - "0.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n", - "1.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n", - "2.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n", - "3.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n", - "4.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n", - "... ... ... ... ... ... ... \n", - "17514.0 0.000009 0.000009 0.000009 0.000009 0.000009 0.000009 \n", - "17515.0 0.000009 0.000009 0.000009 0.000009 0.000009 0.000009 \n", - "17516.0 0.000009 0.000009 0.000009 0.000009 0.000009 0.000009 \n", - "17517.0 0.000009 0.000009 0.000009 0.000009 0.000009 0.000009 \n", - "17518.0 0.000009 0.000009 0.000009 0.000009 0.000009 0.000009 \n", - "\n", - " 10.893939 11.095960 11.297980 11.500000 \n", - "0.0 0.000000 0.000000 0.000000 0.000000 \n", - "1.0 0.000000 0.000000 0.000000 0.000000 \n", - "2.0 0.000000 0.000000 0.000000 0.000000 \n", - "3.0 0.000000 0.000000 0.000000 0.000000 \n", - "4.0 0.000000 0.000000 0.000000 0.000000 \n", - "... ... ... ... ... \n", - "17514.0 0.000009 0.000009 0.000009 0.000009 \n", - "17515.0 0.000009 0.000009 0.000009 0.000009 \n", - "17516.0 0.000009 0.000009 0.000009 0.000009 \n", - "17517.0 0.000009 0.000009 0.000009 0.000009 \n", - "17518.0 0.000009 0.000009 0.000009 0.000009 \n", - "\n", - "[17519 rows x 72 columns]\n" + "Your results will be stored in c:\\Users\\mkempe\\Documents\\GitHub\\PVDegradationTools\\TEMP\\results\n", + "The folder must already exist or the file will not be created\n" ] } ], "source": [ - "print(oxygen_profile)" + "print (\"Your results will be stored in %s\" % output_folder)\n", + "print ('The folder must already exist or the file will not be created')\n", + "\n", + "#Writes the meterological data to an *.csv file.\n", + "pvdeg.weather.write(data_df=weather_df, metadata=meta, savefile=os.path.join(output_folder, 'WeatherFile.csv')) \n", + "\n", + "#Writes a file with the edge seal oxygen profile calculations.\n", + "pd.DataFrame(oxygen_profile).to_csv(os.path.join(output_folder, 'ES_Oxygen_profile.csv')) \n", + "\n", + "#Writes a file with temperature data used in the model calculations.\n", + "pd.DataFrame(temperature).to_csv(os.path.join(output_folder, 'ES_Temperature_profile.csv')) \n" ] } ], From 3d9c451997c8047ec767fb7d660b082a334f42d7 Mon Sep 17 00:00:00 2001 From: Kempe Date: Thu, 19 Sep 2024 18:00:40 -0600 Subject: [PATCH 07/32] Update diffusion.py Fixing some problems in the calculation of the interface nodes and modifying it to do a reaction and a degradation calculation. --- pvdeg/diffusion.py | 117 ++++++++++++++++++++++++++++++--------------- 1 file changed, 79 insertions(+), 38 deletions(-) diff --git a/pvdeg/diffusion.py b/pvdeg/diffusion.py index ef1f6bc..3178022 100644 --- a/pvdeg/diffusion.py +++ b/pvdeg/diffusion.py @@ -8,25 +8,24 @@ from pvdeg import DATA_DIR from numba import jit import numpy as np +from typing import Callable def esdiffusion( temperature, - edge_seal=None, - encapsulant=None, + edge_seal="OX005", + encapsulant="OX003", edge_seal_width=1.5, encapsulant_width=10, seal_nodes=20, encapsulant_nodes=50, press = 0.209, repeat = 1, - Dos=None, - Eads=None, - Sos=None, - Eass=None, - Doe=None, - Eade=None, - Soe=None, - Ease=None, + Dos=None, Eads=None, Sos=None,Eass=None, Doe=None, Eade=None, Soe=None, Ease=None, + react_func = None, + deg_func = None, + deg = None, + perm = None, + printout = True, **kwarg ): @@ -58,40 +57,68 @@ def esdiffusion( This is the partial pressure of oxygen. repeat : integer, optional This is the number of times to do the calculation for the whole dataset. E.g. repeat the 1-y data for 10 years. + react_func : string, optional + This is the name of the function that will be calculating the consumption of oxygen. + deg_func :string, optional + This is the name of the function that will be calculating the degradation. + printout : Boolean + This allows you to suppress printing messages during code execution by setting it to false. + deg : Numpy Array + One can send in an array with predefined degradation data already in it if desired. + I.e. you can have some pre degradation or areas that require more degradation. + perm : Numpy Array + One can send in an array with the permeant already in it if desired. kwargs : dict, optional - If es or enc are left at 'None' then the use parameters, Dos, Eads, Sos, Eass, Doe, Eade, Soe, Ease in units of + If edge_seal or encapsulant are set at 'None' then you can enter your own parameters for, Dos, Eads, Sos, Eass, Doe, Eade, Soe, Ease in units of [cm²/s], [g/cm³], or [kJ/mol] for diffusivity, solubility, or activation energy respectively. If specific parameters are provided, - then the JSON ones can be overridden. + then the JSON ones will be overridden. + Should also contain any key word arguments that need to be passed to the function calculating consumption of the permeant or degradation. Returns ------- ingress_data : pandas.DataFrame - This will give the concentration profile as a function of temperature along with degradation parameters in futur iterations.. + This will give the concentration profile as a function of time. + If there is a degradation function called, this data will also be inclueded on a node by node basis under a third index. """ with open(os.path.join(DATA_DIR, "O2permeation.json")) as user_file: O2 = json.load(user_file) user_file.close() - # O2 - if edge_seal == None: - esp = O2.get("OX005") # This is the number for the edge seal in the json file - else: - esp = O2.get(edge_seal) + with open(os.path.join(DATA_DIR, "H2Opermeation.json")) as user_file: + H2O = json.load(user_file) + user_file.close() - if encapsulant == None: - encp = O2.get( - "OX003" - ) # This is the number for the encapsulant in the json file + if edge_seal[0,2]=="OX": + esp = O2.get(edge_seal) + if printout: + print("Oxygen ingress parameters loaded for the edge seal.") else: - encp = O2.get(encapsulant) + if edge_seal[0,1]=="W": + esp = H2O.get(edge_seal) + if printout: + print("Water ingress parameters loaded for the edge seal.") + else: + print("Edge seal material not found") - try: - print("The edge seal is", esp.get("name"), ".") - print("The encapsulant is", encp.get("name"), ".") - except: - print("") + if encapsulant[0,2]=="OX": + encp = O2.get(encapsulant) + if printout: + print("Oxygen ingress parameters loaded for the encapsulant.") + else: + if encapsulant[0,1]=="W": + encp = H2O.get(encapsulant) + if printout: + print("Water ingress parameters loaded for the eencapsulant.") + else: + print("Encapsulant material not found") + if printout: + try: + print("The edge seal is", esp.get("name"), ".") + print("The encapsulant is", encp.get("name"), ".") + except: + print("Unknown material selected.") - # These are the edge seal oxygen permeation parameters + # These are the edge seal oxygen or water permeation parameters if Dos == None: Dos = esp.get("Do") if Eads == None: @@ -136,12 +163,14 @@ def esdiffusion( perm_mid = np.array( np.zeros((seal_nodes + encapsulant_nodes + 3)), dtype=np.float64 - ) # This is the profile at a transition point between output points. - perm = np.array( - np.zeros( - (len(temperature) * repeat - repeat + 1, seal_nodes + encapsulant_nodes + 3), dtype=np.float64 - ) - ) # It adds in two nodes for the interface concentration for both materials and one for the hour column. + ) # This is the profile at a transition point between output points. + if perm == None: + perm = np.array( + np.zeros( + (len(temperature) * repeat - repeat + 1, seal_nodes + encapsulant_nodes + 3), dtype=np.float64 + ) + ) # It adds in two nodes for the interface concentration for both materials and one for the hour column. + temperature = pd.DataFrame( temperature, columns=["module_temperature", "time", "time_step"] ) # This adds the number of time steps to be used as a subdivision between data points. [s] @@ -163,7 +192,8 @@ def esdiffusion( time_step[row] = np.trunc(fos / f_max) + 1 else: time_step[row] = np.trunc(foe / f_max) + 1 - + if deg_func != None and deg == None: # Sets up an array to do the degradation calculation. + deg=perm perm[0][1] = Sos * np.exp(-Eass / met_data[0][0]) perm_mid = perm[0] for rp_num in range(repeat): @@ -222,21 +252,32 @@ def esdiffusion( perm[row + 1 + rp_row][1] = Sos * np.exp( -Eass / (met_data[row + 1][0] + dtemp * mid_point) ) + + + # Runs the degradation calculation. + if deg_func != None: + print('oops') + # Runs the reaction with permeant function. + if react_func != None: + print('oops') + perm_mid = perm[row + 1 + rp_row] # Calculate edge seal at interface to encapsulant. - # Blocked out code did weird things and was based on equal flxes. Actually using a simple averaging. This looks better and is not used in the diffusion calculations. + # Blocked out code did weird things and was based on equal fluxes. Actually using a simple averaging. This looks better and is not used in the diffusion calculations. #perm[row + 1 + rp_row][seal_nodes + 1] = (perm_mid[seal_nodes + 3]*r1 # + perm_mid[seal_nodes]*r2) / (1+r2) perm[row + 1 + rp_row][seal_nodes + 1] = perm_mid[seal_nodes ]+(perm_mid[seal_nodes]-perm_mid[seal_nodes-1])/2 # Calculate encapsulant at interface to the edge seal. #perm[row + 1 + rp_row][seal_nodes + 2] = perm[row + 1 + rp_row][seal_nodes + 1] / r1 - perm[row + 1 + rp_row][seal_nodes + 2] = perm_mid[seal_nodes + 3]-(perm_mid[seal_nodes + 4]-perm_mid[seal_nodes+3])/2 + perm[row + 1 + rp_row][seal_nodes + 2] = perm_mid[seal_nodes + 3]+(perm_mid[seal_nodes + 4]-perm_mid[seal_nodes+3])/2 # Puts in the time for the first column. perm[row + 1 + rp_row][0] = rp_time + met_data[row + 1][1] + + # Because it is cycling around, it needs to start with the last temperature. met_data[0][0] = met_data[met_data.shape[0] - 1][0] From c3cdfe580106e1ad00e961bff496ed22a7fe2789 Mon Sep 17 00:00:00 2001 From: Kempe Date: Thu, 19 Sep 2024 18:01:01 -0600 Subject: [PATCH 08/32] Update utilities.py Modified the Json file access tool. --- pvdeg/utilities.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/pvdeg/utilities.py b/pvdeg/utilities.py index 2374df9..4f74469 100644 --- a/pvdeg/utilities.py +++ b/pvdeg/utilities.py @@ -515,9 +515,15 @@ def _read_material(name, fname="O2permeation.json"): fpath = os.path.join(DATA_DIR, fname) with open(fpath) as f: data = json.load(f) - + f.close() + print('work') if name is None: - material_list = data.keys() + material_list = '' + print('working') + for key in data: + if 'name' in data[key].keys(): + material_list = material_list + key + "=" + data[key]['name'] + '\n' + material_list = material_list[0:len(material_list)-1] return [*material_list] mat_dict = data[name] From 573fd93a00ffaa4399544d8c535d3d9a30c91118 Mon Sep 17 00:00:00 2001 From: Kempe Date: Thu, 19 Sep 2024 18:01:27 -0600 Subject: [PATCH 09/32] Update Tools-Edge Seal Oxygen Ingress.ipynb Modifying the output to show json options. --- .../Tools-Edge Seal Oxygen Ingress.ipynb | 76 +++++++++++++++---- 1 file changed, 63 insertions(+), 13 deletions(-) diff --git a/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb b/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb index 9c74dc5..3ca8df8 100644 --- a/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb +++ b/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -111,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -152,9 +152,18 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 29, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['OX000', 'OX001', 'OX002', 'OX003', 'OX004', 'OX005', 'OX006', 'OX007', 'OX008', 'OX009', 'OX010', 'OX011', 'OX012', 'OX013']\n", + "['W000', 'W001', 'W002', 'W003', 'W004', 'W005', 'W006', 'W007', 'W008', 'W009', 'W010', 'W011', 'W012', 'W013', 'W014', 'W015', 'W016', 'W017', 'W018', 'W019', 'W020', 'W021', 'W022', 'W023', 'W024', 'W025', 'W026', 'W027', 'W028', 'W029', 'W030', 'W031', 'W032', 'W033', 'W034', 'W035', 'W036', 'W037', 'W038', 'W039', 'W040']\n" + ] + } + ], "source": [ "es = 'OX005' #This is the number for the edge seal in the json file\n", "enc = 'OX003' #This is the number for the encapsulant in the json file\n", @@ -162,7 +171,9 @@ "encw = 10 #This is the encapsulant width in [cm]\n", "sn = 20 #This is the number of edge seal nodes to use\n", "en = 50 #This is the number of encapsulant nodes to use\n", - "pressure = 0.2109 * (1 - 0.0065 * meta.get('altitude') / 288.15) ** 5.25588" + "pressure = 0.2109 * (1 - 0.0065 * meta.get('altitude') / 288.15) ** 5.25588\n", + "print(pvdeg.utilities._read_material(name=None, fname=\"O2permeation.json\"))\n", + "print(pvdeg.utilities._read_material(name=None, fname=\"H2Opermeation.json\"))" ] }, { @@ -176,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -204,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -226,12 +237,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -266,7 +277,46 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OX001=Tedlar\n", + "OX002=ST504\n", + "OX003=EVA\n", + "OX004=AAA polyamide backsheet\n", + "OX005=Helioseal_101_dry\n", + "OX006=Helioseal_101_wet\n", + "OX007=LPO3_dry\n", + "OX008=LPO3_wet\n", + "OX009=Nagase_dry\n", + "OX010=Nagase_wet\n", + "OX011=Oppanol_B_200\n", + "OX012=EVA\n", + "OX013=polyolefin elastomer (POE)\n" + ] + } + ], + "source": [ + "fpath = os.path.join(DATA_DIR, \"O2permeation.json\")\n", + "with open(fpath) as f:\n", + " data = json.load(f)\n", + "f.close()\n", + "\n", + "material_list = ''\n", + "for key in data:\n", + " if 'name' in data[key].keys():\n", + " material_list = material_list + key + \"=\" + data[key]['name'] + '\\n'\n", + "material_list = material_list[0:len(material_list)-1]\n", + "print(material_list)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, "metadata": {}, "outputs": [ { From fedbb0e1250d7619b39ceab500be98ed7b6705f1 Mon Sep 17 00:00:00 2001 From: MDKempe <58960264+MDKempe@users.noreply.github.com> Date: Thu, 19 Sep 2024 18:30:20 -0600 Subject: [PATCH 10/32] C:\Users\mkempe\Documents\GitHub\PVDegradationTools\pvdeg --- .../Tools-Edge Seal Oxygen Ingress.ipynb | 24 +++++++++---------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb b/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb index 3ca8df8..51f4ed2 100644 --- a/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb +++ b/tutorials_and_tools/tutorials_and_tools/Tools-Edge Seal Oxygen Ingress.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -36,18 +36,16 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import os\n", - "from pathlib import Path\n", "import pvdeg\n", "import pandas as pd\n", "from pvdeg import DATA_DIR\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "import seaborn as sns\n", "import json" ] }, @@ -66,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -86,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -111,7 +109,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -152,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -187,7 +185,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -215,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -237,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -277,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -316,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 11, "metadata": {}, "outputs": [ { From f0c1d3a189f12a1c6cb51602cb0b45ca73b3f52d Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Thu, 19 Sep 2024 18:37:08 -0600 Subject: [PATCH 11/32] fix 1d diffusion string indexing --- pvdeg/diffusion.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pvdeg/diffusion.py b/pvdeg/diffusion.py index 3178022..e40f26d 100644 --- a/pvdeg/diffusion.py +++ b/pvdeg/diffusion.py @@ -88,24 +88,24 @@ def esdiffusion( H2O = json.load(user_file) user_file.close() - if edge_seal[0,2]=="OX": + if edge_seal[0:2]=="OX": esp = O2.get(edge_seal) if printout: print("Oxygen ingress parameters loaded for the edge seal.") else: - if edge_seal[0,1]=="W": + if edge_seal[0:1]=="W": esp = H2O.get(edge_seal) if printout: print("Water ingress parameters loaded for the edge seal.") else: print("Edge seal material not found") - if encapsulant[0,2]=="OX": + if encapsulant[0:2]=="OX": encp = O2.get(encapsulant) if printout: print("Oxygen ingress parameters loaded for the encapsulant.") else: - if encapsulant[0,1]=="W": + if encapsulant[0:1]=="W": encp = H2O.get(encapsulant) if printout: print("Water ingress parameters loaded for the eencapsulant.") From cbe0680389e879bff3a46d6413adb75305ce20c8 Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Thu, 19 Sep 2024 18:53:47 -0600 Subject: [PATCH 12/32] Fix: test/data/test-scenario.json --- tests/data/test-scenario.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/data/test-scenario.json b/tests/data/test-scenario.json index d641306..387888f 100644 --- a/tests/data/test-scenario.json +++ b/tests/data/test-scenario.json @@ -14,10 +14,10 @@ "Fickian": true, "Ead": 29.43112031, "Do": 0.129061678, - "Eas": 32.3137806, - "So": 87.81142774, - "Eap": 61.7449009, - "Po": 97917899126 + "Eas": 16.6314948252219, + "So": 0.136034525059804, + "Eap": 49.1083457348515, + "Po": 528718258.338532 }, "temp_model": "sapm", From b4e93b2635029d903dbfd32d4c2a80f2b36124f1 Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Thu, 19 Sep 2024 19:22:40 -0600 Subject: [PATCH 13/32] Fix: test_read_material_bad --- pvdeg/utilities.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/pvdeg/utilities.py b/pvdeg/utilities.py index 4f74469..342e302 100644 --- a/pvdeg/utilities.py +++ b/pvdeg/utilities.py @@ -518,13 +518,16 @@ def _read_material(name, fname="O2permeation.json"): f.close() print('work') if name is None: - material_list = '' - print('working') - for key in data: - if 'name' in data[key].keys(): - material_list = material_list + key + "=" + data[key]['name'] + '\n' - material_list = material_list[0:len(material_list)-1] - return [*material_list] + return list(data.keys()) + + # what was the point of this + # material_list = '' + # print('working') + # for key in data: + # if 'name' in data[key].keys(): + # material_list = material_list + key + "=" + data[key]['name'] + '\n' + # material_list = material_list[0:len(material_list)-1] + # return [*material_list] mat_dict = data[name] return mat_dict From 21a48531bd37438f9d474b83281426cbfb4e829e Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Thu, 19 Sep 2024 19:27:34 -0600 Subject: [PATCH 14/32] Fix: Run tests and cleanup --- pvdeg/utilities.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/pvdeg/utilities.py b/pvdeg/utilities.py index 342e302..9c5f215 100644 --- a/pvdeg/utilities.py +++ b/pvdeg/utilities.py @@ -516,11 +516,13 @@ def _read_material(name, fname="O2permeation.json"): with open(fpath) as f: data = json.load(f) f.close() - print('work') + if name is None: return list(data.keys()) - # what was the point of this + # Mike Added + # broke test + # =========== # material_list = '' # print('working') # for key in data: From 655414c29bc94c19e9ab2c39f172a308b820a46c Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Fri, 20 Sep 2024 18:41:45 -0600 Subject: [PATCH 15/32] Top Level import for ScenarioGeospatialScenario --- pvdeg/__init__.py | 2 +- pvdeg/scenario.py | 65 +- .../Scenario - Geospatial.ipynb | 1105 ++------- ...rm Mountain Prefferential Downselect.ipynb | 2196 +---------------- .../Scenario - Single Location.ipynb | 348 +-- .../Scenario - Temperatrure.ipynb | 8 +- 6 files changed, 479 insertions(+), 3245 deletions(-) diff --git a/pvdeg/__init__.py b/pvdeg/__init__.py index 6613597..0b770fc 100644 --- a/pvdeg/__init__.py +++ b/pvdeg/__init__.py @@ -12,7 +12,7 @@ from . import humidity from . import letid from . import montecarlo -from . import scenario +from .scenario import Scenario, GeospatialScenario from . import spectral from . import symbolic from . import standards diff --git a/pvdeg/scenario.py b/pvdeg/scenario.py index 2f1df3b..57397d5 100644 --- a/pvdeg/scenario.py +++ b/pvdeg/scenario.py @@ -16,16 +16,13 @@ import matplotlib.pyplot as plt from collections import OrderedDict from copy import deepcopy -from typing import List, Union, Optional, Tuple, Callable +from typing import List, Union, Optional, Tuple, Callable, overload from functools import partial import pprint from IPython.display import display, HTML import cartopy.crs as ccrs import cartopy.feature as cfeature -### premade scenario with locations of interest. Ask Mike? -# TODO: geospatial reset weather and addLocation from gids. - class Scenario: """ @@ -1193,27 +1190,40 @@ def addLocation( bbox_gids = pvdeg.geospatial.apply_bounding_box(geo_meta, **bbox_kwarg) geo_meta = geo_meta.loc[bbox_gids] + + # Downselect by Region + # ====================================================== + # string to list whole word list or keep list toList = lambda s: s if isinstance(s, list) else [s] if country: countries = toList(country) + self._check_set(countries, set(geo_meta["country"])) geo_meta = geo_meta[geo_meta["country"].isin(countries)] + + if state: states = toList(state) states = [ pvdeg.utilities._get_state(entry) if len(entry) == 2 else entry for entry in states ] + + self._check_set(states, set(geo_meta["state"])) geo_meta = geo_meta[geo_meta["state"].isin(states)] + + if county: if isinstance(county, str): county = toList(county) + self._check_set(county, set(geo_meta["county"])) geo_meta = geo_meta[geo_meta["county"].isin(county)] - # we don't downsample weather data until this runs - # because on NSRDB we are storing weather OUT of MEMORY with dask + # ====================================================== + + geo_meta, geo_gids = pvdeg.utilities.gid_downsampling( geo_meta, downsample_factor ) @@ -1533,7 +1543,7 @@ def coords_tonumpy(self) -> np.array: return coords - def geospatial_data(self) -> tuple[xr.Dataset, pd.DataFrame]: + def get_geospatial_data(self) -> tuple[xr.Dataset, pd.DataFrame]: """ Extract the geospatial weather dataset and metadata dataframe from the scenario object @@ -1548,7 +1558,7 @@ def geospatial_data(self) -> tuple[xr.Dataset, pd.DataFrame]: Returns: -------- - (weather_data, meta_data): (xr.Dataset, pd.DataFrame) + (weather_data, meta_data): tuple[xr.Dataset, pd.DataFrame] A tuple of weather data as an `xarray.Dataset` and the corresponding meta data as a dataframe. """ # downsample here, not done already happens at pipeline runtime @@ -1557,6 +1567,26 @@ def geospatial_data(self) -> tuple[xr.Dataset, pd.DataFrame]: ) return geo_weather_sub, self.meta_data + # @dispatch(xr.Dataset, pd.DataFrame) + def set_geospatial_data(self, weather_ds: xr.Dataset, meta_df: pd.DataFrame ) -> None: + """ + Parameters: + ----------- + weather_ds : xarray.Dataset + Dataset containing weather data for a block of gids. + meta_df : pandas.DataFrame + DataFrame containing meta data for a block of gids. + + Modifies: + ---------- + self.weather_data + sets to weather_ds + self.meta_data + sets to meta_df + """ + self.weather_data, self.meta_data = weather_ds, meta_df + + def addJob( self, func: Callable = None, @@ -1580,7 +1610,6 @@ def addJob( set flag to get a userWarning notifying the user of the job added to the pipeline in method call. ``default = False`` """ - # check if we can do geospatial analyis on desired function try: pvdeg.geospatial.template_parameters(func) except ValueError: @@ -1590,10 +1619,6 @@ def addJob( geo_job_dict = {"geospatial_job": {"job": func, "params": func_params}} - # # UNTESTED - # if func_params: - # geo_job_dict.update(func_params) - self.pipeline = geo_job_dict if see_added: @@ -1740,7 +1765,8 @@ def getValidRegions( f"self.geospatial should be True. Current value = {self.geospatial}" ) - discard_weather, meta_df = Scenario._get_geospatial_data(year=2022) + # discard_weather, meta_df = Scenario._get_geospatial_data(year=2022) + discard_weather, meta_df = self._get_geospatial_data(year=2022) if country: meta_df = meta_df[meta_df["country"] == country] @@ -1972,6 +1998,17 @@ def plot_USA( fpath if fpath else [f"os.getcwd/{self.name}-{self.results[data_from_result]}"] fig.savefig() + + def _check_set(self, iterable, to_check: set): + """Check if iterable is a subset of to_check""" + if not isinstance(iterable, set): + iterable = set(iterable) + + if not iterable.issubset(to_check): + raise ValueError(f"All of iterable: {iterable} does not exist in {to_check}") + + + def format_pipeline(self): pipeline_html = "
" if "geospatial_job" in self.pipeline: diff --git a/tutorials_and_tools/tutorials_and_tools/Scenario - Geospatial.ipynb b/tutorials_and_tools/tutorials_and_tools/Scenario - Geospatial.ipynb index 9b47deb..805dcdc 100644 --- a/tutorials_and_tools/tutorials_and_tools/Scenario - Geospatial.ipynb +++ b/tutorials_and_tools/tutorials_and_tools/Scenario - Geospatial.ipynb @@ -14,7 +14,8 @@ "metadata": {}, "source": [ "## Define Geospatial Scenario Object\n", - "Scenario is a general class that can be used to replace the legacy functional pvdeg analysis approach with an object orented one. ``Scenario`` can preform single location or geospatial analysis. The scenario constructor takes many arguments but the only required one for the following use cases is ``geospatial``. Choose ``geospatial = True`` to preform geospatial analysis or ``geospatial = False`` to preform a single location scenario. The ``name`` attribute is visible in when we display the entire scenario and is present in the file of saved information about the scenario." + "\n", + "To preform geospatial analysis we can create a `GeospatialScenario` object. Alternatively, to preform single location analysis use `Scenario`. Scenario and GeospatialScenario are generalized classes that can be used to replace the legacy functional pvdeg analysis approach with an object orented one." ] }, { @@ -23,9 +24,8 @@ "metadata": {}, "outputs": [], "source": [ - "geospatial_standoff_scenario = pvdeg.scenario.Geospatial_Scenario(\n", + "geospatial_standoff_scenario = pvdeg.GeospatialScenario(\n", " name='standoff geospatial',\n", - " geospatial = True,\n", ")" ] }, @@ -46,19 +46,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/tford/.conda-envs/pvdeg_env/lib/python3.10/site-packages/xarray/core/dataset.py:271: UserWarning: The specified chunks separate the stored chunks along dimension \"phony_dim_1\" starting at index 500. This could degrade performance. Instead, consider rechunking after loading.\n", + "/home/tford/.conda-envs/rpp/lib/python3.10/site-packages/xarray/core/dataset.py:274: UserWarning: The specified chunks separate the stored chunks along dimension \"phony_dim_1\" starting at index 500. This could degrade performance. Instead, consider rechunking after loading.\n", " warnings.warn(\n", - "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:1155: UserWarning: Gids Added - [449211 449212 450161 450162 450163 450164 451112 451113 451114 451115\n", - " 452064 452065 452066 452067 452068 453015 453016 453017 453018 453019\n", - " 453020 453965 453966 453967 453968 453969 453973 453974 453975 454915\n", - " 454916 454917 454918 454919 454920 454922 454923 454924 454925 454926\n", - " 455867 455868 455869 455870 455871 455872 455873 455874 455875 455876\n", - " 455877 456818 456819 456820 456821 456822 456823 456824 456825 456826\n", - " 456827 456828 457768 457769 457770 457771 457772 457773 457774 457775\n", - " 457776 457777 458719 458720 458721 458722 458723 458724 458725 458726\n", - " 459670 459671 459672 459673 459674 459675 459676 460610 460611 460612\n", - " 460613 460614 460615 461552 461553 461554 461555 461556 462496 462497\n", - " 462498 462499 463455 464426]\n", + "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:1237: UserWarning: Gids Added - [449212 454915 460611]\n", " warnings.warn(message, UserWarning)\n" ] } @@ -90,8 +80,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:1183: UserWarning: standoff added to pipeline as \n", - " {'geospatial_job': }\n", + "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:1626: UserWarning: standoff added to pipeline as \n", + " {'geospatial_job': {'job': , 'params': {}}}\n", " warnings.warn(message, UserWarning)\n" ] } @@ -113,37 +103,25 @@ "output_type": "stream", "text": [ "Name : standoff geospatial\n", - "\u001b[1;32mGEOSPATIAL = True\u001b[0m\n", "Pipeline : \n", - " geospatial_job\n", - "0 \n", + " geospatial_job.job\n", + "0 \n", "Results : Pipeline results : \n", "Pipeline has not been run\n", - "('gids : [449211 449212 450161 450162 450163 450164 451112 451113 451114 '\n", - " '451115\\n'\n", - " ' 452064 452065 452066 452067 452068 453015 453016 453017 453018 453019\\n'\n", - " ' 453020 453965 453966 453967 453968 453969 453973 453974 453975 454915\\n'\n", - " ' 454916 454917 454918 454919 454920 454922 454923 454924 454925 454926\\n'\n", - " ' 455867 455868 455869 455870 455871 455872 455873 455874 455875 455876\\n'\n", - " ' 455877 456818 456819 456820 456821 456822 456823 456824 456825 456826\\n'\n", - " ' 456827 456828 457768 457769 457770 457771 457772 457773 457774 457775\\n'\n", - " ' 457776 457777 458719 458720 458721 458722 458723 458724 458725 458726\\n'\n", - " ' 459670 459671 459672 459673 459674 459675 459676 460610 460611 460612\\n'\n", - " ' 460613 460614 460615 461552 461553 461554 461555 461556 462496 462497\\n'\n", - " ' 462498 462499 463455 464426]')\n", + "'gids : [449212 454915 460611]'\n", "'test modules :'\n", - "scenario weather : Size: 44MB\n", - "Dimensions: (time: 17520, gid: 104)\n", + "scenario weather : Size: 2TB\n", + "Dimensions: (time: 17520, gid: 2018267)\n", "Coordinates:\n", - " * gid (gid) int64 832B 449211 449212 450161 ... 463455 464426\n", + " * gid (gid) int64 16MB 0 1 2 3 ... 2018264 2018265 2018266\n", " * time (time) datetime64[ns] 140kB 2022-01-01 ... 2022-12-31T...\n", "Data variables:\n", - " temp_air (time, gid) float32 7MB dask.array\n", - " wind_speed (time, gid) float32 7MB dask.array\n", - " dhi (time, gid) float32 7MB dask.array\n", - " ghi (time, gid) float32 7MB dask.array\n", - " dni (time, gid) float32 7MB dask.array\n", - " relative_humidity (time, gid) float32 7MB dask.array\n", + " temp_air (time, gid) float64 283GB dask.array\n", + " wind_speed (time, gid) float64 283GB dask.array\n", + " dhi (time, gid) float64 283GB dask.array\n", + " ghi (time, gid) float64 283GB dask.array\n", + " dni (time, gid) float64 283GB dask.array\n", + " relative_humidity (time, gid) float64 283GB dask.array\n", "Attributes:\n", " full_version_record: {\"rex\": \"0.2.80\", \"pandas\": \"2.0.0\", \"numpy\": \"1.23...\n", " package: rex\n", @@ -169,218 +147,26 @@ "execution_count": 6, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tford/.conda-envs/rpp/lib/python3.10/site-packages/distributed/node.py:182: UserWarning: Port 8787 is already in use.\n", + "Perhaps you already have a cluster running?\n", + "Hosting the HTTP server on port 37481 instead\n", + " warnings.warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "Dashboard: http://127.0.0.1:8787/status\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "Dashboard: http://127.0.0.1:37481/status\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n" ] } @@ -769,162 +555,31 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
<xarray.Dataset> Size: 6kB\n",
-       "Dimensions:    (latitude: 14, longitude: 17)\n",
+       "
<xarray.Dataset> Size: 164B\n",
+       "Dimensions:    (latitude: 2, longitude: 3)\n",
        "Coordinates:\n",
-       "  * latitude   (latitude) float32 56B 39.37 39.41 39.45 ... 39.81 39.85 39.89\n",
-       "  * longitude  (longitude) float32 68B -106.4 -106.4 -106.3 ... -105.8 -105.8\n",
+       "  * latitude   (latitude) float32 8B 39.61 39.85\n",
+       "  * longitude  (longitude) float32 12B -106.4 -106.2 -105.9\n",
        "Data variables:\n",
-       "    T98_inf    (latitude, longitude) float64 2kB nan nan nan nan ... nan nan nan\n",
-       "    x          (latitude, longitude) float64 2kB nan nan nan nan ... nan nan nan\n",
-       "    T98_0      (latitude, longitude) float64 2kB nan nan nan nan ... nan nan nan\n",
+       "    x          (latitude, longitude) float64 48B nan nan 0.5751 1.432 1.421 nan\n",
+       "    T98_0      (latitude, longitude) float64 48B nan nan 72.15 75.22 75.25 nan\n",
+       "    T98_inf    (latitude, longitude) float64 48B nan nan 46.77 48.81 48.51 nan\n",
        "Attributes:\n",
-       "    long_name:  Standoff dataset
" + " long_name: Standoff dataset" ], "text/plain": [ - " Size: 6kB\n", - "Dimensions: (latitude: 14, longitude: 17)\n", + " Size: 164B\n", + "Dimensions: (latitude: 2, longitude: 3)\n", "Coordinates:\n", - " * latitude (latitude) float32 56B 39.37 39.41 39.45 ... 39.81 39.85 39.89\n", - " * longitude (longitude) float32 68B -106.4 -106.4 -106.3 ... -105.8 -105.8\n", + " * latitude (latitude) float32 8B 39.61 39.85\n", + " * longitude (longitude) float32 12B -106.4 -106.2 -105.9\n", "Data variables:\n", - " T98_inf (latitude, longitude) float64 2kB nan nan nan nan ... nan nan nan\n", - " x (latitude, longitude) float64 2kB nan nan nan nan ... nan nan nan\n", - " T98_0 (latitude, longitude) float64 2kB nan nan nan nan ... nan nan nan\n", + " x (latitude, longitude) float64 48B nan nan 0.5751 1.432 1.421 nan\n", + " T98_0 (latitude, longitude) float64 48B nan nan 72.15 75.22 75.25 nan\n", + " T98_inf (latitude, longitude) float64 48B nan nan 46.77 48.81 48.51 nan\n", "Attributes:\n", " long_name: Standoff dataset" ] @@ -949,7 +604,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -960,25 +615,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Limited Geospatial Functionality\n", - "Only the following functions are currently supported for pvdeg geospatial analysis\n", + "## Example Geospatial Functionality\n", + "Many functions are supported for geospatial analysis, here are a few.\n", "- ``pvdeg.standards.standoff`` \n", "- ``pvdeg.humidity.module`` \n", - "- ``pvdeg.letid.calc_letid_outdoors``" + "- ``pvdeg.letid.calc_letid_outdoors``\n", + "\n", + "See the Geospatial Templates tutorial for an example on this." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/tford/.conda-envs/pvdeg_env/lib/python3.10/site-packages/xarray/core/dataset.py:271: UserWarning: The specified chunks separate the stored chunks along dimension \"phony_dim_1\" starting at index 500. This could degrade performance. Instead, consider rechunking after loading.\n", + "/home/tford/.conda-envs/rpp/lib/python3.10/site-packages/xarray/core/dataset.py:274: UserWarning: The specified chunks separate the stored chunks along dimension \"phony_dim_1\" starting at index 500. This could degrade performance. Instead, consider rechunking after loading.\n", " warnings.warn(\n", - "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:1155: UserWarning: Gids Added - [474405 474406 474407 474408 474409 474410 474411 474412 474413 474414\n", + "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:1237: UserWarning: Gids Added - [474405 474406 474407 474408 474409 474410 474411 474412 474413 474414\n", " 474415 474416 474417 474418 474419 474420 474421 474422 474423 475420\n", " 475421 475422 475423 475424 475425 475426 475427 475428 475429 475430\n", " 475431 475432 475433 475434 475435 475436 475437 475438 476435 476436\n", @@ -993,14 +650,14 @@ " 481539 481540 481542 481543 481544 482557 482558 482559 482560 482561\n", " 482562 482564 482565]\n", " warnings.warn(message, UserWarning)\n", - "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:1183: UserWarning: module added to pipeline as \n", - " {'geospatial_job': }\n", + "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:1626: UserWarning: module added to pipeline as \n", + " {'geospatial_job': {'job': , 'params': {}}}\n", " warnings.warn(message, UserWarning)\n" ] } ], "source": [ - "geospatial_humidity_scenario = pvdeg.scenario.Geospatial_Scenario(\n", + "geospatial_humidity_scenario = pvdeg.GeospatialScenario(\n", " name = 'humidity scenario',\n", " geospatial = True\n", ")\n", @@ -1019,16 +676,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/tford/.conda-envs/pvdeg_env/lib/python3.10/site-packages/distributed/node.py:182: UserWarning: Port 8787 is already in use.\n", + "/home/tford/.conda-envs/rpp/lib/python3.10/site-packages/distributed/node.py:182: UserWarning: Port 8787 is already in use.\n", "Perhaps you already have a cluster running?\n", - "Hosting the HTTP server on port 37307 instead\n", + "Hosting the HTTP server on port 40703 instead\n", " warnings.warn(\n" ] }, @@ -1036,406 +693,140 @@ "name": "stdout", "output_type": "stream", "text": [ - "Dashboard: http://127.0.0.1:37307/status\n", + "Dashboard: http://127.0.0.1:40703/status\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n" + "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n" ] } ], @@ -1445,7 +836,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -1821,176 +1212,176 @@ " * longitude (longitude) float32 36B -105.4 -105.3 ... -105.1 -105.1\n", " * time (time) datetime64[ns] 140kB 2022-01-01 ... 2022-12-31...\n", "Data variables:\n", + " RH_surface_outside (time, latitude, longitude) float64 24MB 76.96 ... 58.81\n", " RH_back_encap (time, latitude, longitude) float64 24MB 76.96 ... 44.67\n", - " RH_front_encap (time, latitude, longitude) float64 24MB 42.21 ... 31.69\n", " RH_backsheet (time, latitude, longitude) float64 24MB 76.96 ... 51.74\n", - " RH_surface_outside (time, latitude, longitude) float64 24MB 76.96 ... 58.81
    • " ], "text/plain": [ " Size: 96MB\n", @@ -2021,13 +1412,13 @@ " * longitude (longitude) float32 36B -105.4 -105.3 ... -105.1 -105.1\n", " * time (time) datetime64[ns] 140kB 2022-01-01 ... 2022-12-31...\n", "Data variables:\n", + " RH_surface_outside (time, latitude, longitude) float64 24MB 76.96 ... 58.81\n", " RH_back_encap (time, latitude, longitude) float64 24MB 76.96 ... 44.67\n", - " RH_front_encap (time, latitude, longitude) float64 24MB 42.21 ... 31.69\n", " RH_backsheet (time, latitude, longitude) float64 24MB 76.96 ... 51.74\n", - " RH_surface_outside (time, latitude, longitude) float64 24MB 76.96 ... 58.81" + " RH_front_encap (time, latitude, longitude) float64 24MB 42.21 ... 31.69" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -2039,9 +1430,9 @@ ], "metadata": { "kernelspec": { - "display_name": "pvdeg_env", + "display_name": "rpp", "language": "python", - "name": "python3" + "name": "rpp" }, "language_info": { "codemirror_mode": { @@ -2057,5 +1448,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/tutorials_and_tools/tutorials_and_tools/Scenario - Non-uniform Mountain Prefferential Downselect.ipynb b/tutorials_and_tools/tutorials_and_tools/Scenario - Non-uniform Mountain Prefferential Downselect.ipynb index 1dcf4a8..d6a8c13 100644 --- a/tutorials_and_tools/tutorials_and_tools/Scenario - Non-uniform Mountain Prefferential Downselect.ipynb +++ b/tutorials_and_tools/tutorials_and_tools/Scenario - Non-uniform Mountain Prefferential Downselect.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -33,7 +33,7 @@ } ], "source": [ - "dynamic_points = pvdeg.scenario.GeospatialScenario(\n", + "dynamic_points = pvdeg.GeospatialScenario(\n", " name='dynamic-selection'\n", ")\n", "\n", @@ -54,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -66,6 +66,17 @@ }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(
    ,\n", + " )" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -87,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -123,21 +134,21 @@ " \n", " \n", " \n", - " 407393\n", - " 38.529999\n", - " -108.260002\n", - " 2203\n", + " 282901\n", + " 41.889999\n", + " -114.019997\n", + " 1704\n", " -7\n", " United States\n", - " Colorado\n", - " Montrose\n", + " Utah\n", + " Box Elder\n", " 2\n", " \n", " \n", - " 295746\n", - " 41.889999\n", - " -113.379997\n", - " 2537\n", + " 282903\n", + " 41.810001\n", + " -114.019997\n", + " 2093\n", " -7\n", " United States\n", " Utah\n", @@ -145,36 +156,36 @@ " 2\n", " \n", " \n", - " 462552\n", - " 37.410000\n", - " -105.860001\n", - " 2297\n", + " 282905\n", + " 41.730000\n", + " -114.019997\n", + " 1880\n", " -7\n", " United States\n", - " Colorado\n", - " Alamosa\n", + " Utah\n", + " Box Elder\n", " 2\n", " \n", " \n", - " 416313\n", - " 37.889999\n", - " -107.860001\n", - " 3061\n", + " 282907\n", + " 41.650002\n", + " -114.019997\n", + " 1903\n", " -7\n", " United States\n", - " Colorado\n", - " San Miguel\n", + " Utah\n", + " Box Elder\n", " 2\n", " \n", " \n", - " 377412\n", - " 37.250000\n", - " -109.620003\n", - " 1352\n", + " 282909\n", + " 41.570000\n", + " -114.019997\n", + " 1936\n", " -7\n", " United States\n", " Utah\n", - " San Juan\n", + " Box Elder\n", " 2\n", " \n", " \n", @@ -189,96 +200,96 @@ " ...\n", " \n", " \n", - " 368545\n", - " 38.209999\n", - " -110.019997\n", - " 1527\n", + " 559787\n", + " 37.330002\n", + " -102.099998\n", + " 1139\n", " -7\n", " United States\n", - " Utah\n", - " Wayne\n", + " Colorado\n", + " Baca\n", " 2\n", " \n", " \n", - " 310605\n", - " 41.810001\n", - " -112.660004\n", - " 1496\n", + " 559789\n", + " 37.250000\n", + " -102.099998\n", + " 1141\n", " -7\n", " United States\n", - " Utah\n", - " Box Elder\n", + " Colorado\n", + " Baca\n", " 2\n", " \n", " \n", - " 343651\n", - " 40.529999\n", - " -111.139999\n", - " 2394\n", + " 559791\n", + " 37.169998\n", + " -102.099998\n", + " 1149\n", " -7\n", " United States\n", - " Utah\n", - " Wasatch\n", + " Colorado\n", + " Baca\n", " 2\n", " \n", " \n", - " 456842\n", - " 38.849998\n", - " -106.099998\n", - " 2682\n", + " 559793\n", + " 37.090000\n", + " -102.099998\n", + " 1096\n", " -7\n", " United States\n", " Colorado\n", - " Chaffee\n", + " Baca\n", " 2\n", " \n", " \n", - " 389841\n", - " 39.889999\n", - " -109.059998\n", - " 1921\n", + " 559795\n", + " 37.009998\n", + " -102.099998\n", + " 1122\n", " -7\n", " United States\n", - " Utah\n", - " Uintah\n", + " Colorado\n", + " Baca\n", " 2\n", " \n", " \n", "\n", - "

    795 rows × 8 columns

    \n", + "

    7956 rows × 8 columns

    \n", "" ], "text/plain": [ " latitude longitude altitude tz country state \\\n", - "407393 38.529999 -108.260002 2203 -7 United States Colorado \n", - "295746 41.889999 -113.379997 2537 -7 United States Utah \n", - "462552 37.410000 -105.860001 2297 -7 United States Colorado \n", - "416313 37.889999 -107.860001 3061 -7 United States Colorado \n", - "377412 37.250000 -109.620003 1352 -7 United States Utah \n", + "282901 41.889999 -114.019997 1704 -7 United States Utah \n", + "282903 41.810001 -114.019997 2093 -7 United States Utah \n", + "282905 41.730000 -114.019997 1880 -7 United States Utah \n", + "282907 41.650002 -114.019997 1903 -7 United States Utah \n", + "282909 41.570000 -114.019997 1936 -7 United States Utah \n", "... ... ... ... .. ... ... \n", - "368545 38.209999 -110.019997 1527 -7 United States Utah \n", - "310605 41.810001 -112.660004 1496 -7 United States Utah \n", - "343651 40.529999 -111.139999 2394 -7 United States Utah \n", - "456842 38.849998 -106.099998 2682 -7 United States Colorado \n", - "389841 39.889999 -109.059998 1921 -7 United States Utah \n", - "\n", - " county wind_height \n", - "407393 Montrose 2 \n", - "295746 Box Elder 2 \n", - "462552 Alamosa 2 \n", - "416313 San Miguel 2 \n", - "377412 San Juan 2 \n", - "... ... ... \n", - "368545 Wayne 2 \n", - "310605 Box Elder 2 \n", - "343651 Wasatch 2 \n", - "456842 Chaffee 2 \n", - "389841 Uintah 2 \n", - "\n", - "[795 rows x 8 columns]" + "559787 37.330002 -102.099998 1139 -7 United States Colorado \n", + "559789 37.250000 -102.099998 1141 -7 United States Colorado \n", + "559791 37.169998 -102.099998 1149 -7 United States Colorado \n", + "559793 37.090000 -102.099998 1096 -7 United States Colorado \n", + "559795 37.009998 -102.099998 1122 -7 United States Colorado \n", + "\n", + " county wind_height \n", + "282901 Box Elder 2 \n", + "282903 Box Elder 2 \n", + "282905 Box Elder 2 \n", + "282907 Box Elder 2 \n", + "282909 Box Elder 2 \n", + "... ... ... \n", + "559787 Baca 2 \n", + "559789 Baca 2 \n", + "559791 Baca 2 \n", + "559793 Baca 2 \n", + "559795 Baca 2 \n", + "\n", + "[7956 rows x 8 columns]" ] }, - "execution_count": 32, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -289,7 +300,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -303,18 +314,29 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(
    ,\n", + " )" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -332,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -354,1478 +376,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The array tilt angle was not provided, therefore the latitude tilt of 41.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 41.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.1 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.3 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.2 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.6 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.0 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.4 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 38.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 40.9 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 37.5 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n" - ] - }, - { - "ename": "ValueError", - "evalue": "conflicting sizes for dimension 'gid': length 795 on 'gid' and length 723 on {'gid': 'x'}", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[28], line 9\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# geospatial analysis now\u001b[39;00m\n\u001b[1;32m 3\u001b[0m geo \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfunc\u001b[39m\u001b[38;5;124m\"\u001b[39m: pvdeg\u001b[38;5;241m.\u001b[39mstandards\u001b[38;5;241m.\u001b[39mstandoff,\n\u001b[1;32m 5\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mweather_ds\u001b[39m\u001b[38;5;124m\"\u001b[39m: sub_weather,\n\u001b[1;32m 6\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmeta_df\u001b[39m\u001b[38;5;124m\"\u001b[39m: dynamic_points\u001b[38;5;241m.\u001b[39mmeta_data,\n\u001b[1;32m 7\u001b[0m }\n\u001b[0;32m----> 9\u001b[0m analysis_result \u001b[38;5;241m=\u001b[39m \u001b[43mpvdeg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgeospatial\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43manalysis\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgeo\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/dev/PVDegradationTools/pvdeg/geospatial.py:206\u001b[0m, in \u001b[0;36manalysis\u001b[0;34m(weather_ds, meta_df, func, template, **func_kwargs)\u001b[0m\n\u001b[1;32m 202\u001b[0m mindex_obj \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mMultiIndex\u001b[38;5;241m.\u001b[39mfrom_arrays(\n\u001b[1;32m 203\u001b[0m [meta_df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlatitude\u001b[39m\u001b[38;5;124m\"\u001b[39m], meta_df[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlongitude\u001b[39m\u001b[38;5;124m\"\u001b[39m]], names\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlatitude\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlongitude\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 204\u001b[0m )\n\u001b[1;32m 205\u001b[0m mindex_coords \u001b[38;5;241m=\u001b[39m xr\u001b[38;5;241m.\u001b[39mCoordinates\u001b[38;5;241m.\u001b[39mfrom_pandas_multiindex(mindex_obj, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgid\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 206\u001b[0m stacked \u001b[38;5;241m=\u001b[39m \u001b[43mstacked\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43massign_coords\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmindex_coords\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 208\u001b[0m stacked \u001b[38;5;241m=\u001b[39m stacked\u001b[38;5;241m.\u001b[39mdrop_duplicates(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgid\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 209\u001b[0m res \u001b[38;5;241m=\u001b[39m stacked\u001b[38;5;241m.\u001b[39munstack(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgid\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;66;03m# , sparse=True\u001b[39;00m\n", - "File \u001b[0;32m~/.conda-envs/rpp/lib/python3.10/site-packages/xarray/core/common.py:644\u001b[0m, in \u001b[0;36mDataWithCoords.assign_coords\u001b[0;34m(self, coords, **coords_kwargs)\u001b[0m\n\u001b[1;32m 641\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 642\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_calc_assign_results(coords_combined)\n\u001b[0;32m--> 644\u001b[0m \u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcoords\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresults\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 645\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m data\n", - "File \u001b[0;32m~/.conda-envs/rpp/lib/python3.10/site-packages/xarray/core/coordinates.py:566\u001b[0m, in \u001b[0;36mCoordinates.update\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 560\u001b[0m \u001b[38;5;66;03m# special case for PandasMultiIndex: updating only its dimension coordinate\u001b[39;00m\n\u001b[1;32m 561\u001b[0m \u001b[38;5;66;03m# is still allowed but depreciated.\u001b[39;00m\n\u001b[1;32m 562\u001b[0m \u001b[38;5;66;03m# It is the only case where we need to actually drop coordinates here (multi-index levels)\u001b[39;00m\n\u001b[1;32m 563\u001b[0m \u001b[38;5;66;03m# TODO: remove when removing PandasMultiIndex's dimension coordinate.\u001b[39;00m\n\u001b[1;32m 564\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_drop_coords(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_names \u001b[38;5;241m-\u001b[39m coords_to_align\u001b[38;5;241m.\u001b[39m_names)\n\u001b[0;32m--> 566\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_update_coords\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcoords\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindexes\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda-envs/rpp/lib/python3.10/site-packages/xarray/core/coordinates.py:751\u001b[0m, in \u001b[0;36mDatasetCoordinates._update_coords\u001b[0;34m(self, coords, indexes)\u001b[0m\n\u001b[1;32m 748\u001b[0m variables\u001b[38;5;241m.\u001b[39mupdate(coords)\n\u001b[1;32m 750\u001b[0m \u001b[38;5;66;03m# check for inconsistent state *before* modifying anything in-place\u001b[39;00m\n\u001b[0;32m--> 751\u001b[0m dims \u001b[38;5;241m=\u001b[39m \u001b[43mcalculate_dimensions\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvariables\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 752\u001b[0m new_coord_names \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m(coords)\n\u001b[1;32m 753\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m dim, size \u001b[38;5;129;01min\u001b[39;00m dims\u001b[38;5;241m.\u001b[39mitems():\n", - "File \u001b[0;32m~/.conda-envs/rpp/lib/python3.10/site-packages/xarray/core/variable.py:3008\u001b[0m, in \u001b[0;36mcalculate_dimensions\u001b[0;34m(variables)\u001b[0m\n\u001b[1;32m 3006\u001b[0m last_used[dim] \u001b[38;5;241m=\u001b[39m k\n\u001b[1;32m 3007\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m dims[dim] \u001b[38;5;241m!=\u001b[39m size:\n\u001b[0;32m-> 3008\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 3009\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mconflicting sizes for dimension \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdim\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m: \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 3010\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlength \u001b[39m\u001b[38;5;132;01m{\u001b[39;00msize\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mk\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m and length \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdims[dim]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m on \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mlast_used\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 3011\u001b[0m )\n\u001b[1;32m 3012\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dims\n", - "\u001b[0;31mValueError\u001b[0m: conflicting sizes for dimension 'gid': length 795 on 'gid' and length 723 on {'gid': 'x'}" - ] - } - ], + "outputs": [], "source": [ "# geospatial analysis now\n", "\n", @@ -1849,483 +402,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
    <xarray.Dataset> Size: 61kB\n",
-       "Dimensions:    (latitude: 42, longitude: 60)\n",
-       "Coordinates:\n",
-       "  * latitude   (latitude) float32 168B 37.01 37.09 37.17 ... 41.49 41.65 41.89\n",
-       "  * longitude  (longitude) float32 240B -113.9 -113.6 -113.4 ... -102.7 -102.6\n",
-       "Data variables:\n",
-       "    x          (latitude, longitude) float64 20kB nan nan nan ... nan nan nan\n",
-       "    T98_0      (latitude, longitude) float64 20kB nan nan nan ... nan nan nan\n",
-       "    T98_inf    (latitude, longitude) float64 20kB nan nan nan ... nan nan nan
    " - ], - "text/plain": [ - " Size: 61kB\n", - "Dimensions: (latitude: 42, longitude: 60)\n", - "Coordinates:\n", - " * latitude (latitude) float32 168B 37.01 37.09 37.17 ... 41.49 41.65 41.89\n", - " * longitude (longitude) float32 240B -113.9 -113.6 -113.4 ... -102.7 -102.6\n", - "Data variables:\n", - " x (latitude, longitude) float64 20kB nan nan nan ... nan nan nan\n", - " T98_0 (latitude, longitude) float64 20kB nan nan nan ... nan nan nan\n", - " T98_inf (latitude, longitude) float64 20kB nan nan nan ... nan nan nan" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "analysis_result" ] @@ -2341,31 +420,9 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(
    ,\n", - " )" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
    " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pvdeg.geospatial.plot_USA(analysis_result['x'])" ] @@ -2381,20 +438,9 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
    " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "pvdeg.geospatial.plot_sparse_analysis(analysis_result, data_var='x', method='linear')" ] diff --git a/tutorials_and_tools/tutorials_and_tools/Scenario - Single Location.ipynb b/tutorials_and_tools/tutorials_and_tools/Scenario - Single Location.ipynb index 65cf9f3..64de766 100644 --- a/tutorials_and_tools/tutorials_and_tools/Scenario - Single Location.ipynb +++ b/tutorials_and_tools/tutorials_and_tools/Scenario - Single Location.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -44,8 +44,8 @@ "output_type": "stream", "text": [ "Working on a Linux 4.18.0-477.10.1.el8_8.x86_64\n", - "Python version 3.10.9 | packaged by conda-forge | (main, Feb 2 2023, 20:20:04) [GCC 11.3.0]\n", - "pvdeg version 0.3.1.dev220+gaf1083c.d20240608\n" + "Python version 3.10.14 | packaged by conda-forge | (main, Mar 20 2024, 12:45:18) [GCC 12.3.0]\n", + "pvdeg version 0.3.1.dev223+g03f3e6a.d20240708\n" ] } ], @@ -73,11 +73,11 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "simple_scenario = pvdeg.scenario.Scenario(\n", + "simple_scenario = pvdeg.Scenario(\n", " name=\"Point Minimum Standoff\",\n", " email='user@mail.com',\n", " api_key='DEMO_KEY'\n", @@ -96,21 +96,21 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Column \"relative_humidity\" not found in DataFrame. Calculating...\n" + " \r" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:212: UserWarning: Gids Added - [1060699]\n", + "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:230: UserWarning: Gids Added - [1060699]\n", " warnings.warn(message, UserWarning)\n" ] } @@ -124,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -412,7 +412,7 @@ "[8760 rows x 15 columns]" ] }, - "execution_count": 20, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -443,15 +443,15 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:375: UserWarning: standoff added to pipeline as \n", - " {'job': , 'params': {}}\n", + "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:396: UserWarning: standoff added to pipeline as \n", + " {'job': , 'params': {}}\n", " warnings.warn(message, UserWarning)\n" ] } @@ -474,15 +474,15 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:375: UserWarning: solder_fatigue added to pipeline as \n", - " {'job': , 'params': {'wind_factor': 0.33}}\n", + "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:396: UserWarning: solder_fatigue added to pipeline as \n", + " {'job': , 'params': {'wind_factor': 0.33}}\n", " warnings.warn(message, UserWarning)\n" ] } @@ -511,15 +511,15 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:375: UserWarning: standoff added to pipeline as \n", - " {'job': , 'params': {'weather_df': Year Month Day Hour Minute dni dhi ghi \\\n", + "/home/tford/dev/PVDegradationTools/pvdeg/scenario.py:396: UserWarning: standoff added to pipeline as \n", + " {'job': , 'params': {'weather_df': Year Month Day Hour Minute dni dhi ghi \\\n", "1999-01-01 00:30:00-07:00 1999 1 1 0 30 0.0 0.0 0.0 \n", "1999-01-01 01:30:00-07:00 1999 1 1 1 30 0.0 0.0 0.0 \n", "1999-01-01 02:30:00-07:00 1999 1 1 2 30 0.0 0.0 0.0 \n", @@ -577,7 +577,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -586,34 +586,8 @@ "text": [ "Name : Point Minimum Standoff\n", "Pipeline : \n", - " BLHZH.job WCBOQ.job WCBOQ.params.wind_factor PUKRE.job PUKRE.params.weather_df PUKRE.params.meta.Source PUKRE.params.meta.Location ID PUKRE.params.meta.City PUKRE.params.meta.State PUKRE.params.meta.Country PUKRE.params.meta.Clearsky DHI Units PUKRE.params.meta.Clearsky DNI Units PUKRE.params.meta.Clearsky GHI Units PUKRE.params.meta.Dew Point Units PUKRE.params.meta.DHI Units PUKRE.params.meta.DNI Units PUKRE.params.meta.GHI Units PUKRE.params.meta.Solar Zenith Angle Units PUKRE.params.meta.Temperature Units PUKRE.params.meta.Pressure Units PUKRE.params.meta.Relative Humidity Units PUKRE.params.meta.Precipitable Water Units PUKRE.params.meta.Wind Direction Units PUKRE.params.meta.Wind Speed Units PUKRE.params.meta.Cloud Type -15 PUKRE.params.meta.Cloud Type 0 PUKRE.params.meta.Cloud Type 1 PUKRE.params.meta.Cloud Type 2 PUKRE.params.meta.Cloud Type 3 PUKRE.params.meta.Cloud Type 4 PUKRE.params.meta.Cloud Type 5 PUKRE.params.meta.Cloud Type 6 PUKRE.params.meta.Cloud Type 7 PUKRE.params.meta.Cloud Type 8 PUKRE.params.meta.Cloud Type 9 PUKRE.params.meta.Cloud Type 10 PUKRE.params.meta.Cloud Type 11 PUKRE.params.meta.Cloud Type 12 PUKRE.params.meta.Fill Flag 0 PUKRE.params.meta.Fill Flag 1 PUKRE.params.meta.Fill Flag 2 PUKRE.params.meta.Fill Flag 3 PUKRE.params.meta.Fill Flag 4 PUKRE.params.meta.Fill Flag 5 PUKRE.params.meta.Surface Albedo Units PUKRE.params.meta.Version PUKRE.params.meta.latitude PUKRE.params.meta.longitude PUKRE.params.meta.altitude PUKRE.params.meta.tz MUDMB.job FOYEQ.job FOYEQ.params.wind_factor UJIKB.job UJIKB.params.weather_df UJIKB.params.meta.Source UJIKB.params.meta.Location ID UJIKB.params.meta.City UJIKB.params.meta.State UJIKB.params.meta.Country UJIKB.params.meta.Clearsky DHI Units UJIKB.params.meta.Clearsky DNI Units UJIKB.params.meta.Clearsky GHI Units UJIKB.params.meta.Dew Point Units UJIKB.params.meta.DHI Units UJIKB.params.meta.DNI Units UJIKB.params.meta.GHI Units UJIKB.params.meta.Solar Zenith Angle Units UJIKB.params.meta.Temperature Units UJIKB.params.meta.Pressure Units UJIKB.params.meta.Relative Humidity Units UJIKB.params.meta.Precipitable Water Units UJIKB.params.meta.Wind Direction Units UJIKB.params.meta.Wind Speed Units UJIKB.params.meta.Cloud Type -15 UJIKB.params.meta.Cloud Type 0 UJIKB.params.meta.Cloud Type 1 UJIKB.params.meta.Cloud Type 2 UJIKB.params.meta.Cloud Type 3 UJIKB.params.meta.Cloud Type 4 UJIKB.params.meta.Cloud Type 5 UJIKB.params.meta.Cloud Type 6 UJIKB.params.meta.Cloud Type 7 UJIKB.params.meta.Cloud Type 8 UJIKB.params.meta.Cloud Type 9 UJIKB.params.meta.Cloud Type 10 UJIKB.params.meta.Cloud Type 11 UJIKB.params.meta.Cloud Type 12 UJIKB.params.meta.Fill Flag 0 UJIKB.params.meta.Fill Flag 1 UJIKB.params.meta.Fill Flag 2 UJIKB.params.meta.Fill Flag 3 UJIKB.params.meta.Fill Flag 4 UJIKB.params.meta.Fill Flag 5 UJIKB.params.meta.Surface Albedo Units UJIKB.params.meta.Version UJIKB.params.meta.latitude UJIKB.params.meta.longitude UJIKB.params.meta.altitude UJIKB.params.meta.tz\n", - "0 0.33 Year Month Day Hour Minute dni dhi ghi \\\n", - "1999-01-01 00:30:00-07:00 1999 1 1 0 30 0.0 0.0 0.0 \n", - "1999-01-01 01:30:00-07:00 1999 1 1 1 30 0.0 0.0 0.0 \n", - "1999-01-01 02:30:00-07:00 1999 1 1 2 30 0.0 0.0 0.0 \n", - "1999-01-01 03:30:00-07:00 1999 1 1 3 30 0.0 0.0 0.0 \n", - "1999-01-01 04:30:00-07:00 1999 1 1 4 30 0.0 0.0 0.0 \n", - "... ... ... ... ... ... ... ... ... \n", - "1999-12-31 19:30:00-07:00 1999 12 31 19 30 0.0 0.0 0.0 \n", - "1999-12-31 20:30:00-07:00 1999 12 31 20 30 0.0 0.0 0.0 \n", - "1999-12-31 21:30:00-07:00 1999 12 31 21 30 0.0 0.0 0.0 \n", - "1999-12-31 22:30:00-07:00 1999 12 31 22 30 0.0 0.0 0.0 \n", - "1999-12-31 23:30:00-07:00 1999 12 31 23 30 0.0 0.0 0.0 \n", - "\n", - " temp_air dew_point wind_speed relative_humidity \n", - "1999-01-01 00:30:00-07:00 0.0 -5.0 1.8 79.39 \n", - "1999-01-01 01:30:00-07:00 0.0 -4.0 1.7 80.84 \n", - "1999-01-01 02:30:00-07:00 0.0 -4.0 1.5 82.98 \n", - "1999-01-01 03:30:00-07:00 0.0 -4.0 1.3 85.01 \n", - "1999-01-01 04:30:00-07:00 0.0 -4.0 1.3 85.81 \n", - "... ... ... ... ... \n", - "1999-12-31 19:30:00-07:00 0.0 -3.0 0.9 83.63 \n", - "1999-12-31 20:30:00-07:00 0.0 -3.0 1.2 86.82 \n", - "1999-12-31 21:30:00-07:00 0.0 -4.0 1.6 83.78 \n", - "1999-12-31 22:30:00-07:00 0.0 -4.0 1.7 81.22 \n", - "1999-12-31 23:30:00-07:00 0.0 -5.0 1.8 79.43 \n", - "\n", - "[8760 rows x 12 columns] NSRDB 145809 - - - w/m2 w/m2 w/m2 c w/m2 w/m2 w/m2 Degree c mbar % cm Degrees m/s N/A Clear Probably Clear Fog Water Super-Cooled Water Mixed Opaque Ice Cirrus Overlapping Overshooting Unknown Dust Smoke N/A Missing Image Low Irradiance Exceeds Clearsky Missing CLoud Properties Rayleigh Violation N/A 3.0.6 39.73 -105.18 1820 -7 0.33 Year Month Day Hour Minute dni dhi ghi \\\n", + " KWRFI.job MRFGY.job MRFGY.params.wind_factor CXKHX.job CXKHX.params.weather_df CXKHX.params.meta.Source CXKHX.params.meta.Location ID CXKHX.params.meta.City CXKHX.params.meta.State CXKHX.params.meta.Country CXKHX.params.meta.Clearsky DHI Units CXKHX.params.meta.Clearsky DNI Units CXKHX.params.meta.Clearsky GHI Units CXKHX.params.meta.Dew Point Units CXKHX.params.meta.DHI Units CXKHX.params.meta.DNI Units CXKHX.params.meta.GHI Units CXKHX.params.meta.Solar Zenith Angle Units CXKHX.params.meta.Temperature Units CXKHX.params.meta.Pressure Units CXKHX.params.meta.Relative Humidity Units CXKHX.params.meta.Precipitable Water Units CXKHX.params.meta.Wind Direction Units CXKHX.params.meta.Wind Speed Units CXKHX.params.meta.Cloud Type -15 CXKHX.params.meta.Cloud Type 0 CXKHX.params.meta.Cloud Type 1 CXKHX.params.meta.Cloud Type 2 CXKHX.params.meta.Cloud Type 3 CXKHX.params.meta.Cloud Type 4 CXKHX.params.meta.Cloud Type 5 CXKHX.params.meta.Cloud Type 6 CXKHX.params.meta.Cloud Type 7 CXKHX.params.meta.Cloud Type 8 CXKHX.params.meta.Cloud Type 9 CXKHX.params.meta.Cloud Type 10 CXKHX.params.meta.Cloud Type 11 CXKHX.params.meta.Cloud Type 12 CXKHX.params.meta.Fill Flag 0 CXKHX.params.meta.Fill Flag 1 CXKHX.params.meta.Fill Flag 2 CXKHX.params.meta.Fill Flag 3 CXKHX.params.meta.Fill Flag 4 CXKHX.params.meta.Fill Flag 5 CXKHX.params.meta.Surface Albedo Units CXKHX.params.meta.Version CXKHX.params.meta.latitude CXKHX.params.meta.longitude CXKHX.params.meta.altitude CXKHX.params.meta.tz\n", + "0 0.33 Year Month Day Hour Minute dni dhi ghi \\\n", "1999-01-01 00:30:00-07:00 1999 1 1 0 30 0.0 0.0 0.0 \n", "1999-01-01 01:30:00-07:00 1999 1 1 1 30 0.0 0.0 0.0 \n", "1999-01-01 02:30:00-07:00 1999 1 1 2 30 0.0 0.0 0.0 \n", @@ -708,7 +682,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -728,57 +702,13 @@ "
    \n", "

    Pipeline

    \n", "
    \n", - "
    \n", - "

    \n", - " ► \n", - " standoff, #BLHZH\n", - "

    \n", - "
    \n", - "
    \n", - "

    Job: standoff

    \n", - "

    Parameters:

    \n", - "
    \n", - " 
    {}
    \n", - "
    \n", - "
    \n", - " \n", - "
    \n", - "

    \n", - " ► \n", - " solder_fatigue, #WCBOQ\n", - "

    \n", - "
    \n", - "
    \n", - "

    Job: solder_fatigue

    \n", - "

    Parameters:

    \n", - "
    \n", - " 
    {\n",
-       "  \"wind_factor\": 0.33\n",
-       "}
    \n", - "
    \n", - "
    \n", - " \n", - "
    \n", - "

    \n", - " ► \n", - " standoff, #PUKRE\n", - "

    \n", - "
    \n", - "
    \n", - "

    Job: standoff

    \n", - "

    Parameters:

    \n", - "
    \n", - " 
    Unserializable data type
    \n", - "
    \n", - "
    \n", - " \n", - "
    \n", + "
    \n", "

    \n", - " ► \n", - " standoff, #MUDMB\n", + " ►\n", + " standoff, #KWRFI\n", "

    \n", "
    \n", - "
    \n", + "
    \n", "

    Job: standoff

    \n", "

    Parameters:

    \n", "
    \n", @@ -786,13 +716,13 @@ "
    \n", "
    \n", " \n", - "
    \n", + "
    \n", "

    \n", - " ► \n", - " solder_fatigue, #FOYEQ\n", + " ►\n", + " solder_fatigue, #MRFGY\n", "

    \n", "
    \n", - "
    \n", + "
    \n", "

    Job: solder_fatigue

    \n", "

    Parameters:

    \n", "
    \n", @@ -802,13 +732,13 @@ "
    \n", "
    \n", " \n", - "
    \n", + "
    \n", "

    \n", - " ► \n", - " standoff, #UJIKB\n", + " ►\n", + " standoff, #CXKHX\n", "

    \n", "
    \n", - "
    \n", + "
    \n", "

    Job: standoff

    \n", "

    Parameters:

    \n", "
    \n", @@ -826,7 +756,7 @@ " \n", "
    \n", "

    \n", - " ► \n", + " ►\n", " Weather Data\n", "

    \n", "
    \n", @@ -1098,25 +1028,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The array tilt angle was not provided, therefore the latitude tilt of 25.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The array tilt angle was not provided, therefore the latitude tilt of 25.8 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", - "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", - "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 25.8 was used.\n", "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", "The array tilt angle was not provided, therefore the latitude tilt of 25.8 was used.\n", @@ -1140,183 +1058,25 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "BLHZH x T98_0 T98_inf\n", + "KWRFI x T98_0 T98_inf\n", "0 1.20347 74...\n", - "WCBOQ WCBOQ\n", + "MRFGY MRFGY\n", "0 4.562892\n", - "PUKRE x T98_0 T98_inf\n", - "0 2.008636 ...\n", - "MUDMB x T98_0 T98_inf\n", - "0 1.20347 74...\n", - "FOYEQ FOYEQ\n", - "0 4.562892\n", - "UJIKB x T98_0 T98_inf\n", + "CXKHX x T98_0 T98_inf\n", "0 2.008636 ...\n", "dtype: object\n", "We can't see out data in here so we need to do another step\n", "\n", - "this is the list of all available frames in results : Index(['BLHZH', 'WCBOQ', 'PUKRE', 'MUDMB', 'FOYEQ', 'UJIKB'], dtype='object')\n", + "this is the list of all available frames in results : Index(['KWRFI', 'MRFGY', 'CXKHX'], dtype='object')\n", "\n", - "BLHZH\n" - ] - }, - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    xT98_0T98_inf
    01.2034774.0024350.322188
    \n", - "
    " - ], - "text/plain": [ - " x T98_0 T98_inf\n", - "0 1.20347 74.00243 50.322188" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WCBOQ\n" - ] - }, - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    WCBOQ
    04.562892
    \n", - "
    " - ], - "text/plain": [ - " WCBOQ\n", - "0 4.562892" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PUKRE\n" - ] - }, - { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    xT98_0T98_inf
    02.00863677.03864450.561112
    \n", - "
    " - ], - "text/plain": [ - " x T98_0 T98_inf\n", - "0 2.008636 77.038644 50.561112" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MUDMB\n" + "KWRFI\n" ] }, { @@ -1368,7 +1128,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "FOYEQ\n" + "MRFGY\n" ] }, { @@ -1392,7 +1152,7 @@ " \n", " \n", " \n", - " FOYEQ\n", + " MRFGY\n", " \n", " \n", " \n", @@ -1405,7 +1165,7 @@ "
    " ], "text/plain": [ - " FOYEQ\n", + " MRFGY\n", "0 4.562892" ] }, @@ -1416,7 +1176,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "UJIKB\n" + "CXKHX\n" ] }, { @@ -1489,7 +1249,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -1499,9 +1259,9 @@ ], "metadata": { "kernelspec": { - "display_name": "rd-tools", + "display_name": "rpp", "language": "python", - "name": "python3" + "name": "rpp" }, "language_info": { "codemirror_mode": { @@ -1513,9 +1273,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.14" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/tutorials_and_tools/tutorials_and_tools/Scenario - Temperatrure.ipynb b/tutorials_and_tools/tutorials_and_tools/Scenario - Temperatrure.ipynb index 71737e5..3816328 100644 --- a/tutorials_and_tools/tutorials_and_tools/Scenario - Temperatrure.ipynb +++ b/tutorials_and_tools/tutorials_and_tools/Scenario - Temperatrure.ipynb @@ -81,7 +81,7 @@ } ], "source": [ - "scene_temp = pvdeg.scenario.Scenario(\n", + "scene_temp = pvdeg.Scenario(\n", " name= 'temperature and degradation',\n", " api_key='DEMO_KEY',\n", " email='user@mail.com',\n", @@ -2361,9 +2361,9 @@ ], "metadata": { "kernelspec": { - "display_name": "rd-tools", + "display_name": "rpp", "language": "python", - "name": "python3" + "name": "rpp" }, "language_info": { "codemirror_mode": { @@ -2379,5 +2379,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From 085525d7d8f8bdb43cf895c89231be9bcb656a76 Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Fri, 20 Sep 2024 18:49:48 -0600 Subject: [PATCH 16/32] scenario.py methods return fig, ax --- pvdeg/scenario.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/pvdeg/scenario.py b/pvdeg/scenario.py index 57397d5..a2d2d42 100644 --- a/pvdeg/scenario.py +++ b/pvdeg/scenario.py @@ -1,5 +1,7 @@ """Class to define an analysis scenario.""" +import matplotlib.axes +import matplotlib.figure import pvdeg from pvdeg import utilities @@ -1787,13 +1789,15 @@ def plot(self): "The 'plot' method is not accessible in GeospatialScenario, only in Scenario" ) + import matplotlib + def plot_coords( self, coord_1: Optional[tuple[float]] = None, coord_2: Optional[tuple[float]] = None, coords: Optional[np.ndarray[float]] = None, size: Union[int, float] = 1, - ): + ) -> tuple[matplotlib.figure, matplotlib.axes]: """ Plot lat-long coordinate pairs on blank map. Quickly view geospatial datapoints before your analysis. @@ -1852,7 +1856,7 @@ def plot_meta_classification( coord_2: Optional[tuple[float]] = None, coords: Optional[np.ndarray[float]] = None, size: Union[int, float] = 1, - ): + ) -> tuple[matplotlib.figure, matplotlib.axes]: """ Plot classified lat-long coordinate pairs on map. Quicly view geospatial datapoints with binary classification in a meta_data @@ -1937,7 +1941,7 @@ def plot_world( self, data_variable: str, cmap: str = "viridis", - ): + ) -> tuple[matplotlib.figure, matplotlib.axes]: da = (self.results)[data_variable] fig, ax = plt.subplots( @@ -1956,6 +1960,8 @@ def plot_world( ax.add_feature(cfeature.LAKES, edgecolor="black") plt.show() + return fig, ax + # test this def plot_USA( self, @@ -1964,7 +1970,7 @@ def plot_USA( cmap: str = "viridis", vmin: Union[int, float] = 0, vmax: Optional[Union[int, float]] = None, - ): + ) -> tuple[matplotlib.figure, matplotlib.axes]: """ Plot a vizualization of the geospatial scenario result. Only works on geospatial scenarios. @@ -1998,6 +2004,8 @@ def plot_USA( fpath if fpath else [f"os.getcwd/{self.name}-{self.results[data_from_result]}"] fig.savefig() + return fig, ax + def _check_set(self, iterable, to_check: set): """Check if iterable is a subset of to_check""" From 127016b9a8f15468150095a9ad6eab46a30d3774 Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Fri, 27 Sep 2024 15:18:27 -0600 Subject: [PATCH 17/32] GeospatialScenario Display Fixes --- pvdeg/scenario.py | 75 ++++++++++++++++++++++++----------------------- 1 file changed, 38 insertions(+), 37 deletions(-) diff --git a/pvdeg/scenario.py b/pvdeg/scenario.py index a2d2d42..dbdde88 100644 --- a/pvdeg/scenario.py +++ b/pvdeg/scenario.py @@ -791,7 +791,7 @@ def plot( start_time: Optional[dt] = None, end_time: Optional[dt] = None, title: str = "", - ) -> None: + ) -> tuple: """ Plot scenario results along an axis using `Scenario.extract` @@ -843,7 +843,8 @@ def plot( Returns: ------- - None + fig, ax: tuple + matplotlib figure and axis objects See Also: --------- @@ -865,6 +866,8 @@ def plot( ax.set_title(f"{self.name} : {title}") plt.show() + return fig, ax + def _ipython_display_(self): file_url = "no file provided" if self.path: @@ -1105,7 +1108,12 @@ def __init__( self.hpc = hpc def __eq__(self, other): - raise NotImplementedError("cannot directly compare geospatial scenario objects") + raise NotImplementedError(""" + Cannot directly compare pvdeg.GeospatialScenario objects + due to larger than memory/out of memory datasets stored in + GeospatialScenario.weather_data attribute. + """) + # add restoring from gids functionality from nsrdb def addLocation( @@ -1180,7 +1188,6 @@ def addLocation( "attributes": nsrdb_attributes, } - # nsrdb_fp = r"/datasets/NSRDB" # kestrel directory geo_weather, geo_meta = pvdeg.weather.get( weather_db, geospatial=True, **weather_arg ) @@ -1222,10 +1229,8 @@ def addLocation( self._check_set(county, set(geo_meta["county"])) geo_meta = geo_meta[geo_meta["county"].isin(county)] - # ====================================================== - geo_meta, geo_gids = pvdeg.utilities.gid_downsampling( geo_meta, downsample_factor ) @@ -2065,11 +2070,11 @@ def _ipython_display_(self):

    Weather Dataset

    - {self.format_weather()} + {self.format_geo_weather()}

    Meta Dataframe

    - {self.format_meta()} + {self.format_geo_meta()}