From 733eb8c2f465e68818e5b1de0d8341d6c8c99b4e Mon Sep 17 00:00:00 2001 From: Bo Gao <83304414+gaobhub@users.noreply.github.com> Date: Mon, 20 Sep 2021 23:25:27 -0500 Subject: [PATCH 1/4] updated data_package without subcatchment 2D/3D triangulate mesh --- new_scripts/hillslopes.py | 286 +++ new_scripts/huc_process.ipynb | 4392 +++++++++++++++++++++++++++++++++ new_scripts/landcover.py | 118 + new_scripts/meshing.py | 187 ++ new_scripts/plot.py | 20 + 5 files changed, 5003 insertions(+) create mode 100644 new_scripts/hillslopes.py create mode 100644 new_scripts/huc_process.ipynb create mode 100644 new_scripts/landcover.py create mode 100644 new_scripts/meshing.py create mode 100644 new_scripts/plot.py diff --git a/new_scripts/hillslopes.py b/new_scripts/hillslopes.py new file mode 100644 index 0000000..4eb5b24 --- /dev/null +++ b/new_scripts/hillslopes.py @@ -0,0 +1,286 @@ +import os +import numpy as np + +import scipy.stats +import collections +import fiona, rasterio, shapely +import rasterio.warp + +import workflow +import workflow.crs +import workflow.warp + +import landcover +import datetime + + +def get_filenames(huc, huc_directory, raster_extension='tif'): + """Set up package directory for one huc to return a dictionary of filenames""" + ppm_dir = os.path.join(huc_directory,'data_preprocessed-meshing') + + filenames = dict() + def register_shapefile(key, filename): + filenames[key] = os.path.join(ppm_dir, filename)+'.shp' + + def register_raster(key, filename): + filenames[key] = os.path.join(ppm_dir, filename)+'.'+raster_extension + + # the HUC shapefile, in native and projected CRS + register_shapefile('huc', f'huc_{huc}') + register_shapefile('huc_proj', f'huc_{huc}_proj') + + # the HUC DEM, land_cover, slope, and aspect rasters + register_raster('dem', f'huc_{huc}_dem') # in units of [m] above sea level + #register_raster('dem_filled', f'huc_{huc}_dem_filled') + #register_raster('d8', f'huc_{huc}_d8') + #register_raster('d8i', f'huc_{huc}_d8i') + #register_raster('weights', f'huc_{huc}_flowpath_weights') + register_raster('land_cover', f'huc_{huc}_landcover') + register_raster('slope', f'huc_{huc}_slope') # in units of [-], e.g. rise over run, NOT % slope + register_raster('aspect', f'huc_{huc}_aspect') # in units of degrees clockwise from North (0 = N, 90 = E, 180 = S) + + # raster and shapefiles of the stream network + register_raster('streams_raster', f'huc_{huc}_streams') + register_shapefile('streams', f'huc_{huc}_streams') # the shapefile extracted from the above raster + register_shapefile('streams_network', f'huc_{huc}_streams_network') # simplified to a network for MOSART + register_shapefile('streams_network_proj', f'huc_{huc}_streams_network_proj') # projected form of the above + + # delineated subcatchments within the HUC + register_shapefile('subcatchments', f'huc_{huc}_subcatchments') # delineated subcatchments + + filenames['flowpaths'] = os.path.join(ppm_dir, 'flowpaths', f'hs_{{}}_flowpaths.pkl') + register_raster('flowpath_length', f'huc_{huc}_flowpath_lengths') # flowpaths within the delineated subcatchments + register_raster('elev_above_streams', f'huc_{huc}_elev_above_streams') + + filenames['daymet'] = os.path.join(huc_directory, 'daymet', f'huc_{huc}_subcatchment{{}}_1980_2020.h5') + filenames['mesh'] = os.path.join(huc_directory, 'mesh', f'sag_hillslope{{}}.exo') + + + return filenames + + +def save_shapefile(filename, shps, crs, extra_properties=None): + if len(shps) == 0: + return + + schema = dict() + if type(shps[0]) is shapely.geometry.Polygon: + schema['geometry'] = 'Polygon' + elif type(shps[0]) is shapely.geometry.LineString: + schema['geometry'] = 'LineString' + else: + raise RuntimeError('Currently this function only writes Polygon or LineString types') + + # set up the properties' schema, used for open and save geodata by fiona + schema['properties'] = collections.OrderedDict() + def register_type(key,atype): + if atype is int: + schema['properties'][key] = 'int' + elif atype is str: + schema['properties'][key] = 'str' + elif atype is float: + schema['properties'][key] = 'float' + else: + pass + if extra_properties is None: + extra_properties = dict() + for key, val in extra_properties.items(): + register_type(key, type(val)) + + try: + shp_property = shps[0].properties + except AttributeError: + pass + else: + for key, val in shp_property.items(): + register_type(key, type(val)) + + + with fiona.open(filename, 'w', + driver='ESRI Shapefile', + schema=schema, + crs=workflow.crs.to_fiona(crs), + crs_wkt=workflow.crs.to_wkt(crs)) as c: + for shp in shps: + props = extra_properties.copy() + try: + props.update(shp.properties) + except AttributeError: + pass + + for key in list(props.keys()): + if key not in schema['properties']: + props.pop(key) + + c.write({'geometry': shapely.geometry.mapping(shp), + 'properties': props}) + + +def save_demfile(filename, dem_profile, dem_raster): + rio_profile = dict(dem_profile).copy() + rio_profile.pop('blockxsize') + rio_profile.pop('blockysize') + rio_profile.pop('tiled') + rio_profile['nodata'] = -9999.0 + + rio_dem = np.where(np.isnan(dem_raster), rio_profile['nodata'], dem_raster).astype(rio_profile['dtype']) + with rasterio.open(filename, 'w', **rio_profile) as dst: + dst.write(rio_dem,1) + + +# Average aspect across the domain +def meanAspect(aspect): + ''' + # tests... + assert(meanAspect(np.array([90,90,90])) == 90) + assert(meanAspect(np.array([0,0,0])) == 0) + assert(meanAspect(np.array([180,180,180])) == 180) + assert(meanAspect(np.array([270,270,270])) == 270) + assert(meanAspect(np.array([89,90,91])) == 90) + assert(meanAspect(np.array([179,180,181])) == 180) + assert(meanAspect(np.array([269,270,271])) == 270) + assert(meanAspect(np.array([359,0,1])) == 0) + ''' + + a = aspect[~np.isnan(aspect)] + a = np.where(a > 180, a - 360, a) + sina = np.sin(np.radians(a)) + cosa = np.cos(np.radians(a)) + avg_aspect_radians = np.arctan2(sum(sina), sum(cosa)) + if avg_aspect_radians < 0: + avg_aspect_radians = 2*np.pi + avg_aspect_radians + return np.degrees(avg_aspect_radians) + + + +# Load a subcatchment shape +def loadSubcatchmentShape(filename, subcatch_id): + subcatch_crs, subcatchments = workflow.get_shapes(filename) + matches = [sc for sc in subcatchments if sc.properties['hs_id'] == subcatch_id] + if len(matches) != 1: + raise RuntimeError("Found invalid subcatchments file or no subcatchment of this id.") + return subcatch_crs, matches[0] + + +# Load a subcatchment raster +def loadSubcatchmentRaster(filename, subcatch_shape, subcatch_crs, nanit=True): + profile, raster = workflow.get_raster_on_shape(filename, subcatch_shape, subcatch_crs, mask=True) + if nanit: + raster[raster==profile['nodata']] = np.nan + return profile, raster + + +# Determine hillslope properties for a given subcatchment. +def parameterizeSubcatchment(filenames, huc, subcatch_id, + target_crs=workflow.crs.default_alaska_crs(), + hillslope_keep_fraction=0.95, + hillslope_bin_dx=100): + + # Find the given subcatchment shape + subcatch_crs, subcatch_shape = loadSubcatchmentShape(filenames['subcatchments'], subcatch_id) + + # Create a dictionary icluding all hillslope info and parameters + hillslope = dict() + hillslope['huc'] = huc + hillslope['subcatchment_id'] = subcatch_id + hillslope['subcatchment'] = subcatch_shape + hillslope['centroid'] = subcatch_shape.centroid.coords[0] # lat/long, required to get meteorological data + hillslope['total_area'] = workflow.warp.shply(subcatch_shape, subcatch_crs, target_crs).area # m^2 + + # Procedures to determine a single hillslope profile geometry for each subcatchment + # Most of the parameters are based on bins in length of flowpath to the stream network + + # 1. Load raster of flowpath lengths for the given subcatchment + fp_profile, fp_lengths = loadSubcatchmentRaster(filenames['flowpath_length'], subcatch_shape, subcatch_crs) + subcatch_mask = ~np.isnan(fp_lengths) + hillslope['raster_profile'] = fp_profile + + # 2. Ensure raster of flowpath lengths >= 0, and sort flowpath lengths + assert(fp_lengths[subcatch_mask].min() >= -1.e-3) + fp_lengths[fp_lengths < 0] = 0. + fp_lengths_masked = fp_lengths[subcatch_mask] + fp_lengths_masked_sorted = np.sort(fp_lengths_masked) + + # 3. Set bin parameters based on flowpath length + hillslope['total_length'] = fp_lengths_masked_sorted[-1] * hillslope_keep_fraction + hillslope['num_bins'] = int(np.round(hillslope['total_length'] / hillslope_bin_dx)) + hillslope['bin_dx'] = hillslope['total_length'] / hillslope['num_bins'] + assert(hillslope['num_bins'] > 3) + + # 4. Bin by flowpath length and save to dictionary + pixel_bin_raster = np.nan * np.ones(fp_lengths.shape, 'd') + pixel_bin_counts = np.zeros((hillslope['num_bins'],),'i') + + i = 0 + interval = 1 + while i < hillslope['num_bins']: + bin_start = i * hillslope['bin_dx'] + bin_end = (i+interval) * hillslope['bin_dx'] + local_mask = (fp_lengths >= bin_start) & (fp_lengths < bin_end) + pixel_bin_raster[local_mask] = i + pixel_bin_counts[i] = np.count_nonzero(local_mask) + + if pixel_bin_counts[i] > 0: + i += 1 + if i-1+interval>hillslope['num_bins']: + break + else: + interval += 1 + continue + + hillslope['bin_counts'] = pixel_bin_counts[np.nonzero(pixel_bin_counts)] + hillslope['num_bins'] = len(hillslope['bin_counts']) + hillslope['bins'] = pixel_bin_raster + +# assert(hillslope['bin_counts'].min() > 0) +# hillslope['bin_counts'] = pixel_bin_counts # THE OLD + + + + # 5. Average elevation (height over stream) for each bin and save to dictionary + _, elevs = loadSubcatchmentRaster(filenames['elev_above_streams'], subcatch_shape, subcatch_crs) + elev_bins = np.zeros((hillslope['num_bins'],),'d') + for i in range(hillslope['num_bins']): + elev_bins[i] = elevs[(hillslope['bins'] == i) & (~np.isnan(elevs))].mean() + + hillslope['elevation'] = elev_bins + + # 6. Average aspect across the entire subcatchment and save to dictionary + _, aspects = loadSubcatchmentRaster(filenames['aspect'], subcatch_shape, subcatch_crs) + hillslope['aspect'] = meanAspect(aspects) + + # 7. Get land cover using mode for each bin and save to dictionary + lc_profile, lc = loadSubcatchmentRaster(filenames['land_cover'], subcatch_shape, subcatch_crs, False) # don't nan-it + assert(lc_profile['nodata'] == 255) # uint8, nan is -1 == 255 + # classify land cover into veg classes + hillslope['lc'] = lc + num_missing, lc = landcover.classifyVegetation(lc) + lc_bins = np.zeros((hillslope['num_bins'],),'i') + + for i in range(hillslope['num_bins']): + bin_lc = lc[hillslope['bins'] == i] + assert(len(bin_lc) > 0) + lc_bins[i] = scipy.stats.mode(bin_lc.ravel())[0][0] + + hillslope['land_cover'] = lc_bins + hillslope['land_cover_raster'] = landcover.veg2img(lc) + + return hillslope + + + + +# Download DayMet +def downloadDaymet(hillslope_pars, raw_directory, save_filename, + start=datetime.date(1980,1,1), + end=datetime.date(2020,12,31)): + import daymet_to_ats + start, end = daymet_to_ats.validate_start_end(start, end) + lon, lat = hillslope_pars['centroid'] + daymet = daymet_to_ats.download_daymet(raw_directory, lat, lon, start, end) + ats = daymet_to_ats.daymet_to_ats(daymet) + attrs = daymet_to_ats.daymet_attrs(lat, lon, start, end) + + daymet_to_ats.write_ats(ats, attrs,save_filename) + + \ No newline at end of file diff --git a/new_scripts/huc_process.ipynb b/new_scripts/huc_process.ipynb new file mode 100644 index 0000000..753065d --- /dev/null +++ b/new_scripts/huc_process.ipynb @@ -0,0 +1,4392 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a45b921c", + "metadata": {}, + "source": [ + "**InteRFACE Data Package Workflow**" + ] + }, + { + "cell_type": "markdown", + "id": "d8af26e3", + "metadata": {}, + "source": [ + "**Objective:** \n", + "* Download all needed data inputs for a ATS + MOSART run on a Sag River HUC.\n", + "* Process raw huc data and generate mesh.\n", + "* Generate a data package in a purely automated way." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "b92fa29a", + "metadata": {}, + "outputs": [], + "source": [ + "import sys,os\n", + "import numpy as np\n", + "import datetime\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.gridspec as gridspec\n", + "import scipy.optimize, scipy.signal, scipy.stats\n", + "import collections\n", + "import logging\n", + "import fiona, rasterio, shapely\n", + "import rasterio.warp\n", + "\n", + "import workflow\n", + "import workflow.crs\n", + "import workflow.warp\n", + "import workflow.source_list\n", + "import workflow.utils\n", + "import workflow.ui\n", + "import workflow.conf\n", + "import workflow.mesh\n", + "\n", + "import hillslopes\n", + "import landcover\n", + "import meshing\n", + "import plot" + ] + }, + { + "cell_type": "markdown", + "id": "3ea2203a", + "metadata": {}, + "source": [ + "# Processing preparation" + ] + }, + { + "cell_type": "markdown", + "id": "ea31aacc", + "metadata": {}, + "source": [ + "## Input for this worksheet" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b9c888d5", + "metadata": {}, + "outputs": [], + "source": [ + "# the HUC to delineate\n", + "huc = '190604020404'\n", + "\n", + "# contributing area, in pixels? [m^2]? used to provide a lower bound on pixels\n", + "# that are included in the stream network \n", + "streams_contributing_area_cutoff = -1 \n", + "\n", + "# target, in pixels, of the subcatchment size\n", + "target_subcatchment_size = 20000\n", + "\n", + "# number of horizontal grid cells in the hillslope\n", + "hillslope_bin_dx = 100\n", + "mesh_dx = 20\n", + "riparian_slope_min = 0.01\n", + "hillslope_slope_min = 0.1\n", + "\n", + "#Don't let individual areas get too small in width -- 10% mean as a min value?\n", + "min_area_ratio = 0.1\n", + "\n", + "# what fraction of the total flowpath lengths do we want to include?\n", + "#\n", + "# Effectively, some small number of pixels are often a long way away from the stream\n", + "# (whether this is real or artifact). We don't need tiny cells up at the top of the\n", + "# hillslope. Maybe keep 95% of the flowpath length?\n", + "hillslope_keep_fraction = 0.95\n", + "\n", + "# demo subcatchment\n", + "subcatch_demo_id = 8\n", + "\n", + "# The top level directory where these packages will go, one subdirectory for each HUC/data package\n", + "package_directory = '../huc'" + ] + }, + { + "cell_type": "markdown", + "id": "d26910d1", + "metadata": {}, + "source": [ + "## Set up directory" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e45012d2", + "metadata": {}, + "outputs": [], + "source": [ + "# directory for one huc\n", + "huc_dir = os.path.join(package_directory,f'{huc}')\n", + "if not os.path.isdir(huc_dir):\n", + " os.mkdir(huc_dir)\n", + "\n", + "# directory of raw hillslope data for this huc, downloaded from USGS\n", + "hillslope_raw_dir = os.path.join(huc_dir, 'data_raw-hillslope')\n", + "if not os.path.isdir(hillslope_raw_dir):\n", + " os.mkdir(hillslope_raw_dir)\n", + " \n", + "# directory of preprocessed hillslope data for meshing in this huc\n", + "pp_hillslope_dir = os.path.join(huc_dir, 'data_preprocessed-meshing')\n", + "if not os.path.isdir(pp_hillslope_dir):\n", + " os.mkdir(pp_hillslope_dir)\n", + " \n", + "# directory of generated meshes\n", + "mesh_dir = os.path.join(huc_dir, 'mesh')\n", + "if not os.path.isdir(mesh_dir):\n", + " os.mkdir(mesh_dir)\n", + " \n", + "# directory of raw daymet data for this huc\n", + "daymet_raw_dir = os.path.join(huc_dir, 'data_raw-daymet')\n", + "if not os.path.isdir(daymet_raw_dir):\n", + " os.mkdir(daymet_raw_dir) \n", + "\n", + "# directory of processed daymet data for this huc\n", + "daymet_dir = os.path.join(huc_dir, 'daymet')\n", + "if not os.path.isdir(daymet_dir):\n", + " os.mkdir(daymet_dir)" + ] + }, + { + "cell_type": "markdown", + "id": "1ab2fb57", + "metadata": {}, + "source": [ + "## Set up data source and watershed_workflow" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "62862906", + "metadata": {}, + "outputs": [], + "source": [ + "target_crs = workflow.crs.default_alaska_crs()\n", + "raster_extension = 'tif'\n", + "\n", + "# data sources\n", + "data_sources = dict()\n", + "data_sources['huc'] = workflow.source_list.huc_sources['WBD'] \n", + "data_sources['dem'] = workflow.source_list.dem_sources['NED 1 arc-second']\n", + "\n", + "# set up watershed_workflow\n", + "workflow.ui.setup_logging(1)\n", + "workflow.conf.rcParams['DEFAULT']['data_directory'] = hillslope_raw_dir" + ] + }, + { + "cell_type": "markdown", + "id": "78e88b15", + "metadata": {}, + "source": [ + "## Set up filenames needed in data package" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9408461c", + "metadata": {}, + "outputs": [], + "source": [ + "filenames = hillslopes.get_filenames(huc, huc_dir)\n", + "# print(filenames)" + ] + }, + { + "cell_type": "markdown", + "id": "30bcee47", + "metadata": {}, + "source": [ + "# Acquire HUC shapefile and DEM from USGS" + ] + }, + { + "cell_type": "markdown", + "id": "7e427d29", + "metadata": {}, + "source": [ + "## Download and conversion" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0883d586", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:32,567 - root - INFO: \n", + "2021-09-20 23:15:32,569 - root - INFO: Loading HUC 190604020404\n", + "2021-09-20 23:15:32,570 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:32,571 - root - INFO: \n", + "2021-09-20 23:15:32,572 - root - INFO: Loading level 12 HUCs in 190604020404\n", + "2021-09-20 23:15:32,573 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:32,575 - root - INFO: Using HUC file \"../huc/190604020404/data_raw-hillslope/hydrography/WBD_19_GDB/WBD_19.gdb\"\n", + "2021-09-20 23:15:34,798 - root - INFO: ... found 1 HUCs\n", + "2021-09-20 23:15:34,798 - root - INFO: -- 190604020404\n", + "2021-09-20 23:15:34,813 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:34,817 - root - INFO: ... found 1\n", + "2021-09-20 23:15:34,818 - root - INFO: \n", + "2021-09-20 23:15:34,818 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:34,818 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:34,819 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:34,850 - root - INFO: Collecting DEMs to tile bounds: [-149.3337383807433, 68.15835009523077, -148.79217986384458, 68.33619896061079]\n", + "2021-09-20 23:15:34,851 - root - INFO: Need:\n", + "2021-09-20 23:15:34,851 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w150.tif\n", + "2021-09-20 23:15:34,852 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w149.tif\n", + "2021-09-20 23:15:34,852 - root - INFO: source files already exist!\n", + "2021-09-20 23:15:34,941 - root - INFO: ... got raster of shape: (641, 1950)\n", + "2021-09-20 23:15:34,950 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:34,982 - root - INFO: shape bounds: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n", + "2021-09-20 23:15:34,987 - root - INFO: casting mask of dtype: float32 to: nan\n", + "2021-09-20 23:15:34,989 - root - INFO: ... got raster bounds: (-149.3337383807433, 68.33619896061079, -148.79207171405866, 68.15814340504932)\n" + ] + } + ], + "source": [ + "# download (if necessary) the HUC shapefile\n", + "huc_crs, huc_shape = workflow.get_huc(data_sources['huc'], huc)\n", + "\n", + "# download (if necessary) the DEM\n", + "dem_profile, dem_raster = workflow.get_raster_on_shape(data_sources['dem'], \n", + " huc_shape, huc_crs, \n", + " mask=True, nodata=np.nan)\n", + "# convert rasterio crs to workfkow standard crs\n", + "native_crs = workflow.crs.from_rasterio(dem_profile['crs'])\n", + "\n", + "# project the shapefile into the native CRS\n", + "huc_shape = workflow.warp.shply(huc_shape, huc_crs, native_crs)" + ] + }, + { + "cell_type": "markdown", + "id": "26f51878", + "metadata": {}, + "source": [ + "## Validate: plot DEM and HUC shape" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "98defa77", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:15:35,185 - root - INFO: BOUNDS: (-149.3337383807433, 68.15814340504932, -148.79207171405866, 68.33619896061079)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig_property = dict()\n", + "fig_property['figsize'] = (12,4)\n", + "fig_property['dpi'] = 80\n", + "fig, ax = workflow.plot.get_ax(native_crs, **fig_property)\n", + "workflow.plot.dem(dem_profile, dem_raster, ax=ax)\n", + "workflow.plot.shply([huc_shape,], native_crs, ax=ax)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a95bc135", + "metadata": {}, + "source": [ + "## Save DEM and HUC shape files do disk" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8474823f", + "metadata": {}, + "outputs": [], + "source": [ + "if not os.path.isfile(filenames['huc']):\n", + " hillslopes.save_shapefile(filenames['huc'], [huc_shape,], native_crs) \n", + "\n", + "if not os.path.isfile(filenames['dem']):\n", + " hillslopes.save_demfile(filenames['dem'], dem_profile, dem_raster)" + ] + }, + { + "cell_type": "markdown", + "id": "49f89c9c", + "metadata": {}, + "source": [ + "# Delineate subcatchments and flowpaths" + ] + }, + { + "cell_type": "markdown", + "id": "4267d9da", + "metadata": {}, + "source": [ + "## Subcatchments and flowpaths source" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "54da22c4", + "metadata": {}, + "outputs": [], + "source": [ + "# NOTE: this needs to be added by Jon!\n", + "#\n", + "# At this point, we need:\n", + "assert(os.path.isfile(filenames['subcatchments'])) # subcatchment shapefile\n", + "assert(os.path.isfile(filenames['streams_raster'])) # streams raster\n", + "assert(os.path.isfile(filenames['aspect'])) # aspect raster\n", + "assert(os.path.isfile(filenames['slope'])) # slope raster\n", + "assert(os.path.isfile(filenames['flowpath_length'])) # raster of each pixel's distance to the stream\n", + "assert(os.path.isfile(filenames['elev_above_streams'])) # raster of HAND" + ] + }, + { + "cell_type": "markdown", + "id": "89ad20b5", + "metadata": {}, + "source": [ + "## Load the shapefiles of subcatchments and flowpaths from source" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0c41298b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:41,924 - root - INFO: \n", + "2021-09-20 23:15:41,926 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:41,927 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:41,928 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:41,983 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:41,984 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:42,009 - root - INFO: Converting to requested CRS\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numbers of subcatchments in basin-190604020404: 44\n" + ] + } + ], + "source": [ + "_, subcatchments = workflow.get_shapes(filenames['subcatchments'], out_crs=native_crs)\n", + "print(f'Numbers of subcatchments in basin-{huc}: ', len(subcatchments))" + ] + }, + { + "cell_type": "markdown", + "id": "78b1a50e", + "metadata": {}, + "source": [ + "## Validate: plot subcatchments and flowpaths" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e5a14591", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:43,741 - root - INFO: BOUNDS: (-149.3337383807433, 68.15814340504932, -148.79207171405866, 68.33619896061079)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig_property = dict()\n", + "fig_property['figsize'] = (12,4)\n", + "fig_property['dpi'] = 80\n", + "fig, ax = workflow.plot.get_ax(native_crs, **fig_property)\n", + "workflow.plot.dem(dem_profile, dem_raster, ax=ax)\n", + "workflow.plot.shply(workflow.utils.flatten(subcatchments),\n", + " native_crs, ax=ax, color='r')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c62d4e99", + "metadata": {}, + "source": [ + "# Land cover" + ] + }, + { + "cell_type": "markdown", + "id": "d3bdb7f1", + "metadata": {}, + "source": [ + "## Project NNSI land cover and save to disk" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cf5331c8", + "metadata": {}, + "outputs": [], + "source": [ + "# if not os.path.isfile(filenames['land_cover']):\n", + "# landcover.reprojectLandCover(dem_profile, nssiImg_filename, filenames['land_cover'])\n", + "# Comment because no NSSI land cover map data" + ] + }, + { + "cell_type": "markdown", + "id": "c2c6a9c8", + "metadata": {}, + "source": [ + "## Validate: plot land cover " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "09835626", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:45,720 - root - INFO: \n", + "2021-09-20 23:15:45,722 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:45,723 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:45,724 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:45,725 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:45,779 - root - INFO: ... got raster of shape: (570, 1879)\n", + "2021-09-20 23:15:45,788 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:45,821 - root - INFO: shape bounds: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n", + "2021-09-20 23:15:45,825 - root - INFO: casting mask of dtype: float32 to: nan\n", + "2021-09-20 23:15:45,826 - root - INFO: ... got raster bounds: (-149.32401615852078, 68.32647673838824, -148.802071714059, 68.16814340504965)\n", + "2021-09-20 23:15:45,943 - root - INFO: BOUNDS: (-149.32401615852078, 68.16814340504965, -148.802071714059, 68.32647673838824)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lc_profile, lc_raster = workflow.get_raster_on_shape(filenames['land_cover'],\n", + " huc_shape, huc_crs, \n", + " mask=True, nodata=np.nan)\n", + "fig_property = dict()\n", + "fig_property['figsize'] = (12,4)\n", + "fig_property['dpi'] = 80\n", + "\n", + "fig, ax = workflow.plot.get_ax(native_crs, **fig_property)\n", + "land_cover = workflow.plot.raster(lc_profile, lc_raster, ax=ax)\n", + "workflow.plot.shply([huc_shape,], native_crs, ax=ax)\n", + "# fig.colorbar(land_cover)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2f8cef6b", + "metadata": {}, + "source": [ + "# Determine hillslopes geometry based on flowpaths" + ] + }, + { + "cell_type": "markdown", + "id": "4e2163b7", + "metadata": {}, + "source": [ + "**Objective:** \n", + "* Determine a single hillslope profile geometry for each subcatchment (44 in total).\n", + "\n", + "**Objects to obtain:** \n", + "* hillslope length\n", + "* an elevation profile along that length\n", + "* a width along that length\n", + "\n", + "**Main idea:**\n", + "* Regard each subcatchment as a single flowpath, with average properties.\n", + "\n", + "**Method:** \n", + "* Route the surface flow and generate a standard D8[1] flowpath direction vector for each pixel of the (smoothed and filled) DEM.\n", + "* Form rasters comprising of \"length along the flowpath to the stream network\" and the corresponding \"height above the stream network.\"\n", + "* Bin the rasters according to the flowpath length.\n", + "* Average pixels in each bin to determine:\n", + " - hillslope length = 90th % of the maximum flowpath length\n", + " - bins as a function of flowpath length\n", + " - elevation as a function of bin\n", + " - number of pixels in each bin gives an area\n", + "\n", + "\n", + "\n", + "**Notes** \n", + "[1] There are eight valid output directions relating to the eight adjacent cells into which flow could travel. This approach is commonly referred to as an [eight-direction (D8) flow model](https://pro.arcgis.com/en/pro-app/latest/tool-reference/raster-analysis/flow-direction.htm). This method models flow direction from each cell to its steepest downslope neighbor. The output is an integer raster whose values range from 1 to 255. The number denotes the flowpath." + ] + }, + { + "cell_type": "markdown", + "id": "25d16b4d", + "metadata": {}, + "source": [ + "## Validate: get hillslope parameters for one subcatchment " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cbceae4f", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:48,690 - root - INFO: \n", + "2021-09-20 23:15:48,691 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:48,692 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:48,693 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:48,700 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:48,701 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:48,757 - root - INFO: \n", + "2021-09-20 23:15:48,758 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:48,758 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:48,758 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:48,759 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:48,803 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-20 23:15:48,812 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:48,844 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:15:48,845 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:48,846 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-20 23:15:48,849 - root - INFO: \n", + "2021-09-20 23:15:48,849 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:48,850 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:48,850 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:48,851 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:48,894 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-20 23:15:48,904 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:48,933 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:15:48,935 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:48,936 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-20 23:15:48,939 - root - INFO: \n", + "2021-09-20 23:15:48,939 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:48,940 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:48,940 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:48,941 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:48,982 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-20 23:15:48,990 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:49,021 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:15:49,022 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:49,023 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-20 23:15:49,025 - root - INFO: \n", + "2021-09-20 23:15:49,025 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:49,025 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:49,026 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:49,026 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:49,066 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-20 23:15:49,075 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:49,105 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:15:49,107 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:49,108 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n" + ] + } + ], + "source": [ + "hillslope_demo_pars = hillslopes.parameterizeSubcatchment(\n", + " filenames, huc, subcatch_demo_id,\n", + " target_crs=workflow.crs.default_alaska_crs(),\n", + " hillslope_keep_fraction=hillslope_keep_fraction,\n", + " hillslope_bin_dx=hillslope_bin_dx)\n", + "\n", + "mesh_demo_pars = mesh.parameterizeMesh(hillslope_demo_pars, mesh_dx,\n", + " riparian_slope_min=riparian_slope_min,\n", + " hillslope_slope_min=hillslope_slope_min,\n", + " min_area_ratio=min_area_ratio)\n", + "# # print(hillslope.keys())" + ] + }, + { + "cell_type": "markdown", + "id": "187c4e5d", + "metadata": {}, + "source": [ + "## Validate: plot the hillslope" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8d9e358a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:15:51,688 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:15:51,793 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbYAAAHoCAYAAAAljcr3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABs0klEQVR4nO3dd3yV5fn48c+VkASyGFmskDDCRraCu2IFrdZNtS7Ur9hqq9Rqkbbu1lFHsb9WW1qtigv3qIPhQBQUiAyRDSasDMLIYARI7t8fz3OSk5OzM87I9X698so5z7yTnJzrXPcUYwxKKaVUtIgJdQGUUkqp5qSBTSmlVFTRwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkUVDWwq4ohIgYicGeIyGBHpF8oyKKXc08CmFCAip4vIjlCXI1Ai8pyI/MnHMSNEZJGIlIvIDhG5u7XKp1QoaGBTKvq9DHwBdAFOA34pIj8NbZGUajka2FTIiMh0EdkpIpUiskFEJtjbG2QhHrKpsSKyVkT2ich/RaS90/Hni8hKEakQkS0iMsnefq2IrLPvt1VEbrS3JwEfAd1FpMr+6i4isSLye/salSKSLyLZTmU4U0Q22WX4h4iIfb0pIvKViPxVRPbb9zrR3r5dREpF5Bqn8iaIyGMisk1ESkTknyLSwflnF5Hf2ucVici19r6pwBXA7+wyv+/hV50LvGSMqTHGbAG+BIYE/AdTKkJoYFMhISIDgF8BY40xKcBEoCCAS1xhn9MX6A/80b7u8cALwB1AJ+BUp+uWAucCqcC1wF9FZJQx5gBwNrDLGJNsf+0CbgMuB86xz7kOOOhUhnOBscBwYLJdHocTgNVAGlbG9Kp9bD/gSuDvIpJsH/uI/TOMsPf3AJyrC7sCHe3t1wP/EJHOxphZwEvAX+wyn+fhdzUTuFpE4uzf+3hggYdjlYp4GthUqNQACcBgEYkzxhTY2YS//m6M2W6M2Qv8GSsAgfXG/6wxZr4xptYYs9MYsx7AGPOBMWaLsSwE5gGneLnH/wF/NMZssM9ZZYzZ47T/YWPMfmPMNuAzrMDk8IMx5r/GmBpgDpAN3G+MqTbGzAOOAP3sLO8G4DfGmL3GmErgQeAyp2sdtc89aoz5EKgCBgTwu/ofcAlwCFgPPGOMWRbA+UpFFA1sKiSMMZuBacC9QKmIvCoi3QO4xHanx4WA49xswG2AFJGzReRrEdkrIvuxMrF0L/fweC1bsdPjg0Cy0/MSp8eHAIwxrtuSgQwgEci3qy33Ax/b2x32GGOOebmXRyLSxb7e/UB7rJ9poojc5M/5SkUiDWwqZIwxLxtjTgZyAINVJQdwAOvN3qGrm9Od27p6Abvsx9uxqicbEJEE4E3gMSDLGNMJ+BAQR3Hc3MPttZpZGVaQG2KM6WR/dTTG+BW4cF9uZ32AGmPMC8aYY8aYHVjVouc0ocxKhTUNbCokRGSAiJxhB5zDWG/uNfbulcA5ItJFRLpiZXaubhaRnnZG8nus6j6AZ4BrRWSCiMSISA8RGQjEY1V97gaOicjZwFlO1ysB0kSko9O2/wAPiEieWI4TkbTm+PkdjDG1wL+x2vsyAewyT/R+ZoNy9/Gyf6N1Sfm5/fvoCvwMWNWUcisVzjSwqVBJAB7GyliKgUysAAUwG+uNtwCrHWyOm/Nftvdttb/+BGCMWYrdMQQoBxYCOXbb1S3Aa8A+4OfAe46L2e1wrwBb7SrB7sAT9vHzgAqsoNmhOX54F9OBzcDXIlKB1bHD3za0Z7DaKfeLyDuuO40xFcBFwG+wfu6VwBqsdkmlopLoQqNKKaWiiWZsSimloooGNqWUUlFFA5tSSqmoooFNKaVUVNHAppRSKqq0C3UBfJk0aZIpKysLdTGUUipk8vPz6x7Hx8czbNgwX8fPNcZMaulyhauwD2xlZWWUlZVRWFgY6qL4lJOTQ0FBQaiLoZSKULm5uW7f63Jyciiwt+d269Yg0Hngbaq4qBf2gQ2gsLCQpoy3u9SI74P89PoDwAo3O9422KuWKKVUUOre61zfS5yCXYG3D/n2+2Rbfy+KiMAWLq4RaH+PofrupxrtM1ifqoJ5QWmmp8KZuyxCX7PB85SVgfV7bY7rt3VhP/PImDFjTH5+vs+MrTmzMoDXDwOJrteciJz3Jxj5TcDXW3nfzQwfA1PyDa6rQe5FmpSRKtWSRIQT90JVF8PqtFr+XhbLrwR9zQZJxP5/f1fgAuAdeP98OK8P8EMAF/Lw+7c/XOcbY8Y0tayRKiICm6ONzflTYnMHMlevXwRy3D+a7Xrmg5tJy3f/u95PLrW0bBuifsJWgarLLDp1hul3Ntz5yMOwf19oChYirv9D3jIvr9chsBV1PQUwb+1xhYWFbTqwRURVpOPFFGy98XECV8ijrGC83+cM4CQ4rnGVo7/O+N3NfJIMMBSAmRSyNxHMLrHmVndn7mRmcydXMQoyYXbpt3W7rto/CjoNrXs+he8aZX7u7B1fgPl1b+Tn4d/5RoWXwsJCeOgRzJrpMGO63+cVcxf9ub/R9o3cTVcecHvOgxTzMFlu911mhFmnumy8FuSOGph5A2b5s/Btw93LFr3ACsb6XWZXT24bxPcHGm6TQQ3/hwoLCzHrgEFB36ZJvPU9aOttbBGRsS1fvhyo/4Tib+Z2nL3rWqCfuG8bayo57jO321dc/AY3iGmwSuXeRDCnCGvmPs0KTmAlgxnB2rrv7jj2XfXyKNJ+7v1vtTcRGF7QcOO1MzFTi8hgEWUUeT3fU1YX7CfTQO+jQsv175zTA9p9Dv8vby4/a7DCT8urTKute3ygLJYXZV2D/VP5MXL7g9zw6NWMcdnny0oGsAZhKIYRbOBFBtbtc2w72wwi2+WtJRca1KsEnHm54+f7b6DtnCKiGVukCCRzez0GBthrMP4ZqD7PZ/fYgNXedzNPivs3/M94vNHSy10OgvR7k1EvXEx+1mTAqt7xFNR87XN15QFhdoPlxIAlMJvPeII73Z/k5OrCUW63FxYWYoAi7qbboPth3Yl+l8nZSXsX81Vn7T0arhwZwGVircA6bidckzePO1s7qE1Yj1k2CCp6AnBErm90zCzmYx77MUceu57nArx+VxPDUw+A3G3oxkB2vSPwvLXvkjeBGPeBsiDA+zSnpvYMb2siKrA5OHofWp9YrD/2pUb4q9P75Zt8ycYmZGhy3GfccvEb3o+5AR6gV0DX7fKPi/j22x+wluCyuMvYVjKYmSTUPb9qWuNr7U0Ern0Lhn8BwOxyK4i54y07rL+X+16dOSQAo+nGAr+CWhFn8l9uZhWZDbbP7yxwqpCT0LSqEs34mj+LBhBySHX6s3wIfOgS1CrTamHmDf5d8Lk7SPlkYKPNlbfPhuGfezztxJ88y7IuvqsSZzHf47577SzsAvvD7dPU/2BmPXA3JC44kaIX77U6cNjeOAzCQOuYpmpCNuaqOXpLtiURGdgcb2q5ubn1AW4dyICD9Qed53+m407tuDc4Xry/MI9v0h3qucvKviOBmp+LtZwmEFtq6OR60PACzD8uZg1PAzB76reuRzS6h8d7PSpwh7szA8/OpnEfc56Rxms02+0kBU35xX1h6v7u7kRC0GuOoJSTk0OZgSwx1PQvtzaO+K7+gJGLYUXjv50ZewqpdwT/yf/ETbF81uV6VnGaz2OHmEF0dfkfqrx9Nuax37OMB72ceXqT2sdWMsDKwlbDqXcbFk2Zh3nOaUFyu03swJlLAJeFyhPBIM3WbuZv0NJsrHlFZGBzaFA12cFgtoHc43+Wdut9N3MtcN73KexYP5EVF7/BcY6dY2hUlRiMvTe/xZV/v7jBtuHAGnma2Yxk/kN/cXtev0tGQR44Aktt//2wsRN7Z03jyhuerLsOMpkVnBBwuaYwklr73q73CsZxfMV3jnaRmdczZxnuB7IHY1E2N1HIU+TAqcLrhbP5LVfyshF6unyydm3gD0d11Uo3CMf/x7DsprcYdffFPNH1LU5rd5F10LEhdP7K0Kdv4w8ig7Ng9qpCmIQV1JwDmpNX55zCSNeNQSbKlWm1nLgplq9qYBa3+3XO2GlWxw9nU4BljwXXseNGBsLMu70e023a/VyAsbrPnwX5J57IfROWEHB9pTcBBCGtQgyNiOo84oljQGJBQUFAgc18cDPH5xtuMsLd36dw29A1AVct+jLDCFniPpO6un9vzMbO+BNQpP8HdNnYiT0rhNkjG17Pn84nrhLMKCZL8IHM1RKzmPGuPdeayamLDF+sE2SwwZwsDH0J1hxwf2zupJwWn37Nn6zQ1yDcgoICVtpRprdM44zimX7ff3AWlIph3uQvG++0M7W4q//Eu+fe1mydPipvn031Ywt5zs+g1hLcdehwlbRgPH8981nAqo7c1VsCGxvmh9wc/19joapB0M4jUaCgoKCuasrcdxPgPnPLnnwn2z6vrHu+P/83bAGmxMGUKZUc38SgNsMI17psS5sEs5t0VcuGDZ05Ik8ze+S3jYKVrw4m928axSX9Gm576LHgyvER93DO7cUwfGGD7eabxYFdaBGIj6peh6RPrGEaF9cIEmt4L1vAkam9Bnfds5/VWJ1mCu9+mhX2ayAQI3YBPYZQzo8B6Ph/M1n5b/fHjvTQYciZ45P66BLrdRnb1TCf39g7oVx+Q2+mAdCXv5LDzIDKO3eiwGuXIpNvabjDrn48+t0ZnP3xRCpug+Frjdf39sq0Wr4qi2WEl2MSv7EyreZyLwM5sVZ487q5/Os59/93jmMcprofKdDAgROXcEmtVY/4LyHoDLUBlw//haITKoS7qMjYwP1QANfg9t/7buYply74zWVvIphkaTD2zJdAMjaHc6sXMyDhMOBfj8m7GEnBIAm6J6Orn/EVc26RJlczLls0m7EHr6LJ49IHwX8NjavcAjTiH9B55OC6qr9Pu07jBzPT7bHn5EKRj3LH94Shvl+2TTIvC9IH7PdYFQlwzuxTSEkwfOjlOpW3z2bpYzSpXStQN07ZhnluIu8bKPLQXd9xTKvw8j7YaBhEBLTjasYWJZo6iNubvYlQdkBIe8XLQauBhyc3+70djuMrxhnhgzueJ4kE3v5gIs/85OEWux+ApC3ihrLYBtumIXWdQPx106Jann6yYdvIkJeuYk2ImsNGxMG1xxq+kb0P9Cmuf+10Gj+NKfJXt+d7e6t9H8gpbvwazL8GmHspn5jXWQHcLpfW73zldUb/yHo4OAtmC4C9f+LrjH6+8XUAXmQGTPYc1ELlRgayzaltrdeIYn65KpOuJqauRsO8CzwH510E2437nhqOY0JN28kiT9QENgfnoQDyeMNPoMF8qncMek7LajgTiLd2Lef9nrrXWwVaBhs937uIM+sef3f7C6w+FWZxDdxyDZwFZzGXYVR7vn4QnO954qbYxjM++Gtl/cOnp8zDnPWnhvs9tJH5zc/u2MPdbFt47C1WuwQf187Uo97OZXUQxXK+zmCniTRenPstV/Xvg6l4nQmA9P93XaZlLn8diuuPnUh9+9ns12YwOMsaX7i2BL6f+xRDJw+z29IOWN+hvgfkyIZVwsPiG4+/ch78DNhd70/3+2dcyYC6xyPY0GgbM+9u0BaWuOBC1py5mKceAFz7fryNz3Yzr9wFHG8fbgOcngq0q30kirrA5py57bvkogb7VvF2wNWQZQeENKGuS72Dr2pAX93r520VHv8jeKqGLOJM3jb3M8V+br4BHHMvr4Cn2sH8CeuYv70bL7gEx/c2tWfTO9bjx8FDN/7GHuRtfmSy6oLBV8/6d56rI4uu5+e1z9TN/LKdSX4HIr+tBvn3IbLXZPIelW4PGQ5cJ4bnEl12zJqG+6HozSe/GH7b9RBraA/AVXbvxYkd7TdWdx0/sILXPCOkzQB5az9X9YezxDB3ojTI3OoCmbsu/e2mU3zHXdbuGXP5yGnfQ0a42WUMP1fBLD9fJDcO74y5L8aqoTgO5J25/PK5HzPDxJBtt4E91bD5lQP/WAL3S+OgFkY0K4suUdPG5kpE6ELwP5tj8LNJuZjZD/vfbuawksG86TTAuj9wld0wNZuRzKsbN+Y+sH3EPZxmJpL4LJ6rYx6FGSfAw5ctIu7qB8jpPw+ATT+F49Z5/9kfYR5nc1+DbU1qP1sEkA1gdc1fFxP4NdZjvWGu9OPYt2FCFTyeZHf82OTmmDUga99k1N0Xu9nZsvI/A3l7kcfxZM7Maz/hE1PRYNuEVSCT99dndfYxfxHDlk3eU5zNeZDq4bX/sRHGiDUOzVOb2koG8I6HXhflC060x39ZLqmFN2MM5kKBt70WK3jN3P7VFpbh0TY25dajB4TbZXKjTM1fT/Q/hIltX/c87z0gzwqQw6gm9w5D4UN/wcyYjrvgdjb38ZHM5Zy0MzFXxLoPNnfAQ2/BQ1mnIJv/SFF7681x6NyvGdjT+5vf2XuAjObr7i9P/pHtt1jVjU8digm6U4j8+xBnrO/g87ihSXAlMGIhyGtvwogvGh8UT0iCWgM+ghqA9N9GrOtUaNAgq3Mcc+wK4cG84sbHOhnuYTJhgJPSa2DCRsyRQaxY5L7TxsJtMezyNP76zIZP34gBerdgUMN3NaHzh3PnSRsAj7Pfh/sHetU0UR3Yar8aEvS5t6+E2X7MrwhWz8PCnzWsWur3p84NBj1/0G8xA37maFhaZh1zyXSY4fm6Z3Mff94zgiVPwvhvcF+leJHVw9Csu6p+2wGwmz48OjLoehJmG/5x5bN1bY9zygQu8npavUWwzB7IsIIx3PfFoEaDpb16Dbin8WZ54yoeTwrgOmug0xV3uR3I7Mu8LEir8H2cqz2pcFYJ/CULJng6/3LA0ZfIkbWNXMz0O6c3auv9w2bY8odFDTd6OBYZ73EW/MoJ68l8xBqu4OmjQd32M+q3rWQATw8vrXu+LZvAxn75c2wTAkkg3etdO5FpAGubojqw/e2kF4M+N5CxZ38xwmTXBGkOOGdi/QUMp3g9xp3fcyFFcjdye18M1wRQKu/i1z2DyQHJPsQt2623u4czDO8iuBbTnVOxBk0DVoVWoG1o98CthkZjp77F+/yczalYniJ98rCAz1vz2ndQfBMTBGTyIvcHOXeQtbO2uGGfMk3uYqLLki6bH5VGFX/n3DadAjEN2scAvM3SeGDBIL4X/8aazXKqhnwHwVR0rQ9QLTRHtb9TiTmqBZ2H8ARKO3y0bVEd2FraFEbSZ5OwaS74HosWWLVfEWfSPe0eGGGlXjc8OhhOtbKz33Jlg2MXDS/x3Zr4Gmy95y+scClH9prMui7YI+9+mvfvg5+OKMakdnV/nUVWUFv05F0B/TysBy60JqcGeIGTuABp0vizEXFWD0e++qPb/YOzYParNJ6zEmAFTOSXgPtOHN7cxi/Jv+YmXuRbPHXv7PvnU9gc67JxIzzI882SDF1mpFGPz8RT/R+LduOUbSReeS8A0ycsad5g5iFL8reDhiPbakqHjmhqL1OB08DWBH02CZvymq+dytlKTsJ8EFtf/Wh3uz9+SgZmehDvQvfAQvO7RoHkPafHjhk7zKquHrO2Zczmi4MSVBuanJfPivdGA7h0WwnccECmvsmouy+ij5djel9uKHDXA7EjHnsm+jJv8pcIi2Cy5zELm3MhNa5lqsEq02qZJTCLhm1kswK4hnlqIrj2Fm0m3lZ29ofzkB2lgqGBzTabkYw29RnEzx5+hNtm3MoTDz3JnDvdrx5sZWruPcjbPJkffKfyfr0ncva9jbf/67kc5HnDe7XCed6q/9bDmxd+ye85CYCNPQ/zrMeWl4bkvHzMmNF1z2+6p5anUmKQKkPSJ+OpCjSoDZrEAD7ijKrAAvKIXbCwx1tu9z3JKDp9dU7d83lZkCapjY67wzHzfWvxoxekq+I77sJc4fJJIsH9GLyQ8yODauqUU5ptqaaK6u7+t3HY7+PfJKHB1FMbzWL+JYe50bSnfxCTBR/HV6xuhqmn3FoJl5TDG44OIs4BbmD9NlnxVFDzJjpbAVz3tz9ibn2eHWY7Pd8J/BoDLjTM8bLSuSeu01x5kz8TZOuihgOW/QkyTh07AublPHP79BbN2Mye2EYZm79WMoCnDsZ4z9iCGMjsEG1d5yORdvePYo9vbe/7IMexG4FJ9c/7D7bPD3ASjyLO5B5zP18HMfVU0H4DMiyfP77flwfe7oTTSvdBGXEDpP/HemPrA5jRAjuhZxxwzI8L7AT+A9xjZX+BZmpN4hzI/Mmc7GP6XjKdzXlO24+CPPYIpt30xr1RPwZZ8UjdU3fHfDTDSzrvQbEREqeBxL1AymNWL9cOy7Mp+c2ORscuW+S9k8hKBnC2iWEE8JDU8vTwUsyrTu2mQXYY1oHMKhJEdWCjt/0PKCcFfu66E/HYeONBEWdai2w+e3/zzHHnocMdYM3q8Zr9pGASz/4wmuuyD/HAauoHOQfe4c+q/vrPkLr5DmuAukrJxu+v7svW1fBfhLvYz4r3Ovl/X1cr8X8etOHAW8O8TgjMyMXEDfvU7a4/94Ph1M+CXzFFiLv8Uzh3PKk0zMoqJgk85HS9cz0PiHZoNI2VqxEbSTzVDlizPweswHb+6B3M8jDezGElA1jj0vtjM/CUPXTjHYTExy/0f/FMO3B5GsisVLiL2sDm3ABdQI9Wuec95n7mfHO/31NYebUIhm6Dh7Ld735JDP9ZY7Up5f32Yx4HbtnegV7fp1gHXAzPDgmsGnLEP0BeKoBZf2UU3wdd9He+GsL3JxmWMtSvSUQARIYgNzXsBk88jOrr3wDrqy6Dsss6kSZulnKxbbhzOlvEfSa1wqW34mUvGd59aR7DvaxnZn42nY/6zGU4H/ssn/kgFsb19HzAJ7CM4JaFeXrKfEy5m6mZ7UHTuy4U7+MEXDh3s9fsTEWiqA1sDQZqGutxUJmb7UHeZhWZXo+ZUya+g9qibI5wFvEpz9QP4loER7i+wWHPcTsfZ3sY9Lzemvs9E7hvSGVdUnMtcO0Q9/MmOgwH5B/AhbCye/32EQuBadBp4Tl+tWldnkWjtefqZK0FI8i/b8XEfQ8LYKWnmSxsC3mAUXd7Hx3u9Z7ujFzMObfVd/zpPxfG+Lnw5ofAhx6PHW9ddyQ+F/KsnLAepjwKd8As5vsuMsu44cpncSwFNwVY4+HYlQzgaYTB9w/C61KC/s4KYgcxXW9MRbqoDWwOzZW5dTJZzLnVx0G+Zu1YCUO3beeh7Gc4T7KB7YA92Plgw6qkqTzjddDz4fsEzoUJa2BkADN1SBx0XjiYfT0EjJWVjdgFMqPA76AGcPurIPfs93pM7MaO9GYmBa+9xYrTmj611e0C0t/7PZ2XcYkb9inPJNzFNHtAdHP1MhzOYgb52WvRMWja30mGVzCWG+SF+gTrqtM9Hvs0gukt3oNaAJoyIFqpcBL1gc05c5O0rUFfx5R5mK/Rl0XZ3OQ06Ouh7BjOOwTd2cYFi6xPxYumzA18XNg91mDnoUkn+zx0xBjqBinPPFZAn765XIvhv3F2MD0GzPqrx6CW3wH4Aa4abs0+D/b1XNuzXHoh1oywlkwxUy/mWpfVst8HapymPNv3ykXkd70UJr5O3ZIGLl7kW+9taG6s4GSvi2z6Ujn7ek78ybMszqshZY81sfMP+J5FqnLCek58fRCJ0wJfwNPX8SsZwNNT5vvO1PylmZqKMlEf2JyZwa5TQQTA3zkUXZzKtrqpp4C6LGyX07anCJzc/RQr7juZvj6OG7EL5IQ3GfWBI2PKBWB1sdR3CgFG8aTb8wdnwYvyLVMYyVwj/M7dQY6A5qEXojy4qNFgaMfKzo5uEY7s5/WPhQE/8zRNVVMXcQucWf4sR666noTbX4LHrvJ9gu2GBYMYI+sCGjQdULn6TNRMTSkP2lRgaxUroXulociOW0O2SdMX1QQ4G84vqP807a4L/Yh/QPmvpjXYtpBT6eRhyilP5mVBmlPP8N6MpGbyl0yQVPKzrFl/vy95qn4+RH+61TuNFzM/s9qnhtM48+kvYD4+hfhjEzn6wh8bnuvjug0W2/RSpg7Ls/lhtJ9dPKUnqzgNc8nVHHz0av/OARKn+Z4J5F4GcmKt96EQb/7tLv417eeNtg+ZAh/fFcQinW4yMs3UVLSJ2gHarkQE48fkvk22CHYYApvp3sMAa2dvXvglfY33ascRAqO9r2jil7rBzoHyY5Bz3LBPuffc5z3OUA9wDlBZLXz4xCMej/FH3LBPeffc2xp18KjYLczKCG5wc3O6cebLmGkPeD9oHcwa5L6sU03gAxbbwlpkSgdoa8YWjEXZyJPuZ9pPuncBVYe+Dux6F4L0PITZ0YG6urnVMOAew8ae1uwp8sZVeFrudMRCuPZ0a6XoUUHMZjs4C2YLWH0t4be8AJMD/zARN+xTjrwyF17yfpy39cLA+hWsSgBwP5VZIC5z6opfOft6zNFnIaPJl22SFxnIS0Yw7/px8Dkw9eAgtrudDS3wD6U6wFq1BW0rsH1h/0OnNm0mjFnMw5zlZbSrvx1B7KzsTb5kxfYO3CX7eWB9J2vjSuhZJczx0eNxOMCL1tixUUGsSea4Rm+cJwt2E9Scp6pyfu6k14C5PPhSsddszBvHIObVgFBTt93RaaMp1wT4+5XPMkuCn4bKnRG+Fr5zc/6i4SX+VyH+ACRCtptg5O8yMM60HU21BW0msOXk5JCbm0tBQQE3VdbS1QT/ZjmSQYGvP+bOb0Cufoozqk7mcWBxVSdiPr7E2ncFPJPkfW2y4cAJYlg2vpBRfXOboUBeuLRZbbhzOqnisnTNjLuYGGRQe8gIN7tZRBrgoIGuEniWUZlWi3k0FqbZG6RnUJ056uZWfKzh9qQTxzPizGf9ukZXE8Pddq3jU+B+KR0vPFUhavalVGNtpo0N7HY25593fSvMYfgaeJx+4+1J/Nd8HNCaZMMBWWg/WQMSfyujfmr1aByc1bCn/HNY3fMvz/I+M9WECmjX0VDjbRmXkYvpe0l91eDmLZA6qfleO97avaaeMgg54QX47xUBZW/WZME5fg2MXskA3vFQjVsEmAul0UDn9w3c6GfA3bVO/J/Sypn9em302lXKC21ja0MaDNZupcbyrff8hRuq3HaSZ2jSx4HNpAFUyDQ6zbLf4OKpC2pgLarZ7vL6N79jK4XHhkORHOJOvE8I7TGo2T0M44Z9yua88Txov7tfFmRmFoxli16getFClpurmRRE5uaPpxEreK30cICb2TvOEzivt58fjoIJamhXfKWC0aYCW4NptgAGmuCytteAe/w79GzuYE6S+8AWiBG7rHsez18Z9VMPZR4Et3KYJ2lvBaqJcPtMaOd47i+X7vLnzD6Fv8bDg/huP6ucbU0NlnLVM1ROWE/mIz+u21c6sZCUPTFUzr6ezEHzGp74vudrrmAsKxjL1P8+Q4fl2XXXASsry5zr/k1/WJ8d0KXx/Iz3MpCi4SUNtiU+fiKc6fVHcy+Q5bADoYOmlQpam6qKdHD+FFzwcRBLQQ+CW039VI++BFLV6MkIgc5f+V6bzOrhmIpM/qAZ7oo17mzG9AYz33tSOWE95pNBkAoSV8MNZbHcIPUT+07bezWLL12H+WRQowl//Z2dYyTLmLb3ar7rYr1uK2dfT/VVwircT0bp7rrFZhB3t+JKOsHIzcmpf41qV3wVIK2KbIMaZG4DXQL7/cKb93jPbn7PSdyJNEvAcmfEGCC/4bZrMfTp6/3d+C9ZMGEG/JYS3PZs9GTkYszt0x1TVzby0Yy5/iUmK/vDbmAL/P2EWG7+L8xyCixfbYTFCwZxRK73K5C9yEDyFzQeaH3gfPiHvXDpzWXWrPjerud6nQPN0fEHGg52liZGSpcPmJqpKRW8NhnYHBxtbs7PCwqhwpzsNWjNaeFypeebuvXQ6vl+45wwwx5YHeAYtLhhn/JgXPDd9B1S9sSQmmGonH09S8ed3iCoAcwaZ3UO8TRbvatFgDlzSaPtMvMu/iXWbBz+9HL0dJ2mapD5N+P1QLvlK9UUbTqwuVbxWEvcGK4FVgYx0LmpRoyBmfkF7LnpLQJ5W/tLFkwQe5Jgl/kU467+E0fazYXZ9obnrJWhG0xvda7/nUEqJ6zHvOqjJ8T7+D2bvavfLLiOVydYQcgcAhIbH2MmPsD7xuo7/7yBzJhav8eTBcVD5uTIqhyvG58cH6I8XU8HTyvVLNp0YHPlPNZthD2rQ2sGuJn5BcwuzmVUgOdNqACZvAhGznc7R+KDk+qzsYqX6ld/BqBP4xWivcl85Mcsy/Be9ReslQzgQI8lvpPTQXCe/fC8+8HncqrDS3yPG/MRULytJu2a+buTk5NDgZeVqZ2vp5RqGg1sTgoKCsjNzQ14SMAIgfQgpjdyteemt/wOavld7QwN+C2DrOpHN0Ht6Hdn0Nd0pWIuDJ9keJBizIz6GY4v86PcxUZIPNV+cgaNqhj9VWwGcbev9q0gu8U7/GbBdVZwdDJ1A3CB9/MaVCvarwPn4ONtMLQ/rxPH68rXtZRSTdcme0X6w3lArPGRQlwnhtWN2sSax+As9wtaFskhnvDUlmZnY3HDPq3bNPsnc3lQfPdsdFaZVgsjNmKODGLWIv+nolrJANa4+Z198Y74DDABuxC6v23oZz+9wwjnBfKncBkA7fpdqUikvSKVW86DuQt/8qbXYzt9NYQ+LVSOmcDPxbDRZXtB/3LPJ9ntZ0d+N5eP1s61NvF8wEOuviqL5UTp2ahrvi9PI5j7pfHCrBcEWAB/vA27LnSKZEF8vsjNzW1UrajVgkpFLs3YfBARRjXDUjD+uDyLRjORpDl6Ovoh7uo/8eMfW4FsWDxMk7voz/0NjqlMq4WZN/h1PXP0WWZd5z5Te5GBeCpV4oITOdACvRAb8PS6DbTbvWZnKgppxqbCxu0C0n9/4x0jvvPr/CMT53JZnPUGXQBMdHOM66Bpb5Zxusd9i2be7XktsWBm8AiCa/f4goIC3jcEVhWplIo6Gtia2eAsmL0K6A2jD9ld8V/179wX+da/IDZyMdPvnM51rtuHwIc+Th2O/7N8uPMiA1k0827eu/WB+lnzm5uf2ZNz93hHx4zzMLDOKbK564yi2ZlSUU0DWzMbDrQbYbiVwww2HeoHTfvDZQyaNw9LYN30m8ui4SVWpjatZe/jbaVndxMDO7eN/b7Qqj59kYF84WZWfnc9HpVS0UMDWwAGZ8HsSXieAR6gBO7oX86TGztyzMOg6UD0/fMpbN4CuCRyD+K74e8yI8x02ZY4zb/ZOpzdOPNlLr7FqnbcJgTVQaNOENmYgyMrc7fPeZq0qWYgAMVIw7LqxMJKtQka2PyQn2W9CT6G0G6uj3XLAPiOmhEgLAKCDGp2l/1L+sHwvMC66TvMOpWAuum7s5IBmIkPQDDrsnoIHv6s/Owui/Knx2LDpYkMzsP0dAkYpdqG4JeRbiMcb5S5ubmcLU9R462bPdTP6NFEccM+xayZzsMyPuCgdpkRKp4Vjiy63uMxN858mbPNIM42g+hmBvEiA7mXgZxtBvHktkF1xzx1MAbOCe5ncAxKdv0CMMZ4/XI36LmgoMDjPtdjAI/31dnylYpu2t3fTyICDz3idnYPoH4NM+e1zJoQ5PpeMp3r8vxY/yytttE280Fs3YTDnnQzgxr0HhQMDC/BrOoKB+GmxFrONjFBDXauu6ZW+SkVEtrdX/nPU1Bz3ud8zIoT2TDnFFLlrsDvNeMuJvoR1MyVsfDfhtuPjPOcqXlSN6B6FZAIT90fQzCjznWGeqVUqGlgC8bIxfS9ZLpfh/afC6kug6SDUZlWC9e+1HDj8M85ctX1PMftXs99EaszxZWsZyUDeAfhG9eD7vbx3JXOUK+UClMa2IIw/c7ppIp/05H4uxyMLzeUxfJ3cc3ExK+g9sU7AgPgpkG1PD3zHsyTDzStZyM6Q71SKnxpYAvAq3NOAeBnc2E4WUH1VAxUZVotmXNzmFUGs3wEMY+et749PWU+9wU7sFpXeFZKRQgNbAF4UKw38gehVYIaADNv4H9jHgx6qZg6b4NhIjwX/CW0/UwpFQk0sAUgmGBWefts/v7o1fzqjhdIeewqa1taLTeUxdYtR3N/fk8OjdlOh+XZ3D16R4Pzby4LfDXqG4d3JvHxCwE4+4wl/g/q8JGBafuZUioSaGBrYX9/9GriZB1fmUFMsgMbIzYyS3oyi/kAlDw7iFSg5NgOZknDbvqBzhIC8N7KrkFNBOxr4LRmaUqpSKCBLQiVt8/GTL+aqenwqjTMYCrTajlQFktimb3hVCs4ndgRKnbb0WYLLPvEaYb96+x9Gb7vfePMl60JiL04z/vuesY0rF4EzciUUhFPB2j7SURIsedn6rA8m/+NeZCxz15N6nUugW3CeswnP67Lxpqb68DqoLmsHK2Uih46QFv5reIUO6KcAbMYy/Drrq/f5nCEgFecDgWdN1EpFa00Y/OTiPAvmjahsC8rGcAaHwPMXjJCdjAZm053pVSboRmbChultTF8cbGPg4KshtQ1yJRSbYUGtgA41vmaJet9HruSATyNcArWVFYvMhBfy42awzRaFDMobjIxHVCtlGordNkaPzkvX+OPp4eXYnoLdxgrxTrTCAbvXyQ2T1ndLRejGZpSqq3QjM1P7lZolic9zxR88S3W4pznvQsy82WM7ySv6XSFaKWU0s4jgXJkbAUFBSDN0e+++eTm5NT1dNTFNJVqu9p65xGtigyQc+aWm5Pjcxqq5pKbk4PY3zGmwXPHY9AVopVSSqsig+Ac3AAruDUle/MjODqqFx33dMzb6Hge7pm3Ukq1Fs3YmiDQDiWeuOvs4anzh+Oezs+1Y4hSStXTjK0JGmRujozJOYvzUyCdPVyrGbXaUSmlGtKMrRm4y9z8ycK0K75SSjU/zdiaQaM2N3TtMqWUCpWw7+4vIuHT118ppSJDmTFmUqgLESphH9iUUkqpQGgbm1JKqaiigU0ppVRU0cCmlFIqqmhgU0opFVU0sCmllIoqGtiUUkpFFQ1sSimloooGNqWUUlFFA5tSSqmoooFNKaVUVNHAppRSKqpoYFNKKRVVNLAppZSKKhrYlFJKRRUNbEoppaKKBjallFJRRQObUkqpqKKBTSmlVFTRwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkUVDWxKKaWiigY2pZRSUUUDm1JKqaiigU0ppVRU0cCmlFIqqmhgU0opFVU0sCmllIoqGtiUUkpFFQ1sSimloooGNqWUUlGlXagL4MukSZNMWVlZqIuhlFIhk5+fX/c4Pj6eYcOG+Tp+rjFmUkuXK1yFfWArKytj+fLloS6GUkqFjIhwplwCwIIjb/h8TxSR9NYoV7iKiKrI3NxcRCTsv3Jzc0P9q1JKRTBP73XtSaw7pj2JPt+L2rqwz9gACgsLMcZQW5zXqvcdt/ISv49dOukhfUEppZrE8V7345hLPR5zspzjcd/82tcB2vx7UUQENoeYrpsAWjzABRLQHI7/eAbxmalBvaBycnIoKCgI+DylWkNubi6FhYUNtulrNnjufp8OccmdGfmLJ2DqeJ/XWfHP2zxev62LiMCWk5ODiNT9M8V03dTq2Zs/hj9/U1DnrbrmqRb/hKVvRCpQjjfg9iTWte84fFn4YZvLClz/h7wFKG/ikjsz4sbH/T7eWwBzd/+cnJyAyxRtxBgT6jJ4NWbMGONoKBURHOUNNrAFk41Fg2VnP0y4/61VeHHusOBL+Yf9fB7z9Yg3AP/+Bzues9mv+zor8yPLSZ+1JODrOiwwbzT4H/Ln9+NPmXzxFNic3w/d7Ms3xoxp8s0jVERkbA6umRu0fLVktPCnmtRTVhfsJ9NA76NCy/Xv7NxhoTk5Apwn4frh09Fpw/l5U3kKWq48VQcr9yIqsDneDNtaFUhz8KeadNnZD7vdXlhYyNiP7vTrPr4+ac+vfV3/fmHKn44LTTH63l/6dZy7rKqlszF/eOu00dIcfxvln4gKbA6aubUMT1ldfGaq39comzre6xvMj2MubfTJN1Ca8TV/Fg1WBhJsUDv6TgZxF+xuchmCDU4tHdSC4eih6Is/f0vNzgITUW1srpzrmI//eEZrFku1ME+ZnyPjC/fXbUsLpP2rNQTblhR3we4GVZOesrpwDFy++BvYWuL1rG1sEcxd5qYBLvIcfSfDzVb3gc1XxhcJ2VxzZFst1f4VCs5tau6yPvevj9DxN2BB9GVjE3+UZPbsrfF6TP7q6pBP5xXRgU3b3CLf0XcyAv407q2tY0Gh944J4aCl27IiiWvQyr/36UbHjOMSmNVaJXIv2Iw02trG9uytYencXl6Pie22KeTTeUV0YHPIyckhNzeXgoIClk56CNDMLVLEXbCbMoJ703AXEJvafucPf7JCb5/Um9KW1daMW3mJHfwC7/7fXFwztEAy7kjKxqJJVAS2goKCujnWHG86Syc9pMEtQgTd6cDNp/jW6Lnmz+Bkd4Oao1FzjNPyZNzKS+y21pYPat6qF10DWU5OTlRlYdEoKgIbaLVkJAu+DSU0n+JD2e27pbRkgAqEc3tbqDM1h2irTgw1EXkWOBcoNcYMtbd1AeYAuUABMNkYs09Ejqf+I6wA9xpj3vZ1j6gJbA7OHUoy/3l5qIujfAimjU1Fr0A/5LjLtLxV83rKzLxVL2p1YrN7Dvg78ILTtjuBT4wxD4vInfbz6cAaYIwx5piIdANWicj7xphj3m4QdYHNOXPLDG1RlGpVZVPHN6rWDYceha5d+sG5mtFS/mE/t8c0V6cRXxmpZmWtxxjzhYjkumw+Hzjdfvw88Dkw3Rhz0OmY9oBff6SoC2xKqXpxF+wOi+DWFIG2fxXUFni9nk5PFZayjDFFAMaYIhGpy0tE5ATgWSAHuMpXtgYa2FSIxV2wm/ILfE+g60yrL8OXu+76o+/9JRPPGdFgW0c/2s6+HvEG7PJ+jGum5U8bu2ZnLS5dRJxn1ZhljAk69zbGfAMMEZFBwPMi8pEx5rC3czSwKaWazbiVl7id5Ni/Qc0Pud0aSPuXcxs7oMu6hEZZELOelIhINztb6waUuh5gjFknIgeAoYD76ahsGtiUCjF3bWOuIiVLPfpOBuNwH9yCFUiG5do7WjOziPEecA3wsP39XQAR6Q1stzuP5AADsHpNeqWBTSnVbOIu2G1PklCffa34p/Xd34HNjrGojuODybA0KwtfIvIKVkeRdBHZAdyDFdBeE5HrgW2Ao2vrycCdInIUqAVuMsaU+bqHBjalolQoOo18PeINcnNf8VgF6E8G5TzZQrAZV7jPF9qWGWM8jcOa4ObY2cDsQO+hgU1FJF/dt8O12s5duf2ZecWfqcfcXcfX7yGQgdn12Zg3t1FY2LTZ6jUoqabSwKYijj+BoAzv68KFSlPWLAv03Kb8/J5Wdo622epVdNLAplQr6njO5labvqpsavNXRWpX+bZt3aHODaY9c89XVt/yojqw6Uz/Khy1ViYZbAB1ZGs6kFlFqqgObEqp4Gl2piJV1AY2XV1bqcC4ZmqanalIFbWBTZexCQ3niW09Kf8wsCm0AlE/kDn0y500B9fB283dhb/hBMVWYNNMTbWkAJet+THWGLd44AhwhzHmU1/3iNrA5hCpy9g05xtYMD3xWnKNNMe1m9JDMBK5tnm1dq9NT7/vmK6bAM3UVKt5Dv+XrSkDzjPG7BKRocBcoIevG0R9YIvEZWyae/qkcJtk2HHtQMvliWsQDrbTREv+zO6mzfJnSEL6rCU+x6/5w93SMWBNUJz7i/qAppmaamkBLluzwumY74H2IpJgjKn2do+oD2xtmeMNPo7wzIy8ZYX+ZnPNldn6G9SCDZrBZqfB3M/TvcatvKTRAOsV/wSR32pAU80pmNn9PS5b4+RiYIWvoAYa2KJeOFf3eQsm/mRzwQa1pmRmzfX7dJS9KWPaPA2i9ka78KtWEMzs/l6JyBDgEeAsf47XwBbl3L35h3OwUy1LO4aoMOVx2RoR6Qm8DVxtjNniz8XaVGBrawO23WUmrTXrhWpe7rIzf2fLd6bZmQpTnpat6QR8AMwwxnzl78XaVGBTbUO4zRHZUrPsa/alIlGAy9b8CugH3CUid9nbzjLGNFqI1FmbCWw5OTnk5uZSUFDQ5jK3tqTFeza2ckccnd5KRZsAl635E/CnQO/RZgJbQUFBqw/W9mewsjtlUzN8DmIO9trps5aAr/5JETK4Of/ep+sej1t5SdC/E3/4s8q1J87lBKus3rK4BsHZXqRTszOl/NdmAhs0nmZr6aSHWixrs964WuaNtiWvHQ78zYycZxkP59+J79nQG5tf+zqgg6ZVeDH723Hs3dZfwDZQbSqwOQZrO6/Q2xKzkViZQ/Bvsr6zqvB8A/fF36zHNaj5N2C8ZX8n/mW6/vO2pEzZ1PENAppmakoFpk0FNgfn2UgKXAasarub8pcjqwL4ccylXo70zbXXow6aVip4bTKwOTiqJp2fR9J8kiq0nLOqPMZ6PM7fIRbOHUS06lGp4LXpwObI3BycMzjN3FpGS3V9b0nOmZkzEcEYY71uTIHP64z8xROA5xlDtIOIagsCnN0/DXgDGAs8Z4z5lT/3aNOBzZUOCWhZ4Ta+zJmn4OXgrbu9a+bvjvO6gJ4GVmuWptqI5/B/dv/DwF3AUPvLLxrYnIRiSICKDN6yKdfM3x3n15VmZqotC3B2/wPAlyIS0FIgMU0sY9RxfPrOzc0FaDQbuoou82tfZ37t63U9ZR1/d8dzx1dTsynH66o5rqVUmEsXkeVOX1P9OKfB7P7QtFXGNGNzoStvt02OLMrxd2/urMqfrE6pKNHss/sHSgObB8GuvB3OA4Wjiac2sWC63efm5jZqL9OsSqlW5XF2/2BoVaQHBQUFGGMCmj29pVeeVg05Vxc6qhAD4eiGX1hYWJdROf7ummEp1aocs/uD0+z+wdKMzQ/+dlHXoNY8fPVQdHCuLnRUIc6vfd1n1ubv9ZVSzS/A2f0RkQIgFYgXkQuwZvdf6+0eGtj8oAGr9XnqXl9QUOB2/kTnKsQ8xnodFO16ba12VKr1BDK7v318bqD30MCmWlUw2ZiDt44dDaZJswdLOwZEOzgGRut0VUpFNw1sfnC8GTd1PsC2xlMQ82flZ3dZlD8dO1xXcHB3X83QlIpuGtgiiLfqtUiqLg22K70/HTq8DdfQgdFKNU273QdI+9fiUBfDJw1sPri23YSKzyVfmnFJlWC5ZmihnDrK3TRXmqkp1TZoYPPBOQPIk+YPbMGuUeaq/MN+YTfcIJQZknbXV6rt0sAWYv4EtXDkT/uZZkhKKVeBzO5v75sBXA/UALcYY+b6uocGtigSd8Fuyi8IaK7QoLM8b9WM2o6llPLiOfyc3V9EBgOXAUOA7sACEelvjKnxdgMNbCFUNnW8zyrGcOGaoTnWIlNKqUAEMru/vf1VY0w18IOIbAaOB7x+GtfA1krctaVFSlBz0GpGpVQLaTC7v4g4ZvfvAXztdNwOe5tXGtiimD9TgTlXQ/oaPK3d5ZVSfkgXkeVOz2cZY4Ltt+1umRWfb0Ia2KJcIO1nvgZOa5amlPJDMMvWeJrdfweQ7XRcT2CXr4tpYAuAtwHSvrR070d32ZmvoKbtZkqpMOGY3f9hGs7u/x7wsog8gdV5JA9Y6utiGtgCEM5d8wPt2egIatpuppRqTYHM7m+M+V5EXgPWAseAm331iAQNbFHDn+m2yj9sPBRA282UUq0piNn9/wz8OZB7aGBrIzxNd6VZmlIq2ugK2m1A2dTxDVabdsyhqCtFK6WikWZsAVg66SEAjv94RohL4p1j3TFnugaZUqqpKtk3d4F5I93HYWWtUhgvNLD5yXmW/86TbgGsziRfj3jDr/NH3/vLBh08mtLD0hdPq08rpVRTGGMmhboM/tDA5qcGKzTbGZG/mdu4lZe0VLEa0BWilVJKA1vAcnJyyM3N9bttatzKS+rGmLVklgbaIUQppQAk3D/Zjxkzxixfvtz3ga3IdSCzr8zNn6mtfHHXbuarXEqptklE8oOY/SNqaMYWBOf2toKCApZOeogfx1xatz/QzMyfoOWcjRUUFDTKzjRTU0opiwa2IDi3t7njzywggQY/x0Bqxz1dn2umppRSFg1sTdAgc6stAKjL3HzNlO/M1+TDjnu53tN5u1JKKYsO0G6CgoKCukxJRMjNza3b5zog2tsXWBmXty9Hlui4p/NzHWStlFL1NGNrBs5Vk3kyFtA5GJVSKlTCvleky4J1SimlfCuLlMHULSHsA5tSSikVCG1jU0opFVU0sCmllIoqGtiUUkpFFQ1sSimloooGNqWUUlFFA5tSSqmoooFNKaVUVNHAppRSKqpoYFNKKRVVNLAppZSKKhrYlFJKRRUNbEoppaKKBjallFJRRQObUkqpqKKBTSmlVFTRwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkUVDWxKKaWiigY2pZRSUUUDm1JKqaiigU0ppVRU0cCmlFIqqjQ5sIlIrIisEJH/2c+7iMh8Edlkf+/sdOwMEdksIhtEZGJT762UUkq5EmNM0y4gchswBkg1xpwrIn8B9hpjHhaRO4HOxpjpIjIYeAU4HugOLAD6G2NqvF0/PT3d5ObmNqmMSinV1uTn55cZYzJCXY5QaNeUk0WkJ/AT4M/Abfbm84HT7cfPA58D0+3trxpjqoEfRGQzVpBb4u0eubm5LF++vCnFVEqpNkdECkNdhlBpalXkTOB3QK3TtixjTBGA/T3T3t4D2O503A57m1JKKdVsgs7YRORcoNQYky8ip/tzipttbutBRWQqMBWgV69ewRZRKaXCmjGGsqojFOw5wO7KavYcOMKeqmr2HjjC3gNH+H+Xj0TE3Vun8qYpVZEnAT8VkXOA9kCqiLwIlIhIN2NMkYh0A0rt43cA2U7n9wR2ubuwMWYWMAtgzJgxTWsEVEqpMGCMYWNJFV9tLmN9cQWbS6vYsvsA5YeONjq2Y4c40pLiOXCkhuSEJrUYtUlB/8aMMTOAGQB2xna7MeZKEXkUuAZ42P7+rn3Ke8DLIvIEVueRPGBp0CVXSqkwt/fAEb7YuJsvNu3my01llFZWA5CenEC/zCTOPa4b/TKT6ZORTGZKAmlJ8XROiicuVkdiNUVLfBR4GHhNRK4HtgGXAhhjvheR14C1wDHgZl89IpVSKtLU1hoWb9nDK8u2Me/7Yo7WGDonxnFyXgan9Evn5Lx0unfqEOpiRrUmd/dvaWPGjDHaK1IpFe72VFXz6rLtzFm2nW17D9KxQxwXjerBhSN7MLR7R2JiWretTETyjTFjWvWmYUIrb5VSqgm27z3IvxdtZc6y7VQfq2Vcny789qz+TBzSlfZxsaEuXpukgU0ppYKwrqiCfy7cwv9WFxEjcOHIHkw9tQ/9MlNCXbQ2TwObUkoFYO2uCmYu2Mi8tSUkxcdy3Um5XH9yH7p2bB/qoimbBjallPLDhuJKnvxkIx9+V0xKQjtunZDHdSf1pmNiXKiLplxoYFNKKS+27K5i5oJN/G/1LpLi23HLGf24/uQ+GtDCmAY2pZRyY/vegzz5ySbe+nYH7eNi+cVpfZl6Sh86J8WHumjKBw1sSinlpLj8MP/v003MWbadmBjhupN684vT+5KenBDqoik/aWBTSimgpOIwT3++hZeXbsMYw+XH9+LmH/XTTiERSAObUqpNK608zD8/38pL3xRyrNZwyaie/OqMfmR3SQx10VSQNLAppdqk0orD/OsLK6AdrTFcOLIHvz6jHzlpSaEummoiDWxKqTZl1/5D/HPhFl5dtp2aWsP5I7rz6zPy6J2uAS1aaGBTSrUJhXsO8M+FW3gjfwcAF4/qyS9P76sZWhTSwKaUimrriyt4+vMtvL9qF+1iYrhsbC9+cXpfeugM+1FLA5tSKip9u20fT322hQXrrKmv/u+UPvzfyb3JTNVejtFOA5tSKmoYY/h8w27+uXAL3/ywl06JcfzmzP5cc2IOnRJ1YHVboYFNKRXxjtbU8r/Vu/jXwq2sL66kW8f2/PEng7j8+F4kJejbXFujf3GlVMSqOHyUOUu389ziAnbuP0ReZjKPXTqcnw7vTny7mFAXT4WIBjalVMTZse8g//2qgDnLtlNVfYwTenfhvp8O4YyBma2+UrUKPxrYlFIRwRjDsoJ9PL+4gI+/L0aAnxzXjf87uQ/DenYMdfFUGNHAppQKa4eP1vDeql0891UBa4sq6Nghjv87pTfXjM+lu3bZV25oYFNKhaXtew/y0jfbeG35dvYeOMKArBQeumgYF4zoQYf42FAXT4UxDWxKqbBRU2tYuLGU2UsK+XzjbgQ4c1AWU07KZXyfNES0/SwYIrLaj8N2G2MmtHhhWoEGNqVUyJVWHOa15dt5Zel2du4/REZKAr8+I4/Lj8+mW0etbmwGscA5XvYL8F4rlaXFaWBTSoVEba1h0eYyXvlmGwvWlXCs1jC+Txq/P2cQZw3JIi5Wu+s3oxuNMYXeDhCRm1qrMC1NA5tSqlWVVBzm9eXbmbN8O9v3HqJLUjzXndyby8Zm0ycjOdTFi0rGmC+b45hIoYFNKdXiHG1nL3+znc82lFJjZ2d3TBzIxCFZJLTTziCtQUTOBR4AcrDe/wUwxpjUkBasmWlgU0q1mF37D/Ha8u3MWbadovLDpCfHc8MpffjZ2Gxd/yw0ZgIXAd8ZY0yIy9JiNLAppZpVTa3hs/WlvLJ0G59tKMUAp+RlcPe5g5kwKEunugqt7cCaaA5qoIFNKdVMSisO8+qy7by6dBu7yg+TkZLATaf342djs8nukhjq4inL74APRWQhUO3YaIx5InRFan4a2JRSQTPGsHjLHl76ppB531s9G0/JS+fu86zsTHs2hp0/A1VAeyBq1/HRwKaUClj5oaO89e0OZn9dyNbdB+icGMd1J/fm58f3IlfbzsJZF2PMWaEuREvTwKaU8tu6ogpeWFLIOyt2cuhoDSOyO/H4pcP5yXHdaB+nPRsjwAIROcsYMy/UBWlJGtiUUl5VH6vh4zXFzF5SyPLCfbSPi+H84T24clyOzqofeW4Gfici1cBRtLu/Uqot2bHvIK8s3cacZdspqzpCbloif/zJIC4Z3ZNOiVHbPBPVjDEpoS5Da9DAppSqU1Nr+GLjbl78upDPNpQCMGFQFleNy+Hkfum6iGeEEpGuxpjiph4TKYIObCKSDbwAdAVqgVnGmCdFpAswB8gFCoDJxph99jkzgOuBGuAWY8zcJpVeKdUsdldW25MQb2PHvkOkJ1td9S8/oRc9dM2zaPAhMKoZjokITcnYjgG/NcZ8KyIpQL6IzAemAJ8YYx4WkTuBO4HpIjIYuAwYAnTHasTsb4ypadqPoJQKhjGGJVv28NI325i3tpijNdY0VzPO1kmIo9BwEanwsl8Ab/sjStCBzRhTBBTZjytFZB3QAzgfON0+7Hngc2C6vf1VY0w18IOIbAaOB5YEWwalVOD2HjjCm/k7eHnpNn4oO0CnxDiuGZ/L5Sf0oq9OQhyVjDFtqstqs7SxiUguMBL4Bsiygx7GmCIRybQP6wF87XTaDnubu+tNBaYC9OrVqzmKqFSbVltr+HrrHl5euo1535dwpKaWsbmduWVCP84eql31VXRpcmATkWTgTWCaMabCywq37na4na/MGDMLmAUwZsyYqJ7TTKmWVFp5mDfzdzJn2TYK9hykY4c4rhjXi8uP70X/rDbRQU61QU0KbCIShxXUXjLGvGVvLhGRbna21g0otbfvALKdTu8J7GrK/ZVSjR2rqeWzDbuZs6x+iZjjc7tw65l5mp2pNqEpvSIFeAZY5zKB5nvANcDD9vd3nba/LCJPYHUeyQOWBnt/pVRDG0sqefPbHbz97U5KK6tJT07g/07pzeQx2dp2pgAQkSeBOcaYxaEuS0tqSsZ2EnAV8J2IrLS3/R4roL0mItcD24BLAYwx34vIa8BarB6VN2uPSKWapqyqmvdW7uKtFTtYs7OCdjHC6QMymDwmmx8NzNSejcrVt8AfRaQ/8DZWkFse4jI1Own3ZXnGjBljli+Put+7UkErP3SUed8X8/7qIr7aXEZNrWFYj45cNKoH5w3vTnpyQqiLqMKAiOQbY8Z42NcFuBhrCFYvY0xeqxauhenMI0pFgMrDR/l0fSn/W13Ewg27OVJTS8/OHZh6ah8uHNlDO4KoQPUDBmJNpLE2tEVpfhrYlApTZVXVzF9bwtzvi1m8eQ9HamrJSk3gqvE5nDe8O8N7dsRLL2SlGhGRR4CLgC1YM0Q9YIzZH9JCtQANbEqFCWMM64sr+WxDKZ+tLyW/cB+1BrK7dODq8TlMHNqV0b0663yNqil+AMYbY8pCXZCWpIFNqRCqOHyUJVv2sHDjbj5fX8qu8sMADO2Ryq/PyGPikK4M6paimZlqLrOAn4tIH2PM/SLSC+hqjImqHuoa2JRqRUdralm1fT9fbCrjy027WbWjnJpaQ3JCO07ul860MzM5bUAGWantQ11UFZ3+gTVp/RnA/UAl1ljksaEsVHPTwKZUC6qpNawrqmDxljIWb9nD0h/2cvBIDTECw3p24qbT+3Jyv3RG9upMfDvtmq9a3AnGmFEisgLAGLNPRKJucT0NbEo1I2MMm0urWLxlD4u3lPH11r2UHzoKQN+MJC4e1ZPxfdM4sW+aLtapQuGoiMRiT2coIhlYGVxU0cCmVBMVlR9i0aYyvtxkZWVlVdUA9OzcgbMGZ3FSv3TG903T6kUVDv6GNTA7U0T+DFwC/DG0RWp+GtiUCtDhozUs2bqHhRt28+XmMjaXVgGQkZLASf3SOKmvFciyuySGuKRKNWSMeUlE8oEJWBPTX2CMWRfiYjU7DWxK+WHHvoN8tmE3n60vZfGWMg4fraV9XAzH907jsrHZnJyXzoAs7b2owpM904hDKfCK8z5jzN7WL1XL0cCmlBu1tYY1u8qZv7aE+WtLWF9cCUCvLolcNrYXPxqYyQm9u+hM+SpS5GO1qzl/8nI8N0CfUBSqpWhgU8pWfayGxVv2sGBtCQvWlVBSUU2MwJjcLvzhnEGcMSiTPulJmpWpiGOM6R3qMrQmDWyqTSs/eJTPNpQyf20Jn28o5cCRGhLjYzmtfwZnDsrijIGZdE7S3osqOtjLjV0B9DbGPKADtJWKEtv2HGT+uhIWrC1hacFeamoNGSkJ/HRED84anMX4vmlaxaii1VPUD9B+AB2grVRkOlZTy4rt+/l0fSmfritlQ4nVXtY/K5kbT+3DmYOzGNGzk87BqNoCHaCtVKTae+AIX2zczafrS1m4cTflh47SLkYYk9uZu84dzJmDMslJSwp1MZVqbTpAW6lIcbSmlpXb97Nww26+2LSb73aWYwykJ8fXtZWd0j+d1PZxoS6qUqGkA7SVCleOqau+3FzGV5v38M3WPVRWHyNGYFSvzvzmzP6c2j+D43p01CpGpWw6QFupMGKMoXDPQb7euoevt+5h8ZY9lFZaU1f16pLIucO7cWpeBif2S6djB83KlPLEGLMeWB/qcrQkDWwqLNXWGrbsrmJZwT6W/rCHr7fupbjCWqssPTme8X3TOblfGif2Tdepq5RSDWhgU2Gh+lgNa3aWs7xgH8sK9pFfuJd9B61Z8TNSEjihdxfG9UljXJ80+mboIGmllGca2FRI7K6s5ttt+/i2cB/LC/fx3Y5yjtRYnbN6pydx5qAsxvbuwtjcLuSmJWogU0r5TQObanFHa2pZX1RpBTL7a/veQwDEx8YwtEcq15yYw+icLozK6URmii7vopQKngY21ayMMezYd4hVO/azctt+Vmzfz5qd5VQfs7KxzJQERvXqzFXjchjVqzNDe3TUWT6UUs1KA5tqkpKKw3y3o5zVO/azakc53+0sZ++BIwAktIthaI+OXDkuhxHZnRjZqxM9OnXQakWlVIvSwKb8YoyhqPwwa3aWs2anFcDW7Kpgt93lPkagf1YKZw7KZFjPTgzv2ZGBXVOJbxcT4pIrpdoaDWyqkdpaw7a9B/l+VwVrdlmB7PtdFXWZWIxAXmYKp+SlM6xHR4b16MiQ7h3pEK9Vikqp0NPA1sYdrallc2kVa3dV1AWydbsqqKw+BkC7GKnLxIbaAWxwt1QNYkqpsKWBrQ3Zd+AI64srWV9cwbqiCtYWVbCxuKqum337uBgGdUvl/JHdGdrdCmL9uyaT0E6DmFIqcmhgi0IHjxxjc2kVG4or2WR/X19cQUlFdd0xXZLiGdI9lWtPymVw91SGdE+ld3oysTqvolIqwmlgi2Dlh46yubSKLaVVbN5dxaaSSjbvrmLHvkMYYx0T3y6GvhnJnNQ3nYHdUhjYNZWB3VLISE7Q3olKqaikgS3MHTlWy7a9BykoO8APZQfYWlbFllLre1nVkbrjHAFsRHZnJo/OJi8rhf5ZyeSkJWkWppRqUzSwhYHKw0fZvvcQ2/YeYNveg2zbe5DCPQcp2HOAnfsOUWvqj+2SFE/fjCQmDMyiT0YSfTOSyctKpmfnRA1gSimFBrYWZ4xh74Ej7Nx/iF37D7Fz/2F27jvEjn0H2bHvEDv3H6L80NEG53RKjCO7cyIjsjtz4Yge5KYnkZueRO+0JDonRd0q7kop1aw0sDWBMYb9B49SVH6YkorDFJUfpqj8ELv2W9+Lyg+za/+huumkHDrExZLdpQM9OycyOqczPTt3oFeXRLLtL11PTCmlgtfqgU1EJgFPArHAf4wxD7d2GXyprTXsO3iE3VXVlFZUs7uymtLKakorD1NaYX0vqaimpOJwo6AVI5CZ0p5undozuFsqEwZm0qNzB7p36kAP+6tTYpx23FBKqRbSqoFNRGKBfwA/BnYAy0TkPWPM2pa+97GaWvYePEJZ5RH2HKimrKqaPVVW8CqrPEJZlRXAyqqq2XvgCMecG7ZsyQntyExJIDM1gRHZnejasT1Zqe3pZn/v2rE9WSkJtIvVaaSUUipUWjtjOx7YbIzZCiAirwLnA80e2O56Zw0bSyrZc+AIe6qq6xatdBUfG0N6cjzpKQl069ieYT06kp4ST2ZKezJSEqyvZOt7UoLW3CqlVLhr7XfqHsB2p+c7gBNcDxKRqcBUgF69egV1o92V1RgDeZnJjOvThbSkBNKS40lPTrC/rGCWktBOqwWVUiqKtHZgcxdBGtX5GWNmAbMAxowZ07hO0A//vGp0MKcppZSKcK3dGLQDyHZ63hPY1cplUEopFcVaO7AtA/JEpLeIxAOXAe+1chmUUkpFMTEmqJq+4G8ocg4wE6u7/7PGmD/7OH43UBjk7dKBsiDPDTUte+uL1HKDlj1UwrnsOcaYjFAXIhRaPbC1JhFZbowZE+pyBEPL3voitdygZQ+VSC57NNMBV0oppaKKBjallFJRJdoD26xQF6AJtOytL1LLDVr2UInksketqG5jU0op1fZEe8amlFKqjdHAppRSKqpoYFNKKRVVNLAppZSKKhrYlFJKRRUNbEoppaKKBjallFJRRQObUkqpqKKBTSmlVFTRwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkWVdqEugC/p6ekmNzc31MVQSqmIkp+fX2aMyQh1OUIh7ANbbm4uy5cvD3UxlFIqoohIYajLECpaFamUUiqqRG1gW7OznPKDR0NdDKWUUq0s7Ksig2GM4eaXv6Vo/2FOG5DB+SO6M2FgFh3iY0NdNKWUUi0sKgMbwN8uG8l7q3bx/qpdzF9bQlJ8LGcN6cqFI3twUr90YmMk1EVUSinVAsQYE+oyeDVmzBjTlM4jNbWGb37Yw3srd/Hhd0VUHD5G19T2XDCyB5eM7kG/zJRmLK1SSoUHEck3xowJdTlCIeoDm7PqYzV8sq6UN/N38PnG3dTUGob37Mjksdn8dHh3UtrHNct9lFIq1DSweTtAJBt4AegK1AKzjDFPikgXYA6QCxQAk40x++xzZgDXAzXALcaYufb20cBzQAfgQ+BW46MAzRnYnO2urObdlTt5ffkONpRU0iEulnOP68Zlx2czqldnRLSqUikVuTSweTtApBvQzRjzrYikAPnABcAUYK8x5mERuRPobIyZLiKDgVeA44HuwAKgvzGmRkSWArcCX2MFtr8ZYz7ydv+WCmwOxhhW7Sjn1aXbeG/VLg4eqSEvM5krTujFRaN7kqpZnFIqAmlgC+QEkXeBv9tfpxtjiuzg97kxZoCdrWGMecg+fi5wL1ZW95kxZqC9/XL7/Bu93a+lA5uzqupj/G/VLl5Zuo1VO8rpEBfLBSO7c8UJOQzt0bFVyqCUUs2hLQe2gHpFikguMBL4BsgyxhQB2MEt0z6sB1ZG5rDD3nbUfuy6PWwkJ7TjsuN7cdnxvVi9Yz8vfl3I2yt28srS7Yzq1YkpJ/Xm7KFdiYuN2uF/SikV8fwObCKSDLwJTDPGVHhpg3K3w3jZ7u5eU4GpAL169fK3iM3quJ6d+MslnfjDOYN549sdzF5SwC2vrCArNYErT8jh8hN6kZ6cEJKyKaWU8syv1ENE4rCC2kvGmLfszSV2FaSjHa7U3r4DyHY6vSewy97e0832Rowxs4wxY4wxYzIyQjuHZ8fEOK4/uTef/vZ0/jtlLAO6pvL4/I2c+NCn3PH6KtYXV4S0fEoppRryGdjESs2eAdYZY55w2vUecI39+BrgXaftl4lIgoj0BvKApXa1ZaWIjLOvebXTOWEvJkb40cBMXrjueBbcdhqTx/bk/dW7mDRzEVc98w2fbygl3IdOKKVUW+BPr8iTgUXAd1jd/QF+j9XO9hrQC9gGXGqM2Wuf8wfgOuAYVtXlR/b2MdR39/8I+HWouvs3h/0Hj/DSN9t4fnEBpZXV5GUmc8OpfTh/RHcS2un0XUqp0GnLnUfa1ADtlnLkWC0ffLeLWV/8wLqiCrJSE7j2pN78/IReOlxAKRUSGtjCWCQENgdjDIs2lTHri618ubmM5IR2XDGuF9ef3JvMlPahLp5Sqg3RwBbGIimwOVuzs5x/fbGVD1bvol1sDD8bk82Np/WhZ+fEUBdNKdUGaGALY5Ea2BwKyg7wz4VbePPbHRgDF4zswU2n96VPRnKoi6aUimIa2MJYpAc2h137DzHri628umwbR47V8tPh3fnVGXn0y9QAp5RqfhrYwli0BDaHsqpq/v3FVl5YUsjhYzWcd1x3bpnQT5fPUUo1Kw1sYSzaApvDnqpq/r3oB15YUsChozWce1x3bp2gGZxSqnloYAtj0RrYHPYeOMK/F23l+cUFHD5awwUjenDLhDxy05NCXTSlVATTwBbGoj2wOZRVVfOvhVt4YUkhx2oNF4+yApz2olRKBUMDWxhrK4HNobTiME8v3MJL32zDGMPlx/fiVz/qR2aqjoNTSvlPA1sYa2uBzWHX/kP8v0838/ry7bSLFa45MZdfnNqXzknxoS6aUioCaGALY201sDkU7jnAzAWbeGflTpLj23HDqX24/uTeJCUEtJSeUqqN0cAWxtp6YHPYWFLJ4/M2MPf7EtKS4rn5R/24YlwvnWxZKeWWBrYwpoGtoRXb9vHo3A0s3rKHHp06MO3MPC4a1ZPYGI8Lvyql2qC2HNj8WmhUhY+RvTrz8g3jePH6E0hPjueON1YzceYXfLymWNeDU0opNLBFrJPz0nnn5pP455WjMMbwixfzueCpxSzeXBbqoimlVEhpYItgIsKkod2YO+1U/nLJceyuOMzP//MNV/7nG1Zt3x/q4imlVEhoG1sUOXy0hhe/LuSpz7ew98ARzh7ald+eNUCn6VKqDWrLbWwa2KJQ5eGj/GfRD/xn0VYOHa3h4lE9mfbj/vTo1CHURVNKtRINbGFMA1vw9lRV89TnW5i9pBCAK8b14uYf9SM9OSHEJVNKtTQNbGFMA1vT7dx/iL8t2MTr+dtpHxfLdSf15oZT+9CxQ1yoi6aUaiEa2MKYBrbms2V3FU/M38gHq4vo2CGOG0/rw5QTc0mM11lMlIo27gKbiPQH7gBygLp/fGPMGa1cvBalga0NWrOznMfnbeCzDbtJT47nptP78fMTetE+TmcxUSpaeAhsq4B/AvlAjWO7MSa/lYvXojSwtWH5hXt5dO4Gvt66l+4d2/OrM/K4dExP4mJ1FIhSkc5DYMs3xowOVZlaiwa2Ns4Yw+Ite3h07gZWbt9PdpcO3HJGHheO7EE7DXBKRSznwCYiXezNtwClwNtAteNYY8ze1i9hy9HApgArwH2+YTdPzN/IdzvL6Z2exK0T8jhveHedh1KpCOQS2H4ADODun9kYY/q0auFamAY21YAxhvlrS3hi/kbWF1fSNyOJX5+hAU6pSOOhKrK9Meawr22RTuuaVAMiwllDuvLhLafw1BWjiIuNYdqclfz4iYW89e0OjtXUhrqISqngLfZzW0TTft7KrZgY4Zxh3Zg0pCvz1hYzc8EmbnttFX/7ZBM3nd6PC0b2IL6dfi5SKhKISFegB9BBREZSXyWZCiSGrGAtRKsilV9qaw3z1pbwt082sbaogh6dOnDjaX2YPCZbhwkoFYZc2tiuAaYAYwDnN9RK4DljzFutX8KWo4FNBcTRyeTvn20mv3Af6ckJ3HBKb35+Qi9S2utMJkqFCw9tbBcbY94MVZlaiwY2FRRjDF9v3cs/PtvMl5vLSEloxxXjcrjupFwyU9uHunhKtXkuGdtt3o41xjzROqVqHdrGpoIiIozvm8b4vmms3rGffy3cyqwvtvDslz9w0age3HBqH/pm6HI5SoWJFPv7AGAs8J79/Dzgi5CUqAVpxqaaTUHZAf7z5VZeX76D6mO1/GhABtef3IeT+qUhokMFlGpNHqoi5wEXG2Mq7ecpwOvGmEmhKGNL0cCmml1ZVTUvfl3Ii18XUlZ1hIFdU7jupN78dER37WiiVCvxENjWA8ONMdX28wRglTFmYCjK2FI0sKkWc/hoDe+v2sUzX/7A+uJKOifGMXlMNleckEOvtKjrYaxUWPEQ2P4ATMaaUssAFwKvGWMeDEERW4wGNtXijDEs2bqH2UsKmbe2hFpjOL1/BleNz+G0/pk6o4lSLcDTemwiMgo4xX76hTFmReuWrOX5DGwi8ixwLlBqjBlqb+sCzAFygQJgsjFmn71vBnA91pIItxhj5trbRwPPAR2AD4FbjR9RVQNbdCkqP8QrS7fzytJt7K6splvH9lwyuieXjs7WLE6pZuTSKzLVGFPhNBlyA21uEmQRORWoAl5wCmx/AfYaYx4WkTuBzsaY6SIyGHgFOB7oDiwA+htjakRkKXAr8DVWYPubMeYjXwXUwBadjtbUMn9tCa8t384XG3dTa2Bcny5MHpPNWUO6kpygHXaVagqXwPY/Y8y5TpMhQ/3sI21zEmQRyQX+5xTYNgCnG2OKRKQb8LkxZoCdrWGMecg+bi5wL1ZW95mjgVJELrfPv9HXvTWwRb+i8kO89e1OXlu+ncI9B2kfF8OEQVn8dHh3Th+QQUI77XCiVKA8tLHNxurev8gYsz40JWt5wX4szjLGFAHYwS3T3t4DKyNz2GFvO2o/dt3ulohMBaYC9OrVK8giqkjRrWMHbv5RP355Wl/yt+3jvZW7+OC7Ij5YXURK+3ZMHNKViUO6ckpeuvaqVKpp/gucDPw/EekDrMAKck+GtljNq7nre9yu9eNlu1vGmFnALLAytuYpmgp3MTHC2NwujM3twt3nDearzWW8t2oXc78v5o38HXSIi+XU/umcNbgrPxqYSZek+FAXWamIYoz5VEQWYg3S/hHwC2AooIENKBGRbk5VkaX29h1AttNxPYFd9vaebrYr5VZcbAynD8jk9AGZHDlWyzc/7GHe9yXMW1vM3O9LEIFhPTpyal4Gp+SlMyqnM3G64rdSXonIJ0ASsARYBIw1xpR6PyvyBBvY3gOuAR62v7/rtP1lEXkCq/NIHrDU7jxSKSLjgG+Aq4H/16SSqzYjvl0Mp+RlcEpeBvf9dAird5azcMNuFm3azdMLt/D3zzaTnNCOUTmdOT63M2NyuzAiu5NWWyrV2GpgNFaWVg7sF5ElxphDoS1W8/KnV+QrwOlAOlAC3AO8A7wG9AK2AZc6uovaAwCvA44B0xw9H0VkDPXd/T8Cfq3d/VVTlR86ypItZSzaVMaygr1sLKkCIC5WGNqjI8f16MhQ+ysvM5l2mtWpNsLTODZ7XzJwLXA70NUYk9CqhWthOkBbRZX9B4+QX7iPpQV7WVG4n+93lXPgSA0ACe1iGNg1hQFdUxjQNbXucXpyVP1PKwV47BX5K6zB2aOBQup7SH4agiK2GB0spKJKp8R4JgzKYsKgLMBaIHVr2QHW7Cznu53lrCuq4JN1pby2vL6TbnpyPP2zUuifZQU663Gyri+nolEH4Akg3xhzLNSFaSmasak2aXdlNRuKK1lfXMHGkko2lFSxqaSSg3Z2B9C9Y3v6d01hgFPQ65eZrG13KiJ4q4qMdpqxqTYpIyWBjJQETs5Lr9tWW2vYuf8QG4or2VhaycZiK+At3ryHIzW1AMTGCLlpiQy0qzIHdUtlcPdUunVsr0vzKBUmNLApZYuJEbK7JJLdJZEzB2fVbT9WU0vBngOsL660s7xKvttZzgffFdUd0ykxjkFdrSA32A52/TKTdQiCUiGggU0pH9rFxtAvM4V+mSmce1z99qrqY6wvqmBdUQVriypYu6uCF78upPqYld3Fx8bQLzOZQd1SGdQtxf6eqgPLlWphGtiUClJyQjvG5HZhTG79hOmO7G5tUSVrd1kB74tNu3nz2/rOKpkpCQzsZlVlOnpm9stM1jkxlWomGtiUakbO2d1Ph3ev215WVc36okrWFVWwrriCDcWVPPdVw7a73ulJDOiawsCsFPrbQS+7cyIxul6dUgHRwKZUK0hPTuDkvIadVRzZ3boiq+1uQ0kl3+0o54PV9W13ifGx5GVZwW5A1xQGdkthYFetzlTKG+3ur1SYOVB9zBqCYHdUcQS9vQeO1B2TkZJQ1ytzQJYV8LQ6UznT7v5KqbCRlNCOkb06M7JX57ptxhh2V1lj7zYUV1pZXkkFzy0u4Mix+urMvhlJ1lAEu7PK4G6pZKYk6FAE1aZoYFMqAogImSntyUxpzyl5GXXbnYcirC+yBpznF+7jvVX1i2d0SYpnULcUBtu9Mgd3T6Vvhg5FUNFLA5tSEczTUITyQ0frhiKsK6pkXXEFzy8prMvu4mNjyMtKZkj3VIZ078iQ7lbQS0rQtwQV+fRVrFQU6tghjhP6pHFCn7S6bcdqavmh7ABriyr4fpcV9BY4zZspAr3TkhjUPbUu4A3ulkpGik4SrSKLBjal2oh2sTHkZaWQl5XC+SN6AFbbXXHFYdbusoLd97vKWbV9f4OemZkpCQ1mVBnULZXctCRidRiCClMa2JRqw0SEbh070K1jh7oVEcCqylxrBzrHrCpfbirjWK3Vi7pDXCwDuqbUBbrB3aylgJK1KlOFAe3ur5TyS/WxGjaVVLHWMY2YXZ1Zcbh+9ZOctEQGdbWC3cBuKQzqmkrPzh10kHkIaHd/pZTyIaFdbN1q5A7GWCsirHPMqlJUwfriSuauLcbxmTk5oZ29uGuKPY1YKgO6ptCxg653p1qGZmxKqWbnGGRuDUOoYJ393Tm769axfV3AG5Clc2Y2N83YlFKqGXkaZF5ccbh++Z+iCo/r3Q3omkJeZv2K5rlpibTTcXfKTxrYlFKtwrmjyo8GZNZtP1pTS6HTencbS6yZVT5aU1+dGRcr9ElPJi8rmf5ZKfTPSiYvK4WcLhrwVGMa2JRSIRXnYZD54aM1bC6tYmNJJRtLqthUUsmqHfv5n9NQhPjYGPpkJNEvM5m8zBTyspLJy0wmJy2J+HYa8NoqDWxKqbDUPq5xZxWw2u82l1axqbSKTaWVbCqpYuX2hgGvXYyQk5ZIv8zkuqDXLzOZPhlJJMbr216007+wUiqiJCW0Y3h2J4Znd2qw/eCRY2zdfcAOelbA21RaxYJ1pdTU1neS69GpA/0yk+mbkVwX+PplJutSQFFEA5tSKiokxrdzm+EdOWa14TmyvC27q9hcWsU3P+zh8NHauuM6J8bVBbu+Gcn0zUyiX0YKPTp30FlWIowGNqVUVItvVz+V2NlO22trrTF4m3dX1WV6W3ZXMX9tCa8e2N7g/D7pSfTJSKJ3ehJ90pPpnZFEn/QkOiVqlheONLAppdqkmBghu0si2V0S+dGAhvv2HTjC1rIqO9hZQW9dUSVzvy9pUK3ZsUMcuWmJ5KQlkZuWSK+0JLI7dyC7SyJZqe010wsRDWxKKeWic1I8o5O6MDqnS4PtR2tq2b73ID+UHWDr7gMU7j1A4Z6DdueVXTjFPOJihR6dOtCzcyI9OnWge6cO9Ojcge6d2tO9Ywe6dmxP+zgdjN4SNLAppZSf4mJj6JORTJ+MZCYMarjvyLFadu0/xPZ9B9m29yDb91qPd+47xKcbStldWd3oeh07xNE1tT1ZHduTmZJQ/5XanoyUBEZkd9IFYYOggU0ppZpBfLsYctOTyE1Pcru/+lgNRfsPs3P/IYrLD1Nccbjue0nFYTYWV1JWVV23ggLA+gcmoUld4DSwKaVUK0hoF+s18IHVoWXfwSOUVlZTVlWtVZVB0sCmlFJhIiZGSEtOIC1ZVy1vCq28VUopFVU0sCmllIoqYb8em4jsBgqDPD0dKGvG4rQmLXvri9Ryg5Y9VMK57DnGmIxQFyIUwj6wNYWILI/Uhfa07K0vUssNWvZQieSyRzOtilRKKRVVNLAppZSKKtEe2GaFugBNoGVvfZFabtCyh0oklz1qRXUbm1JKqbYn2jM2pZRSbUxUBjYRmSQiG0Rks4jcGeryuBKRbBH5TETWicj3InKrvb2LiMwXkU32985O58ywf54NIjIxdKUHEYkVkRUi8j/7eUSU2y5PJxF5Q0TW27//8ZFQfhH5jf1aWSMir4hI+3Att4g8KyKlIrLGaVvAZRWR0SLynb3vbyLS4mvAeCj7o/brZbWIvC0incKx7MqJMSaqvoBYYAvQB4gHVgGDQ10ulzJ2A0bZj1OAjcBg4C/Anfb2O4FH7MeD7Z8jAeht/3yxISz/bcDLwP/s5xFRbrtMzwP/Zz+OBzqFe/mBHsAPQAf7+WvAlHAtN3AqMApY47Qt4LICS4HxgAAfAWeHqOxnAe3sx4+Ea9n1q/4rGjO244HNxpitxpgjwKvA+SEuUwPGmCJjzLf240pgHdab1/lYb7zY3y+wH58PvGqMqTbG/ABsxvo5W52I9AR+AvzHaXPYlxtARFKx3rieATDGHDHG7Ccyyt8O6CAi7YBEYBdhWm5jzBfAXpfNAZVVRLoBqcaYJcaKFC84ndOqZTfGzDPGHLOffg30DMeyq3rRGNh6ANudnu+wt4UlEckFRgLfAFnGmCKwgh+QaR8WTj/TTOB3QK3TtkgoN1hZ/G7gv3ZV6n9EJIkwL78xZifwGLANKALKjTHzCPNyuwi0rD3sx67bQ+06rAwMIq/sbUY0BjZ3ddlh2fVTRJKBN4FpxpgKb4e62dbqP5OInAuUGmPy/T3FzbZQ/i3aYVUzPW2MGQkcwKoW8yQsym+3R52PVd3VHUgSkSu9neJmW1j+D+C5rGH3M4jIH4BjwEuOTW4OC8uytzXRGNh2ANlOz3tiVduEFRGJwwpqLxlj3rI3l9jVGNjfS+3t4fIznQT8VEQKsKp4zxCRFwn/cjvsAHYYY76xn7+BFejCvfxnAj8YY3YbY44CbwEnEv7ldhZoWXdQX+XnvD0kROQa4FzgCrt6ESKk7G1RNAa2ZUCeiPQWkXjgMuC9EJepAbuH1DPAOmPME0673gOusR9fA7zrtP0yEUkQkd5AHlbjdKsyxswwxvQ0xuRi/V4/NcZcSZiX28EYUwxsF5EB9qYJwFrCv/zbgHEikmi/diZgtcuGe7mdBVRWu7qyUkTG2T/z1U7ntCoRmQRMB35qjDnotCvsy95mhbr3Skt8Aedg9TTcAvwh1OVxU76TsaomVgMr7a9zgDTgE2CT/b2L0zl/sH+eDYRBDyvgdOp7RUZSuUcAy+3f/TtA50goP3AfsB5YA8zG6okXluUGXsFqCzyKlb1cH0xZgTH2z7sF+Dv2hBIhKPtmrLY0x//qP8Ox7PpV/6UzjyillIoq0VgVqZRSqg3TwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkUVDWwqJEQk13kGdZd994vImfbjz0VkjP24QETSvVyz7tiWICJTROTvLXTd7k7Pvf6cTufsFpH/eDvOzXmPikixiNwebHmVCnftQl0ApVwZY+4OdRla2RSsMU+Bzk4xxxjzq0BOMMbcISIHAryPUhFFMzYVSrEi8m+x1hmbJyIdAETkORG5xNNJIpIkIh+IyCqx1if7mZtjLrfXw1ojIo84ba8SkcdF5FsR+UREMuztfUXkYxHJF5FFIjLQW8FFJENE3hSRZfbXSfb2e8Va0+tzEdkqIrc4nXOXWOt6zRdrTbXb7Z9zDPCSiKx0/A6AX9tl/M5XWexrTxGRd0TkfRH5QUR+JSK32ZM9fy0iXXxdQ6looYFNhVIe8A9jzBBgP3Cxn+dNAnYZY4YbY4YCHzvvtKv1HgHOwJppZKyIXGDvTgK+NcaMAhYC99jbZwG/NsaMBm4HnvJRhieBvxpjxtrldq4SHAhMxFoq5h4RibOrSC/GWsnhIqxghjHmDayZUK4wxowwxhyyr1Fml/Fpuzz+GAr83L7vn4GDxprseQnWtE5KtQlaFalC6QdjzEr7cT6Q6+d53wGP2ZnY/4wxi1z2jwU+N8bsBhCRl7DWYXsHa7mdOfZxLwJvibXKwonA61K/0HGCjzKcCQx2Oj5VRFLsxx8YY6qBahEpBbKwplF71xG4ROR9H9d3TIydjxUI/fGZsdb3qxSRcsBxj++A4/y8hlIRTwObCqVqp8c1QAdPBzozxmwUkdFY82s+JCLzjDH3Ox3ibtkQj5fDqrnYb4wZEcB5McB4pwzLurEV6Fx/rnYBlsn5Go7zAzkHrABe7fRY/9dVm6FVkSri2FWNB40xL2ItwDnK5ZBvgNNEJF1EYoHLsaodwXrNO9rvfg58aay18H4QkUvt64uIDPdRjHlAXccNERnh4/gvgfNEpL2dIf7EaV8lkOL+NKVUoPRTnIpEw4BHRaQWaxb2XzrvNMYUicgM4DOsTOlDY4xj2ZADwBARyQfKAUfHkyuAp0Xkj0Ac1npzq7yU4RbgHyKyGuv/6AvgF54ONsYsE5H37GsWYrWrldu7nwP+KSKHgPG+f3yllDc6u79qU0SkyhiTHKJ7JxtjqkQkESsQTjXGfBvktaYAYwLt7m+fey9QZYx5LJh7KxXutCpSqdYzS0RWAt8CbwYb1GyHgLODGaANXImVuSoVlTRjU0opFVU0Y1NKKRVVNLAppZSKKhrYlFJKRRUNbEoppaKKBjallFJRRQObUkqpqPL/AfFvRikpvoLtAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,8))\n", + "plt.tight_layout()\n", + "gs = gridspec.GridSpec(4,1)\n", + "axs = [fig.add_subplot(gs[2,0]), fig.add_subplot(gs[3,0])]\n", + "plot.plot(hillslope_demo_pars, mesh_demo_pars, fig=fig, axs=axs)\n", + "\n", + "ax0 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[0,:])\n", + "workflow.plot.raster(hillslope_demo_pars['raster_profile'], hillslope_demo_pars['bins'],\n", + " ax=ax0, cmap='prism')\n", + "subcatch = hillslope_demo_pars['subcatchment']\n", + "workflow.plot.shply(subcatch, native_crs, ax=ax0, color='k')\n", + "ax0.set_title(f'subcatchment {subcatch_demo_id}')\n", + "\n", + "ax1 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[1,:])\n", + "vmin, vmax = min(hillslope_demo_pars['land_cover']), max(hillslope_demo_pars['land_cover'])\n", + "cmap = plt.get_cmap(('viridis'),vmax-vmin+1)\n", + "lc = workflow.plot.raster(hillslope_demo_pars['raster_profile'],\n", + " hillslope_demo_pars['land_cover_raster'], \n", + " ax=ax1, vmin=vmin-0.5, vmax=vmax+0.5, cmap=cmap)\n", + "workflow.plot.shply(subcatch, native_crs, ax=ax1, color='k')\n", + "position=fig.add_axes([0.95, 0.55, 0.02,0.1])\n", + "\n", + "fig.colorbar(lc,ticks=np.arange(vmin,vmax+1),cax=position)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1f4cb183", + "metadata": {}, + "source": [ + "## Get parameters for all hillslopes" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "44f418ed", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:53,812 - root - INFO: \n", + "2021-09-20 23:15:53,813 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:53,814 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:53,815 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:53,822 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:53,823 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:53,881 - root - INFO: \n", + "2021-09-20 23:15:53,881 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:53,882 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:53,882 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:53,883 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:53,926 - root - INFO: ... got raster of shape: (69, 322)\n", + "2021-09-20 23:15:53,936 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:53,966 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "2021-09-20 23:15:53,968 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:53,968 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", + "2021-09-20 23:15:53,972 - root - INFO: \n", + "2021-09-20 23:15:53,972 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:53,973 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:53,973 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:53,974 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:54,017 - root - INFO: ... got raster of shape: (69, 322)\n", + "2021-09-20 23:15:54,025 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:54,055 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "2021-09-20 23:15:54,057 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:54,058 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", + "2021-09-20 23:15:54,061 - root - INFO: \n", + "2021-09-20 23:15:54,062 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:54,062 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,062 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:54,063 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:54,105 - root - INFO: ... got raster of shape: (69, 322)\n", + "2021-09-20 23:15:54,115 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "bounds in my_crs: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "bounds in my_crs: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:54,145 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "2021-09-20 23:15:54,147 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:54,148 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", + "2021-09-20 23:15:54,152 - root - INFO: \n", + "2021-09-20 23:15:54,152 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:54,153 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,153 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:54,154 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:54,197 - root - INFO: ... got raster of shape: (69, 322)\n", + "2021-09-20 23:15:54,205 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:54,235 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "2021-09-20 23:15:54,237 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:54,238 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", + "2021-09-20 23:15:54,255 - root - INFO: \n", + "2021-09-20 23:15:54,255 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:54,256 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,256 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:54,263 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:54,264 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:54,316 - root - INFO: \n", + "2021-09-20 23:15:54,317 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:54,317 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,317 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:54,318 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:54,362 - root - INFO: ... got raster of shape: (64, 331)\n", + "2021-09-20 23:15:54,372 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "bounds in my_crs: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:54,402 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "2021-09-20 23:15:54,405 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:54,406 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", + "2021-09-20 23:15:54,410 - root - INFO: \n", + "2021-09-20 23:15:54,411 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:54,411 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,411 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:54,412 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:54,461 - root - INFO: ... got raster of shape: (64, 331)\n", + "2021-09-20 23:15:54,471 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:54,502 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "2021-09-20 23:15:54,504 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:54,505 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", + "2021-09-20 23:15:54,508 - root - INFO: \n", + "2021-09-20 23:15:54,509 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:54,509 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,510 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:54,511 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:54,555 - root - INFO: ... got raster of shape: (64, 331)\n", + "2021-09-20 23:15:54,563 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:54,593 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "2021-09-20 23:15:54,595 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:54,596 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", + "2021-09-20 23:15:54,600 - root - INFO: \n", + "2021-09-20 23:15:54,601 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:54,601 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,602 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:54,603 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:54,646 - root - INFO: ... got raster of shape: (64, 331)\n", + "2021-09-20 23:15:54,656 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "bounds in my_crs: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "bounds in my_crs: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:54,687 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "2021-09-20 23:15:54,688 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:54,689 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", + "2021-09-20 23:15:54,708 - root - INFO: \n", + "2021-09-20 23:15:54,708 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:54,709 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,710 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:54,715 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:54,715 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:54,769 - root - INFO: \n", + "2021-09-20 23:15:54,770 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:54,770 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,771 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:54,773 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:54,816 - root - INFO: ... got raster of shape: (97, 237)\n", + "2021-09-20 23:15:54,825 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:54,856 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "2021-09-20 23:15:54,858 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:54,859 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", + "2021-09-20 23:15:54,862 - root - INFO: \n", + "2021-09-20 23:15:54,863 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:54,863 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,864 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:54,865 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:54,908 - root - INFO: ... got raster of shape: (97, 237)\n", + "2021-09-20 23:15:54,918 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:54,951 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "2021-09-20 23:15:54,952 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:54,953 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", + "2021-09-20 23:15:54,957 - root - INFO: \n", + "2021-09-20 23:15:54,957 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:54,958 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:54,958 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:54,960 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:55,005 - root - INFO: ... got raster of shape: (97, 237)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "bounds in my_crs: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "bounds in my_crs: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:55,016 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:55,059 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "2021-09-20 23:15:55,062 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:55,063 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", + "2021-09-20 23:15:55,070 - root - INFO: \n", + "2021-09-20 23:15:55,071 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:55,072 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,073 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:55,075 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:55,125 - root - INFO: ... got raster of shape: (97, 237)\n", + "2021-09-20 23:15:55,134 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:55,166 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "2021-09-20 23:15:55,168 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:55,169 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", + "2021-09-20 23:15:55,185 - root - INFO: \n", + "2021-09-20 23:15:55,186 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:55,187 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,187 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:55,192 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:55,193 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:55,249 - root - INFO: \n", + "2021-09-20 23:15:55,250 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:55,250 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,251 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:55,252 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:55,295 - root - INFO: ... got raster of shape: (59, 233)\n", + "2021-09-20 23:15:55,303 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "bounds in my_crs: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:55,335 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "2021-09-20 23:15:55,337 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:55,338 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", + "2021-09-20 23:15:55,341 - root - INFO: \n", + "2021-09-20 23:15:55,342 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:55,342 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,343 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:55,344 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:55,388 - root - INFO: ... got raster of shape: (59, 233)\n", + "2021-09-20 23:15:55,396 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:55,427 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "2021-09-20 23:15:55,429 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:55,430 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", + "2021-09-20 23:15:55,433 - root - INFO: \n", + "2021-09-20 23:15:55,434 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:55,434 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,434 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:55,436 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:55,478 - root - INFO: ... got raster of shape: (59, 233)\n", + "2021-09-20 23:15:55,488 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:55,519 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "2021-09-20 23:15:55,521 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:55,521 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", + "2021-09-20 23:15:55,524 - root - INFO: \n", + "2021-09-20 23:15:55,525 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:55,525 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,525 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:55,527 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:55,569 - root - INFO: ... got raster of shape: (59, 233)\n", + "2021-09-20 23:15:55,579 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "bounds in my_crs: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "bounds in my_crs: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:55,614 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "2021-09-20 23:15:55,616 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:55,617 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", + "2021-09-20 23:15:55,633 - root - INFO: \n", + "2021-09-20 23:15:55,634 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:55,634 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,635 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:55,639 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:55,640 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:55,696 - root - INFO: \n", + "2021-09-20 23:15:55,697 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:55,698 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,698 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:55,699 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:55,743 - root - INFO: ... got raster of shape: (98, 377)\n", + "2021-09-20 23:15:55,752 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:55,785 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "2021-09-20 23:15:55,787 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:55,788 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", + "2021-09-20 23:15:55,792 - root - INFO: \n", + "2021-09-20 23:15:55,792 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:55,793 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,793 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:55,795 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:55,837 - root - INFO: ... got raster of shape: (98, 377)\n", + "2021-09-20 23:15:55,845 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:55,875 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "2021-09-20 23:15:55,878 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:55,879 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", + "2021-09-20 23:15:55,883 - root - INFO: \n", + "2021-09-20 23:15:55,884 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:55,884 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,885 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:55,886 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:55,928 - root - INFO: ... got raster of shape: (98, 377)\n", + "2021-09-20 23:15:55,937 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "bounds in my_crs: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "bounds in my_crs: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:55,966 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "2021-09-20 23:15:55,969 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:55,970 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", + "2021-09-20 23:15:55,975 - root - INFO: \n", + "2021-09-20 23:15:55,976 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:55,976 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:55,977 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:55,978 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:56,021 - root - INFO: ... got raster of shape: (98, 377)\n", + "2021-09-20 23:15:56,030 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:56,059 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "2021-09-20 23:15:56,061 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:56,062 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", + "2021-09-20 23:15:56,082 - root - INFO: \n", + "2021-09-20 23:15:56,082 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:56,083 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,084 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:56,089 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:56,090 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:56,141 - root - INFO: \n", + "2021-09-20 23:15:56,142 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:56,143 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,143 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:56,144 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:56,186 - root - INFO: ... got raster of shape: (46, 147)\n", + "2021-09-20 23:15:56,195 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "bounds in my_crs: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:56,225 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "2021-09-20 23:15:56,227 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:56,228 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", + "2021-09-20 23:15:56,231 - root - INFO: \n", + "2021-09-20 23:15:56,232 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:56,232 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,232 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:56,233 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:56,274 - root - INFO: ... got raster of shape: (46, 147)\n", + "2021-09-20 23:15:56,283 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:56,315 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "2021-09-20 23:15:56,316 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:56,317 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", + "2021-09-20 23:15:56,320 - root - INFO: \n", + "2021-09-20 23:15:56,320 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:56,320 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,321 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:56,321 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:56,361 - root - INFO: ... got raster of shape: (46, 147)\n", + "2021-09-20 23:15:56,369 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:56,398 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "2021-09-20 23:15:56,400 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:56,401 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", + "2021-09-20 23:15:56,402 - root - INFO: \n", + "2021-09-20 23:15:56,403 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:56,403 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,404 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:56,404 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:56,445 - root - INFO: ... got raster of shape: (46, 147)\n", + "2021-09-20 23:15:56,453 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "bounds in my_crs: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "bounds in my_crs: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:56,482 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "2021-09-20 23:15:56,484 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:56,485 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", + "2021-09-20 23:15:56,500 - root - INFO: \n", + "2021-09-20 23:15:56,501 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:56,502 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,502 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:56,507 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:56,508 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:56,562 - root - INFO: \n", + "2021-09-20 23:15:56,563 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:56,563 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,564 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:56,567 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:56,608 - root - INFO: ... got raster of shape: (96, 194)\n", + "2021-09-20 23:15:56,617 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:56,647 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "2021-09-20 23:15:56,649 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:56,650 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", + "2021-09-20 23:15:56,654 - root - INFO: \n", + "2021-09-20 23:15:56,655 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:56,655 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,656 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:56,658 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:56,701 - root - INFO: ... got raster of shape: (96, 194)\n", + "2021-09-20 23:15:56,710 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:56,741 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "2021-09-20 23:15:56,743 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:56,744 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", + "2021-09-20 23:15:56,747 - root - INFO: \n", + "2021-09-20 23:15:56,748 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:56,748 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,749 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:56,751 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:56,791 - root - INFO: ... got raster of shape: (96, 194)\n", + "2021-09-20 23:15:56,800 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "bounds in my_crs: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "bounds in my_crs: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:56,831 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "2021-09-20 23:15:56,833 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:56,833 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", + "2021-09-20 23:15:56,837 - root - INFO: \n", + "2021-09-20 23:15:56,837 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:56,838 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,838 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:56,840 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:56,881 - root - INFO: ... got raster of shape: (96, 194)\n", + "2021-09-20 23:15:56,890 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:56,920 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "2021-09-20 23:15:56,922 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:56,923 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", + "2021-09-20 23:15:56,939 - root - INFO: \n", + "2021-09-20 23:15:56,940 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:56,940 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:56,940 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:56,945 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:56,946 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:56,999 - root - INFO: \n", + "2021-09-20 23:15:57,000 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,001 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,001 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:57,002 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:57,049 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-20 23:15:57,058 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:57,089 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:15:57,091 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:57,092 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-20 23:15:57,095 - root - INFO: \n", + "2021-09-20 23:15:57,095 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,096 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,096 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:57,097 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:57,140 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-20 23:15:57,149 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:57,181 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:15:57,184 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:57,185 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-20 23:15:57,187 - root - INFO: \n", + "2021-09-20 23:15:57,188 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,188 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,188 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:57,189 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:57,231 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-20 23:15:57,240 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:57,272 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:15:57,274 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:57,275 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-20 23:15:57,277 - root - INFO: \n", + "2021-09-20 23:15:57,277 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,278 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,278 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:57,279 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:57,321 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-20 23:15:57,330 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:57,361 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:15:57,363 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:57,364 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-20 23:15:57,379 - root - INFO: \n", + "2021-09-20 23:15:57,380 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:57,381 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,381 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:57,386 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:57,387 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:57,445 - root - INFO: \n", + "2021-09-20 23:15:57,446 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,446 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,447 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:57,448 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:57,490 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-20 23:15:57,499 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:57,531 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "2021-09-20 23:15:57,533 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:57,533 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-20 23:15:57,535 - root - INFO: \n", + "2021-09-20 23:15:57,535 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,536 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,536 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:57,537 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:57,578 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-20 23:15:57,587 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:57,617 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "2021-09-20 23:15:57,619 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:57,619 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-20 23:15:57,620 - root - INFO: \n", + "2021-09-20 23:15:57,621 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,621 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,622 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:57,623 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:57,665 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-20 23:15:57,674 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "bounds in my_crs: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "bounds in my_crs: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:57,704 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "2021-09-20 23:15:57,706 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:57,706 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-20 23:15:57,707 - root - INFO: \n", + "2021-09-20 23:15:57,708 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,708 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,709 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:57,709 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:57,751 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-20 23:15:57,759 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:57,791 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "2021-09-20 23:15:57,792 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:57,793 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-20 23:15:57,806 - root - INFO: \n", + "2021-09-20 23:15:57,806 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:57,807 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,807 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:57,811 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:57,812 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:57,872 - root - INFO: \n", + "2021-09-20 23:15:57,873 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,874 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,875 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:57,875 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:57,918 - root - INFO: ... got raster of shape: (19, 30)\n", + "2021-09-20 23:15:57,928 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "bounds in my_crs: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:57,958 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "2021-09-20 23:15:57,960 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:57,961 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-20 23:15:57,962 - root - INFO: \n", + "2021-09-20 23:15:57,963 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:57,963 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:57,963 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:57,964 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,006 - root - INFO: ... got raster of shape: (19, 30)\n", + "2021-09-20 23:15:58,015 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:58,044 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "2021-09-20 23:15:58,046 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:58,047 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-20 23:15:58,048 - root - INFO: \n", + "2021-09-20 23:15:58,048 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:58,048 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,049 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:58,050 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,090 - root - INFO: ... got raster of shape: (19, 30)\n", + "2021-09-20 23:15:58,099 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:58,129 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "2021-09-20 23:15:58,131 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:58,132 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-20 23:15:58,132 - root - INFO: \n", + "2021-09-20 23:15:58,133 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:58,133 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,134 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:58,134 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,176 - root - INFO: ... got raster of shape: (19, 30)\n", + "2021-09-20 23:15:58,184 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "bounds in my_crs: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "bounds in my_crs: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:58,215 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "2021-09-20 23:15:58,217 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:58,218 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-20 23:15:58,229 - root - INFO: \n", + "2021-09-20 23:15:58,229 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:58,230 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,230 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:58,234 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:58,235 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:58,298 - root - INFO: \n", + "2021-09-20 23:15:58,299 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:58,299 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,299 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:58,300 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,342 - root - INFO: ... got raster of shape: (117, 192)\n", + "2021-09-20 23:15:58,351 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:58,382 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "2021-09-20 23:15:58,384 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:58,385 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", + "2021-09-20 23:15:58,392 - root - INFO: \n", + "2021-09-20 23:15:58,393 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:58,393 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,394 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:58,395 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,436 - root - INFO: ... got raster of shape: (117, 192)\n", + "2021-09-20 23:15:58,445 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:58,476 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "2021-09-20 23:15:58,478 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:58,480 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", + "2021-09-20 23:15:58,484 - root - INFO: \n", + "2021-09-20 23:15:58,485 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:58,485 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,486 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:58,487 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,528 - root - INFO: ... got raster of shape: (117, 192)\n", + "2021-09-20 23:15:58,537 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "bounds in my_crs: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "bounds in my_crs: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:58,568 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "2021-09-20 23:15:58,571 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:58,571 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", + "2021-09-20 23:15:58,576 - root - INFO: \n", + "2021-09-20 23:15:58,576 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:58,577 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,577 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:58,578 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,621 - root - INFO: ... got raster of shape: (117, 192)\n", + "2021-09-20 23:15:58,631 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:58,663 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "2021-09-20 23:15:58,666 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:58,666 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", + "2021-09-20 23:15:58,685 - root - INFO: \n", + "2021-09-20 23:15:58,686 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:58,686 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,687 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:58,692 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:58,692 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:58,747 - root - INFO: \n", + "2021-09-20 23:15:58,747 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:58,748 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,749 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:58,749 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,792 - root - INFO: ... got raster of shape: (95, 128)\n", + "2021-09-20 23:15:58,801 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "bounds in my_crs: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:58,832 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "2021-09-20 23:15:58,834 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:58,834 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", + "2021-09-20 23:15:58,838 - root - INFO: \n", + "2021-09-20 23:15:58,839 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:58,839 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,840 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:58,840 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,883 - root - INFO: ... got raster of shape: (95, 128)\n", + "2021-09-20 23:15:58,891 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:58,922 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "2021-09-20 23:15:58,923 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:58,924 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", + "2021-09-20 23:15:58,928 - root - INFO: \n", + "2021-09-20 23:15:58,929 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:58,929 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:58,929 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:58,930 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:58,974 - root - INFO: ... got raster of shape: (95, 128)\n", + "2021-09-20 23:15:58,983 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:59,013 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "2021-09-20 23:15:59,015 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:59,016 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", + "2021-09-20 23:15:59,019 - root - INFO: \n", + "2021-09-20 23:15:59,019 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:59,020 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,020 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:59,021 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:59,063 - root - INFO: ... got raster of shape: (95, 128)\n", + "2021-09-20 23:15:59,073 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "bounds in my_crs: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "bounds in my_crs: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:59,103 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "2021-09-20 23:15:59,106 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:59,107 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", + "2021-09-20 23:15:59,125 - root - INFO: \n", + "2021-09-20 23:15:59,126 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:59,126 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,127 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:59,132 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:59,132 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:59,183 - root - INFO: \n", + "2021-09-20 23:15:59,184 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:59,185 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,185 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:59,186 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:59,228 - root - INFO: ... got raster of shape: (99, 206)\n", + "2021-09-20 23:15:59,237 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:59,266 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "2021-09-20 23:15:59,268 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:59,269 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", + "2021-09-20 23:15:59,272 - root - INFO: \n", + "2021-09-20 23:15:59,273 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:59,273 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,274 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:59,275 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:59,315 - root - INFO: ... got raster of shape: (99, 206)\n", + "2021-09-20 23:15:59,323 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:59,352 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "2021-09-20 23:15:59,354 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:59,355 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", + "2021-09-20 23:15:59,358 - root - INFO: \n", + "2021-09-20 23:15:59,359 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:59,359 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,360 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:59,360 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:59,401 - root - INFO: ... got raster of shape: (99, 206)\n", + "2021-09-20 23:15:59,411 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "bounds in my_crs: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "bounds in my_crs: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:59,441 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "2021-09-20 23:15:59,443 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:59,444 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", + "2021-09-20 23:15:59,448 - root - INFO: \n", + "2021-09-20 23:15:59,448 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:59,449 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,449 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:59,450 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:59,491 - root - INFO: ... got raster of shape: (99, 206)\n", + "2021-09-20 23:15:59,501 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:59,532 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "2021-09-20 23:15:59,534 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:59,535 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", + "2021-09-20 23:15:59,554 - root - INFO: \n", + "2021-09-20 23:15:59,555 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:59,555 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,555 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:59,560 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:59,561 - root - INFO: Converting to shapely\n", + "2021-09-20 23:15:59,614 - root - INFO: \n", + "2021-09-20 23:15:59,614 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:59,615 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,616 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:15:59,617 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:59,658 - root - INFO: ... got raster of shape: (68, 215)\n", + "2021-09-20 23:15:59,667 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "bounds in my_crs: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:59,701 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "2021-09-20 23:15:59,702 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:15:59,703 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", + "2021-09-20 23:15:59,707 - root - INFO: \n", + "2021-09-20 23:15:59,707 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:59,707 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,708 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:15:59,708 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:59,749 - root - INFO: ... got raster of shape: (68, 215)\n", + "2021-09-20 23:15:59,759 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:59,791 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "2021-09-20 23:15:59,793 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:15:59,794 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", + "2021-09-20 23:15:59,797 - root - INFO: \n", + "2021-09-20 23:15:59,798 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:59,798 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,798 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:15:59,799 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:59,842 - root - INFO: ... got raster of shape: (68, 215)\n", + "2021-09-20 23:15:59,851 - root - INFO: Masking to shape\n", + "2021-09-20 23:15:59,883 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "2021-09-20 23:15:59,885 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:15:59,885 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", + "2021-09-20 23:15:59,888 - root - INFO: \n", + "2021-09-20 23:15:59,889 - root - INFO: Loading Raster\n", + "2021-09-20 23:15:59,889 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,890 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:15:59,891 - root - INFO: Collecting raster\n", + "2021-09-20 23:15:59,931 - root - INFO: ... got raster of shape: (68, 215)\n", + "2021-09-20 23:15:59,940 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "bounds in my_crs: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "bounds in my_crs: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:15:59,972 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "2021-09-20 23:15:59,974 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:15:59,975 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", + "2021-09-20 23:15:59,993 - root - INFO: \n", + "2021-09-20 23:15:59,994 - root - INFO: Loading shapes\n", + "2021-09-20 23:15:59,994 - root - INFO: ------------------------------\n", + "2021-09-20 23:15:59,994 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:15:59,999 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:15:59,999 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:00,051 - root - INFO: \n", + "2021-09-20 23:16:00,052 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:00,052 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,053 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:00,054 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:00,096 - root - INFO: ... got raster of shape: (86, 196)\n", + "2021-09-20 23:16:00,105 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:00,136 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "2021-09-20 23:16:00,138 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:00,139 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", + "2021-09-20 23:16:00,142 - root - INFO: \n", + "2021-09-20 23:16:00,143 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:00,143 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,144 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:00,145 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:00,188 - root - INFO: ... got raster of shape: (86, 196)\n", + "2021-09-20 23:16:00,197 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:00,228 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "2021-09-20 23:16:00,230 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:00,231 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", + "2021-09-20 23:16:00,235 - root - INFO: \n", + "2021-09-20 23:16:00,236 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:00,236 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,236 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:00,237 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:00,279 - root - INFO: ... got raster of shape: (86, 196)\n", + "2021-09-20 23:16:00,288 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "bounds in my_crs: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "bounds in my_crs: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:00,318 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "2021-09-20 23:16:00,320 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:00,321 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", + "2021-09-20 23:16:00,325 - root - INFO: \n", + "2021-09-20 23:16:00,325 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:00,326 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,326 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:00,327 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:00,367 - root - INFO: ... got raster of shape: (86, 196)\n", + "2021-09-20 23:16:00,376 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:00,406 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "2021-09-20 23:16:00,408 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:00,409 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", + "2021-09-20 23:16:00,427 - root - INFO: \n", + "2021-09-20 23:16:00,428 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:00,428 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,429 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:00,433 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:00,434 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:00,487 - root - INFO: \n", + "2021-09-20 23:16:00,488 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:00,489 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,489 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:00,490 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:00,532 - root - INFO: ... got raster of shape: (69, 203)\n", + "2021-09-20 23:16:00,540 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "bounds in my_crs: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:00,570 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "2021-09-20 23:16:00,572 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:00,574 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", + "2021-09-20 23:16:00,576 - root - INFO: \n", + "2021-09-20 23:16:00,577 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:00,577 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,578 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:00,578 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:00,619 - root - INFO: ... got raster of shape: (69, 203)\n", + "2021-09-20 23:16:00,628 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:00,659 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "2021-09-20 23:16:00,661 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:00,663 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", + "2021-09-20 23:16:00,666 - root - INFO: \n", + "2021-09-20 23:16:00,666 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:00,666 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,667 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:00,667 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:00,706 - root - INFO: ... got raster of shape: (69, 203)\n", + "2021-09-20 23:16:00,715 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:00,745 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "2021-09-20 23:16:00,747 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:00,748 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", + "2021-09-20 23:16:00,750 - root - INFO: \n", + "2021-09-20 23:16:00,751 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:00,751 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,751 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:00,752 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:00,794 - root - INFO: ... got raster of shape: (69, 203)\n", + "2021-09-20 23:16:00,803 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "bounds in my_crs: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "bounds in my_crs: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:00,833 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "2021-09-20 23:16:00,835 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:00,836 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", + "2021-09-20 23:16:00,853 - root - INFO: \n", + "2021-09-20 23:16:00,854 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:00,854 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,854 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:00,859 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:00,860 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:00,914 - root - INFO: \n", + "2021-09-20 23:16:00,915 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:00,915 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:00,916 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:00,917 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:00,958 - root - INFO: ... got raster of shape: (89, 263)\n", + "2021-09-20 23:16:00,967 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:00,999 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "2021-09-20 23:16:01,001 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:01,002 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", + "2021-09-20 23:16:01,006 - root - INFO: \n", + "2021-09-20 23:16:01,007 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,007 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,008 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:01,009 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:01,053 - root - INFO: ... got raster of shape: (89, 263)\n", + "2021-09-20 23:16:01,064 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:01,095 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "2021-09-20 23:16:01,097 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:01,098 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", + "2021-09-20 23:16:01,101 - root - INFO: \n", + "2021-09-20 23:16:01,102 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,102 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,102 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:01,103 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:01,145 - root - INFO: ... got raster of shape: (89, 263)\n", + "2021-09-20 23:16:01,153 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "bounds in my_crs: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "bounds in my_crs: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:01,184 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "2021-09-20 23:16:01,186 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:01,187 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", + "2021-09-20 23:16:01,191 - root - INFO: \n", + "2021-09-20 23:16:01,191 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,192 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,192 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:01,193 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:01,237 - root - INFO: ... got raster of shape: (89, 263)\n", + "2021-09-20 23:16:01,247 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:01,279 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "2021-09-20 23:16:01,281 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:01,281 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", + "2021-09-20 23:16:01,300 - root - INFO: \n", + "2021-09-20 23:16:01,300 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:01,301 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,301 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:01,305 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:01,306 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:01,360 - root - INFO: \n", + "2021-09-20 23:16:01,361 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,361 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,362 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:01,363 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:01,406 - root - INFO: ... got raster of shape: (100, 191)\n", + "2021-09-20 23:16:01,415 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "bounds in my_crs: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:01,445 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "2021-09-20 23:16:01,448 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:01,448 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", + "2021-09-20 23:16:01,452 - root - INFO: \n", + "2021-09-20 23:16:01,452 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,453 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,453 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:01,454 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:01,497 - root - INFO: ... got raster of shape: (100, 191)\n", + "2021-09-20 23:16:01,506 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:01,537 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "2021-09-20 23:16:01,539 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:01,539 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", + "2021-09-20 23:16:01,543 - root - INFO: \n", + "2021-09-20 23:16:01,543 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,544 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,544 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:01,545 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:01,587 - root - INFO: ... got raster of shape: (100, 191)\n", + "2021-09-20 23:16:01,596 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:01,626 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "2021-09-20 23:16:01,628 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:01,629 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", + "2021-09-20 23:16:01,631 - root - INFO: \n", + "2021-09-20 23:16:01,632 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,632 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,633 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:01,634 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:01,676 - root - INFO: ... got raster of shape: (100, 191)\n", + "2021-09-20 23:16:01,685 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "bounds in my_crs: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "bounds in my_crs: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:01,716 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "2021-09-20 23:16:01,718 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:01,718 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", + "2021-09-20 23:16:01,736 - root - INFO: \n", + "2021-09-20 23:16:01,737 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:01,737 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,738 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:01,743 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:01,744 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:01,795 - root - INFO: \n", + "2021-09-20 23:16:01,796 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,797 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,797 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:01,798 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:01,841 - root - INFO: ... got raster of shape: (92, 198)\n", + "2021-09-20 23:16:01,850 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:01,881 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "2021-09-20 23:16:01,883 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:01,884 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", + "2021-09-20 23:16:01,887 - root - INFO: \n", + "2021-09-20 23:16:01,888 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,888 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,889 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:01,890 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:01,932 - root - INFO: ... got raster of shape: (92, 198)\n", + "2021-09-20 23:16:01,941 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:01,972 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "2021-09-20 23:16:01,974 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:01,976 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", + "2021-09-20 23:16:01,979 - root - INFO: \n", + "2021-09-20 23:16:01,980 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:01,980 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:01,981 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:01,981 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,023 - root - INFO: ... got raster of shape: (92, 198)\n", + "2021-09-20 23:16:02,031 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "bounds in my_crs: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "bounds in my_crs: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:02,062 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "2021-09-20 23:16:02,065 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:02,065 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", + "2021-09-20 23:16:02,069 - root - INFO: \n", + "2021-09-20 23:16:02,069 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:02,070 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,070 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:02,071 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,114 - root - INFO: ... got raster of shape: (92, 198)\n", + "2021-09-20 23:16:02,123 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:02,154 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "2021-09-20 23:16:02,156 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:02,157 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", + "2021-09-20 23:16:02,174 - root - INFO: \n", + "2021-09-20 23:16:02,174 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:02,175 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,175 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:02,181 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:02,182 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:02,235 - root - INFO: \n", + "2021-09-20 23:16:02,236 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:02,236 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,237 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:02,238 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,281 - root - INFO: ... got raster of shape: (98, 188)\n", + "2021-09-20 23:16:02,290 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "bounds in my_crs: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:02,320 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "2021-09-20 23:16:02,322 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:02,323 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", + "2021-09-20 23:16:02,327 - root - INFO: \n", + "2021-09-20 23:16:02,328 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:02,328 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,328 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:02,329 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,370 - root - INFO: ... got raster of shape: (98, 188)\n", + "2021-09-20 23:16:02,379 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:02,409 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "2021-09-20 23:16:02,411 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:02,412 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", + "2021-09-20 23:16:02,417 - root - INFO: \n", + "2021-09-20 23:16:02,417 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:02,417 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,418 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:02,419 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,460 - root - INFO: ... got raster of shape: (98, 188)\n", + "2021-09-20 23:16:02,470 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:02,501 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "2021-09-20 23:16:02,503 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:02,504 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", + "2021-09-20 23:16:02,508 - root - INFO: \n", + "2021-09-20 23:16:02,508 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:02,508 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,509 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:02,510 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,552 - root - INFO: ... got raster of shape: (98, 188)\n", + "2021-09-20 23:16:02,562 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "bounds in my_crs: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "bounds in my_crs: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:02,594 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "2021-09-20 23:16:02,596 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:02,596 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", + "2021-09-20 23:16:02,615 - root - INFO: \n", + "2021-09-20 23:16:02,616 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:02,616 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,617 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:02,621 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:02,622 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:02,675 - root - INFO: \n", + "2021-09-20 23:16:02,676 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:02,676 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,677 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:02,678 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,719 - root - INFO: ... got raster of shape: (79, 96)\n", + "2021-09-20 23:16:02,728 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:02,758 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "2021-09-20 23:16:02,760 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:02,761 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", + "2021-09-20 23:16:02,764 - root - INFO: \n", + "2021-09-20 23:16:02,765 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:02,765 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,765 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:02,767 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,808 - root - INFO: ... got raster of shape: (79, 96)\n", + "2021-09-20 23:16:02,817 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:02,848 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "2021-09-20 23:16:02,850 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:02,851 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", + "2021-09-20 23:16:02,854 - root - INFO: \n", + "2021-09-20 23:16:02,854 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:02,855 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,855 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:02,856 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,899 - root - INFO: ... got raster of shape: (79, 96)\n", + "2021-09-20 23:16:02,908 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "bounds in my_crs: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "bounds in my_crs: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:02,940 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "2021-09-20 23:16:02,941 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:02,942 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", + "2021-09-20 23:16:02,945 - root - INFO: \n", + "2021-09-20 23:16:02,945 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:02,946 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:02,946 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:02,948 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:02,990 - root - INFO: ... got raster of shape: (79, 96)\n", + "2021-09-20 23:16:03,000 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:03,031 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "2021-09-20 23:16:03,034 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:03,035 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", + "2021-09-20 23:16:03,052 - root - INFO: \n", + "2021-09-20 23:16:03,052 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:03,053 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,053 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:03,058 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:03,058 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:03,112 - root - INFO: \n", + "2021-09-20 23:16:03,113 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:03,114 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,114 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:03,115 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:03,157 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-20 23:16:03,166 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "bounds in my_crs: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:03,197 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "2021-09-20 23:16:03,199 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:03,199 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", + "2021-09-20 23:16:03,202 - root - INFO: \n", + "2021-09-20 23:16:03,203 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:03,203 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,203 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:03,204 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:03,245 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-20 23:16:03,254 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:03,284 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "2021-09-20 23:16:03,286 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:03,287 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", + "2021-09-20 23:16:03,288 - root - INFO: \n", + "2021-09-20 23:16:03,289 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:03,289 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,290 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:03,290 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:03,331 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-20 23:16:03,340 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:03,370 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "2021-09-20 23:16:03,372 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:03,373 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", + "2021-09-20 23:16:03,374 - root - INFO: \n", + "2021-09-20 23:16:03,375 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:03,376 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,376 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:03,377 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:03,419 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-20 23:16:03,427 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "bounds in my_crs: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "bounds in my_crs: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:03,458 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "2021-09-20 23:16:03,460 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:03,461 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", + "2021-09-20 23:16:03,475 - root - INFO: \n", + "2021-09-20 23:16:03,475 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:03,476 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,476 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:03,482 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:03,482 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:03,543 - root - INFO: \n", + "2021-09-20 23:16:03,544 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:03,544 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,544 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:03,547 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:03,590 - root - INFO: ... got raster of shape: (122, 301)\n", + "2021-09-20 23:16:03,599 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:03,630 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "2021-09-20 23:16:03,633 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:03,634 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", + "2021-09-20 23:16:03,637 - root - INFO: \n", + "2021-09-20 23:16:03,638 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:03,638 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,638 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:03,642 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:03,686 - root - INFO: ... got raster of shape: (122, 301)\n", + "2021-09-20 23:16:03,695 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:03,728 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "2021-09-20 23:16:03,730 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:03,731 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", + "2021-09-20 23:16:03,733 - root - INFO: \n", + "2021-09-20 23:16:03,734 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:03,734 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,735 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:03,738 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:03,782 - root - INFO: ... got raster of shape: (122, 301)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "bounds in my_crs: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "bounds in my_crs: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:03,792 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:03,824 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "2021-09-20 23:16:03,828 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:03,828 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", + "2021-09-20 23:16:03,834 - root - INFO: \n", + "2021-09-20 23:16:03,834 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:03,835 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,835 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:03,838 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:03,882 - root - INFO: ... got raster of shape: (122, 301)\n", + "2021-09-20 23:16:03,891 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:03,924 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "2021-09-20 23:16:03,926 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:03,927 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", + "2021-09-20 23:16:03,942 - root - INFO: \n", + "2021-09-20 23:16:03,943 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:03,944 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:03,944 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:03,950 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:03,951 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:04,001 - root - INFO: \n", + "2021-09-20 23:16:04,001 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,002 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,002 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:04,003 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:04,045 - root - INFO: ... got raster of shape: (69, 204)\n", + "2021-09-20 23:16:04,054 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "bounds in my_crs: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:04,085 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "2021-09-20 23:16:04,087 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:04,088 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", + "2021-09-20 23:16:04,091 - root - INFO: \n", + "2021-09-20 23:16:04,092 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,092 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,092 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:04,093 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:04,141 - root - INFO: ... got raster of shape: (69, 204)\n", + "2021-09-20 23:16:04,149 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:04,180 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "2021-09-20 23:16:04,182 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:04,183 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", + "2021-09-20 23:16:04,186 - root - INFO: \n", + "2021-09-20 23:16:04,187 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,187 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,187 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:04,188 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:04,230 - root - INFO: ... got raster of shape: (69, 204)\n", + "2021-09-20 23:16:04,239 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:04,270 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "2021-09-20 23:16:04,272 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:04,273 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", + "2021-09-20 23:16:04,275 - root - INFO: \n", + "2021-09-20 23:16:04,276 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,276 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,277 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:04,278 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:04,319 - root - INFO: ... got raster of shape: (69, 204)\n", + "2021-09-20 23:16:04,327 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "bounds in my_crs: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "bounds in my_crs: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:04,357 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "2021-09-20 23:16:04,359 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:04,359 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", + "2021-09-20 23:16:04,377 - root - INFO: \n", + "2021-09-20 23:16:04,378 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:04,378 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,378 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:04,384 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:04,385 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:04,436 - root - INFO: \n", + "2021-09-20 23:16:04,437 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,437 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,438 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:04,440 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:04,483 - root - INFO: ... got raster of shape: (124, 328)\n", + "2021-09-20 23:16:04,493 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:04,525 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "2021-09-20 23:16:04,526 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:04,527 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", + "2021-09-20 23:16:04,530 - root - INFO: \n", + "2021-09-20 23:16:04,531 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,531 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,532 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:04,534 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:04,576 - root - INFO: ... got raster of shape: (124, 328)\n", + "2021-09-20 23:16:04,585 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:04,616 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "2021-09-20 23:16:04,618 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:04,619 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", + "2021-09-20 23:16:04,621 - root - INFO: \n", + "2021-09-20 23:16:04,622 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,622 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,623 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:04,625 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:04,665 - root - INFO: ... got raster of shape: (124, 328)\n", + "2021-09-20 23:16:04,673 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "bounds in my_crs: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "bounds in my_crs: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:04,705 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "2021-09-20 23:16:04,707 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:04,708 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", + "2021-09-20 23:16:04,713 - root - INFO: \n", + "2021-09-20 23:16:04,713 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,714 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,714 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:04,717 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:04,758 - root - INFO: ... got raster of shape: (124, 328)\n", + "2021-09-20 23:16:04,767 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:04,798 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "2021-09-20 23:16:04,800 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:04,801 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", + "2021-09-20 23:16:04,817 - root - INFO: \n", + "2021-09-20 23:16:04,818 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:04,818 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,818 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:04,823 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:04,824 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:04,877 - root - INFO: \n", + "2021-09-20 23:16:04,878 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,878 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,879 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:04,880 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:04,923 - root - INFO: ... got raster of shape: (95, 310)\n", + "2021-09-20 23:16:04,932 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:04,964 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "2021-09-20 23:16:04,966 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:04,967 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", + "2021-09-20 23:16:04,970 - root - INFO: \n", + "2021-09-20 23:16:04,970 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:04,971 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:04,971 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:04,973 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:05,018 - root - INFO: ... got raster of shape: (95, 310)\n", + "2021-09-20 23:16:05,028 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:05,069 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "2021-09-20 23:16:05,071 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:05,072 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", + "2021-09-20 23:16:05,077 - root - INFO: \n", + "2021-09-20 23:16:05,078 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:05,079 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,080 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:05,082 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:05,133 - root - INFO: ... got raster of shape: (95, 310)\n", + "2021-09-20 23:16:05,143 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:05,177 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "2021-09-20 23:16:05,179 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:05,179 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", + "2021-09-20 23:16:05,183 - root - INFO: \n", + "2021-09-20 23:16:05,184 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:05,184 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,184 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:05,186 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:05,230 - root - INFO: ... got raster of shape: (95, 310)\n", + "2021-09-20 23:16:05,239 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:05,274 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "2021-09-20 23:16:05,276 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:05,278 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", + "2021-09-20 23:16:05,294 - root - INFO: \n", + "2021-09-20 23:16:05,294 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:05,295 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,295 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:05,300 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:05,301 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:05,358 - root - INFO: \n", + "2021-09-20 23:16:05,358 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:05,359 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,359 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:05,361 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:05,407 - root - INFO: ... got raster of shape: (67, 367)\n", + "2021-09-20 23:16:05,416 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:05,449 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "2021-09-20 23:16:05,452 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:05,453 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", + "2021-09-20 23:16:05,456 - root - INFO: \n", + "2021-09-20 23:16:05,456 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:05,457 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,457 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:05,459 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:05,503 - root - INFO: ... got raster of shape: (67, 367)\n", + "2021-09-20 23:16:05,512 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:05,545 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "2021-09-20 23:16:05,547 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:05,548 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", + "2021-09-20 23:16:05,551 - root - INFO: \n", + "2021-09-20 23:16:05,551 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:05,552 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,552 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:05,553 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:05,595 - root - INFO: ... got raster of shape: (67, 367)\n", + "2021-09-20 23:16:05,603 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:05,634 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "2021-09-20 23:16:05,636 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:05,637 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", + "2021-09-20 23:16:05,641 - root - INFO: \n", + "2021-09-20 23:16:05,642 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:05,642 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,643 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:05,644 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:05,685 - root - INFO: ... got raster of shape: (67, 367)\n", + "2021-09-20 23:16:05,694 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:05,727 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "2021-09-20 23:16:05,729 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:05,730 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", + "2021-09-20 23:16:05,750 - root - INFO: \n", + "2021-09-20 23:16:05,750 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:05,751 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,752 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:05,757 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:05,757 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:05,815 - root - INFO: \n", + "2021-09-20 23:16:05,815 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:05,816 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,816 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:05,817 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:05,860 - root - INFO: ... got raster of shape: (53, 365)\n", + "2021-09-20 23:16:05,869 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:05,899 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "2021-09-20 23:16:05,901 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:05,902 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", + "2021-09-20 23:16:05,906 - root - INFO: \n", + "2021-09-20 23:16:05,907 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:05,907 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,907 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:05,908 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:05,949 - root - INFO: ... got raster of shape: (53, 365)\n", + "2021-09-20 23:16:05,958 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:05,989 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "2021-09-20 23:16:05,991 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:05,992 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", + "2021-09-20 23:16:05,995 - root - INFO: \n", + "2021-09-20 23:16:05,996 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:05,996 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:05,996 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:05,997 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:06,040 - root - INFO: ... got raster of shape: (53, 365)\n", + "2021-09-20 23:16:06,050 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:06,082 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "2021-09-20 23:16:06,085 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:06,086 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", + "2021-09-20 23:16:06,089 - root - INFO: \n", + "2021-09-20 23:16:06,089 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:06,090 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,091 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:06,092 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:06,138 - root - INFO: ... got raster of shape: (53, 365)\n", + "2021-09-20 23:16:06,148 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:06,179 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "2021-09-20 23:16:06,182 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:06,183 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", + "2021-09-20 23:16:06,201 - root - INFO: \n", + "2021-09-20 23:16:06,201 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:06,202 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,202 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:06,207 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:06,208 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:06,261 - root - INFO: \n", + "2021-09-20 23:16:06,262 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:06,262 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,263 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:06,267 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:06,312 - root - INFO: ... got raster of shape: (114, 209)\n", + "2021-09-20 23:16:06,321 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:06,356 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "2021-09-20 23:16:06,359 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:06,359 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", + "2021-09-20 23:16:06,362 - root - INFO: \n", + "2021-09-20 23:16:06,362 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:06,363 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,363 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:06,368 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:06,412 - root - INFO: ... got raster of shape: (114, 209)\n", + "2021-09-20 23:16:06,421 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:06,455 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "2021-09-20 23:16:06,458 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:06,459 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", + "2021-09-20 23:16:06,461 - root - INFO: \n", + "2021-09-20 23:16:06,461 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:06,462 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,462 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:06,466 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:06,511 - root - INFO: ... got raster of shape: (114, 209)\n", + "2021-09-20 23:16:06,519 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:06,554 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "2021-09-20 23:16:06,556 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:06,557 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", + "2021-09-20 23:16:06,560 - root - INFO: \n", + "2021-09-20 23:16:06,560 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:06,561 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,561 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:06,565 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:06,609 - root - INFO: ... got raster of shape: (114, 209)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:06,618 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:06,652 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "2021-09-20 23:16:06,655 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:06,656 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", + "2021-09-20 23:16:06,669 - root - INFO: \n", + "2021-09-20 23:16:06,670 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:06,670 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,671 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:06,675 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:06,676 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:06,730 - root - INFO: \n", + "2021-09-20 23:16:06,731 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:06,731 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,732 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:06,733 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:06,775 - root - INFO: ... got raster of shape: (48, 192)\n", + "2021-09-20 23:16:06,784 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:06,816 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "2021-09-20 23:16:06,817 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:06,818 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", + "2021-09-20 23:16:06,821 - root - INFO: \n", + "2021-09-20 23:16:06,822 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:06,822 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,822 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:06,823 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:06,865 - root - INFO: ... got raster of shape: (48, 192)\n", + "2021-09-20 23:16:06,874 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:06,908 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "2021-09-20 23:16:06,911 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:06,912 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", + "2021-09-20 23:16:06,916 - root - INFO: \n", + "2021-09-20 23:16:06,916 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:06,916 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:06,917 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:06,917 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:06,962 - root - INFO: ... got raster of shape: (48, 192)\n", + "2021-09-20 23:16:06,972 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:07,006 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "2021-09-20 23:16:07,009 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:07,009 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", + "2021-09-20 23:16:07,013 - root - INFO: \n", + "2021-09-20 23:16:07,014 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:07,015 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,015 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:07,016 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:07,061 - root - INFO: ... got raster of shape: (48, 192)\n", + "2021-09-20 23:16:07,070 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:07,104 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "2021-09-20 23:16:07,106 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:07,107 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", + "2021-09-20 23:16:07,122 - root - INFO: \n", + "2021-09-20 23:16:07,122 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:07,123 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,123 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:07,128 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:07,128 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:07,192 - root - INFO: \n", + "2021-09-20 23:16:07,192 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:07,193 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,194 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:07,196 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:07,241 - root - INFO: ... got raster of shape: (66, 302)\n", + "2021-09-20 23:16:07,251 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:07,285 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "2021-09-20 23:16:07,286 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:07,287 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", + "2021-09-20 23:16:07,290 - root - INFO: \n", + "2021-09-20 23:16:07,290 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:07,291 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,291 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:07,293 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:07,338 - root - INFO: ... got raster of shape: (66, 302)\n", + "2021-09-20 23:16:07,348 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:07,382 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "2021-09-20 23:16:07,384 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:07,385 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", + "2021-09-20 23:16:07,388 - root - INFO: \n", + "2021-09-20 23:16:07,388 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:07,389 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,389 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:07,391 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:07,438 - root - INFO: ... got raster of shape: (66, 302)\n", + "2021-09-20 23:16:07,446 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:07,479 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "2021-09-20 23:16:07,481 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:07,482 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", + "2021-09-20 23:16:07,486 - root - INFO: \n", + "2021-09-20 23:16:07,487 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:07,487 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,487 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:07,489 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:07,533 - root - INFO: ... got raster of shape: (66, 302)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:07,542 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:07,575 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "2021-09-20 23:16:07,577 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:07,578 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", + "2021-09-20 23:16:07,594 - root - INFO: \n", + "2021-09-20 23:16:07,594 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:07,595 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,595 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:07,601 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:07,602 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:07,655 - root - INFO: \n", + "2021-09-20 23:16:07,656 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:07,656 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,657 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:07,658 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:07,699 - root - INFO: ... got raster of shape: (75, 294)\n", + "2021-09-20 23:16:07,707 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:07,737 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "2021-09-20 23:16:07,739 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:07,739 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", + "2021-09-20 23:16:07,743 - root - INFO: \n", + "2021-09-20 23:16:07,743 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:07,744 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,744 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:07,745 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:07,787 - root - INFO: ... got raster of shape: (75, 294)\n", + "2021-09-20 23:16:07,796 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:07,827 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "2021-09-20 23:16:07,829 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:07,829 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", + "2021-09-20 23:16:07,833 - root - INFO: \n", + "2021-09-20 23:16:07,834 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:07,834 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,834 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:07,835 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:07,875 - root - INFO: ... got raster of shape: (75, 294)\n", + "2021-09-20 23:16:07,884 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:07,916 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "2021-09-20 23:16:07,918 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:07,919 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", + "2021-09-20 23:16:07,922 - root - INFO: \n", + "2021-09-20 23:16:07,922 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:07,923 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:07,923 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:07,924 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:07,967 - root - INFO: ... got raster of shape: (75, 294)\n", + "2021-09-20 23:16:07,976 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:08,008 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "2021-09-20 23:16:08,010 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:08,011 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", + "2021-09-20 23:16:08,029 - root - INFO: \n", + "2021-09-20 23:16:08,030 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:08,030 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,031 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:08,036 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:08,037 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:08,092 - root - INFO: \n", + "2021-09-20 23:16:08,093 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:08,094 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,094 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:08,095 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:08,139 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-20 23:16:08,148 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:08,180 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "2021-09-20 23:16:08,183 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:08,183 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-20 23:16:08,188 - root - INFO: \n", + "2021-09-20 23:16:08,188 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:08,189 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,189 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:08,190 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:08,232 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-20 23:16:08,241 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:08,271 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "2021-09-20 23:16:08,273 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:08,274 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-20 23:16:08,277 - root - INFO: \n", + "2021-09-20 23:16:08,278 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:08,278 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,278 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:08,279 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:08,323 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-20 23:16:08,333 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:08,364 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "2021-09-20 23:16:08,366 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:08,367 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-20 23:16:08,370 - root - INFO: \n", + "2021-09-20 23:16:08,371 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:08,371 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,372 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:08,373 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:08,416 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-20 23:16:08,425 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:08,456 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "2021-09-20 23:16:08,458 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:08,459 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-20 23:16:08,477 - root - INFO: \n", + "2021-09-20 23:16:08,478 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:08,478 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,479 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:08,485 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:08,485 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:08,538 - root - INFO: \n", + "2021-09-20 23:16:08,539 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:08,539 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,540 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:08,541 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:08,581 - root - INFO: ... got raster of shape: (107, 212)\n", + "2021-09-20 23:16:08,590 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:08,621 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "2021-09-20 23:16:08,623 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:08,624 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", + "2021-09-20 23:16:08,627 - root - INFO: \n", + "2021-09-20 23:16:08,628 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:08,628 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,629 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:08,630 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:08,673 - root - INFO: ... got raster of shape: (107, 212)\n", + "2021-09-20 23:16:08,683 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:08,714 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "2021-09-20 23:16:08,716 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:08,717 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", + "2021-09-20 23:16:08,720 - root - INFO: \n", + "2021-09-20 23:16:08,721 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:08,721 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,721 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:08,722 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:08,764 - root - INFO: ... got raster of shape: (107, 212)\n", + "2021-09-20 23:16:08,773 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:08,806 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "2021-09-20 23:16:08,808 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:08,809 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", + "2021-09-20 23:16:08,813 - root - INFO: \n", + "2021-09-20 23:16:08,814 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:08,814 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,814 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:08,815 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:08,857 - root - INFO: ... got raster of shape: (107, 212)\n", + "2021-09-20 23:16:08,867 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:08,899 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "2021-09-20 23:16:08,901 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:08,902 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", + "2021-09-20 23:16:08,919 - root - INFO: \n", + "2021-09-20 23:16:08,920 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:08,921 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,921 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:08,926 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:08,927 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:08,984 - root - INFO: \n", + "2021-09-20 23:16:08,985 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:08,985 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:08,986 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:08,986 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:09,032 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-09-20 23:16:09,041 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:09,072 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-09-20 23:16:09,075 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:09,075 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-09-20 23:16:09,079 - root - INFO: \n", + "2021-09-20 23:16:09,079 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:09,080 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,080 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:09,081 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:09,123 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-09-20 23:16:09,133 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:09,164 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-09-20 23:16:09,166 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:09,168 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-09-20 23:16:09,172 - root - INFO: \n", + "2021-09-20 23:16:09,172 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:09,173 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,173 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:09,174 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:09,216 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-09-20 23:16:09,226 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:09,256 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-09-20 23:16:09,259 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:09,259 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-09-20 23:16:09,264 - root - INFO: \n", + "2021-09-20 23:16:09,265 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:09,265 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,266 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:09,267 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:09,311 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-09-20 23:16:09,320 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:09,352 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-09-20 23:16:09,354 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:09,355 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-09-20 23:16:09,374 - root - INFO: \n", + "2021-09-20 23:16:09,375 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:09,375 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,375 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:09,381 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:09,382 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:09,436 - root - INFO: \n", + "2021-09-20 23:16:09,437 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:09,437 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,437 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:09,439 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:09,484 - root - INFO: ... got raster of shape: (122, 176)\n", + "2021-09-20 23:16:09,493 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:09,525 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "2021-09-20 23:16:09,527 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:09,527 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", + "2021-09-20 23:16:09,530 - root - INFO: \n", + "2021-09-20 23:16:09,531 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:09,531 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,531 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:09,533 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:09,577 - root - INFO: ... got raster of shape: (122, 176)\n", + "2021-09-20 23:16:09,586 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:09,618 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "2021-09-20 23:16:09,620 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:09,621 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", + "2021-09-20 23:16:09,624 - root - INFO: \n", + "2021-09-20 23:16:09,624 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:09,625 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,625 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:09,627 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:09,670 - root - INFO: ... got raster of shape: (122, 176)\n", + "2021-09-20 23:16:09,679 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:09,714 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "2021-09-20 23:16:09,716 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:09,716 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", + "2021-09-20 23:16:09,720 - root - INFO: \n", + "2021-09-20 23:16:09,720 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:09,721 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,721 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:09,723 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:09,767 - root - INFO: ... got raster of shape: (122, 176)\n", + "2021-09-20 23:16:09,776 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:09,808 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "2021-09-20 23:16:09,810 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:09,811 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", + "2021-09-20 23:16:09,825 - root - INFO: \n", + "2021-09-20 23:16:09,826 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:09,827 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,827 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:09,833 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:09,834 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:09,887 - root - INFO: \n", + "2021-09-20 23:16:09,887 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:09,888 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,888 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:09,889 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:09,935 - root - INFO: ... got raster of shape: (75, 333)\n", + "2021-09-20 23:16:09,945 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:09,976 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "2021-09-20 23:16:09,978 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:09,979 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", + "2021-09-20 23:16:09,984 - root - INFO: \n", + "2021-09-20 23:16:09,984 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:09,984 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:09,985 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:09,985 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:10,029 - root - INFO: ... got raster of shape: (75, 333)\n", + "2021-09-20 23:16:10,039 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:10,070 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "2021-09-20 23:16:10,072 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:10,073 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", + "2021-09-20 23:16:10,076 - root - INFO: \n", + "2021-09-20 23:16:10,077 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:10,077 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,077 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:10,078 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:10,121 - root - INFO: ... got raster of shape: (75, 333)\n", + "2021-09-20 23:16:10,130 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:10,161 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "2021-09-20 23:16:10,163 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:10,164 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", + "2021-09-20 23:16:10,167 - root - INFO: \n", + "2021-09-20 23:16:10,168 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:10,168 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,168 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:10,169 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:10,213 - root - INFO: ... got raster of shape: (75, 333)\n", + "2021-09-20 23:16:10,222 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:10,254 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "2021-09-20 23:16:10,257 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:10,257 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", + "2021-09-20 23:16:10,275 - root - INFO: \n", + "2021-09-20 23:16:10,276 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:10,276 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,277 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:10,282 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:10,283 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:10,337 - root - INFO: \n", + "2021-09-20 23:16:10,338 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:10,339 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,339 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:10,340 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:10,385 - root - INFO: ... got raster of shape: (59, 297)\n", + "2021-09-20 23:16:10,394 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:10,428 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "2021-09-20 23:16:10,430 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:10,430 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", + "2021-09-20 23:16:10,434 - root - INFO: \n", + "2021-09-20 23:16:10,435 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:10,435 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,435 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:10,436 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:10,480 - root - INFO: ... got raster of shape: (59, 297)\n", + "2021-09-20 23:16:10,489 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:10,522 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "2021-09-20 23:16:10,524 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:10,525 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", + "2021-09-20 23:16:10,528 - root - INFO: \n", + "2021-09-20 23:16:10,529 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:10,529 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,530 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:10,531 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:10,578 - root - INFO: ... got raster of shape: (59, 297)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:10,588 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:10,623 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "2021-09-20 23:16:10,625 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:10,626 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", + "2021-09-20 23:16:10,631 - root - INFO: \n", + "2021-09-20 23:16:10,632 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:10,632 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,633 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:10,634 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:10,680 - root - INFO: ... got raster of shape: (59, 297)\n", + "2021-09-20 23:16:10,690 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:10,721 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "2021-09-20 23:16:10,724 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:10,725 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", + "2021-09-20 23:16:10,740 - root - INFO: \n", + "2021-09-20 23:16:10,740 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:10,741 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,741 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:10,747 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:10,748 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:10,804 - root - INFO: \n", + "2021-09-20 23:16:10,804 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:10,805 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,805 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:10,806 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:10,848 - root - INFO: ... got raster of shape: (103, 231)\n", + "2021-09-20 23:16:10,857 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:10,889 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "2021-09-20 23:16:10,890 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:10,891 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", + "2021-09-20 23:16:10,896 - root - INFO: \n", + "2021-09-20 23:16:10,897 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:10,897 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,897 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:10,898 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:10,941 - root - INFO: ... got raster of shape: (103, 231)\n", + "2021-09-20 23:16:10,951 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:10,981 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "2021-09-20 23:16:10,984 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:10,984 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", + "2021-09-20 23:16:10,987 - root - INFO: \n", + "2021-09-20 23:16:10,988 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:10,988 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:10,989 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:10,989 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:11,032 - root - INFO: ... got raster of shape: (103, 231)\n", + "2021-09-20 23:16:11,041 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:11,074 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "2021-09-20 23:16:11,076 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:11,077 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", + "2021-09-20 23:16:11,082 - root - INFO: \n", + "2021-09-20 23:16:11,082 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:11,083 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,083 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:11,084 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:11,126 - root - INFO: ... got raster of shape: (103, 231)\n", + "2021-09-20 23:16:11,135 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:11,166 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "2021-09-20 23:16:11,168 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:11,169 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", + "2021-09-20 23:16:11,186 - root - INFO: \n", + "2021-09-20 23:16:11,186 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:11,187 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,187 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:11,193 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:11,193 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:11,249 - root - INFO: \n", + "2021-09-20 23:16:11,249 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:11,250 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,250 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:11,251 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:11,292 - root - INFO: ... got raster of shape: (50, 188)\n", + "2021-09-20 23:16:11,302 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:11,334 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "2021-09-20 23:16:11,336 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:11,337 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", + "2021-09-20 23:16:11,340 - root - INFO: \n", + "2021-09-20 23:16:11,340 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:11,341 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,341 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:11,342 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:11,384 - root - INFO: ... got raster of shape: (50, 188)\n", + "2021-09-20 23:16:11,392 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:11,424 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "2021-09-20 23:16:11,425 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:11,426 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", + "2021-09-20 23:16:11,429 - root - INFO: \n", + "2021-09-20 23:16:11,430 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:11,430 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,430 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:11,431 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:11,474 - root - INFO: ... got raster of shape: (50, 188)\n", + "2021-09-20 23:16:11,483 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:11,515 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "2021-09-20 23:16:11,517 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:11,518 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", + "2021-09-20 23:16:11,521 - root - INFO: \n", + "2021-09-20 23:16:11,521 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:11,521 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,522 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:11,522 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:11,564 - root - INFO: ... got raster of shape: (50, 188)\n", + "2021-09-20 23:16:11,573 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:11,604 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "2021-09-20 23:16:11,606 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:11,607 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", + "2021-09-20 23:16:11,622 - root - INFO: \n", + "2021-09-20 23:16:11,623 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:11,623 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,623 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:11,628 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:11,628 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:11,685 - root - INFO: \n", + "2021-09-20 23:16:11,686 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:11,687 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,687 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:11,689 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:11,732 - root - INFO: ... got raster of shape: (155, 254)\n", + "2021-09-20 23:16:11,741 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:11,773 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "2021-09-20 23:16:11,775 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:11,776 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", + "2021-09-20 23:16:11,780 - root - INFO: \n", + "2021-09-20 23:16:11,780 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:11,780 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,781 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:11,782 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:11,826 - root - INFO: ... got raster of shape: (155, 254)\n", + "2021-09-20 23:16:11,836 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:11,867 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "2021-09-20 23:16:11,870 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:11,870 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", + "2021-09-20 23:16:11,874 - root - INFO: \n", + "2021-09-20 23:16:11,874 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:11,875 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,875 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:11,877 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:11,921 - root - INFO: ... got raster of shape: (155, 254)\n", + "2021-09-20 23:16:11,930 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:11,963 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "2021-09-20 23:16:11,966 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:11,966 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", + "2021-09-20 23:16:11,972 - root - INFO: \n", + "2021-09-20 23:16:11,973 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:11,973 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:11,974 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:11,975 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:12,019 - root - INFO: ... got raster of shape: (155, 254)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:12,027 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:12,060 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "2021-09-20 23:16:12,062 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:12,062 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", + "2021-09-20 23:16:12,080 - root - INFO: \n", + "2021-09-20 23:16:12,081 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:12,082 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,082 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:12,134 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:12,135 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:12,190 - root - INFO: \n", + "2021-09-20 23:16:12,191 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:12,191 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,192 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:12,193 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:12,236 - root - INFO: ... got raster of shape: (39, 185)\n", + "2021-09-20 23:16:12,246 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:12,282 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "2021-09-20 23:16:12,285 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:12,286 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", + "2021-09-20 23:16:12,288 - root - INFO: \n", + "2021-09-20 23:16:12,288 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:12,289 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,289 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:12,290 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:12,329 - root - INFO: ... got raster of shape: (39, 185)\n", + "2021-09-20 23:16:12,338 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:12,367 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "2021-09-20 23:16:12,369 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:12,370 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", + "2021-09-20 23:16:12,372 - root - INFO: \n", + "2021-09-20 23:16:12,372 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:12,373 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,373 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:12,374 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:12,416 - root - INFO: ... got raster of shape: (39, 185)\n", + "2021-09-20 23:16:12,425 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:12,458 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "2021-09-20 23:16:12,460 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:12,461 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", + "2021-09-20 23:16:12,463 - root - INFO: \n", + "2021-09-20 23:16:12,463 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:12,463 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,464 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:12,464 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:12,507 - root - INFO: ... got raster of shape: (39, 185)\n", + "2021-09-20 23:16:12,517 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:12,548 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "2021-09-20 23:16:12,550 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:12,551 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", + "2021-09-20 23:16:12,565 - root - INFO: \n", + "2021-09-20 23:16:12,566 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:12,566 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,566 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:12,572 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:12,573 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:12,637 - root - INFO: \n", + "2021-09-20 23:16:12,638 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:12,639 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,639 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:12,642 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:12,685 - root - INFO: ... got raster of shape: (121, 413)\n", + "2021-09-20 23:16:12,694 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:12,727 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "2021-09-20 23:16:12,730 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:12,730 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", + "2021-09-20 23:16:12,734 - root - INFO: \n", + "2021-09-20 23:16:12,734 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:12,735 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,735 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:12,739 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:12,785 - root - INFO: ... got raster of shape: (121, 413)\n", + "2021-09-20 23:16:12,794 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:12,828 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "2021-09-20 23:16:12,830 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:12,831 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", + "2021-09-20 23:16:12,834 - root - INFO: \n", + "2021-09-20 23:16:12,835 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:12,836 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,836 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:12,840 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:12,884 - root - INFO: ... got raster of shape: (121, 413)\n", + "2021-09-20 23:16:12,893 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:12,925 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "2021-09-20 23:16:12,928 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:12,929 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", + "2021-09-20 23:16:12,934 - root - INFO: \n", + "2021-09-20 23:16:12,935 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:12,935 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:12,936 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:12,939 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:12,982 - root - INFO: ... got raster of shape: (121, 413)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:12,991 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:13,025 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "2021-09-20 23:16:13,027 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:13,028 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", + "2021-09-20 23:16:13,044 - root - INFO: \n", + "2021-09-20 23:16:13,045 - root - INFO: Loading shapes\n", + "2021-09-20 23:16:13,046 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:13,046 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-20 23:16:13,052 - root - INFO: ... found 44 shapes\n", + "2021-09-20 23:16:13,052 - root - INFO: Converting to shapely\n", + "2021-09-20 23:16:13,107 - root - INFO: \n", + "2021-09-20 23:16:13,108 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:13,109 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:13,110 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-20 23:16:13,110 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:13,154 - root - INFO: ... got raster of shape: (73, 306)\n", + "2021-09-20 23:16:13,163 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:13,193 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "2021-09-20 23:16:13,194 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-20 23:16:13,195 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", + "2021-09-20 23:16:13,199 - root - INFO: \n", + "2021-09-20 23:16:13,200 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:13,200 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:13,200 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-20 23:16:13,201 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:13,244 - root - INFO: ... got raster of shape: (73, 306)\n", + "2021-09-20 23:16:13,254 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:13,286 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "2021-09-20 23:16:13,288 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-20 23:16:13,289 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", + "2021-09-20 23:16:13,293 - root - INFO: \n", + "2021-09-20 23:16:13,293 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:13,294 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:13,294 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-20 23:16:13,295 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:13,338 - root - INFO: ... got raster of shape: (73, 306)\n", + "2021-09-20 23:16:13,348 - root - INFO: Masking to shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:16:13,380 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "2021-09-20 23:16:13,382 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-20 23:16:13,383 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", + "2021-09-20 23:16:13,387 - root - INFO: \n", + "2021-09-20 23:16:13,388 - root - INFO: Loading Raster\n", + "2021-09-20 23:16:13,389 - root - INFO: ------------------------------\n", + "2021-09-20 23:16:13,389 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-20 23:16:13,390 - root - INFO: Collecting raster\n", + "2021-09-20 23:16:13,432 - root - INFO: ... got raster of shape: (73, 306)\n", + "2021-09-20 23:16:13,441 - root - INFO: Masking to shape\n", + "2021-09-20 23:16:13,473 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "2021-09-20 23:16:13,475 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-20 23:16:13,476 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n" + ] + } + ], + "source": [ + "hillslope_pars = []\n", + "mesh_pars = []\n", + "subcatch_all_ids = 1+np.arange(len(subcatchments))\n", + "for subcatch_id in subcatch_all_ids:\n", + " hillslope_pars.append(hillslopes.parameterizeSubcatchment(\n", + " filenames, huc, subcatch_id,\n", + " target_crs=workflow.crs.default_alaska_crs(),\n", + " hillslope_keep_fraction=hillslope_keep_fraction,\n", + " hillslope_bin_dx=hillslope_bin_dx))\n", + " \n", + "for i in range(len(hillslope_pars)): \n", + " mesh_pars.append(mesh.parameterizeMesh(hillslope_pars[i], mesh_dx,\n", + " riparian_slope_min=riparian_slope_min,\n", + " hillslope_slope_min=hillslope_slope_min,\n", + " min_area_ratio=min_area_ratio))" + ] + }, + { + "cell_type": "markdown", + "id": "d89ac989", + "metadata": {}, + "source": [ + "## Plot all hillslopes" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "789b2ed3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:50,618 - root - INFO: BOUNDS: (-149.32346060296518, 68.18897673838367, -149.23401615851776, 68.20814340505098)\n", + "2021-09-20 23:18:50,723 - root - INFO: BOUNDS: (-149.32346060296518, 68.18897673838367, -149.23401615851776, 68.20814340505098)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:50,876 - root - INFO: BOUNDS: (-149.32346060296518, 68.1800878494945, -149.23151615851768, 68.19786562727286)\n", + "2021-09-20 23:18:50,982 - root - INFO: BOUNDS: (-149.32346060296518, 68.1800878494945, -149.23151615851768, 68.19786562727286)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:51,146 - root - INFO: BOUNDS: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "2021-09-20 23:18:51,256 - root - INFO: BOUNDS: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:51,408 - root - INFO: BOUNDS: (-149.27262726963016, 68.19925451616179, -149.2079050474058, 68.21564340505122)\n", + "2021-09-20 23:18:51,516 - root - INFO: BOUNDS: (-149.27262726963016, 68.19925451616179, -149.2079050474058, 68.21564340505122)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:51,672 - root - INFO: BOUNDS: (-149.2759606029636, 68.20731007171761, -149.17123838073792, 68.23453229394075)\n", + "2021-09-20 23:18:51,778 - root - INFO: BOUNDS: (-149.2759606029636, 68.20731007171761, -149.17123838073792, 68.23453229394075)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:51,930 - root - INFO: BOUNDS: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "2021-09-20 23:18:52,035 - root - INFO: BOUNDS: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:52,193 - root - INFO: BOUNDS: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "2021-09-20 23:18:52,304 - root - INFO: BOUNDS: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:52,465 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n", + "2021-09-20 23:18:52,571 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:52,721 - root - INFO: BOUNDS: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "2021-09-20 23:18:52,826 - root - INFO: BOUNDS: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:53,519 - root - INFO: BOUNDS: (-149.12262726962518, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "2021-09-20 23:18:53,628 - root - INFO: BOUNDS: (-149.12262726962518, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:53,792 - root - INFO: BOUNDS: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "2021-09-20 23:18:53,902 - root - INFO: BOUNDS: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:54,057 - root - INFO: BOUNDS: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25119896060797)\n", + "2021-09-20 23:18:54,170 - root - INFO: BOUNDS: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25119896060797)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:54,325 - root - INFO: BOUNDS: (-149.0859606029573, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "2021-09-20 23:18:54,437 - root - INFO: BOUNDS: (-149.0859606029573, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:54,595 - root - INFO: BOUNDS: (-149.0901272696241, 68.23231007171844, -149.0304050473999, 68.25119896060797)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:18:54,711 - root - INFO: BOUNDS: (-149.0901272696241, 68.23231007171844, -149.0304050473999, 68.25119896060797)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:54,871 - root - INFO: BOUNDS: (-149.0304050473999, 68.24425451616328, -148.97596060295365, 68.26814340505297)\n", + "2021-09-20 23:18:54,979 - root - INFO: BOUNDS: (-149.0304050473999, 68.24425451616328, -148.97596060295365, 68.26814340505297)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:55,146 - root - INFO: BOUNDS: (-149.03096060295547, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "2021-09-20 23:18:55,250 - root - INFO: BOUNDS: (-149.03096060295547, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:55,395 - root - INFO: BOUNDS: (-149.0134606029549, 68.25592118283033, -148.94040504739692, 68.28064340505338)\n", + "2021-09-20 23:18:55,502 - root - INFO: BOUNDS: (-149.0134606029549, 68.25592118283033, -148.94040504739692, 68.28064340505338)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:55,651 - root - INFO: BOUNDS: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "2021-09-20 23:18:55,870 - root - INFO: BOUNDS: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:56,033 - root - INFO: BOUNDS: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "2021-09-20 23:18:56,141 - root - INFO: BOUNDS: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:56,303 - root - INFO: BOUNDS: (-148.94012726961913, 68.26425451616394, -148.88790504739518, 68.29147673838708)\n", + "2021-09-20 23:18:56,402 - root - INFO: BOUNDS: (-148.94012726961913, 68.26425451616394, -148.88790504739518, 68.29147673838708)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:56,555 - root - INFO: BOUNDS: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29619896060946)\n", + "2021-09-20 23:18:56,666 - root - INFO: BOUNDS: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29619896060946)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:56,808 - root - INFO: BOUNDS: (-148.9109606029515, 68.29175451616486, -148.88707171406182, 68.30147673838741)\n", + "2021-09-20 23:18:56,914 - root - INFO: BOUNDS: (-148.9109606029515, 68.29175451616486, -148.88707171406182, 68.30147673838741)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:57,080 - root - INFO: BOUNDS: (-148.88596060295066, 68.27925451616444, -148.80234949183676, 68.31314340505446)\n", + "2021-09-20 23:18:57,184 - root - INFO: BOUNDS: (-148.88596060295066, 68.27925451616444, -148.80234949183676, 68.31314340505446)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:57,329 - root - INFO: BOUNDS: (-148.89096060295083, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "2021-09-20 23:18:57,429 - root - INFO: BOUNDS: (-148.89096060295083, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:57,590 - root - INFO: BOUNDS: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "2021-09-20 23:18:57,700 - root - INFO: BOUNDS: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:57,862 - root - INFO: BOUNDS: (-149.2034606029612, 68.22814340505164, -149.11734949184722, 68.25453229394141)\n", + "2021-09-20 23:18:57,974 - root - INFO: BOUNDS: (-149.2034606029612, 68.22814340505164, -149.11734949184722, 68.25453229394141)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:58,297 - root - INFO: BOUNDS: (-149.0434606029559, 68.30758784949873, -148.94151615850805, 68.32619896061045)\n", + "2021-09-20 23:18:58,409 - root - INFO: BOUNDS: (-149.0434606029559, 68.30758784949873, -148.94151615850805, 68.32619896061045)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:58,568 - root - INFO: BOUNDS: (-149.0434606029559, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:18:58,671 - root - INFO: BOUNDS: (-149.0434606029559, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:58,831 - root - INFO: BOUNDS: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "2021-09-20 23:18:58,940 - root - INFO: BOUNDS: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:59,102 - root - INFO: BOUNDS: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30953229394324)\n", + "2021-09-20 23:18:59,210 - root - INFO: BOUNDS: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30953229394324)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:59,369 - root - INFO: BOUNDS: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "2021-09-20 23:18:59,479 - root - INFO: BOUNDS: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:59,629 - root - INFO: BOUNDS: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "2021-09-20 23:18:59,740 - root - INFO: BOUNDS: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:18:59,896 - root - INFO: BOUNDS: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "2021-09-20 23:19:00,004 - root - INFO: BOUNDS: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:00,148 - root - INFO: BOUNDS: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "2021-09-20 23:19:00,242 - root - INFO: BOUNDS: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:00,403 - root - INFO: BOUNDS: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20453229393975)\n", + "2021-09-20 23:19:00,511 - root - INFO: BOUNDS: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20453229393975)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:00,670 - root - INFO: BOUNDS: (-149.2117939362948, 68.17675451616104, -149.1629050474043, 68.21064340505106)\n", + "2021-09-20 23:19:00,780 - root - INFO: BOUNDS: (-149.2117939362948, 68.17675451616104, -149.1629050474043, 68.21064340505106)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:00,943 - root - INFO: BOUNDS: (-149.21096060296145, 68.25869896060821, -149.11846060295838, 68.27953229394224)\n", + "2021-09-20 23:19:01,052 - root - INFO: BOUNDS: (-149.21096060296145, 68.25869896060821, -149.11846060295838, 68.27953229394224)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:01,218 - root - INFO: BOUNDS: (-149.2101272696281, 68.25314340505247, -149.12762726962535, 68.26953229394191)\n", + "2021-09-20 23:19:01,545 - root - INFO: BOUNDS: (-149.2101272696281, 68.25314340505247, -149.12762726962535, 68.26953229394191)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:01,693 - root - INFO: BOUNDS: (-149.12762726962535, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "2021-09-20 23:19:01,795 - root - INFO: BOUNDS: (-149.12762726962535, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:01,946 - root - INFO: BOUNDS: (-149.13179393629215, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "2021-09-20 23:19:02,049 - root - INFO: BOUNDS: (-149.13179393629215, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:02,204 - root - INFO: BOUNDS: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "2021-09-20 23:19:02,307 - root - INFO: BOUNDS: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:02,457 - root - INFO: BOUNDS: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:19:02,558 - root - INFO: BOUNDS: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:02,726 - root - INFO: BOUNDS: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "2021-09-20 23:19:02,842 - root - INFO: BOUNDS: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n", + "2021-09-20 23:19:03,008 - root - INFO: BOUNDS: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24036562727427)\n", + "2021-09-20 23:19:03,125 - root - INFO: BOUNDS: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24036562727427)\n", + ":38: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(20,30),dpi=80)\n", + "nx, ny = 6,8\n", + "sep=0.02\n", + "\n", + "axs = []\n", + "for i in range(nx):\n", + " for j in range(ny):\n", + " sub_id = i*ny+j+1\n", + " if sub_id > len(subcatchments):\n", + " continue\n", + " \n", + " gs = gridspec.GridSpec(4,1,bottom=j/ny+sep, left=i/nx+sep, top=(j+1)/ny - sep, right=(i+1)/nx - sep)\n", + " ax1 = fig.add_subplot(gs[2,0])\n", + " ax2 = fig.add_subplot(gs[3,0])\n", + " axs = [ax1,ax2]\n", + " h_par = hillslope_pars[sub_id-1]\n", + " m_par = mesh_pars[sub_id-1] \n", + " plot.plot(h_par, m_par, fig=fig, axs=axs)\n", + " \n", + " ax0 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[0,0])\n", + " ax0.set_title(f'subcatchment {sub_id}')\n", + " workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", + " hillslope_pars[sub_id-1]['bins'], ax=ax0, cmap='prism')\n", + " subcatch = hillslope_pars[sub_id-1]['subcatchment']\n", + " workflow.plot.shply(subcatch, native_crs, ax=ax0, color='k')\n", + " \n", + " ax1 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[1,0])\n", + " vmin, vmax = min(hillslope_pars[sub_id-1]['land_cover']), max(hillslope_pars[sub_id-1]['land_cover'])\n", + " cmap = plt.get_cmap(('viridis'),vmax-vmin+1)\n", + " lc = workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", + " hillslope_pars[sub_id-1]['land_cover_raster'], \n", + " ax=ax1, vmin=vmin-0.5, vmax=vmax+0.5, cmap=cmap)\n", + " workflow.plot.shply(subcatch, native_crs, ax=ax1, color='k')\n", + " position=fig.add_axes([i/nx+sep+0.13, j/ny+sep+0.045, 0.006,0.04])\n", + "\n", + " fig.colorbar(lc,ticks=np.arange(vmin,vmax+1),cax=position)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d60fb0f2", + "metadata": {}, + "source": [ + "# Generate mesh" + ] + }, + { + "cell_type": "markdown", + "id": "366f43ba", + "metadata": {}, + "source": [ + "## Column spinup mesh" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "d75f2a06", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening exodus file: ../huc/190604020404/mesh/column.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/column.exo\n" + ] + } + ], + "source": [ + "if os.path.isfile(os.path.join(mesh_dir,'column.exo')):\n", + " os.remove(os.path.join(mesh_dir,'column.exo'))\n", + "colum_mesh = meshing.createColumnMesh(meshing.layeringStructure(), \n", + " os.path.join(mesh_dir,'column.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "973ad6c6", + "metadata": {}, + "source": [ + "## For a given subcatchment" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4396c703", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope8.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope8.exo\n" + ] + } + ], + "source": [ + "m2 = meshing.createHillslopeMesh2D(mesh_demo_pars)\n", + "m3 = meshing.createHillslopeMesh3D(m2, mesh_demo_pars, meshing.layeringStructure(),\n", + " os.path.join(mesh_dir,f'sag_hillslope{subcatch_demo_id}.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "d121163b", + "metadata": {}, + "source": [ + "## For all subcatchments" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "457de366", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope1.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope1.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope2.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope2.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope3.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope3.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope4.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope4.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope5.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope5.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope6.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope6.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope7.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope7.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope8.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope8.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope9.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope9.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope10.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope10.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope11.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope11.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope12.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope12.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope13.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope13.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope14.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope14.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope15.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope15.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope16.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope16.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope17.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope17.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope18.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope18.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope19.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope19.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope20.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope20.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope21.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope21.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope22.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope22.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope23.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope23.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope24.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope24.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope25.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope25.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope26.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope26.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope27.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope27.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope28.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope28.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope29.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope29.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope30.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope30.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope31.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope31.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope32.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope32.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope33.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope33.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope34.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope34.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope35.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope35.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope36.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope36.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope37.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope37.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope38.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope38.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope39.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope39.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope40.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope40.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope41.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope41.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope42.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope42.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope43.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope43.exo\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope44.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope44.exo\n" + ] + } + ], + "source": [ + "subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", + "for subcatch_id in subcatch_all_ids:\n", + " index = subcatch_id - 1\n", + " m2 = meshing.createHillslopeMesh2D(mesh_pars[index])\n", + " m3 = meshing.createHillslopeMesh3D(m2, mesh_pars[index], meshing.layeringStructure(),\n", + " os.path.join(mesh_dir,f'sag_hillslope{subcatch_id}.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "bd6e1541", + "metadata": {}, + "source": [ + "# DayMet" + ] + }, + { + "cell_type": "markdown", + "id": "42957ce2", + "metadata": {}, + "source": [ + "## For a given subcatchment" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "f40ce9ae", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-20 23:22:55,812 - root - INFO: Querying: https://daymet.ornl.gov/single-pixel/api/data?lat=68.2176&lon=-149.1589&vars=dayl,prcp,srad,swe,tmax,tmin,vp&start=1980-01-01&end=2020-12-31\n", + "2021-09-20 23:23:01,948 - root - INFO: returned code: 200\n", + "2021-09-20 23:23:01,949 - root - INFO: writing to disk: ../huc/190604020404/data_raw-daymet/daymet_raw_68p2176_-149p1589.dat\n", + "2021-09-20 23:23:02,036 - root - INFO: Converting to ATS\n", + "2021-09-20 23:23:02,038 - root - INFO: Writing ATS file: ../huc/190604020404/daymet/huc_190604020404_subcatchment8_1980_2020.h5\n" + ] + } + ], + "source": [ + "start, end = datetime.date(1980,1,1), datetime.date(2020,12,31)\n", + "hillslopes.downloadDaymet(hillslope_demo_pars, daymet_raw_dir, \n", + " os.path.join(daymet_dir, f'huc_{huc}_subcatchment{subcatch_demo_id}_'\n", + " +str(start.year)+'_'+str(end.year)+'.h5'),\n", + " start, end)" + ] + }, + { + "cell_type": "markdown", + "id": "ddf3aa46", + "metadata": {}, + "source": [ + "## For all subcatchment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2e67606", + "metadata": {}, + "outputs": [], + "source": [ + "start, end = datetime.date(1980,1,1), datetime.date(2020,12,31)\n", + "subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", + "for subcatch_id in subcatch_all_ids:\n", + " index = subcatch_id - 1\n", + " hillslopes.downloadDaymet(hillslope_pars[index], daymet_raw_dir, \n", + " os.path.join(daymet_dir, f'huc_{huc}_subcatchment{subcatch_id}_'\n", + " +str(start.year)+'_'+str(end.year)+'.h5'),\n", + " start, end)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab520b03", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df4cbfbb", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c78c4030", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:watershed_workflow]", + "language": "python", + "name": "conda-env-watershed_workflow-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.4" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "288px" + }, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/new_scripts/landcover.py b/new_scripts/landcover.py new file mode 100644 index 0000000..ef7c2fd --- /dev/null +++ b/new_scripts/landcover.py @@ -0,0 +1,118 @@ +import numpy as np +import rasterio +import attr + +_lc_ids = [1,2,3,5,6,7,8,9,10,11,14,16,18,19,20,21,22,23,50,51,91,92,95,96,99] +_lc_names = ['Bare Ground','Sparsely Vegetated','Open Water','FWM: Arctophila Fulva', + 'FWM: Carex Aquatillis','Wet Sedge','Wet Sedge - Sphagnum','Mesic Herbaceous','Tussock Tundra', + 'Tussock Shrub Tundra','Mesic Sedge-Dwarf Shrub Tundra','Dwarf Shrub - Dryas','Dwarf Shrub - Other', + 'Birch Ericaceous Low Shrub','Low-Tall Willow','Alder','Marine Beach/Beach Meadow','Coastal Marsh', + 'Ice / Snow','Burned Area','Open Needleleaf','Woodland Needleleaf','Open Mixed Needleleaf/Deciduous', + 'Deciduous','Unclassified (cloud, terrain shadow, etc.)'] + +name_to_id = dict(zip(_lc_names, _lc_ids)) +id_to_name = dict(zip(_lc_ids, _lc_names)) + +class_names, class_ids = dict(), dict() +class_names['shrub'] = ['Birch Ericaceous Low Shrub','Low-Tall Willow','Alder'] +class_names['sedge'] = ['FWM: Carex Aquatillis', 'Mesic Sedge-Dwarf Shrub Tundra', 'Wet Sedge','Wet Sedge - Sphagnum'] +class_names['tussock'] = ['Tussock Tundra','Tussock Shrub Tundra', 'Dwarf Shrub - Dryas'] +class_names['sparse_veg'] = ['Bare Ground','Sparsely Vegetated','Dwarf Shrub - Other','Open Water','Ice / Snow'] +for group, names in class_names.items(): + class_ids[group] = [name_to_id[name] for name in names] + + +def vegClasses(): + return list(class_ids.keys()) + + +# Remaps from NSSI IDs to lumped ATS IDs around shrub,sedge,tussock,and sparse_veg +def classifyVegetation(lc): + lc_remap = np.zeros(lc.shape, dtype=np.uint8) + lc_remap[lc == 255] = 255 + for i, (group,ids) in enumerate(class_ids.items()): + ats_id = 100+i + for veg_id in ids: + lc_remap[lc == veg_id] = ats_id + missing_id = set(lc[[lc_remap == 0]]) + for mid in missing_id: + raise RuntimeError(f'Missing vegetation id {mid} type {id_to_name[mid]}') + + return len(missing_id), lc_remap + + +# Return a float version with NaNs to improve plotting +def veg2img(lc): + new_lc = np.nan * np.ones(lc.shape, 'd') + for i in set(lc.ravel()): + new_lc[lc == i] = i + new_lc[lc == 255] = np.nan + return new_lc + + +# Reprojects land cover from the NSSI default CRS into (ugh) Lat/Long the CRS of the bands +def reprojectLandCover(dem_profile, nssiImg_filename, lc_filename): + rio_profile = dem_profile.copy() + rio_profile.pop('blockxsize') + rio_profile.pop('blockysize') + rio_profile.pop('tiled') + rio_profile['nodata'] = 255 + rio_profile['driver'] = 'GTiff' + + with rasterio.open(nnsiImg_filename, 'r') as fin: + with rasterio.open(lc_filename, 'w', **rio_profile) as fout: + rasterio.warp.reproject( + source=rasterio.band(fin, 1), + destination=rasterio.band(fout, 1), + src_transform=fin.transform, + src_crs=fin.crs, + dst_transform=rio_profile['transform'], + dst_crs=rio_profile['crs'], + resampling=rasterio.enums.Resampling.nearest) + + + + +# Determine soil structure according to land cover +@attr.s +class SoilHorizons: + acrotelm = attr.ib() + catotelm = attr.ib() + +soil_horizons = dict() +soil_horizons['riparian sparse_veg'] = SoilHorizons(acrotelm=0, catotelm=0) +soil_horizons['hillslope sparse_veg'] = SoilHorizons(acrotelm=0, catotelm=0) + +soil_horizons['riparian sedge'] = SoilHorizons(acrotelm=0.10, catotelm=0.30) +soil_horizons['hillslope sedge'] = SoilHorizons(acrotelm=0.08, catotelm=0.20) + +soil_horizons['riparian shrub'] = SoilHorizons(acrotelm=0.12, catotelm=0.24) +soil_horizons['hillslope shrub'] = SoilHorizons(acrotelm=0.14, catotelm=0.14) + +soil_horizons['riparian tussock'] = SoilHorizons(acrotelm=0.10, catotelm=0.14) +soil_horizons['hillslope tussock'] = SoilHorizons(acrotelm=0.10, catotelm=0.14) + +soil_horizons['average'] = SoilHorizons(acrotelm=0.1, catotelm=0.2) + + + +# Given a soil cell thickness dz, determine the material label of each cell +def soilStructure(dz, land_cover): + ''' + 1000 = mineral + 1001 = acrotelm + 1002 = catotelm + ''' + if land_cover == -999: + lc_name = 'average' + elif land_cover < 110: + lc_name = 'hillslope ' + vegClasses()[land_cover - 100] + else: + lc_name = 'riparian ' + vegClasses()[land_cover - 110] + + horizons = soil_horizons[lc_name] + z_depth = np.cumsum(dz) + soil_type = np.where(z_depth < horizons.acrotelm, 1001, + np.where(z_depth < horizons.acrotelm + horizons.catotelm, 1002, 1000)) + + return soil_type \ No newline at end of file diff --git a/new_scripts/meshing.py b/new_scripts/meshing.py new file mode 100644 index 0000000..7c1f118 --- /dev/null +++ b/new_scripts/meshing.py @@ -0,0 +1,187 @@ +import numpy as np +import scipy +import hillslopes +import landcover +import workflow +import os + +# Given a hillslope's parameters, generate the mesh parameters +def parameterizeMesh(hillslope, dx, + riparian_slope_min=0.01, + hillslope_slope_min=0.1, + min_area_ratio=0.1): + mesh = dict() + + # 1. Determine x coordinate + mesh['huc'] = hillslope['huc'] + mesh['subcatchment_id'] = hillslope['subcatchment_id'] + mesh['dx'] = dx + mesh['num_cells'] = int(np.round(hillslope['total_length'] / dx)) + mesh['length'] = mesh['dx'] * mesh['num_cells'] + mesh['x'] = np.linspace(0, mesh['length'], mesh['num_cells']) + + # 2. Determine z coordinate + # 2.1 Interpolate from (x,z)=(0,0), and (x,z)=(bin_centroid,bin_average) + x_bin = np.concatenate([np.array([0.,]), (np.arange(0,hillslope['num_bins']) + 0.5)*hillslope['bin_dx']]) + z_bin = np.concatenate([np.array([0.,]), hillslope['elevation']]) + z_native = np.interp(mesh['x'], x_bin, z_bin) + z = scipy.signal.savgol_filter(z_native, window_length=11, polyorder=3) + z = z - z[0] + + # 2.2 Determine riparian area and hillslope area according to slope + slope = (z[1:] - z[0:-1]) / (mesh['x'][1:] - mesh['x'][0:-1]) + riparian = np.zeros(slope.shape, 'i') + i = 0 + while i < len(slope) and slope[i] < 0.1: # in the riparian zone + riparian[i] = 1 + if slope[i] < riparian_slope_min: + z[i+1] = riparian_slope_min * (mesh['x'][i+1] - mesh['x'][i]) + z[i] + i += 1 + + if i == 1: + mesh['riparian_width'] = 0 + else: + mesh['riparian_width'] = (mesh['x'][i-1] + mesh['x'][i])/2. + + while i < len(slope): # hillslope starts from here + if slope[i] < hillslope_slope_min: + z[i+1] = hillslope_slope_min * (mesh['x'][i+1] - mesh['x'][i]) + z[i] + i += 1 + + mesh['riparian'] = riparian + + # smooth z once more to deal with discontinuities + z = scipy.signal.savgol_filter(z, window_length=5, polyorder=3) + z = z - z[0] + mesh['z'] = z + + # 3. Determine y coordinate + # 3.1 Interpolate bins to create a bin-consistent profile + y = np.interp(mesh['x'], x_bin[1:], hillslope['bin_counts']) + + # 3.2 Smooth y + y = scipy.signal.savgol_filter(y, window_length=51, polyorder=3, mode='nearest') + + # 3.3 Don't let individual areas get too small -- 10% mean as a min value? + min_y = min_area_ratio * y.mean() + y = np.maximum(y, min_y) + + # 3.4 Scale by area ratios to ensure that the final mesh has the identical surface area as the subcatchment it represents + y_factor = hillslope['total_area'] / np.trapz(y, mesh['x']) + y = y_factor * y + mesh['y'] = y + + # 4. Resample land cover onto mesh + land_cover_mesh = np.zeros(slope.shape, 'i') + def lc_index(lc_type, is_riparian): + if is_riparian: + return lc_type + 10 + else: + return lc_type + + for i in range(len(land_cover_mesh)): + x = (mesh['x'][i] + mesh['x'][i+1])/2 + j_bin = np.where(x_bin>x,x_bin,np.inf).argmin()-1 +# j_bin = int(np.round(x / hillslope['bin_dx'] - 0.5)) # THE OLD + land_cover_mesh[i] = lc_index(hillslope['land_cover'][j_bin], riparian[i]) + mesh['land_cover'] = land_cover_mesh + + # 5. Add aspect to mesh + mesh['aspect'] = hillslope['aspect'] + + return mesh + + + +# Take mesh parameters and turn those into a 2D surface transect mesh +def createHillslopeMesh2D(mesh_pars): + labeled_sets = list() + for i,vtype in zip(range(100, 104), landcover.vegClasses()): + labeled_sets.append(workflow.mesh.LabeledSet(f'hillslope {vtype}', i, 'CELL', + [int(c) for c in np.where(mesh_pars['land_cover'] == i)[0]])) + for i,vtype in zip(range(110, 114), landcover.vegClasses()): + labeled_sets.append(workflow.mesh.LabeledSet(f'riparian {vtype}', i, 'CELL', + [int(c) for c in np.where(mesh_pars['land_cover'] == i)[0]])) + assert(min(mesh_pars['y']) > 0) + m2 = workflow.mesh.Mesh2D.from_Transect(mesh_pars['x'], mesh_pars['z'], mesh_pars['y'], + labeled_sets=labeled_sets) + rotation = 90 + mesh_pars['aspect'] # 90 makes the aspect due north + m2.transform(mat=workflow.mesh.transform_rotation(np.radians(rotation))) + return m2 + + +# Preparing layer extrusion data +# +# Meshes are extruded in the vertical by "layer", where a layer may consist of multiple cells in the z direction. +# These layers are logical unit to make construction easier, +# and may or may not correspond to material type (organic/mineral soil). +# +# The extrusion process is then given four lists, each of length num_layers. +def layeringStructure(organic_cells=30, organic_cell_dz=0.02, + increase2depth=9.4, increase_cells=20, largest_dz=2.0, + bottom_depth=45): + layer_types = [] # a list of strings that tell the extruding code how to do the layers. + # See meshing_ats documentation for more, but here we will use only "constant", + # which means that dz within the layer is constant. + + layer_data = [] # this data depends upon the layer type, but for constant is the thickness of the layer + + layer_ncells = [] # number of cells (in the vertical) in the layer. + # The dz of each cell is the layer thickness / number of cells. + + # 30 layers at 2cm makes 60cm of cells, covering the deepest organic layer and getting into mineral soil + n_top = organic_cells + dz = organic_cell_dz + current_depth = 0 + for i in range(n_top): + layer_types.append('constant') + layer_data.append(dz) + layer_ncells.append(1) + + # telescope from 2cm to 2m + dzs, res = workflow.mesh.optimize_dzs(organic_cell_dz, largest_dz, increase2depth, increase_cells) + for dz in dzs: + layer_types.append('constant') + layer_data.append(dz) + layer_ncells.append(1) + + num_at_2m = int(np.round((bottom_depth - sum(layer_data)) / largest_dz)) + for i in range(num_at_2m): + layer_types.append('constant') + layer_data.append(2) + layer_ncells.append(1) + + return layer_types, layer_data, layer_ncells + + + +# Exstrude the 2D hillslope surface mesh downward to construct 3D hillslope mesh +def createHillslopeMesh3D(m2, mesh_pars, layer_info, mesh_fname): + if os.path.isfile(mesh_fname): + os.remove(mesh_fname) + + layer_types, layer_data, layer_ncells = layer_info + layer_mat_ids_near_surface = np.array([landcover.soilStructure(layer_data, mesh_pars['land_cover'][c]) + for c in range(m2.num_cells())]).transpose() + layer_mat_ids = list(layer_mat_ids_near_surface) + m3 = workflow.mesh.Mesh3D.extruded_Mesh2D(m2, layer_types, layer_data, layer_ncells, layer_mat_ids) + m3.write_exodus(mesh_fname) + + + +# Create column mesh for spinup +def createColumnMesh(layer_info, filename): + m2 = workflow.mesh.Mesh2D.from_Transect(np.array([-0.5, 0.5]), np.array([0., 0.]), 1.0) + + layer_types, layer_data, layer_ncells = layer_info + layer_mat_ids = list(landcover.soilStructure(layer_data, -999)) + + m3 = workflow.mesh.Mesh3D.extruded_Mesh2D(m2, layer_types, layer_data, layer_ncells, layer_mat_ids) + m3.write_exodus(filename) + + + + + + + \ No newline at end of file diff --git a/new_scripts/plot.py b/new_scripts/plot.py new file mode 100644 index 0000000..ad315ae --- /dev/null +++ b/new_scripts/plot.py @@ -0,0 +1,20 @@ +import matplotlib.pyplot as plt + + +def plot(hillslope_pars, mesh_pars, fig=None, axs=None, color='k'): + """plotting routine""" + if fig is None: + fig = plt.figure() + if axs is None: + axs = fig.subplots(2,1, sharex=True) + fig.subplots_adjust(hspace=0) + + axs[0].plot(mesh_pars['x'], mesh_pars['z']) + axs[0].set_xticklabels([]) + axs[0].set_ylabel('elev [m]') + axs[0].yaxis.set_label_position("right") + + axs[1].plot(mesh_pars['x'], mesh_pars['y']) + axs[1].set_xlabel('hillslope length [m]') + axs[1].set_ylabel('width') + axs[1].yaxis.set_label_position("right") \ No newline at end of file From d278b3d93fe1d3bf623f565a0a3088139ac08e92 Mon Sep 17 00:00:00 2001 From: Bo Gao <83304414+gaobhub@users.noreply.github.com> Date: Thu, 23 Sep 2021 13:55:12 -0500 Subject: [PATCH 2/4] updated data_package to create parameters, meshes, daymet for a huc --- new_scripts/hillslopes.py | 70 +- new_scripts/huc_process.ipynb | 8496 +++++++++++++++++++++++---------- new_scripts/landcover.py | 2 +- new_scripts/meshing.py | 75 +- 4 files changed, 6009 insertions(+), 2634 deletions(-) diff --git a/new_scripts/hillslopes.py b/new_scripts/hillslopes.py index 4eb5b24..c845a84 100644 --- a/new_scripts/hillslopes.py +++ b/new_scripts/hillslopes.py @@ -51,10 +51,6 @@ def register_raster(key, filename): filenames['flowpaths'] = os.path.join(ppm_dir, 'flowpaths', f'hs_{{}}_flowpaths.pkl') register_raster('flowpath_length', f'huc_{huc}_flowpath_lengths') # flowpaths within the delineated subcatchments register_raster('elev_above_streams', f'huc_{huc}_elev_above_streams') - - filenames['daymet'] = os.path.join(huc_directory, 'daymet', f'huc_{huc}_subcatchment{{}}_1980_2020.h5') - filenames['mesh'] = os.path.join(huc_directory, 'mesh', f'sag_hillslope{{}}.exo') - return filenames @@ -163,8 +159,8 @@ def loadSubcatchmentShape(filename, subcatch_id): # Load a subcatchment raster -def loadSubcatchmentRaster(filename, subcatch_shape, subcatch_crs, nanit=True): - profile, raster = workflow.get_raster_on_shape(filename, subcatch_shape, subcatch_crs, mask=True) +def loadSubcatchmentRaster(filename, subcatch, subcatch_crs, nanit=True): + profile, raster = workflow.get_raster_on_shape(filename, subcatch, subcatch_crs, mask=True) if nanit: raster[raster==profile['nodata']] = np.nan return profile, raster @@ -177,21 +173,24 @@ def parameterizeSubcatchment(filenames, huc, subcatch_id, hillslope_bin_dx=100): # Find the given subcatchment shape - subcatch_crs, subcatch_shape = loadSubcatchmentShape(filenames['subcatchments'], subcatch_id) + subcatch_crs, subcatch = loadSubcatchmentShape(filenames['subcatchments'], subcatch_id) # Create a dictionary icluding all hillslope info and parameters hillslope = dict() hillslope['huc'] = huc hillslope['subcatchment_id'] = subcatch_id - hillslope['subcatchment'] = subcatch_shape - hillslope['centroid'] = subcatch_shape.centroid.coords[0] # lat/long, required to get meteorological data - hillslope['total_area'] = workflow.warp.shply(subcatch_shape, subcatch_crs, target_crs).area # m^2 + hillslope['centroid'] = subcatch.centroid.coords[0] # lat/long, required to get meteorological data + hillslope['subcatchment'] = workflow.warp.shply(subcatch, subcatch_crs, target_crs) + hillslope['subcatchment_native_crs'] = subcatch_crs + hillslope['subcatchment_target_crs'] = target_crs + hillslope['total_area'] = hillslope['subcatchment'].area # m^2 + # Procedures to determine a single hillslope profile geometry for each subcatchment # Most of the parameters are based on bins in length of flowpath to the stream network # 1. Load raster of flowpath lengths for the given subcatchment - fp_profile, fp_lengths = loadSubcatchmentRaster(filenames['flowpath_length'], subcatch_shape, subcatch_crs) + fp_profile, fp_lengths = loadSubcatchmentRaster(filenames['flowpath_length'], subcatch, subcatch_crs) subcatch_mask = ~np.isnan(fp_lengths) hillslope['raster_profile'] = fp_profile @@ -238,7 +237,7 @@ def parameterizeSubcatchment(filenames, huc, subcatch_id, # 5. Average elevation (height over stream) for each bin and save to dictionary - _, elevs = loadSubcatchmentRaster(filenames['elev_above_streams'], subcatch_shape, subcatch_crs) + _, elevs = loadSubcatchmentRaster(filenames['elev_above_streams'], subcatch, subcatch_crs) elev_bins = np.zeros((hillslope['num_bins'],),'d') for i in range(hillslope['num_bins']): elev_bins[i] = elevs[(hillslope['bins'] == i) & (~np.isnan(elevs))].mean() @@ -246,11 +245,12 @@ def parameterizeSubcatchment(filenames, huc, subcatch_id, hillslope['elevation'] = elev_bins # 6. Average aspect across the entire subcatchment and save to dictionary - _, aspects = loadSubcatchmentRaster(filenames['aspect'], subcatch_shape, subcatch_crs) + _, aspects = loadSubcatchmentRaster(filenames['aspect'], subcatch, subcatch_crs) hillslope['aspect'] = meanAspect(aspects) # 7. Get land cover using mode for each bin and save to dictionary - lc_profile, lc = loadSubcatchmentRaster(filenames['land_cover'], subcatch_shape, subcatch_crs, False) # don't nan-it + lc_profile, lc = loadSubcatchmentRaster(filenames['land_cover'], subcatch, subcatch_crs, False) # don't nan-it + assert(lc_profile['nodata'] == 255) # uint8, nan is -1 == 255 # classify land cover into veg classes hillslope['lc'] = lc @@ -265,8 +265,48 @@ def parameterizeSubcatchment(filenames, huc, subcatch_id, hillslope['land_cover'] = lc_bins hillslope['land_cover_raster'] = landcover.veg2img(lc) - return hillslope + + # 8. Smooth subcatchment for easier 3D simulation + def smoothSubcatchmentShape(subcatch, subcatch_crs, smoothing_factor=100, plot=False): + if type(subcatch) is shapely.geometry.MultiPolygon: + subcatch_simp = shapely.ops.cascaded_union(subcatch.buffer(100)) + if type(subcatch_simp) is shapely.geometry.MultiPolygon: + # see if this is one tiny island + total_area = sum(p.area for p in subcatch_simp) + assert(total_area > 0) + polygons = [p for p in subcatch_simp if p.area/total_area > 0.01] + if len(polygons) > 1: + # give up, this will throw + return shapely.geometry.MultiPolygon(polygons) + + subcatch_simp = polygons[0] + subcatch_simp = subcatch_simp.simplify(smoothing_factor) + else: + subcatch_simp = subcatch.simplify(smoothing_factor) + + # find a buffer value that matches the original area + def optimize_func(radius): + subcatch_buff = subcatch_simp.buffer(radius).simplify(smoothing_factor) + return abs(subcatch_buff.area - subcatch.area) + + res = scipy.optimize.minimize_scalar(optimize_func) + subcatch_new = subcatch_simp.buffer(res.x).simplify(smoothing_factor) + if plot: + print("error: ", subcatch.area - subcatch_new.area) + fig, ax = workflow.plot.get_ax(crs=subcatch_crs) + workflow.plot.shply(subcatch_new, subcatch_crs, 'r', ax=ax) + workflow.plot.shply(subcatch, subcatch_crs, 'b', ax=ax) + + return subcatch_new + + subcatch_new = smoothSubcatchmentShape(hillslope['subcatchment'], + hillslope['subcatchment_target_crs'], + smoothing_factor=100, plot=False) + + hillslope['subcatchment_smooth'] = subcatch_new + + return hillslope diff --git a/new_scripts/huc_process.ipynb b/new_scripts/huc_process.ipynb index 753065d..a370c2d 100644 --- a/new_scripts/huc_process.ipynb +++ b/new_scripts/huc_process.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 1, "id": "b92fa29a", "metadata": {}, "outputs": [], @@ -229,31 +229,31 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:32,567 - root - INFO: \n", - "2021-09-20 23:15:32,569 - root - INFO: Loading HUC 190604020404\n", - "2021-09-20 23:15:32,570 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:32,571 - root - INFO: \n", - "2021-09-20 23:15:32,572 - root - INFO: Loading level 12 HUCs in 190604020404\n", - "2021-09-20 23:15:32,573 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:32,575 - root - INFO: Using HUC file \"../huc/190604020404/data_raw-hillslope/hydrography/WBD_19_GDB/WBD_19.gdb\"\n", - "2021-09-20 23:15:34,798 - root - INFO: ... found 1 HUCs\n", - "2021-09-20 23:15:34,798 - root - INFO: -- 190604020404\n", - "2021-09-20 23:15:34,813 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:34,817 - root - INFO: ... found 1\n", - "2021-09-20 23:15:34,818 - root - INFO: \n", - "2021-09-20 23:15:34,818 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:34,818 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:34,819 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:34,850 - root - INFO: Collecting DEMs to tile bounds: [-149.3337383807433, 68.15835009523077, -148.79217986384458, 68.33619896061079]\n", - "2021-09-20 23:15:34,851 - root - INFO: Need:\n", - "2021-09-20 23:15:34,851 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w150.tif\n", - "2021-09-20 23:15:34,852 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w149.tif\n", - "2021-09-20 23:15:34,852 - root - INFO: source files already exist!\n", - "2021-09-20 23:15:34,941 - root - INFO: ... got raster of shape: (641, 1950)\n", - "2021-09-20 23:15:34,950 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:34,982 - root - INFO: shape bounds: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n", - "2021-09-20 23:15:34,987 - root - INFO: casting mask of dtype: float32 to: nan\n", - "2021-09-20 23:15:34,989 - root - INFO: ... got raster bounds: (-149.3337383807433, 68.33619896061079, -148.79207171405866, 68.15814340504932)\n" + "2021-09-23 13:19:22,496 - root - INFO: \n", + "2021-09-23 13:19:22,497 - root - INFO: Loading HUC 190604020404\n", + "2021-09-23 13:19:22,497 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:22,498 - root - INFO: \n", + "2021-09-23 13:19:22,499 - root - INFO: Loading level 12 HUCs in 190604020404\n", + "2021-09-23 13:19:22,500 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:22,501 - root - INFO: Using HUC file \"../huc/190604020404/data_raw-hillslope/hydrography/WBD_19_GDB/WBD_19.gdb\"\n", + "2021-09-23 13:19:24,538 - root - INFO: ... found 1 HUCs\n", + "2021-09-23 13:19:24,539 - root - INFO: -- 190604020404\n", + "2021-09-23 13:19:24,549 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:24,550 - root - INFO: ... found 1\n", + "2021-09-23 13:19:24,551 - root - INFO: \n", + "2021-09-23 13:19:24,551 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:24,552 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:24,553 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:24,583 - root - INFO: Collecting DEMs to tile bounds: [-149.3337383807433, 68.15835009523077, -148.79217986384458, 68.33619896061079]\n", + "2021-09-23 13:19:24,585 - root - INFO: Need:\n", + "2021-09-23 13:19:24,585 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w150.tif\n", + "2021-09-23 13:19:24,585 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w149.tif\n", + "2021-09-23 13:19:24,586 - root - INFO: source files already exist!\n", + "2021-09-23 13:19:24,679 - root - INFO: ... got raster of shape: (641, 1950)\n", + "2021-09-23 13:19:24,688 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:24,719 - root - INFO: shape bounds: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n", + "2021-09-23 13:19:24,723 - root - INFO: casting mask of dtype: float32 to: nan\n", + "2021-09-23 13:19:24,725 - root - INFO: ... got raster bounds: (-149.3337383807433, 68.33619896061079, -148.79207171405866, 68.15814340504932)\n" ] } ], @@ -292,7 +292,7 @@ "text": [ "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", " proj_string = self.to_proj4()\n", - "2021-09-20 23:15:35,185 - root - INFO: BOUNDS: (-149.3337383807433, 68.15814340504932, -148.79207171405866, 68.33619896061079)\n" + "2021-09-23 13:19:24,915 - root - INFO: BOUNDS: (-149.3337383807433, 68.15814340504932, -148.79207171405866, 68.33619896061079)\n" ] }, { @@ -379,7 +379,7 @@ "id": "89ad20b5", "metadata": {}, "source": [ - "## Load the shapefiles of subcatchments and flowpaths from source" + "## Load all subcatchments and flowpaths from source" ] }, { @@ -392,13 +392,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:41,924 - root - INFO: \n", - "2021-09-20 23:15:41,926 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:41,927 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:41,928 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:41,983 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:41,984 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:42,009 - root - INFO: Converting to requested CRS\n" + "2021-09-23 13:19:25,085 - root - INFO: \n", + "2021-09-23 13:19:25,086 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:25,086 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:25,087 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:25,136 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:25,137 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:25,160 - root - INFO: Converting to requested CRS\n" ] }, { @@ -432,7 +432,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:43,741 - root - INFO: BOUNDS: (-149.3337383807433, 68.15814340504932, -148.79207171405866, 68.33619896061079)\n" + "2021-09-23 13:19:25,325 - root - INFO: BOUNDS: (-149.3337383807433, 68.15814340504932, -148.79207171405866, 68.33619896061079)\n" ] }, { @@ -477,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "cf5331c8", "metadata": {}, "outputs": [], @@ -497,7 +497,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "09835626", "metadata": { "scrolled": false @@ -507,17 +507,17 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:45,720 - root - INFO: \n", - "2021-09-20 23:15:45,722 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:45,723 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:45,724 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:45,725 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:45,779 - root - INFO: ... got raster of shape: (570, 1879)\n", - "2021-09-20 23:15:45,788 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:45,821 - root - INFO: shape bounds: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n", - "2021-09-20 23:15:45,825 - root - INFO: casting mask of dtype: float32 to: nan\n", - "2021-09-20 23:15:45,826 - root - INFO: ... got raster bounds: (-149.32401615852078, 68.32647673838824, -148.802071714059, 68.16814340504965)\n", - "2021-09-20 23:15:45,943 - root - INFO: BOUNDS: (-149.32401615852078, 68.16814340504965, -148.802071714059, 68.32647673838824)\n" + "2021-09-23 13:19:25,482 - root - INFO: \n", + "2021-09-23 13:19:25,482 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:25,483 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:25,483 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:25,484 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:25,535 - root - INFO: ... got raster of shape: (570, 1879)\n", + "2021-09-23 13:19:25,544 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:25,578 - root - INFO: shape bounds: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n", + "2021-09-23 13:19:25,583 - root - INFO: casting mask of dtype: float32 to: nan\n", + "2021-09-23 13:19:25,584 - root - INFO: ... got raster bounds: (-149.32401615852078, 68.32647673838824, -148.802071714059, 68.16814340504965)\n", + "2021-09-23 13:19:25,695 - root - INFO: BOUNDS: (-149.32401615852078, 68.16814340504965, -148.802071714059, 68.32647673838824)\n" ] }, { @@ -605,7 +605,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "cbceae4f", "metadata": { "scrolled": false @@ -615,39 +615,39 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:48,690 - root - INFO: \n", - "2021-09-20 23:15:48,691 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:48,692 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:48,693 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:48,700 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:48,701 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:48,757 - root - INFO: \n", - "2021-09-20 23:15:48,758 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:48,758 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:48,758 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:48,759 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:48,803 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-20 23:15:48,812 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:48,844 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:15:48,845 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:48,846 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-20 23:15:48,849 - root - INFO: \n", - "2021-09-20 23:15:48,849 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:48,850 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:48,850 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:48,851 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:48,894 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-20 23:15:48,904 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:48,933 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:15:48,935 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:48,936 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-20 23:15:48,939 - root - INFO: \n", - "2021-09-20 23:15:48,939 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:48,940 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:48,940 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:48,941 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:48,982 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-20 23:15:48,990 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:25,805 - root - INFO: \n", + "2021-09-23 13:19:25,805 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:25,806 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:25,806 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:25,811 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:25,812 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:25,866 - root - INFO: \n", + "2021-09-23 13:19:25,866 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:25,867 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:25,867 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:25,868 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:25,917 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-23 13:19:25,927 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:25,959 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-23 13:19:25,961 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:25,961 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-23 13:19:25,964 - root - INFO: \n", + "2021-09-23 13:19:25,965 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:25,965 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:25,965 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:25,966 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:26,009 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-23 13:19:26,018 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:26,050 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-23 13:19:26,052 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:26,053 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-23 13:19:26,056 - root - INFO: \n", + "2021-09-23 13:19:26,057 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:26,057 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:26,057 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:26,058 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:26,102 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-23 13:19:26,111 - root - INFO: Masking to shape\n" ] }, { @@ -663,19 +663,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:49,021 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:15:49,022 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:49,023 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-20 23:15:49,025 - root - INFO: \n", - "2021-09-20 23:15:49,025 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:49,025 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:49,026 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:49,026 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:49,066 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-20 23:15:49,075 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:49,105 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:15:49,107 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:49,108 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n" + "2021-09-23 13:19:26,143 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-23 13:19:26,145 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:26,146 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-23 13:19:26,148 - root - INFO: \n", + "2021-09-23 13:19:26,148 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:26,149 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:26,149 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:26,149 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:26,191 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-23 13:19:26,200 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:26,231 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-23 13:19:26,233 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:26,234 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n" ] }, { @@ -689,15 +689,15 @@ "source": [ "hillslope_demo_pars = hillslopes.parameterizeSubcatchment(\n", " filenames, huc, subcatch_demo_id,\n", - " target_crs=workflow.crs.default_alaska_crs(),\n", + " target_crs=target_crs,\n", " hillslope_keep_fraction=hillslope_keep_fraction,\n", " hillslope_bin_dx=hillslope_bin_dx)\n", "\n", - "mesh_demo_pars = mesh.parameterizeMesh(hillslope_demo_pars, mesh_dx,\n", + "mesh_demo_pars = meshing.parameterizeMesh(hillslope_demo_pars, mesh_dx,\n", " riparian_slope_min=riparian_slope_min,\n", " hillslope_slope_min=hillslope_slope_min,\n", " min_area_ratio=min_area_ratio)\n", - "# # print(hillslope.keys())" + "# print(hillslope.keys())" ] }, { @@ -710,7 +710,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "8d9e358a", "metadata": {}, "outputs": [ @@ -720,13 +720,13 @@ "text": [ "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", " proj_string = self.to_proj4()\n", - "2021-09-20 23:15:51,688 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:15:51,793 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n" + "2021-09-23 13:19:26,397 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n", + "2021-09-23 13:19:26,500 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbYAAAHoCAYAAAAljcr3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABs0klEQVR4nO3dd3yV5fn48c+VkASyGFmskDDCRraCu2IFrdZNtS7Ur9hqq9Rqkbbu1lFHsb9WW1qtigv3qIPhQBQUiAyRDSasDMLIYARI7t8fz3OSk5OzM87I9X698so5z7yTnJzrXPcUYwxKKaVUtIgJdQGUUkqp5qSBTSmlVFTRwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkUVDWwq4ohIgYicGeIyGBHpF8oyKKXc08CmFCAip4vIjlCXI1Ai8pyI/MnHMSNEZJGIlIvIDhG5u7XKp1QoaGBTKvq9DHwBdAFOA34pIj8NbZGUajka2FTIiMh0EdkpIpUiskFEJtjbG2QhHrKpsSKyVkT2ich/RaS90/Hni8hKEakQkS0iMsnefq2IrLPvt1VEbrS3JwEfAd1FpMr+6i4isSLye/salSKSLyLZTmU4U0Q22WX4h4iIfb0pIvKViPxVRPbb9zrR3r5dREpF5Bqn8iaIyGMisk1ESkTknyLSwflnF5Hf2ucVici19r6pwBXA7+wyv+/hV50LvGSMqTHGbAG+BIYE/AdTKkJoYFMhISIDgF8BY40xKcBEoCCAS1xhn9MX6A/80b7u8cALwB1AJ+BUp+uWAucCqcC1wF9FZJQx5gBwNrDLGJNsf+0CbgMuB86xz7kOOOhUhnOBscBwYLJdHocTgNVAGlbG9Kp9bD/gSuDvIpJsH/uI/TOMsPf3AJyrC7sCHe3t1wP/EJHOxphZwEvAX+wyn+fhdzUTuFpE4uzf+3hggYdjlYp4GthUqNQACcBgEYkzxhTY2YS//m6M2W6M2Qv8GSsAgfXG/6wxZr4xptYYs9MYsx7AGPOBMWaLsSwE5gGneLnH/wF/NMZssM9ZZYzZ47T/YWPMfmPMNuAzrMDk8IMx5r/GmBpgDpAN3G+MqTbGzAOOAP3sLO8G4DfGmL3GmErgQeAyp2sdtc89aoz5EKgCBgTwu/ofcAlwCFgPPGOMWRbA+UpFFA1sKiSMMZuBacC9QKmIvCoi3QO4xHanx4WA49xswG2AFJGzReRrEdkrIvuxMrF0L/fweC1bsdPjg0Cy0/MSp8eHAIwxrtuSgQwgEci3qy33Ax/b2x32GGOOebmXRyLSxb7e/UB7rJ9poojc5M/5SkUiDWwqZIwxLxtjTgZyAINVJQdwAOvN3qGrm9Od27p6Abvsx9uxqicbEJEE4E3gMSDLGNMJ+BAQR3Hc3MPttZpZGVaQG2KM6WR/dTTG+BW4cF9uZ32AGmPMC8aYY8aYHVjVouc0ocxKhTUNbCokRGSAiJxhB5zDWG/uNfbulcA5ItJFRLpiZXaubhaRnnZG8nus6j6AZ4BrRWSCiMSISA8RGQjEY1V97gaOicjZwFlO1ysB0kSko9O2/wAPiEieWI4TkbTm+PkdjDG1wL+x2vsyAewyT/R+ZoNy9/Gyf6N1Sfm5/fvoCvwMWNWUcisVzjSwqVBJAB7GyliKgUysAAUwG+uNtwCrHWyOm/Nftvdttb/+BGCMWYrdMQQoBxYCOXbb1S3Aa8A+4OfAe46L2e1wrwBb7SrB7sAT9vHzgAqsoNmhOX54F9OBzcDXIlKB1bHD3za0Z7DaKfeLyDuuO40xFcBFwG+wfu6VwBqsdkmlopLoQqNKKaWiiWZsSimloooGNqWUUlFFA5tSSqmoooFNKaVUVNHAppRSKqq0C3UBfJk0aZIpKysLdTGUUipk8vPz6x7Hx8czbNgwX8fPNcZMaulyhauwD2xlZWWUlZVRWFgY6qL4lJOTQ0FBQaiLoZSKULm5uW7f63Jyciiwt+d269Yg0Hngbaq4qBf2gQ2gsLCQpoy3u9SI74P89PoDwAo3O9422KuWKKVUUOre61zfS5yCXYG3D/n2+2Rbfy+KiMAWLq4RaH+PofrupxrtM1ifqoJ5QWmmp8KZuyxCX7PB85SVgfV7bY7rt3VhP/PImDFjTH5+vs+MrTmzMoDXDwOJrteciJz3Jxj5TcDXW3nfzQwfA1PyDa6rQe5FmpSRKtWSRIQT90JVF8PqtFr+XhbLrwR9zQZJxP5/f1fgAuAdeP98OK8P8EMAF/Lw+7c/XOcbY8Y0tayRKiICm6ONzflTYnMHMlevXwRy3D+a7Xrmg5tJy3f/u95PLrW0bBuifsJWgarLLDp1hul3Ntz5yMOwf19oChYirv9D3jIvr9chsBV1PQUwb+1xhYWFbTqwRURVpOPFFGy98XECV8ijrGC83+cM4CQ4rnGVo7/O+N3NfJIMMBSAmRSyNxHMLrHmVndn7mRmcydXMQoyYXbpt3W7rto/CjoNrXs+he8aZX7u7B1fgPl1b+Tn4d/5RoWXwsJCeOgRzJrpMGO63+cVcxf9ub/R9o3cTVcecHvOgxTzMFlu911mhFmnumy8FuSOGph5A2b5s/Btw93LFr3ACsb6XWZXT24bxPcHGm6TQQ3/hwoLCzHrgEFB36ZJvPU9aOttbBGRsS1fvhyo/4Tib+Z2nL3rWqCfuG8bayo57jO321dc/AY3iGmwSuXeRDCnCGvmPs0KTmAlgxnB2rrv7jj2XfXyKNJ+7v1vtTcRGF7QcOO1MzFTi8hgEWUUeT3fU1YX7CfTQO+jQsv175zTA9p9Dv8vby4/a7DCT8urTKute3ygLJYXZV2D/VP5MXL7g9zw6NWMcdnny0oGsAZhKIYRbOBFBtbtc2w72wwi2+WtJRca1KsEnHm54+f7b6DtnCKiGVukCCRzez0GBthrMP4ZqD7PZ/fYgNXedzNPivs3/M94vNHSy10OgvR7k1EvXEx+1mTAqt7xFNR87XN15QFhdoPlxIAlMJvPeII73Z/k5OrCUW63FxYWYoAi7qbboPth3Yl+l8nZSXsX81Vn7T0arhwZwGVircA6bidckzePO1s7qE1Yj1k2CCp6AnBErm90zCzmYx77MUceu57nArx+VxPDUw+A3G3oxkB2vSPwvLXvkjeBGPeBsiDA+zSnpvYMb2siKrA5OHofWp9YrD/2pUb4q9P75Zt8ycYmZGhy3GfccvEb3o+5AR6gV0DX7fKPi/j22x+wluCyuMvYVjKYmSTUPb9qWuNr7U0Ern0Lhn8BwOxyK4i54y07rL+X+16dOSQAo+nGAr+CWhFn8l9uZhWZDbbP7yxwqpCT0LSqEs34mj+LBhBySHX6s3wIfOgS1CrTamHmDf5d8Lk7SPlkYKPNlbfPhuGfezztxJ88y7IuvqsSZzHf47577SzsAvvD7dPU/2BmPXA3JC44kaIX77U6cNjeOAzCQOuYpmpCNuaqOXpLtiURGdgcb2q5ubn1AW4dyICD9Qed53+m407tuDc4Xry/MI9v0h3qucvKviOBmp+LtZwmEFtq6OR60PACzD8uZg1PAzB76reuRzS6h8d7PSpwh7szA8/OpnEfc56Rxms02+0kBU35xX1h6v7u7kRC0GuOoJSTk0OZgSwx1PQvtzaO+K7+gJGLYUXjv50ZewqpdwT/yf/ETbF81uV6VnGaz2OHmEF0dfkfqrx9Nuax37OMB72ceXqT2sdWMsDKwlbDqXcbFk2Zh3nOaUFyu03swJlLAJeFyhPBIM3WbuZv0NJsrHlFZGBzaFA12cFgtoHc43+Wdut9N3MtcN73KexYP5EVF7/BcY6dY2hUlRiMvTe/xZV/v7jBtuHAGnma2Yxk/kN/cXtev0tGQR44Aktt//2wsRN7Z03jyhuerLsOMpkVnBBwuaYwklr73q73CsZxfMV3jnaRmdczZxnuB7IHY1E2N1HIU+TAqcLrhbP5LVfyshF6unyydm3gD0d11Uo3CMf/x7DsprcYdffFPNH1LU5rd5F10LEhdP7K0Kdv4w8ig7Ng9qpCmIQV1JwDmpNX55zCSNeNQSbKlWm1nLgplq9qYBa3+3XO2GlWxw9nU4BljwXXseNGBsLMu70e023a/VyAsbrPnwX5J57IfROWEHB9pTcBBCGtQgyNiOo84oljQGJBQUFAgc18cDPH5xtuMsLd36dw29A1AVct+jLDCFniPpO6un9vzMbO+BNQpP8HdNnYiT0rhNkjG17Pn84nrhLMKCZL8IHM1RKzmPGuPdeayamLDF+sE2SwwZwsDH0J1hxwf2zupJwWn37Nn6zQ1yDcgoICVtpRprdM44zimX7ff3AWlIph3uQvG++0M7W4q//Eu+fe1mydPipvn031Ywt5zs+g1hLcdehwlbRgPH8981nAqo7c1VsCGxvmh9wc/19joapB0M4jUaCgoKCuasrcdxPgPnPLnnwn2z6vrHu+P/83bAGmxMGUKZUc38SgNsMI17psS5sEs5t0VcuGDZ05Ik8ze+S3jYKVrw4m928axSX9Gm576LHgyvER93DO7cUwfGGD7eabxYFdaBGIj6peh6RPrGEaF9cIEmt4L1vAkam9Bnfds5/VWJ1mCu9+mhX2ayAQI3YBPYZQzo8B6Ph/M1n5b/fHjvTQYciZ45P66BLrdRnb1TCf39g7oVx+Q2+mAdCXv5LDzIDKO3eiwGuXIpNvabjDrn48+t0ZnP3xRCpug+Frjdf39sq0Wr4qi2WEl2MSv7EyreZyLwM5sVZ487q5/Os59/93jmMcprofKdDAgROXcEmtVY/4LyHoDLUBlw//haITKoS7qMjYwP1QANfg9t/7buYply74zWVvIphkaTD2zJdAMjaHc6sXMyDhMOBfj8m7GEnBIAm6J6Orn/EVc26RJlczLls0m7EHr6LJ49IHwX8NjavcAjTiH9B55OC6qr9Pu07jBzPT7bHn5EKRj3LH94Shvl+2TTIvC9IH7PdYFQlwzuxTSEkwfOjlOpW3z2bpYzSpXStQN07ZhnluIu8bKPLQXd9xTKvw8j7YaBhEBLTjasYWJZo6iNubvYlQdkBIe8XLQauBhyc3+70djuMrxhnhgzueJ4kE3v5gIs/85OEWux+ApC3ihrLYBtumIXWdQPx106Jann6yYdvIkJeuYk2ImsNGxMG1xxq+kb0P9Cmuf+10Gj+NKfJXt+d7e6t9H8gpbvwazL8GmHspn5jXWQHcLpfW73zldUb/yHo4OAtmC4C9f+LrjH6+8XUAXmQGTPYc1ELlRgayzaltrdeIYn65KpOuJqauRsO8CzwH510E2437nhqOY0JN28kiT9QENgfnoQDyeMNPoMF8qncMek7LajgTiLd2Lef9nrrXWwVaBhs937uIM+sef3f7C6w+FWZxDdxyDZwFZzGXYVR7vn4QnO954qbYxjM++Gtl/cOnp8zDnPWnhvs9tJH5zc/u2MPdbFt47C1WuwQf187Uo97OZXUQxXK+zmCniTRenPstV/Xvg6l4nQmA9P93XaZlLn8diuuPnUh9+9ns12YwOMsaX7i2BL6f+xRDJw+z29IOWN+hvgfkyIZVwsPiG4+/ch78DNhd70/3+2dcyYC6xyPY0GgbM+9u0BaWuOBC1py5mKceAFz7fryNz3Yzr9wFHG8fbgOcngq0q30kirrA5py57bvkogb7VvF2wNWQZQeENKGuS72Dr2pAX93r520VHv8jeKqGLOJM3jb3M8V+br4BHHMvr4Cn2sH8CeuYv70bL7gEx/c2tWfTO9bjx8FDN/7GHuRtfmSy6oLBV8/6d56rI4uu5+e1z9TN/LKdSX4HIr+tBvn3IbLXZPIelW4PGQ5cJ4bnEl12zJqG+6HozSe/GH7b9RBraA/AVXbvxYkd7TdWdx0/sILXPCOkzQB5az9X9YezxDB3ojTI3OoCmbsu/e2mU3zHXdbuGXP5yGnfQ0a42WUMP1fBLD9fJDcO74y5L8aqoTgO5J25/PK5HzPDxJBtt4E91bD5lQP/WAL3S+OgFkY0K4suUdPG5kpE6ELwP5tj8LNJuZjZD/vfbuawksG86TTAuj9wld0wNZuRzKsbN+Y+sH3EPZxmJpL4LJ6rYx6FGSfAw5ctIu7qB8jpPw+ATT+F49Z5/9kfYR5nc1+DbU1qP1sEkA1gdc1fFxP4NdZjvWGu9OPYt2FCFTyeZHf82OTmmDUga99k1N0Xu9nZsvI/A3l7kcfxZM7Maz/hE1PRYNuEVSCT99dndfYxfxHDlk3eU5zNeZDq4bX/sRHGiDUOzVOb2koG8I6HXhflC060x39ZLqmFN2MM5kKBt70WK3jN3P7VFpbh0TY25dajB4TbZXKjTM1fT/Q/hIltX/c87z0gzwqQw6gm9w5D4UN/wcyYjrvgdjb38ZHM5Zy0MzFXxLoPNnfAQ2/BQ1mnIJv/SFF7681x6NyvGdjT+5vf2XuAjObr7i9P/pHtt1jVjU8digm6U4j8+xBnrO/g87ihSXAlMGIhyGtvwogvGh8UT0iCWgM+ghqA9N9GrOtUaNAgq3Mcc+wK4cG84sbHOhnuYTJhgJPSa2DCRsyRQaxY5L7TxsJtMezyNP76zIZP34gBerdgUMN3NaHzh3PnSRsAj7Pfh/sHetU0UR3Yar8aEvS5t6+E2X7MrwhWz8PCnzWsWur3p84NBj1/0G8xA37maFhaZh1zyXSY4fm6Z3Mff94zgiVPwvhvcF+leJHVw9Csu6p+2wGwmz48OjLoehJmG/5x5bN1bY9zygQu8npavUWwzB7IsIIx3PfFoEaDpb16Dbin8WZ54yoeTwrgOmug0xV3uR3I7Mu8LEir8H2cqz2pcFYJ/CULJng6/3LA0ZfIkbWNXMz0O6c3auv9w2bY8odFDTd6OBYZ73EW/MoJ68l8xBqu4OmjQd32M+q3rWQATw8vrXu+LZvAxn75c2wTAkkg3etdO5FpAGubojqw/e2kF4M+N5CxZ38xwmTXBGkOOGdi/QUMp3g9xp3fcyFFcjdye18M1wRQKu/i1z2DyQHJPsQt2623u4czDO8iuBbTnVOxBk0DVoVWoG1o98CthkZjp77F+/yczalYniJ98rCAz1vz2ndQfBMTBGTyIvcHOXeQtbO2uGGfMk3uYqLLki6bH5VGFX/n3DadAjEN2scAvM3SeGDBIL4X/8aazXKqhnwHwVR0rQ9QLTRHtb9TiTmqBZ2H8ARKO3y0bVEd2FraFEbSZ5OwaS74HosWWLVfEWfSPe0eGGGlXjc8OhhOtbKz33Jlg2MXDS/x3Zr4Gmy95y+scClH9prMui7YI+9+mvfvg5+OKMakdnV/nUVWUFv05F0B/TysBy60JqcGeIGTuABp0vizEXFWD0e++qPb/YOzYParNJ6zEmAFTOSXgPtOHN7cxi/Jv+YmXuRbPHXv7PvnU9gc67JxIzzI882SDF1mpFGPz8RT/R+LduOUbSReeS8A0ycsad5g5iFL8reDhiPbakqHjmhqL1OB08DWBH02CZvymq+dytlKTsJ8EFtf/Wh3uz9+SgZmehDvQvfAQvO7RoHkPafHjhk7zKquHrO2Zczmi4MSVBuanJfPivdGA7h0WwnccECmvsmouy+ij5djel9uKHDXA7EjHnsm+jJv8pcIi2Cy5zELm3MhNa5lqsEq02qZJTCLhm1kswK4hnlqIrj2Fm0m3lZ29ofzkB2lgqGBzTabkYw29RnEzx5+hNtm3MoTDz3JnDvdrx5sZWruPcjbPJkffKfyfr0ncva9jbf/67kc5HnDe7XCed6q/9bDmxd+ye85CYCNPQ/zrMeWl4bkvHzMmNF1z2+6p5anUmKQKkPSJ+OpCjSoDZrEAD7ijKrAAvKIXbCwx1tu9z3JKDp9dU7d83lZkCapjY67wzHzfWvxoxekq+I77sJc4fJJIsH9GLyQ8yODauqUU5ptqaaK6u7+t3HY7+PfJKHB1FMbzWL+JYe50bSnfxCTBR/HV6xuhqmn3FoJl5TDG44OIs4BbmD9NlnxVFDzJjpbAVz3tz9ibn2eHWY7Pd8J/BoDLjTM8bLSuSeu01x5kz8TZOuihgOW/QkyTh07AublPHP79BbN2Mye2EYZm79WMoCnDsZ4z9iCGMjsEG1d5yORdvePYo9vbe/7IMexG4FJ9c/7D7bPD3ASjyLO5B5zP18HMfVU0H4DMiyfP77flwfe7oTTSvdBGXEDpP/HemPrA5jRAjuhZxxwzI8L7AT+A9xjZX+BZmpN4hzI/Mmc7GP6XjKdzXlO24+CPPYIpt30xr1RPwZZ8UjdU3fHfDTDSzrvQbEREqeBxL1AymNWL9cOy7Mp+c2ORscuW+S9k8hKBnC2iWEE8JDU8vTwUsyrTu2mQXYY1oHMKhJEdWCjt/0PKCcFfu66E/HYeONBEWdai2w+e3/zzHHnocMdYM3q8Zr9pGASz/4wmuuyD/HAauoHOQfe4c+q/vrPkLr5DmuAukrJxu+v7svW1fBfhLvYz4r3Ovl/X1cr8X8etOHAW8O8TgjMyMXEDfvU7a4/94Ph1M+CXzFFiLv8Uzh3PKk0zMoqJgk85HS9cz0PiHZoNI2VqxEbSTzVDlizPweswHb+6B3M8jDezGElA1jj0vtjM/CUPXTjHYTExy/0f/FMO3B5GsisVLiL2sDm3ABdQI9Wuec95n7mfHO/31NYebUIhm6Dh7Ld735JDP9ZY7Up5f32Yx4HbtnegV7fp1gHXAzPDgmsGnLEP0BeKoBZf2UU3wdd9He+GsL3JxmWMtSvSUQARIYgNzXsBk88jOrr3wDrqy6Dsss6kSZulnKxbbhzOlvEfSa1wqW34mUvGd59aR7DvaxnZn42nY/6zGU4H/ssn/kgFsb19HzAJ7CM4JaFeXrKfEy5m6mZ7UHTuy4U7+MEXDh3s9fsTEWiqA1sDQZqGutxUJmb7UHeZhWZXo+ZUya+g9qibI5wFvEpz9QP4loER7i+wWHPcTsfZ3sY9Lzemvs9E7hvSGVdUnMtcO0Q9/MmOgwH5B/AhbCye/32EQuBadBp4Tl+tWldnkWjtefqZK0FI8i/b8XEfQ8LYKWnmSxsC3mAUXd7Hx3u9Z7ujFzMObfVd/zpPxfG+Lnw5ofAhx6PHW9ddyQ+F/KsnLAepjwKd8As5vsuMsu44cpncSwFNwVY4+HYlQzgaYTB9w/C61KC/s4KYgcxXW9MRbqoDWwOzZW5dTJZzLnVx0G+Zu1YCUO3beeh7Gc4T7KB7YA92Plgw6qkqTzjddDz4fsEzoUJa2BkADN1SBx0XjiYfT0EjJWVjdgFMqPA76AGcPurIPfs93pM7MaO9GYmBa+9xYrTmj611e0C0t/7PZ2XcYkb9inPJNzFNHtAdHP1MhzOYgb52WvRMWja30mGVzCWG+SF+gTrqtM9Hvs0gukt3oNaAJoyIFqpcBL1gc05c5O0rUFfx5R5mK/Rl0XZ3OQ06Ouh7BjOOwTd2cYFi6xPxYumzA18XNg91mDnoUkn+zx0xBjqBinPPFZAn765XIvhv3F2MD0GzPqrx6CW3wH4Aa4abs0+D/b1XNuzXHoh1oywlkwxUy/mWpfVst8HapymPNv3ykXkd70UJr5O3ZIGLl7kW+9taG6s4GSvi2z6Ujn7ek78ybMszqshZY81sfMP+J5FqnLCek58fRCJ0wJfwNPX8SsZwNNT5vvO1PylmZqKMlEf2JyZwa5TQQTA3zkUXZzKtrqpp4C6LGyX07anCJzc/RQr7juZvj6OG7EL5IQ3GfWBI2PKBWB1sdR3CgFG8aTb8wdnwYvyLVMYyVwj/M7dQY6A5qEXojy4qNFgaMfKzo5uEY7s5/WPhQE/8zRNVVMXcQucWf4sR666noTbX4LHrvJ9gu2GBYMYI+sCGjQdULn6TNRMTSkP2lRgaxUroXulociOW0O2SdMX1QQ4G84vqP807a4L/Yh/QPmvpjXYtpBT6eRhyilP5mVBmlPP8N6MpGbyl0yQVPKzrFl/vy95qn4+RH+61TuNFzM/s9qnhtM48+kvYD4+hfhjEzn6wh8bnuvjug0W2/RSpg7Ls/lhtJ9dPKUnqzgNc8nVHHz0av/OARKn+Z4J5F4GcmKt96EQb/7tLv417eeNtg+ZAh/fFcQinW4yMs3UVLSJ2gHarkQE48fkvk22CHYYApvp3sMAa2dvXvglfY33ascRAqO9r2jil7rBzoHyY5Bz3LBPuffc5z3OUA9wDlBZLXz4xCMej/FH3LBPeffc2xp18KjYLczKCG5wc3O6cebLmGkPeD9oHcwa5L6sU03gAxbbwlpkSgdoa8YWjEXZyJPuZ9pPuncBVYe+Dux6F4L0PITZ0YG6urnVMOAew8ae1uwp8sZVeFrudMRCuPZ0a6XoUUHMZjs4C2YLWH0t4be8AJMD/zARN+xTjrwyF17yfpy39cLA+hWsSgBwP5VZIC5z6opfOft6zNFnIaPJl22SFxnIS0Yw7/px8Dkw9eAgtrudDS3wD6U6wFq1BW0rsH1h/0OnNm0mjFnMw5zlZbSrvx1B7KzsTb5kxfYO3CX7eWB9J2vjSuhZJczx0eNxOMCL1tixUUGsSea4Rm+cJwt2E9Scp6pyfu6k14C5PPhSsddszBvHIObVgFBTt93RaaMp1wT4+5XPMkuCn4bKnRG+Fr5zc/6i4SX+VyH+ACRCtptg5O8yMM60HU21BW0msOXk5JCbm0tBQQE3VdbS1QT/ZjmSQYGvP+bOb0Cufoozqk7mcWBxVSdiPr7E2ncFPJPkfW2y4cAJYlg2vpBRfXOboUBeuLRZbbhzOqnisnTNjLuYGGRQe8gIN7tZRBrgoIGuEniWUZlWi3k0FqbZG6RnUJ056uZWfKzh9qQTxzPizGf9ukZXE8Pddq3jU+B+KR0vPFUhavalVGNtpo0N7HY25593fSvMYfgaeJx+4+1J/Nd8HNCaZMMBWWg/WQMSfyujfmr1aByc1bCn/HNY3fMvz/I+M9WECmjX0VDjbRmXkYvpe0l91eDmLZA6qfleO97avaaeMgg54QX47xUBZW/WZME5fg2MXskA3vFQjVsEmAul0UDn9w3c6GfA3bVO/J/Sypn9em302lXKC21ja0MaDNZupcbyrff8hRuq3HaSZ2jSx4HNpAFUyDQ6zbLf4OKpC2pgLarZ7vL6N79jK4XHhkORHOJOvE8I7TGo2T0M44Z9yua88Txov7tfFmRmFoxli16getFClpurmRRE5uaPpxEreK30cICb2TvOEzivt58fjoIJamhXfKWC0aYCW4NptgAGmuCytteAe/w79GzuYE6S+8AWiBG7rHsez18Z9VMPZR4Et3KYJ2lvBaqJcPtMaOd47i+X7vLnzD6Fv8bDg/huP6ucbU0NlnLVM1ROWE/mIz+u21c6sZCUPTFUzr6ezEHzGp74vudrrmAsKxjL1P8+Q4fl2XXXASsry5zr/k1/WJ8d0KXx/Iz3MpCi4SUNtiU+fiKc6fVHcy+Q5bADoYOmlQpam6qKdHD+FFzwcRBLQQ+CW039VI++BFLV6MkIgc5f+V6bzOrhmIpM/qAZ7oo17mzG9AYz33tSOWE95pNBkAoSV8MNZbHcIPUT+07bezWLL12H+WRQowl//Z2dYyTLmLb3ar7rYr1uK2dfT/VVwircT0bp7rrFZhB3t+JKOsHIzcmpf41qV3wVIK2KbIMaZG4DXQL7/cKb93jPbn7PSdyJNEvAcmfEGCC/4bZrMfTp6/3d+C9ZMGEG/JYS3PZs9GTkYszt0x1TVzby0Yy5/iUmK/vDbmAL/P2EWG7+L8xyCixfbYTFCwZxRK73K5C9yEDyFzQeaH3gfPiHvXDpzWXWrPjerud6nQPN0fEHGg52liZGSpcPmJqpKRW8NhnYHBxtbs7PCwqhwpzsNWjNaeFypeebuvXQ6vl+45wwwx5YHeAYtLhhn/JgXPDd9B1S9sSQmmGonH09S8ed3iCoAcwaZ3UO8TRbvatFgDlzSaPtMvMu/iXWbBz+9HL0dJ2mapD5N+P1QLvlK9UUbTqwuVbxWEvcGK4FVgYx0LmpRoyBmfkF7LnpLQJ5W/tLFkwQe5Jgl/kU467+E0fazYXZ9obnrJWhG0xvda7/nUEqJ6zHvOqjJ8T7+D2bvavfLLiOVydYQcgcAhIbH2MmPsD7xuo7/7yBzJhav8eTBcVD5uTIqhyvG58cH6I8XU8HTyvVLNp0YHPlPNZthD2rQ2sGuJn5BcwuzmVUgOdNqACZvAhGznc7R+KDk+qzsYqX6ld/BqBP4xWivcl85Mcsy/Be9ReslQzgQI8lvpPTQXCe/fC8+8HncqrDS3yPG/MRULytJu2a+buTk5NDgZeVqZ2vp5RqGg1sTgoKCsjNzQ14SMAIgfQgpjdyteemt/wOavld7QwN+C2DrOpHN0Ht6Hdn0Nd0pWIuDJ9keJBizIz6GY4v86PcxUZIPNV+cgaNqhj9VWwGcbev9q0gu8U7/GbBdVZwdDJ1A3CB9/MaVCvarwPn4ONtMLQ/rxPH68rXtZRSTdcme0X6w3lArPGRQlwnhtWN2sSax+As9wtaFskhnvDUlmZnY3HDPq3bNPsnc3lQfPdsdFaZVgsjNmKODGLWIv+nolrJANa4+Z198Y74DDABuxC6v23oZz+9wwjnBfKncBkA7fpdqUikvSKVW86DuQt/8qbXYzt9NYQ+LVSOmcDPxbDRZXtB/3LPJ9ntZ0d+N5eP1s61NvF8wEOuviqL5UTp2ahrvi9PI5j7pfHCrBcEWAB/vA27LnSKZEF8vsjNzW1UrajVgkpFLs3YfBARRjXDUjD+uDyLRjORpDl6Ovoh7uo/8eMfW4FsWDxMk7voz/0NjqlMq4WZN/h1PXP0WWZd5z5Te5GBeCpV4oITOdACvRAb8PS6DbTbvWZnKgppxqbCxu0C0n9/4x0jvvPr/CMT53JZnPUGXQBMdHOM66Bpb5Zxusd9i2be7XktsWBm8AiCa/f4goIC3jcEVhWplIo6Gtia2eAsmL0K6A2jD9ld8V/179wX+da/IDZyMdPvnM51rtuHwIc+Th2O/7N8uPMiA1k0827eu/WB+lnzm5uf2ZNz93hHx4zzMLDOKbK564yi2ZlSUU0DWzMbDrQbYbiVwww2HeoHTfvDZQyaNw9LYN30m8ui4SVWpjatZe/jbaVndxMDO7eN/b7Qqj59kYF84WZWfnc9HpVS0UMDWwAGZ8HsSXieAR6gBO7oX86TGztyzMOg6UD0/fMpbN4CuCRyD+K74e8yI8x02ZY4zb/ZOpzdOPNlLr7FqnbcJgTVQaNOENmYgyMrc7fPeZq0qWYgAMVIw7LqxMJKtQka2PyQn2W9CT6G0G6uj3XLAPiOmhEgLAKCDGp2l/1L+sHwvMC66TvMOpWAuum7s5IBmIkPQDDrsnoIHv6s/Owui/Knx2LDpYkMzsP0dAkYpdqG4JeRbiMcb5S5ubmcLU9R462bPdTP6NFEccM+xayZzsMyPuCgdpkRKp4Vjiy63uMxN858mbPNIM42g+hmBvEiA7mXgZxtBvHktkF1xzx1MAbOCe5ncAxKdv0CMMZ4/XI36LmgoMDjPtdjAI/31dnylYpu2t3fTyICDz3idnYPoH4NM+e1zJoQ5PpeMp3r8vxY/yytttE280Fs3YTDnnQzgxr0HhQMDC/BrOoKB+GmxFrONjFBDXauu6ZW+SkVEtrdX/nPU1Bz3ud8zIoT2TDnFFLlrsDvNeMuJvoR1MyVsfDfhtuPjPOcqXlSN6B6FZAIT90fQzCjznWGeqVUqGlgC8bIxfS9ZLpfh/afC6kug6SDUZlWC9e+1HDj8M85ctX1PMftXs99EaszxZWsZyUDeAfhG9eD7vbx3JXOUK+UClMa2IIw/c7ppIp/05H4uxyMLzeUxfJ3cc3ExK+g9sU7AgPgpkG1PD3zHsyTDzStZyM6Q71SKnxpYAvAq3NOAeBnc2E4WUH1VAxUZVotmXNzmFUGs3wEMY+et749PWU+9wU7sFpXeFZKRQgNbAF4UKw38gehVYIaADNv4H9jHgx6qZg6b4NhIjwX/CW0/UwpFQk0sAUgmGBWefts/v7o1fzqjhdIeewqa1taLTeUxdYtR3N/fk8OjdlOh+XZ3D16R4Pzby4LfDXqG4d3JvHxCwE4+4wl/g/q8JGBafuZUioSaGBrYX9/9GriZB1fmUFMsgMbIzYyS3oyi/kAlDw7iFSg5NgOZknDbvqBzhIC8N7KrkFNBOxr4LRmaUqpSKCBLQiVt8/GTL+aqenwqjTMYCrTajlQFktimb3hVCs4ndgRKnbb0WYLLPvEaYb96+x9Gb7vfePMl60JiL04z/vuesY0rF4EzciUUhFPB2j7SURIsedn6rA8m/+NeZCxz15N6nUugW3CeswnP67Lxpqb68DqoLmsHK2Uih46QFv5reIUO6KcAbMYy/Drrq/f5nCEgFecDgWdN1EpFa00Y/OTiPAvmjahsC8rGcAaHwPMXjJCdjAZm053pVSboRmbChultTF8cbGPg4KshtQ1yJRSbYUGtgA41vmaJet9HruSATyNcArWVFYvMhBfy42awzRaFDMobjIxHVCtlGordNkaPzkvX+OPp4eXYnoLdxgrxTrTCAbvXyQ2T1ndLRejGZpSqq3QjM1P7lZolic9zxR88S3W4pznvQsy82WM7ySv6XSFaKWU0s4jgXJkbAUFBSDN0e+++eTm5NT1dNTFNJVqu9p65xGtigyQc+aWm5Pjcxqq5pKbk4PY3zGmwXPHY9AVopVSSqsig+Ac3AAruDUle/MjODqqFx33dMzb6Hge7pm3Ukq1Fs3YmiDQDiWeuOvs4anzh+Oezs+1Y4hSStXTjK0JGmRujozJOYvzUyCdPVyrGbXaUSmlGtKMrRm4y9z8ycK0K75SSjU/zdiaQaM2N3TtMqWUCpWw7+4vIuHT118ppSJDmTFmUqgLESphH9iUUkqpQGgbm1JKqaiigU0ppVRU0cCmlFIqqmhgU0opFVU0sCmllIoqGtiUUkpFFQ1sSimloooGNqWUUlFFA5tSSqmoooFNKaVUVNHAppRSKqpoYFNKKRVVNLAppZSKKhrYlFJKRRUNbEoppaKKBjallFJRRQObUkqpqKKBTSmlVFTRwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkUVDWxKKaWiigY2pZRSUUUDm1JKqaiigU0ppVRU0cCmlFIqqmhgU0opFVU0sCmllIoqGtiUUkpFFQ1sSimloooGNqWUUlGlXagL4MukSZNMWVlZqIuhlFIhk5+fX/c4Pj6eYcOG+Tp+rjFmUkuXK1yFfWArKytj+fLloS6GUkqFjIhwplwCwIIjb/h8TxSR9NYoV7iKiKrI3NxcRCTsv3Jzc0P9q1JKRTBP73XtSaw7pj2JPt+L2rqwz9gACgsLMcZQW5zXqvcdt/ISv49dOukhfUEppZrE8V7345hLPR5zspzjcd/82tcB2vx7UUQENoeYrpsAWjzABRLQHI7/eAbxmalBvaBycnIoKCgI+DylWkNubi6FhYUNtulrNnjufp8OccmdGfmLJ2DqeJ/XWfHP2zxev62LiMCWk5ODiNT9M8V03dTq2Zs/hj9/U1DnrbrmqRb/hKVvRCpQjjfg9iTWte84fFn4YZvLClz/h7wFKG/ikjsz4sbH/T7eWwBzd/+cnJyAyxRtxBgT6jJ4NWbMGONoKBURHOUNNrAFk41Fg2VnP0y4/61VeHHusOBL+Yf9fB7z9Yg3AP/+Bzues9mv+zor8yPLSZ+1JODrOiwwbzT4H/Ln9+NPmXzxFNic3w/d7Ms3xoxp8s0jVERkbA6umRu0fLVktPCnmtRTVhfsJ9NA76NCy/Xv7NxhoTk5Apwn4frh09Fpw/l5U3kKWq48VQcr9yIqsDneDNtaFUhz8KeadNnZD7vdXlhYyNiP7vTrPr4+ac+vfV3/fmHKn44LTTH63l/6dZy7rKqlszF/eOu00dIcfxvln4gKbA6aubUMT1ldfGaq39comzre6xvMj2MubfTJN1Ca8TV/Fg1WBhJsUDv6TgZxF+xuchmCDU4tHdSC4eih6Is/f0vNzgITUW1srpzrmI//eEZrFku1ME+ZnyPjC/fXbUsLpP2rNQTblhR3we4GVZOesrpwDFy++BvYWuL1rG1sEcxd5qYBLvIcfSfDzVb3gc1XxhcJ2VxzZFst1f4VCs5tau6yPvevj9DxN2BB9GVjE3+UZPbsrfF6TP7q6pBP5xXRgU3b3CLf0XcyAv407q2tY0Gh944J4aCl27IiiWvQyr/36UbHjOMSmNVaJXIv2Iw02trG9uytYencXl6Pie22KeTTeUV0YHPIyckhNzeXgoIClk56CNDMLVLEXbCbMoJ703AXEJvafucPf7JCb5/Um9KW1daMW3mJHfwC7/7fXFwztEAy7kjKxqJJVAS2goKCujnWHG86Syc9pMEtQgTd6cDNp/jW6Lnmz+Bkd4Oao1FzjNPyZNzKS+y21pYPat6qF10DWU5OTlRlYdEoKgIbaLVkJAu+DSU0n+JD2e27pbRkgAqEc3tbqDM1h2irTgw1EXkWOBcoNcYMtbd1AeYAuUABMNkYs09Ejqf+I6wA9xpj3vZ1j6gJbA7OHUoy/3l5qIujfAimjU1Fr0A/5LjLtLxV83rKzLxVL2p1YrN7Dvg78ILTtjuBT4wxD4vInfbz6cAaYIwx5piIdANWicj7xphj3m4QdYHNOXPLDG1RlGpVZVPHN6rWDYceha5d+sG5mtFS/mE/t8c0V6cRXxmpZmWtxxjzhYjkumw+Hzjdfvw88Dkw3Rhz0OmY9oBff6SoC2xKqXpxF+wOi+DWFIG2fxXUFni9nk5PFZayjDFFAMaYIhGpy0tE5ATgWSAHuMpXtgYa2FSIxV2wm/ILfE+g60yrL8OXu+76o+/9JRPPGdFgW0c/2s6+HvEG7PJ+jGum5U8bu2ZnLS5dRJxn1ZhljAk69zbGfAMMEZFBwPMi8pEx5rC3czSwKaWazbiVl7id5Ni/Qc0Pud0aSPuXcxs7oMu6hEZZELOelIhINztb6waUuh5gjFknIgeAoYD76ahsGtiUCjF3bWOuIiVLPfpOBuNwH9yCFUiG5do7WjOziPEecA3wsP39XQAR6Q1stzuP5AADsHpNeqWBTSnVbOIu2G1PklCffa34p/Xd34HNjrGojuODybA0KwtfIvIKVkeRdBHZAdyDFdBeE5HrgW2Ao2vrycCdInIUqAVuMsaU+bqHBjalolQoOo18PeINcnNf8VgF6E8G5TzZQrAZV7jPF9qWGWM8jcOa4ObY2cDsQO+hgU1FJF/dt8O12s5duf2ZecWfqcfcXcfX7yGQgdn12Zg3t1FY2LTZ6jUoqabSwKYijj+BoAzv68KFSlPWLAv03Kb8/J5Wdo622epVdNLAplQr6njO5labvqpsavNXRWpX+bZt3aHODaY9c89XVt/yojqw6Uz/Khy1ViYZbAB1ZGs6kFlFqqgObEqp4Gl2piJV1AY2XV1bqcC4ZmqanalIFbWBTZexCQ3niW09Kf8wsCm0AlE/kDn0y500B9fB283dhb/hBMVWYNNMTbWkAJet+THWGLd44AhwhzHmU1/3iNrA5hCpy9g05xtYMD3xWnKNNMe1m9JDMBK5tnm1dq9NT7/vmK6bAM3UVKt5Dv+XrSkDzjPG7BKRocBcoIevG0R9YIvEZWyae/qkcJtk2HHtQMvliWsQDrbTREv+zO6mzfJnSEL6rCU+x6/5w93SMWBNUJz7i/qAppmaamkBLluzwumY74H2IpJgjKn2do+oD2xtmeMNPo7wzIy8ZYX+ZnPNldn6G9SCDZrBZqfB3M/TvcatvKTRAOsV/wSR32pAU80pmNn9PS5b4+RiYIWvoAYa2KJeOFf3eQsm/mRzwQa1pmRmzfX7dJS9KWPaPA2i9ka78KtWEMzs/l6JyBDgEeAsf47XwBbl3L35h3OwUy1LO4aoMOVx2RoR6Qm8DVxtjNniz8XaVGBrawO23WUmrTXrhWpe7rIzf2fLd6bZmQpTnpat6QR8AMwwxnzl78XaVGBTbUO4zRHZUrPsa/alIlGAy9b8CugH3CUid9nbzjLGNFqI1FmbCWw5OTnk5uZSUFDQ5jK3tqTFeza2ckccnd5KRZsAl635E/CnQO/RZgJbQUFBqw/W9mewsjtlUzN8DmIO9trps5aAr/5JETK4Of/ep+sej1t5SdC/E3/4s8q1J87lBKus3rK4BsHZXqRTszOl/NdmAhs0nmZr6aSHWixrs964WuaNtiWvHQ78zYycZxkP59+J79nQG5tf+zqgg6ZVeDH723Hs3dZfwDZQbSqwOQZrO6/Q2xKzkViZQ/Bvsr6zqvB8A/fF36zHNaj5N2C8ZX8n/mW6/vO2pEzZ1PENAppmakoFpk0FNgfn2UgKXAasarub8pcjqwL4ccylXo70zbXXow6aVip4bTKwOTiqJp2fR9J8kiq0nLOqPMZ6PM7fIRbOHUS06lGp4LXpwObI3BycMzjN3FpGS3V9b0nOmZkzEcEYY71uTIHP64z8xROA5xlDtIOIagsCnN0/DXgDGAs8Z4z5lT/3aNOBzZUOCWhZ4Ta+zJmn4OXgrbu9a+bvjvO6gJ4GVmuWptqI5/B/dv/DwF3AUPvLLxrYnIRiSICKDN6yKdfM3x3n15VmZqotC3B2/wPAlyIS0FIgMU0sY9RxfPrOzc0FaDQbuoou82tfZ37t63U9ZR1/d8dzx1dTsynH66o5rqVUmEsXkeVOX1P9OKfB7P7QtFXGNGNzoStvt02OLMrxd2/urMqfrE6pKNHss/sHSgObB8GuvB3OA4Wjiac2sWC63efm5jZqL9OsSqlW5XF2/2BoVaQHBQUFGGMCmj29pVeeVg05Vxc6qhAD4eiGX1hYWJdROf7ummEp1aocs/uD0+z+wdKMzQ/+dlHXoNY8fPVQdHCuLnRUIc6vfd1n1ubv9ZVSzS/A2f0RkQIgFYgXkQuwZvdf6+0eGtj8oAGr9XnqXl9QUOB2/kTnKsQ8xnodFO16ba12VKr1BDK7v318bqD30MCmWlUw2ZiDt44dDaZJswdLOwZEOzgGRut0VUpFNw1sfnC8GTd1PsC2xlMQ82flZ3dZlD8dO1xXcHB3X83QlIpuGtgiiLfqtUiqLg22K70/HTq8DdfQgdFKNU273QdI+9fiUBfDJw1sPri23YSKzyVfmnFJlWC5ZmihnDrK3TRXmqkp1TZoYPPBOQPIk+YPbMGuUeaq/MN+YTfcIJQZknbXV6rt0sAWYv4EtXDkT/uZZkhKKVeBzO5v75sBXA/UALcYY+b6uocGtigSd8Fuyi8IaK7QoLM8b9WM2o6llPLiOfyc3V9EBgOXAUOA7sACEelvjKnxdgMNbCFUNnW8zyrGcOGaoTnWIlNKqUAEMru/vf1VY0w18IOIbAaOB7x+GtfA1krctaVFSlBz0GpGpVQLaTC7v4g4ZvfvAXztdNwOe5tXGtiimD9TgTlXQ/oaPK3d5ZVSfkgXkeVOz2cZY4Ltt+1umRWfb0Ia2KJcIO1nvgZOa5amlPJDMMvWeJrdfweQ7XRcT2CXr4tpYAuAtwHSvrR070d32ZmvoKbtZkqpMOGY3f9hGs7u/x7wsog8gdV5JA9Y6utiGtgCEM5d8wPt2egIatpuppRqTYHM7m+M+V5EXgPWAseAm331iAQNbFHDn+m2yj9sPBRA282UUq0piNn9/wz8OZB7aGBrIzxNd6VZmlIq2ugK2m1A2dTxDVabdsyhqCtFK6WikWZsAVg66SEAjv94RohL4p1j3TFnugaZUqqpKtk3d4F5I93HYWWtUhgvNLD5yXmW/86TbgGsziRfj3jDr/NH3/vLBh08mtLD0hdPq08rpVRTGGMmhboM/tDA5qcGKzTbGZG/mdu4lZe0VLEa0BWilVJKA1vAcnJyyM3N9bttatzKS+rGmLVklgbaIUQppQAk3D/Zjxkzxixfvtz3ga3IdSCzr8zNn6mtfHHXbuarXEqptklE8oOY/SNqaMYWBOf2toKCApZOeogfx1xatz/QzMyfoOWcjRUUFDTKzjRTU0opiwa2IDi3t7njzywggQY/x0Bqxz1dn2umppRSFg1sTdAgc6stAKjL3HzNlO/M1+TDjnu53tN5u1JKKYsO0G6CgoKCukxJRMjNza3b5zog2tsXWBmXty9Hlui4p/NzHWStlFL1NGNrBs5Vk3kyFtA5GJVSKlTCvleky4J1SimlfCuLlMHULSHsA5tSSikVCG1jU0opFVU0sCmllIoqGtiUUkpFFQ1sSimloooGNqWUUlFFA5tSSqmoooFNKaVUVNHAppRSKqpoYFNKKRVVNLAppZSKKhrYlFJKRRUNbEoppaKKBjallFJRRQObUkqpqKKBTSmlVFTRwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkUVDWxKKaWiigY2pZRSUUUDm1JKqaiigU0ppVRU0cCmlFIqqjQ5sIlIrIisEJH/2c+7iMh8Edlkf+/sdOwMEdksIhtEZGJT762UUkq5EmNM0y4gchswBkg1xpwrIn8B9hpjHhaRO4HOxpjpIjIYeAU4HugOLAD6G2NqvF0/PT3d5ObmNqmMSinV1uTn55cZYzJCXY5QaNeUk0WkJ/AT4M/Abfbm84HT7cfPA58D0+3trxpjqoEfRGQzVpBb4u0eubm5LF++vCnFVEqpNkdECkNdhlBpalXkTOB3QK3TtixjTBGA/T3T3t4D2O503A57m1JKKdVsgs7YRORcoNQYky8ip/tzipttbutBRWQqMBWgV69ewRZRKaXCmjGGsqojFOw5wO7KavYcOMKeqmr2HjjC3gNH+H+Xj0TE3Vun8qYpVZEnAT8VkXOA9kCqiLwIlIhIN2NMkYh0A0rt43cA2U7n9wR2ubuwMWYWMAtgzJgxTWsEVEqpMGCMYWNJFV9tLmN9cQWbS6vYsvsA5YeONjq2Y4c40pLiOXCkhuSEJrUYtUlB/8aMMTOAGQB2xna7MeZKEXkUuAZ42P7+rn3Ke8DLIvIEVueRPGBp0CVXSqkwt/fAEb7YuJsvNu3my01llFZWA5CenEC/zCTOPa4b/TKT6ZORTGZKAmlJ8XROiicuVkdiNUVLfBR4GHhNRK4HtgGXAhhjvheR14C1wDHgZl89IpVSKtLU1hoWb9nDK8u2Me/7Yo7WGDonxnFyXgan9Evn5Lx0unfqEOpiRrUmd/dvaWPGjDHaK1IpFe72VFXz6rLtzFm2nW17D9KxQxwXjerBhSN7MLR7R2JiWretTETyjTFjWvWmYUIrb5VSqgm27z3IvxdtZc6y7VQfq2Vcny789qz+TBzSlfZxsaEuXpukgU0ppYKwrqiCfy7cwv9WFxEjcOHIHkw9tQ/9MlNCXbQ2TwObUkoFYO2uCmYu2Mi8tSUkxcdy3Um5XH9yH7p2bB/qoimbBjallPLDhuJKnvxkIx9+V0xKQjtunZDHdSf1pmNiXKiLplxoYFNKKS+27K5i5oJN/G/1LpLi23HLGf24/uQ+GtDCmAY2pZRyY/vegzz5ySbe+nYH7eNi+cVpfZl6Sh86J8WHumjKBw1sSinlpLj8MP/v003MWbadmBjhupN684vT+5KenBDqoik/aWBTSimgpOIwT3++hZeXbsMYw+XH9+LmH/XTTiERSAObUqpNK608zD8/38pL3xRyrNZwyaie/OqMfmR3SQx10VSQNLAppdqk0orD/OsLK6AdrTFcOLIHvz6jHzlpSaEummoiDWxKqTZl1/5D/HPhFl5dtp2aWsP5I7rz6zPy6J2uAS1aaGBTSrUJhXsO8M+FW3gjfwcAF4/qyS9P76sZWhTSwKaUimrriyt4+vMtvL9qF+1iYrhsbC9+cXpfeugM+1FLA5tSKip9u20fT322hQXrrKmv/u+UPvzfyb3JTNVejtFOA5tSKmoYY/h8w27+uXAL3/ywl06JcfzmzP5cc2IOnRJ1YHVboYFNKRXxjtbU8r/Vu/jXwq2sL66kW8f2/PEng7j8+F4kJejbXFujf3GlVMSqOHyUOUu389ziAnbuP0ReZjKPXTqcnw7vTny7mFAXT4WIBjalVMTZse8g//2qgDnLtlNVfYwTenfhvp8O4YyBma2+UrUKPxrYlFIRwRjDsoJ9PL+4gI+/L0aAnxzXjf87uQ/DenYMdfFUGNHAppQKa4eP1vDeql0891UBa4sq6Nghjv87pTfXjM+lu3bZV25oYFNKhaXtew/y0jfbeG35dvYeOMKArBQeumgYF4zoQYf42FAXT4UxDWxKqbBRU2tYuLGU2UsK+XzjbgQ4c1AWU07KZXyfNES0/SwYIrLaj8N2G2MmtHhhWoEGNqVUyJVWHOa15dt5Zel2du4/REZKAr8+I4/Lj8+mW0etbmwGscA5XvYL8F4rlaXFaWBTSoVEba1h0eYyXvlmGwvWlXCs1jC+Txq/P2cQZw3JIi5Wu+s3oxuNMYXeDhCRm1qrMC1NA5tSqlWVVBzm9eXbmbN8O9v3HqJLUjzXndyby8Zm0ycjOdTFi0rGmC+b45hIoYFNKdXiHG1nL3+znc82lFJjZ2d3TBzIxCFZJLTTziCtQUTOBR4AcrDe/wUwxpjUkBasmWlgU0q1mF37D/Ha8u3MWbadovLDpCfHc8MpffjZ2Gxd/yw0ZgIXAd8ZY0yIy9JiNLAppZpVTa3hs/WlvLJ0G59tKMUAp+RlcPe5g5kwKEunugqt7cCaaA5qoIFNKdVMSisO8+qy7by6dBu7yg+TkZLATaf342djs8nukhjq4inL74APRWQhUO3YaIx5InRFan4a2JRSQTPGsHjLHl76ppB531s9G0/JS+fu86zsTHs2hp0/A1VAeyBq1/HRwKaUClj5oaO89e0OZn9dyNbdB+icGMd1J/fm58f3IlfbzsJZF2PMWaEuREvTwKaU8tu6ogpeWFLIOyt2cuhoDSOyO/H4pcP5yXHdaB+nPRsjwAIROcsYMy/UBWlJGtiUUl5VH6vh4zXFzF5SyPLCfbSPi+H84T24clyOzqofeW4Gfici1cBRtLu/Uqot2bHvIK8s3cacZdspqzpCbloif/zJIC4Z3ZNOiVHbPBPVjDEpoS5Da9DAppSqU1Nr+GLjbl78upDPNpQCMGFQFleNy+Hkfum6iGeEEpGuxpjiph4TKYIObCKSDbwAdAVqgVnGmCdFpAswB8gFCoDJxph99jkzgOuBGuAWY8zcJpVeKdUsdldW25MQb2PHvkOkJ1td9S8/oRc9dM2zaPAhMKoZjokITcnYjgG/NcZ8KyIpQL6IzAemAJ8YYx4WkTuBO4HpIjIYuAwYAnTHasTsb4ypadqPoJQKhjGGJVv28NI325i3tpijNdY0VzPO1kmIo9BwEanwsl8Ab/sjStCBzRhTBBTZjytFZB3QAzgfON0+7Hngc2C6vf1VY0w18IOIbAaOB5YEWwalVOD2HjjCm/k7eHnpNn4oO0CnxDiuGZ/L5Sf0oq9OQhyVjDFtqstqs7SxiUguMBL4Bsiygx7GmCIRybQP6wF87XTaDnubu+tNBaYC9OrVqzmKqFSbVltr+HrrHl5euo1535dwpKaWsbmduWVCP84eql31VXRpcmATkWTgTWCaMabCywq37na4na/MGDMLmAUwZsyYqJ7TTKmWVFp5mDfzdzJn2TYK9hykY4c4rhjXi8uP70X/rDbRQU61QU0KbCIShxXUXjLGvGVvLhGRbna21g0otbfvALKdTu8J7GrK/ZVSjR2rqeWzDbuZs6x+iZjjc7tw65l5mp2pNqEpvSIFeAZY5zKB5nvANcDD9vd3nba/LCJPYHUeyQOWBnt/pVRDG0sqefPbHbz97U5KK6tJT07g/07pzeQx2dp2pgAQkSeBOcaYxaEuS0tqSsZ2EnAV8J2IrLS3/R4roL0mItcD24BLAYwx34vIa8BarB6VN2uPSKWapqyqmvdW7uKtFTtYs7OCdjHC6QMymDwmmx8NzNSejcrVt8AfRaQ/8DZWkFse4jI1Own3ZXnGjBljli+Put+7UkErP3SUed8X8/7qIr7aXEZNrWFYj45cNKoH5w3vTnpyQqiLqMKAiOQbY8Z42NcFuBhrCFYvY0xeqxauhenMI0pFgMrDR/l0fSn/W13Ewg27OVJTS8/OHZh6ah8uHNlDO4KoQPUDBmJNpLE2tEVpfhrYlApTZVXVzF9bwtzvi1m8eQ9HamrJSk3gqvE5nDe8O8N7dsRLL2SlGhGRR4CLgC1YM0Q9YIzZH9JCtQANbEqFCWMM64sr+WxDKZ+tLyW/cB+1BrK7dODq8TlMHNqV0b0663yNqil+AMYbY8pCXZCWpIFNqRCqOHyUJVv2sHDjbj5fX8qu8sMADO2Ryq/PyGPikK4M6paimZlqLrOAn4tIH2PM/SLSC+hqjImqHuoa2JRqRUdralm1fT9fbCrjy027WbWjnJpaQ3JCO07ul860MzM5bUAGWantQ11UFZ3+gTVp/RnA/UAl1ljksaEsVHPTwKZUC6qpNawrqmDxljIWb9nD0h/2cvBIDTECw3p24qbT+3Jyv3RG9upMfDvtmq9a3AnGmFEisgLAGLNPRKJucT0NbEo1I2MMm0urWLxlD4u3lPH11r2UHzoKQN+MJC4e1ZPxfdM4sW+aLtapQuGoiMRiT2coIhlYGVxU0cCmVBMVlR9i0aYyvtxkZWVlVdUA9OzcgbMGZ3FSv3TG903T6kUVDv6GNTA7U0T+DFwC/DG0RWp+GtiUCtDhozUs2bqHhRt28+XmMjaXVgGQkZLASf3SOKmvFciyuySGuKRKNWSMeUlE8oEJWBPTX2CMWRfiYjU7DWxK+WHHvoN8tmE3n60vZfGWMg4fraV9XAzH907jsrHZnJyXzoAs7b2owpM904hDKfCK8z5jzN7WL1XL0cCmlBu1tYY1u8qZv7aE+WtLWF9cCUCvLolcNrYXPxqYyQm9u+hM+SpS5GO1qzl/8nI8N0CfUBSqpWhgU8pWfayGxVv2sGBtCQvWlVBSUU2MwJjcLvzhnEGcMSiTPulJmpWpiGOM6R3qMrQmDWyqTSs/eJTPNpQyf20Jn28o5cCRGhLjYzmtfwZnDsrijIGZdE7S3osqOtjLjV0B9DbGPKADtJWKEtv2HGT+uhIWrC1hacFeamoNGSkJ/HRED84anMX4vmlaxaii1VPUD9B+AB2grVRkOlZTy4rt+/l0fSmfritlQ4nVXtY/K5kbT+3DmYOzGNGzk87BqNoCHaCtVKTae+AIX2zczafrS1m4cTflh47SLkYYk9uZu84dzJmDMslJSwp1MZVqbTpAW6lIcbSmlpXb97Nww26+2LSb73aWYwykJ8fXtZWd0j+d1PZxoS6qUqGkA7SVCleOqau+3FzGV5v38M3WPVRWHyNGYFSvzvzmzP6c2j+D43p01CpGpWw6QFupMGKMoXDPQb7euoevt+5h8ZY9lFZaU1f16pLIucO7cWpeBif2S6djB83KlPLEGLMeWB/qcrQkDWwqLNXWGrbsrmJZwT6W/rCHr7fupbjCWqssPTme8X3TOblfGif2Tdepq5RSDWhgU2Gh+lgNa3aWs7xgH8sK9pFfuJd9B61Z8TNSEjihdxfG9UljXJ80+mboIGmllGca2FRI7K6s5ttt+/i2cB/LC/fx3Y5yjtRYnbN6pydx5qAsxvbuwtjcLuSmJWogU0r5TQObanFHa2pZX1RpBTL7a/veQwDEx8YwtEcq15yYw+icLozK6URmii7vopQKngY21ayMMezYd4hVO/azctt+Vmzfz5qd5VQfs7KxzJQERvXqzFXjchjVqzNDe3TUWT6UUs1KA5tqkpKKw3y3o5zVO/azakc53+0sZ++BIwAktIthaI+OXDkuhxHZnRjZqxM9OnXQakWlVIvSwKb8YoyhqPwwa3aWs2anFcDW7Kpgt93lPkagf1YKZw7KZFjPTgzv2ZGBXVOJbxcT4pIrpdoaDWyqkdpaw7a9B/l+VwVrdlmB7PtdFXWZWIxAXmYKp+SlM6xHR4b16MiQ7h3pEK9Vikqp0NPA1sYdrallc2kVa3dV1AWydbsqqKw+BkC7GKnLxIbaAWxwt1QNYkqpsKWBrQ3Zd+AI64srWV9cwbqiCtYWVbCxuKqum337uBgGdUvl/JHdGdrdCmL9uyaT0E6DmFIqcmhgi0IHjxxjc2kVG4or2WR/X19cQUlFdd0xXZLiGdI9lWtPymVw91SGdE+ld3oysTqvolIqwmlgi2Dlh46yubSKLaVVbN5dxaaSSjbvrmLHvkMYYx0T3y6GvhnJnNQ3nYHdUhjYNZWB3VLISE7Q3olKqaikgS3MHTlWy7a9BykoO8APZQfYWlbFllLre1nVkbrjHAFsRHZnJo/OJi8rhf5ZyeSkJWkWppRqUzSwhYHKw0fZvvcQ2/YeYNveg2zbe5DCPQcp2HOAnfsOUWvqj+2SFE/fjCQmDMyiT0YSfTOSyctKpmfnRA1gSimFBrYWZ4xh74Ej7Nx/iF37D7Fz/2F27jvEjn0H2bHvEDv3H6L80NEG53RKjCO7cyIjsjtz4Yge5KYnkZueRO+0JDonRd0q7kop1aw0sDWBMYb9B49SVH6YkorDFJUfpqj8ELv2W9+Lyg+za/+huumkHDrExZLdpQM9OycyOqczPTt3oFeXRLLtL11PTCmlgtfqgU1EJgFPArHAf4wxD7d2GXyprTXsO3iE3VXVlFZUs7uymtLKakorD1NaYX0vqaimpOJwo6AVI5CZ0p5undozuFsqEwZm0qNzB7p36kAP+6tTYpx23FBKqRbSqoFNRGKBfwA/BnYAy0TkPWPM2pa+97GaWvYePEJZ5RH2HKimrKqaPVVW8CqrPEJZlRXAyqqq2XvgCMecG7ZsyQntyExJIDM1gRHZnejasT1Zqe3pZn/v2rE9WSkJtIvVaaSUUipUWjtjOx7YbIzZCiAirwLnA80e2O56Zw0bSyrZc+AIe6qq6xatdBUfG0N6cjzpKQl069ieYT06kp4ST2ZKezJSEqyvZOt7UoLW3CqlVLhr7XfqHsB2p+c7gBNcDxKRqcBUgF69egV1o92V1RgDeZnJjOvThbSkBNKS40lPTrC/rGCWktBOqwWVUiqKtHZgcxdBGtX5GWNmAbMAxowZ07hO0A//vGp0MKcppZSKcK3dGLQDyHZ63hPY1cplUEopFcVaO7AtA/JEpLeIxAOXAe+1chmUUkpFMTEmqJq+4G8ocg4wE6u7/7PGmD/7OH43UBjk7dKBsiDPDTUte+uL1HKDlj1UwrnsOcaYjFAXIhRaPbC1JhFZbowZE+pyBEPL3voitdygZQ+VSC57NNMBV0oppaKKBjallFJRJdoD26xQF6AJtOytL1LLDVr2UInksketqG5jU0op1fZEe8amlFKqjdHAppRSKqpoYFNKKRVVNLAppZSKKhrYlFJKRRUNbEoppaKKBjallFJRRQObUkqpqKKBTSmlVFTRwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkWVdqEugC/p6ekmNzc31MVQSqmIkp+fX2aMyQh1OUIh7ANbbm4uy5cvD3UxlFIqoohIYajLECpaFamUUiqqRG1gW7OznPKDR0NdDKWUUq0s7Ksig2GM4eaXv6Vo/2FOG5DB+SO6M2FgFh3iY0NdNKWUUi0sKgMbwN8uG8l7q3bx/qpdzF9bQlJ8LGcN6cqFI3twUr90YmMk1EVUSinVAsQYE+oyeDVmzBjTlM4jNbWGb37Yw3srd/Hhd0VUHD5G19T2XDCyB5eM7kG/zJRmLK1SSoUHEck3xowJdTlCIeoDm7PqYzV8sq6UN/N38PnG3dTUGob37Mjksdn8dHh3UtrHNct9lFIq1DSweTtAJBt4AegK1AKzjDFPikgXYA6QCxQAk40x++xzZgDXAzXALcaYufb20cBzQAfgQ+BW46MAzRnYnO2urObdlTt5ffkONpRU0iEulnOP68Zlx2czqldnRLSqUikVuTSweTtApBvQzRjzrYikAPnABcAUYK8x5mERuRPobIyZLiKDgVeA44HuwAKgvzGmRkSWArcCX2MFtr8ZYz7ydv+WCmwOxhhW7Sjn1aXbeG/VLg4eqSEvM5krTujFRaN7kqpZnFIqAmlgC+QEkXeBv9tfpxtjiuzg97kxZoCdrWGMecg+fi5wL1ZW95kxZqC9/XL7/Bu93a+lA5uzqupj/G/VLl5Zuo1VO8rpEBfLBSO7c8UJOQzt0bFVyqCUUs2hLQe2gHpFikguMBL4BsgyxhQB2MEt0z6sB1ZG5rDD3nbUfuy6PWwkJ7TjsuN7cdnxvVi9Yz8vfl3I2yt28srS7Yzq1YkpJ/Xm7KFdiYuN2uF/SikV8fwObCKSDLwJTDPGVHhpg3K3w3jZ7u5eU4GpAL169fK3iM3quJ6d+MslnfjDOYN549sdzF5SwC2vrCArNYErT8jh8hN6kZ6cEJKyKaWU8syv1ENE4rCC2kvGmLfszSV2FaSjHa7U3r4DyHY6vSewy97e0832Rowxs4wxY4wxYzIyQjuHZ8fEOK4/uTef/vZ0/jtlLAO6pvL4/I2c+NCn3PH6KtYXV4S0fEoppRryGdjESs2eAdYZY55w2vUecI39+BrgXaftl4lIgoj0BvKApXa1ZaWIjLOvebXTOWEvJkb40cBMXrjueBbcdhqTx/bk/dW7mDRzEVc98w2fbygl3IdOKKVUW+BPr8iTgUXAd1jd/QF+j9XO9hrQC9gGXGqM2Wuf8wfgOuAYVtXlR/b2MdR39/8I+HWouvs3h/0Hj/DSN9t4fnEBpZXV5GUmc8OpfTh/RHcS2un0XUqp0GnLnUfa1ADtlnLkWC0ffLeLWV/8wLqiCrJSE7j2pN78/IReOlxAKRUSGtjCWCQENgdjDIs2lTHri618ubmM5IR2XDGuF9ef3JvMlPahLp5Sqg3RwBbGIimwOVuzs5x/fbGVD1bvol1sDD8bk82Np/WhZ+fEUBdNKdUGaGALY5Ea2BwKyg7wz4VbePPbHRgDF4zswU2n96VPRnKoi6aUimIa2MJYpAc2h137DzHri628umwbR47V8tPh3fnVGXn0y9QAp5RqfhrYwli0BDaHsqpq/v3FVl5YUsjhYzWcd1x3bpnQT5fPUUo1Kw1sYSzaApvDnqpq/r3oB15YUsChozWce1x3bp2gGZxSqnloYAtj0RrYHPYeOMK/F23l+cUFHD5awwUjenDLhDxy05NCXTSlVATTwBbGoj2wOZRVVfOvhVt4YUkhx2oNF4+yApz2olRKBUMDWxhrK4HNobTiME8v3MJL32zDGMPlx/fiVz/qR2aqjoNTSvlPA1sYa2uBzWHX/kP8v0838/ry7bSLFa45MZdfnNqXzknxoS6aUioCaGALY201sDkU7jnAzAWbeGflTpLj23HDqX24/uTeJCUEtJSeUqqN0cAWxtp6YHPYWFLJ4/M2MPf7EtKS4rn5R/24YlwvnWxZKeWWBrYwpoGtoRXb9vHo3A0s3rKHHp06MO3MPC4a1ZPYGI8Lvyql2qC2HNj8WmhUhY+RvTrz8g3jePH6E0hPjueON1YzceYXfLymWNeDU0opNLBFrJPz0nnn5pP455WjMMbwixfzueCpxSzeXBbqoimlVEhpYItgIsKkod2YO+1U/nLJceyuOMzP//MNV/7nG1Zt3x/q4imlVEhoG1sUOXy0hhe/LuSpz7ew98ARzh7ald+eNUCn6VKqDWrLbWwa2KJQ5eGj/GfRD/xn0VYOHa3h4lE9mfbj/vTo1CHURVNKtRINbGFMA1vw9lRV89TnW5i9pBCAK8b14uYf9SM9OSHEJVNKtTQNbGFMA1vT7dx/iL8t2MTr+dtpHxfLdSf15oZT+9CxQ1yoi6aUaiEa2MKYBrbms2V3FU/M38gHq4vo2CGOG0/rw5QTc0mM11lMlIo27gKbiPQH7gBygLp/fGPMGa1cvBalga0NWrOznMfnbeCzDbtJT47nptP78fMTetE+TmcxUSpaeAhsq4B/AvlAjWO7MSa/lYvXojSwtWH5hXt5dO4Gvt66l+4d2/OrM/K4dExP4mJ1FIhSkc5DYMs3xowOVZlaiwa2Ns4Yw+Ite3h07gZWbt9PdpcO3HJGHheO7EE7DXBKRSznwCYiXezNtwClwNtAteNYY8ze1i9hy9HApgArwH2+YTdPzN/IdzvL6Z2exK0T8jhveHedh1KpCOQS2H4ADODun9kYY/q0auFamAY21YAxhvlrS3hi/kbWF1fSNyOJX5+hAU6pSOOhKrK9Meawr22RTuuaVAMiwllDuvLhLafw1BWjiIuNYdqclfz4iYW89e0OjtXUhrqISqngLfZzW0TTft7KrZgY4Zxh3Zg0pCvz1hYzc8EmbnttFX/7ZBM3nd6PC0b2IL6dfi5SKhKISFegB9BBREZSXyWZCiSGrGAtRKsilV9qaw3z1pbwt082sbaogh6dOnDjaX2YPCZbhwkoFYZc2tiuAaYAYwDnN9RK4DljzFutX8KWo4FNBcTRyeTvn20mv3Af6ckJ3HBKb35+Qi9S2utMJkqFCw9tbBcbY94MVZlaiwY2FRRjDF9v3cs/PtvMl5vLSEloxxXjcrjupFwyU9uHunhKtXkuGdtt3o41xjzROqVqHdrGpoIiIozvm8b4vmms3rGffy3cyqwvtvDslz9w0age3HBqH/pm6HI5SoWJFPv7AGAs8J79/Dzgi5CUqAVpxqaaTUHZAf7z5VZeX76D6mO1/GhABtef3IeT+qUhokMFlGpNHqoi5wEXG2Mq7ecpwOvGmEmhKGNL0cCmml1ZVTUvfl3Ii18XUlZ1hIFdU7jupN78dER37WiiVCvxENjWA8ONMdX28wRglTFmYCjK2FI0sKkWc/hoDe+v2sUzX/7A+uJKOifGMXlMNleckEOvtKjrYaxUWPEQ2P4ATMaaUssAFwKvGWMeDEERW4wGNtXijDEs2bqH2UsKmbe2hFpjOL1/BleNz+G0/pk6o4lSLcDTemwiMgo4xX76hTFmReuWrOX5DGwi8ixwLlBqjBlqb+sCzAFygQJgsjFmn71vBnA91pIItxhj5trbRwPPAR2AD4FbjR9RVQNbdCkqP8QrS7fzytJt7K6splvH9lwyuieXjs7WLE6pZuTSKzLVGFPhNBlyA21uEmQRORWoAl5wCmx/AfYaYx4WkTuBzsaY6SIyGHgFOB7oDiwA+htjakRkKXAr8DVWYPubMeYjXwXUwBadjtbUMn9tCa8t384XG3dTa2Bcny5MHpPNWUO6kpygHXaVagqXwPY/Y8y5TpMhQ/3sI21zEmQRyQX+5xTYNgCnG2OKRKQb8LkxZoCdrWGMecg+bi5wL1ZW95mjgVJELrfPv9HXvTWwRb+i8kO89e1OXlu+ncI9B2kfF8OEQVn8dHh3Th+QQUI77XCiVKA8tLHNxurev8gYsz40JWt5wX4szjLGFAHYwS3T3t4DKyNz2GFvO2o/dt3ulohMBaYC9OrVK8giqkjRrWMHbv5RP355Wl/yt+3jvZW7+OC7Ij5YXURK+3ZMHNKViUO6ckpeuvaqVKpp/gucDPw/EekDrMAKck+GtljNq7nre9yu9eNlu1vGmFnALLAytuYpmgp3MTHC2NwujM3twt3nDearzWW8t2oXc78v5o38HXSIi+XU/umcNbgrPxqYSZek+FAXWamIYoz5VEQWYg3S/hHwC2AooIENKBGRbk5VkaX29h1AttNxPYFd9vaebrYr5VZcbAynD8jk9AGZHDlWyzc/7GHe9yXMW1vM3O9LEIFhPTpyal4Gp+SlMyqnM3G64rdSXonIJ0ASsARYBIw1xpR6PyvyBBvY3gOuAR62v7/rtP1lEXkCq/NIHrDU7jxSKSLjgG+Aq4H/16SSqzYjvl0Mp+RlcEpeBvf9dAird5azcMNuFm3azdMLt/D3zzaTnNCOUTmdOT63M2NyuzAiu5NWWyrV2GpgNFaWVg7sF5ElxphDoS1W8/KnV+QrwOlAOlAC3AO8A7wG9AK2AZc6uovaAwCvA44B0xw9H0VkDPXd/T8Cfq3d/VVTlR86ypItZSzaVMaygr1sLKkCIC5WGNqjI8f16MhQ+ysvM5l2mtWpNsLTODZ7XzJwLXA70NUYk9CqhWthOkBbRZX9B4+QX7iPpQV7WVG4n+93lXPgSA0ACe1iGNg1hQFdUxjQNbXucXpyVP1PKwV47BX5K6zB2aOBQup7SH4agiK2GB0spKJKp8R4JgzKYsKgLMBaIHVr2QHW7Cznu53lrCuq4JN1pby2vL6TbnpyPP2zUuifZQU663Gyri+nolEH4Akg3xhzLNSFaSmasak2aXdlNRuKK1lfXMHGkko2lFSxqaSSg3Z2B9C9Y3v6d01hgFPQ65eZrG13KiJ4q4qMdpqxqTYpIyWBjJQETs5Lr9tWW2vYuf8QG4or2VhaycZiK+At3ryHIzW1AMTGCLlpiQy0qzIHdUtlcPdUunVsr0vzKBUmNLApZYuJEbK7JJLdJZEzB2fVbT9WU0vBngOsL660s7xKvttZzgffFdUd0ykxjkFdrSA32A52/TKTdQiCUiGggU0pH9rFxtAvM4V+mSmce1z99qrqY6wvqmBdUQVriypYu6uCF78upPqYld3Fx8bQLzOZQd1SGdQtxf6eqgPLlWphGtiUClJyQjvG5HZhTG79hOmO7G5tUSVrd1kB74tNu3nz2/rOKpkpCQzsZlVlOnpm9stM1jkxlWomGtiUakbO2d1Ph3ev215WVc36okrWFVWwrriCDcWVPPdVw7a73ulJDOiawsCsFPrbQS+7cyIxul6dUgHRwKZUK0hPTuDkvIadVRzZ3boiq+1uQ0kl3+0o54PV9W13ifGx5GVZwW5A1xQGdkthYFetzlTKG+3ur1SYOVB9zBqCYHdUcQS9vQeO1B2TkZJQ1ytzQJYV8LQ6UznT7v5KqbCRlNCOkb06M7JX57ptxhh2V1lj7zYUV1pZXkkFzy0u4Mix+urMvhlJ1lAEu7PK4G6pZKYk6FAE1aZoYFMqAogImSntyUxpzyl5GXXbnYcirC+yBpznF+7jvVX1i2d0SYpnULcUBtu9Mgd3T6Vvhg5FUNFLA5tSEczTUITyQ0frhiKsK6pkXXEFzy8prMvu4mNjyMtKZkj3VIZ078iQ7lbQS0rQtwQV+fRVrFQU6tghjhP6pHFCn7S6bcdqavmh7ABriyr4fpcV9BY4zZspAr3TkhjUPbUu4A3ulkpGik4SrSKLBjal2oh2sTHkZaWQl5XC+SN6AFbbXXHFYdbusoLd97vKWbV9f4OemZkpCQ1mVBnULZXctCRidRiCClMa2JRqw0SEbh070K1jh7oVEcCqylxrBzrHrCpfbirjWK3Vi7pDXCwDuqbUBbrB3aylgJK1KlOFAe3ur5TyS/WxGjaVVLHWMY2YXZ1Zcbh+9ZOctEQGdbWC3cBuKQzqmkrPzh10kHkIaHd/pZTyIaFdbN1q5A7GWCsirHPMqlJUwfriSuauLcbxmTk5oZ29uGuKPY1YKgO6ptCxg653p1qGZmxKqWbnGGRuDUOoYJ393Tm769axfV3AG5Clc2Y2N83YlFKqGXkaZF5ccbh++Z+iCo/r3Q3omkJeZv2K5rlpibTTcXfKTxrYlFKtwrmjyo8GZNZtP1pTS6HTencbS6yZVT5aU1+dGRcr9ElPJi8rmf5ZKfTPSiYvK4WcLhrwVGMa2JRSIRXnYZD54aM1bC6tYmNJJRtLqthUUsmqHfv5n9NQhPjYGPpkJNEvM5m8zBTyspLJy0wmJy2J+HYa8NoqDWxKqbDUPq5xZxWw2u82l1axqbSKTaWVbCqpYuX2hgGvXYyQk5ZIv8zkuqDXLzOZPhlJJMbr216007+wUiqiJCW0Y3h2J4Znd2qw/eCRY2zdfcAOelbA21RaxYJ1pdTU1neS69GpA/0yk+mbkVwX+PplJutSQFFEA5tSKiokxrdzm+EdOWa14TmyvC27q9hcWsU3P+zh8NHauuM6J8bVBbu+Gcn0zUyiX0YKPTp30FlWIowGNqVUVItvVz+V2NlO22trrTF4m3dX1WV6W3ZXMX9tCa8e2N7g/D7pSfTJSKJ3ehJ90pPpnZFEn/QkOiVqlheONLAppdqkmBghu0si2V0S+dGAhvv2HTjC1rIqO9hZQW9dUSVzvy9pUK3ZsUMcuWmJ5KQlkZuWSK+0JLI7dyC7SyJZqe010wsRDWxKKeWic1I8o5O6MDqnS4PtR2tq2b73ID+UHWDr7gMU7j1A4Z6DdueVXTjFPOJihR6dOtCzcyI9OnWge6cO9Ojcge6d2tO9Ywe6dmxP+zgdjN4SNLAppZSf4mJj6JORTJ+MZCYMarjvyLFadu0/xPZ9B9m29yDb91qPd+47xKcbStldWd3oeh07xNE1tT1ZHduTmZJQ/5XanoyUBEZkd9IFYYOggU0ppZpBfLsYctOTyE1Pcru/+lgNRfsPs3P/IYrLD1Nccbjue0nFYTYWV1JWVV23ggLA+gcmoUld4DSwKaVUK0hoF+s18IHVoWXfwSOUVlZTVlWtVZVB0sCmlFJhIiZGSEtOIC1ZVy1vCq28VUopFVU0sCmllIoqYb8em4jsBgqDPD0dKGvG4rQmLXvri9Ryg5Y9VMK57DnGmIxQFyIUwj6wNYWILI/Uhfa07K0vUssNWvZQieSyRzOtilRKKRVVNLAppZSKKtEe2GaFugBNoGVvfZFabtCyh0oklz1qRXUbm1JKqbYn2jM2pZRSbUxUBjYRmSQiG0Rks4jcGeryuBKRbBH5TETWicj3InKrvb2LiMwXkU32985O58ywf54NIjIxdKUHEYkVkRUi8j/7eUSU2y5PJxF5Q0TW27//8ZFQfhH5jf1aWSMir4hI+3Att4g8KyKlIrLGaVvAZRWR0SLynb3vbyLS4mvAeCj7o/brZbWIvC0incKx7MqJMSaqvoBYYAvQB4gHVgGDQ10ulzJ2A0bZj1OAjcBg4C/Anfb2O4FH7MeD7Z8jAeht/3yxISz/bcDLwP/s5xFRbrtMzwP/Zz+OBzqFe/mBHsAPQAf7+WvAlHAtN3AqMApY47Qt4LICS4HxgAAfAWeHqOxnAe3sx4+Ea9n1q/4rGjO244HNxpitxpgjwKvA+SEuUwPGmCJjzLf240pgHdab1/lYb7zY3y+wH58PvGqMqTbG/ABsxvo5W52I9AR+AvzHaXPYlxtARFKx3rieATDGHDHG7Ccyyt8O6CAi7YBEYBdhWm5jzBfAXpfNAZVVRLoBqcaYJcaKFC84ndOqZTfGzDPGHLOffg30DMeyq3rRGNh6ANudnu+wt4UlEckFRgLfAFnGmCKwgh+QaR8WTj/TTOB3QK3TtkgoN1hZ/G7gv3ZV6n9EJIkwL78xZifwGLANKALKjTHzCPNyuwi0rD3sx67bQ+06rAwMIq/sbUY0BjZ3ddlh2fVTRJKBN4FpxpgKb4e62dbqP5OInAuUGmPy/T3FzbZQ/i3aYVUzPW2MGQkcwKoW8yQsym+3R52PVd3VHUgSkSu9neJmW1j+D+C5rGH3M4jIH4BjwEuOTW4OC8uytzXRGNh2ANlOz3tiVduEFRGJwwpqLxlj3rI3l9jVGNjfS+3t4fIznQT8VEQKsKp4zxCRFwn/cjvsAHYYY76xn7+BFejCvfxnAj8YY3YbY44CbwEnEv7ldhZoWXdQX+XnvD0kROQa4FzgCrt6ESKk7G1RNAa2ZUCeiPQWkXjgMuC9EJepAbuH1DPAOmPME0673gOusR9fA7zrtP0yEUkQkd5AHlbjdKsyxswwxvQ0xuRi/V4/NcZcSZiX28EYUwxsF5EB9qYJwFrCv/zbgHEikmi/diZgtcuGe7mdBVRWu7qyUkTG2T/z1U7ntCoRmQRMB35qjDnotCvsy95mhbr3Skt8Aedg9TTcAvwh1OVxU76TsaomVgMr7a9zgDTgE2CT/b2L0zl/sH+eDYRBDyvgdOp7RUZSuUcAy+3f/TtA50goP3AfsB5YA8zG6okXluUGXsFqCzyKlb1cH0xZgTH2z7sF+Dv2hBIhKPtmrLY0x//qP8Ox7PpV/6UzjyillIoq0VgVqZRSqg3TwKaUUiqqaGBTSikVVTSwKaWUiioa2JRSSkUVDWwqJEQk13kGdZd994vImfbjz0VkjP24QETSvVyz7tiWICJTROTvLXTd7k7Pvf6cTufsFpH/eDvOzXmPikixiNwebHmVCnftQl0ApVwZY+4OdRla2RSsMU+Bzk4xxxjzq0BOMMbcISIHAryPUhFFMzYVSrEi8m+x1hmbJyIdAETkORG5xNNJIpIkIh+IyCqx1if7mZtjLrfXw1ojIo84ba8SkcdF5FsR+UREMuztfUXkYxHJF5FFIjLQW8FFJENE3hSRZfbXSfb2e8Va0+tzEdkqIrc4nXOXWOt6zRdrTbXb7Z9zDPCSiKx0/A6AX9tl/M5XWexrTxGRd0TkfRH5QUR+JSK32ZM9fy0iXXxdQ6looYFNhVIe8A9jzBBgP3Cxn+dNAnYZY4YbY4YCHzvvtKv1HgHOwJppZKyIXGDvTgK+NcaMAhYC99jbZwG/NsaMBm4HnvJRhieBvxpjxtrldq4SHAhMxFoq5h4RibOrSC/GWsnhIqxghjHmDayZUK4wxowwxhyyr1Fml/Fpuzz+GAr83L7vn4GDxprseQnWtE5KtQlaFalC6QdjzEr7cT6Q6+d53wGP2ZnY/4wxi1z2jwU+N8bsBhCRl7DWYXsHa7mdOfZxLwJvibXKwonA61K/0HGCjzKcCQx2Oj5VRFLsxx8YY6qBahEpBbKwplF71xG4ROR9H9d3TIydjxUI/fGZsdb3qxSRcsBxj++A4/y8hlIRTwObCqVqp8c1QAdPBzozxmwUkdFY82s+JCLzjDH3Ox3ibtkQj5fDqrnYb4wZEcB5McB4pwzLurEV6Fx/rnYBlsn5Go7zAzkHrABe7fRY/9dVm6FVkSri2FWNB40xL2ItwDnK5ZBvgNNEJF1EYoHLsaodwXrNO9rvfg58aay18H4QkUvt64uIDPdRjHlAXccNERnh4/gvgfNEpL2dIf7EaV8lkOL+NKVUoPRTnIpEw4BHRaQWaxb2XzrvNMYUicgM4DOsTOlDY4xj2ZADwBARyQfKAUfHkyuAp0Xkj0Ac1npzq7yU4RbgHyKyGuv/6AvgF54ONsYsE5H37GsWYrWrldu7nwP+KSKHgPG+f3yllDc6u79qU0SkyhiTHKJ7JxtjqkQkESsQTjXGfBvktaYAYwLt7m+fey9QZYx5LJh7KxXutCpSqdYzS0RWAt8CbwYb1GyHgLODGaANXImVuSoVlTRjU0opFVU0Y1NKKRVVNLAppZSKKhrYlFJKRRUNbEoppaKKBjallFJRRQObUkqpqPL/AfFvRikpvoLtAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -744,11 +744,13 @@ "axs = [fig.add_subplot(gs[2,0]), fig.add_subplot(gs[3,0])]\n", "plot.plot(hillslope_demo_pars, mesh_demo_pars, fig=fig, axs=axs)\n", "\n", + "\n", "ax0 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[0,:])\n", "workflow.plot.raster(hillslope_demo_pars['raster_profile'], hillslope_demo_pars['bins'],\n", " ax=ax0, cmap='prism')\n", "subcatch = hillslope_demo_pars['subcatchment']\n", - "workflow.plot.shply(subcatch, native_crs, ax=ax0, color='k')\n", + "subcatch_crs = hillslope_demo_pars['subcatchment_target_crs']\n", + "workflow.plot.shply(subcatch, subcatch_crs, ax=ax0, color='k')\n", "ax0.set_title(f'subcatchment {subcatch_demo_id}')\n", "\n", "ax1 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[1,:])\n", @@ -757,7 +759,7 @@ "lc = workflow.plot.raster(hillslope_demo_pars['raster_profile'],\n", " hillslope_demo_pars['land_cover_raster'], \n", " ax=ax1, vmin=vmin-0.5, vmax=vmax+0.5, cmap=cmap)\n", - "workflow.plot.shply(subcatch, native_crs, ax=ax1, color='k')\n", + "workflow.plot.shply(subcatch, subcatch_crs, ax=ax1, color='k')\n", "position=fig.add_axes([0.95, 0.55, 0.02,0.1])\n", "\n", "fig.colorbar(lc,ticks=np.arange(vmin,vmax+1),cax=position)\n", @@ -775,7 +777,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "44f418ed", "metadata": {}, "outputs": [ @@ -783,39 +785,39 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:53,812 - root - INFO: \n", - "2021-09-20 23:15:53,813 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:53,814 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:53,815 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:53,822 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:53,823 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:53,881 - root - INFO: \n", - "2021-09-20 23:15:53,881 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:53,882 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:53,882 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:53,883 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:53,926 - root - INFO: ... got raster of shape: (69, 322)\n", - "2021-09-20 23:15:53,936 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:53,966 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "2021-09-20 23:15:53,968 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:53,968 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", - "2021-09-20 23:15:53,972 - root - INFO: \n", - "2021-09-20 23:15:53,972 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:53,973 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:53,973 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:53,974 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:54,017 - root - INFO: ... got raster of shape: (69, 322)\n", - "2021-09-20 23:15:54,025 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:54,055 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "2021-09-20 23:15:54,057 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:54,058 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", - "2021-09-20 23:15:54,061 - root - INFO: \n", - "2021-09-20 23:15:54,062 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:54,062 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,062 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:54,063 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:54,105 - root - INFO: ... got raster of shape: (69, 322)\n", - "2021-09-20 23:15:54,115 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:26,690 - root - INFO: \n", + "2021-09-23 13:19:26,691 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:26,691 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:26,692 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:26,697 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:26,698 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:26,751 - root - INFO: \n", + "2021-09-23 13:19:26,752 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:26,752 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:26,752 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:26,753 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:26,800 - root - INFO: ... got raster of shape: (69, 322)\n", + "2021-09-23 13:19:26,809 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:26,840 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "2021-09-23 13:19:26,842 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:26,842 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", + "2021-09-23 13:19:26,845 - root - INFO: \n", + "2021-09-23 13:19:26,846 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:26,846 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:26,846 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:26,847 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:26,890 - root - INFO: ... got raster of shape: (69, 322)\n", + "2021-09-23 13:19:26,899 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:26,930 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "2021-09-23 13:19:26,932 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:26,933 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", + "2021-09-23 13:19:26,936 - root - INFO: \n", + "2021-09-23 13:19:26,937 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:26,937 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:26,937 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:26,938 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:26,981 - root - INFO: ... got raster of shape: (69, 322)\n", + "2021-09-23 13:19:26,990 - root - INFO: Masking to shape\n" ] }, { @@ -831,32 +833,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:54,145 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "2021-09-20 23:15:54,147 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:54,148 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", - "2021-09-20 23:15:54,152 - root - INFO: \n", - "2021-09-20 23:15:54,152 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:54,153 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,153 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:54,154 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:54,197 - root - INFO: ... got raster of shape: (69, 322)\n", - "2021-09-20 23:15:54,205 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:54,235 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "2021-09-20 23:15:54,237 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:54,238 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", - "2021-09-20 23:15:54,255 - root - INFO: \n", - "2021-09-20 23:15:54,255 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:54,256 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,256 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:54,263 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:54,264 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:54,316 - root - INFO: \n", - "2021-09-20 23:15:54,317 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:54,317 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,317 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:54,318 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:54,362 - root - INFO: ... got raster of shape: (64, 331)\n", - "2021-09-20 23:15:54,372 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:27,022 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "2021-09-23 13:19:27,023 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:27,024 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", + "2021-09-23 13:19:27,028 - root - INFO: \n", + "2021-09-23 13:19:27,029 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:27,029 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,029 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:27,030 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:27,072 - root - INFO: ... got raster of shape: (69, 322)\n", + "2021-09-23 13:19:27,081 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:27,114 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", + "2021-09-23 13:19:27,116 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:27,117 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", + "2021-09-23 13:19:27,139 - root - INFO: \n", + "2021-09-23 13:19:27,140 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:27,141 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,141 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:27,145 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:27,146 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:27,199 - root - INFO: \n", + "2021-09-23 13:19:27,199 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:27,200 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,200 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:27,201 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:27,243 - root - INFO: ... got raster of shape: (64, 331)\n", + "2021-09-23 13:19:27,252 - root - INFO: Masking to shape\n" ] }, { @@ -871,36 +873,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:54,402 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "2021-09-20 23:15:54,405 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:54,406 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", - "2021-09-20 23:15:54,410 - root - INFO: \n", - "2021-09-20 23:15:54,411 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:54,411 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,411 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:54,412 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:54,461 - root - INFO: ... got raster of shape: (64, 331)\n", - "2021-09-20 23:15:54,471 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:54,502 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "2021-09-20 23:15:54,504 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:54,505 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", - "2021-09-20 23:15:54,508 - root - INFO: \n", - "2021-09-20 23:15:54,509 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:54,509 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,510 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:54,511 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:54,555 - root - INFO: ... got raster of shape: (64, 331)\n", - "2021-09-20 23:15:54,563 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:54,593 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "2021-09-20 23:15:54,595 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:54,596 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", - "2021-09-20 23:15:54,600 - root - INFO: \n", - "2021-09-20 23:15:54,601 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:54,601 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,602 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:54,603 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:54,646 - root - INFO: ... got raster of shape: (64, 331)\n", - "2021-09-20 23:15:54,656 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:27,283 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "2021-09-23 13:19:27,285 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:27,286 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", + "2021-09-23 13:19:27,289 - root - INFO: \n", + "2021-09-23 13:19:27,290 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:27,291 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,292 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:27,293 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:27,335 - root - INFO: ... got raster of shape: (64, 331)\n", + "2021-09-23 13:19:27,343 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:27,373 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "2021-09-23 13:19:27,375 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:27,376 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", + "2021-09-23 13:19:27,381 - root - INFO: \n", + "2021-09-23 13:19:27,381 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:27,382 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,383 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:27,384 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:27,424 - root - INFO: ... got raster of shape: (64, 331)\n", + "2021-09-23 13:19:27,434 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:27,464 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "2021-09-23 13:19:27,466 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:27,467 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", + "2021-09-23 13:19:27,472 - root - INFO: \n", + "2021-09-23 13:19:27,472 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:27,473 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,473 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:27,474 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:27,517 - root - INFO: ... got raster of shape: (64, 331)\n", + "2021-09-23 13:19:27,526 - root - INFO: Masking to shape\n" ] }, { @@ -916,41 +918,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:54,687 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "2021-09-20 23:15:54,688 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:54,689 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", - "2021-09-20 23:15:54,708 - root - INFO: \n", - "2021-09-20 23:15:54,708 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:54,709 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,710 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:54,715 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:54,715 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:54,769 - root - INFO: \n", - "2021-09-20 23:15:54,770 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:54,770 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,771 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:54,773 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:54,816 - root - INFO: ... got raster of shape: (97, 237)\n", - "2021-09-20 23:15:54,825 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:54,856 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "2021-09-20 23:15:54,858 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:54,859 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", - "2021-09-20 23:15:54,862 - root - INFO: \n", - "2021-09-20 23:15:54,863 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:54,863 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,864 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:54,865 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:54,908 - root - INFO: ... got raster of shape: (97, 237)\n", - "2021-09-20 23:15:54,918 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:54,951 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "2021-09-20 23:15:54,952 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:54,953 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", - "2021-09-20 23:15:54,957 - root - INFO: \n", - "2021-09-20 23:15:54,957 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:54,958 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:54,958 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:54,960 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:55,005 - root - INFO: ... got raster of shape: (97, 237)\n" + "2021-09-23 13:19:27,556 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", + "2021-09-23 13:19:27,559 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:27,560 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", + "2021-09-23 13:19:27,581 - root - INFO: \n", + "2021-09-23 13:19:27,582 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:27,582 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,582 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:27,587 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:27,588 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:27,640 - root - INFO: \n", + "2021-09-23 13:19:27,641 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:27,641 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,641 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:27,643 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:27,683 - root - INFO: ... got raster of shape: (97, 237)\n", + "2021-09-23 13:19:27,692 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:27,722 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "2021-09-23 13:19:27,724 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:27,725 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", + "2021-09-23 13:19:27,728 - root - INFO: \n", + "2021-09-23 13:19:27,729 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:27,729 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,729 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:27,731 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:27,773 - root - INFO: ... got raster of shape: (97, 237)\n", + "2021-09-23 13:19:27,782 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:27,811 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "2021-09-23 13:19:27,813 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:27,814 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", + "2021-09-23 13:19:27,817 - root - INFO: \n", + "2021-09-23 13:19:27,817 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:27,818 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,818 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:27,820 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:27,861 - root - INFO: ... got raster of shape: (97, 237)\n", + "2021-09-23 13:19:27,870 - root - INFO: Masking to shape\n" ] }, { @@ -966,33 +969,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:55,016 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:55,059 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "2021-09-20 23:15:55,062 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:55,063 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", - "2021-09-20 23:15:55,070 - root - INFO: \n", - "2021-09-20 23:15:55,071 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:55,072 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,073 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:55,075 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:55,125 - root - INFO: ... got raster of shape: (97, 237)\n", - "2021-09-20 23:15:55,134 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:55,166 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "2021-09-20 23:15:55,168 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:55,169 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", - "2021-09-20 23:15:55,185 - root - INFO: \n", - "2021-09-20 23:15:55,186 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:55,187 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,187 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:55,192 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:55,193 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:55,249 - root - INFO: \n", - "2021-09-20 23:15:55,250 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:55,250 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,251 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:55,252 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:55,295 - root - INFO: ... got raster of shape: (59, 233)\n", - "2021-09-20 23:15:55,303 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:27,900 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "2021-09-23 13:19:27,902 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:27,903 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", + "2021-09-23 13:19:27,907 - root - INFO: \n", + "2021-09-23 13:19:27,908 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:27,908 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:27,908 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:27,909 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:27,952 - root - INFO: ... got raster of shape: (97, 237)\n", + "2021-09-23 13:19:27,960 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:27,992 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", + "2021-09-23 13:19:27,994 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:27,994 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", + "2021-09-23 13:19:28,016 - root - INFO: \n", + "2021-09-23 13:19:28,016 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:28,017 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,017 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:28,022 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:28,023 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:28,075 - root - INFO: \n", + "2021-09-23 13:19:28,075 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:28,076 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,076 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:28,078 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:28,121 - root - INFO: ... got raster of shape: (59, 233)\n", + "2021-09-23 13:19:28,130 - root - INFO: Masking to shape\n" ] }, { @@ -1007,36 +1009,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:55,335 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "2021-09-20 23:15:55,337 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:55,338 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", - "2021-09-20 23:15:55,341 - root - INFO: \n", - "2021-09-20 23:15:55,342 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:55,342 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,343 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:55,344 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:55,388 - root - INFO: ... got raster of shape: (59, 233)\n", - "2021-09-20 23:15:55,396 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:55,427 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "2021-09-20 23:15:55,429 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:55,430 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", - "2021-09-20 23:15:55,433 - root - INFO: \n", - "2021-09-20 23:15:55,434 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:55,434 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,434 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:55,436 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:55,478 - root - INFO: ... got raster of shape: (59, 233)\n", - "2021-09-20 23:15:55,488 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:55,519 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "2021-09-20 23:15:55,521 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:55,521 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", - "2021-09-20 23:15:55,524 - root - INFO: \n", - "2021-09-20 23:15:55,525 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:55,525 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,525 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:55,527 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:55,569 - root - INFO: ... got raster of shape: (59, 233)\n", - "2021-09-20 23:15:55,579 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:28,158 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "2021-09-23 13:19:28,161 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:28,162 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", + "2021-09-23 13:19:28,165 - root - INFO: \n", + "2021-09-23 13:19:28,165 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:28,166 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,166 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:28,167 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:28,209 - root - INFO: ... got raster of shape: (59, 233)\n", + "2021-09-23 13:19:28,219 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:28,250 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "2021-09-23 13:19:28,252 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:28,252 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", + "2021-09-23 13:19:28,256 - root - INFO: \n", + "2021-09-23 13:19:28,257 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:28,257 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,258 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:28,259 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:28,300 - root - INFO: ... got raster of shape: (59, 233)\n", + "2021-09-23 13:19:28,309 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:28,339 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "2021-09-23 13:19:28,342 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:28,342 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", + "2021-09-23 13:19:28,345 - root - INFO: \n", + "2021-09-23 13:19:28,345 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:28,346 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,346 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:28,347 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:28,389 - root - INFO: ... got raster of shape: (59, 233)\n", + "2021-09-23 13:19:28,397 - root - INFO: Masking to shape\n" ] }, { @@ -1052,42 +1054,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:55,614 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "2021-09-20 23:15:55,616 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:55,617 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", - "2021-09-20 23:15:55,633 - root - INFO: \n", - "2021-09-20 23:15:55,634 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:55,634 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,635 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:55,639 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:55,640 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:55,696 - root - INFO: \n", - "2021-09-20 23:15:55,697 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:55,698 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,698 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:55,699 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:55,743 - root - INFO: ... got raster of shape: (98, 377)\n", - "2021-09-20 23:15:55,752 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:55,785 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "2021-09-20 23:15:55,787 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:55,788 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", - "2021-09-20 23:15:55,792 - root - INFO: \n", - "2021-09-20 23:15:55,792 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:55,793 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,793 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:55,795 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:55,837 - root - INFO: ... got raster of shape: (98, 377)\n", - "2021-09-20 23:15:55,845 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:55,875 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "2021-09-20 23:15:55,878 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:55,879 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", - "2021-09-20 23:15:55,883 - root - INFO: \n", - "2021-09-20 23:15:55,884 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:55,884 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,885 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:55,886 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:55,928 - root - INFO: ... got raster of shape: (98, 377)\n", - "2021-09-20 23:15:55,937 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:28,426 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", + "2021-09-23 13:19:28,428 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:28,429 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", + "2021-09-23 13:19:28,449 - root - INFO: \n", + "2021-09-23 13:19:28,450 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:28,450 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,450 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:28,456 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:28,456 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:28,508 - root - INFO: \n", + "2021-09-23 13:19:28,508 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:28,509 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,509 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:28,510 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:28,554 - root - INFO: ... got raster of shape: (98, 377)\n", + "2021-09-23 13:19:28,562 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:28,591 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "2021-09-23 13:19:28,593 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:28,594 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", + "2021-09-23 13:19:28,597 - root - INFO: \n", + "2021-09-23 13:19:28,598 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:28,598 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,599 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:28,599 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:28,644 - root - INFO: ... got raster of shape: (98, 377)\n", + "2021-09-23 13:19:28,653 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:28,683 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "2021-09-23 13:19:28,685 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:28,686 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", + "2021-09-23 13:19:28,689 - root - INFO: \n", + "2021-09-23 13:19:28,690 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:28,690 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,690 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:28,691 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:28,734 - root - INFO: ... got raster of shape: (98, 377)\n", + "2021-09-23 13:19:28,743 - root - INFO: Masking to shape\n" ] }, { @@ -1103,32 +1105,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:55,966 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "2021-09-20 23:15:55,969 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:55,970 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", - "2021-09-20 23:15:55,975 - root - INFO: \n", - "2021-09-20 23:15:55,976 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:55,976 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:55,977 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:55,978 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:56,021 - root - INFO: ... got raster of shape: (98, 377)\n", - "2021-09-20 23:15:56,030 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:56,059 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "2021-09-20 23:15:56,061 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:56,062 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", - "2021-09-20 23:15:56,082 - root - INFO: \n", - "2021-09-20 23:15:56,082 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:56,083 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,084 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:56,089 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:56,090 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:56,141 - root - INFO: \n", - "2021-09-20 23:15:56,142 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:56,143 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,143 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:56,144 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:56,186 - root - INFO: ... got raster of shape: (46, 147)\n", - "2021-09-20 23:15:56,195 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:28,773 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "2021-09-23 13:19:28,775 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:28,776 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", + "2021-09-23 13:19:28,781 - root - INFO: \n", + "2021-09-23 13:19:28,782 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:28,782 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,783 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:28,784 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:28,825 - root - INFO: ... got raster of shape: (98, 377)\n", + "2021-09-23 13:19:28,834 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:28,863 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", + "2021-09-23 13:19:28,865 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:28,866 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", + "2021-09-23 13:19:28,884 - root - INFO: \n", + "2021-09-23 13:19:28,885 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:28,886 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,886 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:28,891 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:28,892 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:28,942 - root - INFO: \n", + "2021-09-23 13:19:28,943 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:28,943 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:28,944 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:28,945 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:28,986 - root - INFO: ... got raster of shape: (46, 147)\n", + "2021-09-23 13:19:28,996 - root - INFO: Masking to shape\n" ] }, { @@ -1143,36 +1145,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:56,225 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "2021-09-20 23:15:56,227 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:56,228 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", - "2021-09-20 23:15:56,231 - root - INFO: \n", - "2021-09-20 23:15:56,232 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:56,232 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,232 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:56,233 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:56,274 - root - INFO: ... got raster of shape: (46, 147)\n", - "2021-09-20 23:15:56,283 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:56,315 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "2021-09-20 23:15:56,316 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:56,317 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", - "2021-09-20 23:15:56,320 - root - INFO: \n", - "2021-09-20 23:15:56,320 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:56,320 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,321 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:56,321 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:56,361 - root - INFO: ... got raster of shape: (46, 147)\n", - "2021-09-20 23:15:56,369 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:56,398 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "2021-09-20 23:15:56,400 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:56,401 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", - "2021-09-20 23:15:56,402 - root - INFO: \n", - "2021-09-20 23:15:56,403 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:56,403 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,404 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:56,404 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:56,445 - root - INFO: ... got raster of shape: (46, 147)\n", - "2021-09-20 23:15:56,453 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:29,030 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "2021-09-23 13:19:29,032 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:29,032 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", + "2021-09-23 13:19:29,036 - root - INFO: \n", + "2021-09-23 13:19:29,036 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,037 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,037 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:29,038 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:29,080 - root - INFO: ... got raster of shape: (46, 147)\n", + "2021-09-23 13:19:29,089 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:29,121 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "2021-09-23 13:19:29,123 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:29,123 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", + "2021-09-23 13:19:29,126 - root - INFO: \n", + "2021-09-23 13:19:29,126 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,126 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,127 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:29,127 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:29,169 - root - INFO: ... got raster of shape: (46, 147)\n", + "2021-09-23 13:19:29,177 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:29,207 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "2021-09-23 13:19:29,209 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:29,210 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", + "2021-09-23 13:19:29,211 - root - INFO: \n", + "2021-09-23 13:19:29,212 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,213 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,213 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:29,214 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:29,256 - root - INFO: ... got raster of shape: (46, 147)\n", + "2021-09-23 13:19:29,265 - root - INFO: Masking to shape\n" ] }, { @@ -1188,42 +1190,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:56,482 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "2021-09-20 23:15:56,484 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:56,485 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", - "2021-09-20 23:15:56,500 - root - INFO: \n", - "2021-09-20 23:15:56,501 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:56,502 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,502 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:56,507 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:56,508 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:56,562 - root - INFO: \n", - "2021-09-20 23:15:56,563 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:56,563 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,564 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:56,567 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:56,608 - root - INFO: ... got raster of shape: (96, 194)\n", - "2021-09-20 23:15:56,617 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:56,647 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "2021-09-20 23:15:56,649 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:56,650 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", - "2021-09-20 23:15:56,654 - root - INFO: \n", - "2021-09-20 23:15:56,655 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:56,655 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,656 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:56,658 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:56,701 - root - INFO: ... got raster of shape: (96, 194)\n", - "2021-09-20 23:15:56,710 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:56,741 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "2021-09-20 23:15:56,743 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:56,744 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", - "2021-09-20 23:15:56,747 - root - INFO: \n", - "2021-09-20 23:15:56,748 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:56,748 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,749 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:56,751 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:56,791 - root - INFO: ... got raster of shape: (96, 194)\n", - "2021-09-20 23:15:56,800 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:29,296 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", + "2021-09-23 13:19:29,298 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:29,298 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", + "2021-09-23 13:19:29,316 - root - INFO: \n", + "2021-09-23 13:19:29,316 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:29,317 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,317 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:29,323 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:29,324 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:29,377 - root - INFO: \n", + "2021-09-23 13:19:29,378 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,378 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,379 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:29,381 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:29,422 - root - INFO: ... got raster of shape: (96, 194)\n", + "2021-09-23 13:19:29,431 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:29,461 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "2021-09-23 13:19:29,464 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:29,464 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", + "2021-09-23 13:19:29,467 - root - INFO: \n", + "2021-09-23 13:19:29,468 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,468 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,468 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:29,470 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:29,513 - root - INFO: ... got raster of shape: (96, 194)\n", + "2021-09-23 13:19:29,521 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:29,550 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "2021-09-23 13:19:29,553 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:29,553 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", + "2021-09-23 13:19:29,557 - root - INFO: \n", + "2021-09-23 13:19:29,557 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,557 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,558 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:29,560 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:29,600 - root - INFO: ... got raster of shape: (96, 194)\n", + "2021-09-23 13:19:29,610 - root - INFO: Masking to shape\n" ] }, { @@ -1239,32 +1241,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:56,831 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "2021-09-20 23:15:56,833 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:56,833 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", - "2021-09-20 23:15:56,837 - root - INFO: \n", - "2021-09-20 23:15:56,837 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:56,838 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,838 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:56,840 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:56,881 - root - INFO: ... got raster of shape: (96, 194)\n", - "2021-09-20 23:15:56,890 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:56,920 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "2021-09-20 23:15:56,922 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:56,923 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", - "2021-09-20 23:15:56,939 - root - INFO: \n", - "2021-09-20 23:15:56,940 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:56,940 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:56,940 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:56,945 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:56,946 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:56,999 - root - INFO: \n", - "2021-09-20 23:15:57,000 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,001 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,001 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:57,002 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:57,049 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-20 23:15:57,058 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:29,641 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "2021-09-23 13:19:29,643 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:29,644 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", + "2021-09-23 13:19:29,647 - root - INFO: \n", + "2021-09-23 13:19:29,647 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,648 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,648 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:29,650 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:29,690 - root - INFO: ... got raster of shape: (96, 194)\n", + "2021-09-23 13:19:29,699 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:29,730 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", + "2021-09-23 13:19:29,732 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:29,733 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", + "2021-09-23 13:19:29,754 - root - INFO: \n", + "2021-09-23 13:19:29,755 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:29,755 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,756 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:29,761 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:29,762 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:29,813 - root - INFO: \n", + "2021-09-23 13:19:29,814 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,815 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,815 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:29,816 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:29,856 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-23 13:19:29,864 - root - INFO: Masking to shape\n" ] }, { @@ -1279,36 +1281,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:57,089 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:15:57,091 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:57,092 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-20 23:15:57,095 - root - INFO: \n", - "2021-09-20 23:15:57,095 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,096 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,096 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:57,097 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:57,140 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-20 23:15:57,149 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:57,181 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:15:57,184 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:57,185 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-20 23:15:57,187 - root - INFO: \n", - "2021-09-20 23:15:57,188 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,188 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,188 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:57,189 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:57,231 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-20 23:15:57,240 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:57,272 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:15:57,274 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:57,275 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-20 23:15:57,277 - root - INFO: \n", - "2021-09-20 23:15:57,277 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,278 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,278 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:57,279 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:57,321 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-20 23:15:57,330 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:29,895 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-23 13:19:29,897 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:29,897 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-23 13:19:29,900 - root - INFO: \n", + "2021-09-23 13:19:29,901 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,901 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,901 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:29,902 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:29,944 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-23 13:19:29,952 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:29,980 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-23 13:19:29,982 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:29,982 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-23 13:19:29,986 - root - INFO: \n", + "2021-09-23 13:19:29,986 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:29,987 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:29,987 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:29,988 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,030 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-23 13:19:30,039 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:30,068 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-23 13:19:30,070 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:30,071 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-23 13:19:30,073 - root - INFO: \n", + "2021-09-23 13:19:30,074 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:30,074 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,075 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:30,075 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,116 - root - INFO: ... got raster of shape: (44, 186)\n", + "2021-09-23 13:19:30,125 - root - INFO: Masking to shape\n" ] }, { @@ -1324,42 +1326,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:57,361 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:15:57,363 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:57,364 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-20 23:15:57,379 - root - INFO: \n", - "2021-09-20 23:15:57,380 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:57,381 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,381 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:57,386 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:57,387 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:57,445 - root - INFO: \n", - "2021-09-20 23:15:57,446 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,446 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,447 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:57,448 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:57,490 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-20 23:15:57,499 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:57,531 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "2021-09-20 23:15:57,533 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:57,533 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-20 23:15:57,535 - root - INFO: \n", - "2021-09-20 23:15:57,535 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,536 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,536 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:57,537 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:57,578 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-20 23:15:57,587 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:57,617 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "2021-09-20 23:15:57,619 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:57,619 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-20 23:15:57,620 - root - INFO: \n", - "2021-09-20 23:15:57,621 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,621 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,622 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:57,623 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:57,665 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-20 23:15:57,674 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:30,155 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", + "2021-09-23 13:19:30,157 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:30,158 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", + "2021-09-23 13:19:30,173 - root - INFO: \n", + "2021-09-23 13:19:30,173 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:30,173 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,174 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:30,178 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:30,179 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:30,231 - root - INFO: \n", + "2021-09-23 13:19:30,232 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:30,232 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,233 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:30,234 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,275 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-23 13:19:30,284 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:30,314 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "2021-09-23 13:19:30,316 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:30,317 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-23 13:19:30,318 - root - INFO: \n", + "2021-09-23 13:19:30,318 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:30,319 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,319 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:30,320 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,361 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-23 13:19:30,370 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:30,399 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "2021-09-23 13:19:30,401 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:30,402 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-23 13:19:30,403 - root - INFO: \n", + "2021-09-23 13:19:30,404 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:30,404 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,405 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:30,406 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,448 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-23 13:19:30,456 - root - INFO: Masking to shape\n" ] }, { @@ -1375,32 +1377,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:57,704 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "2021-09-20 23:15:57,706 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:57,706 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-20 23:15:57,707 - root - INFO: \n", - "2021-09-20 23:15:57,708 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,708 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,709 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:57,709 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:57,751 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-20 23:15:57,759 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:57,791 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "2021-09-20 23:15:57,792 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:57,793 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-20 23:15:57,806 - root - INFO: \n", - "2021-09-20 23:15:57,806 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:57,807 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,807 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:57,811 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:57,812 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:57,872 - root - INFO: \n", - "2021-09-20 23:15:57,873 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,874 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,875 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:57,875 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:57,918 - root - INFO: ... got raster of shape: (19, 30)\n", - "2021-09-20 23:15:57,928 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:30,486 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "2021-09-23 13:19:30,488 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:30,489 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-23 13:19:30,490 - root - INFO: \n", + "2021-09-23 13:19:30,491 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:30,491 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,492 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:30,492 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,534 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-23 13:19:30,543 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:30,573 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", + "2021-09-23 13:19:30,575 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:30,575 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-23 13:19:30,591 - root - INFO: \n", + "2021-09-23 13:19:30,591 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:30,592 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,592 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:30,596 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:30,597 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:30,658 - root - INFO: \n", + "2021-09-23 13:19:30,659 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:30,659 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,660 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:30,661 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,701 - root - INFO: ... got raster of shape: (19, 30)\n", + "2021-09-23 13:19:30,710 - root - INFO: Masking to shape\n" ] }, { @@ -1415,36 +1417,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:57,958 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "2021-09-20 23:15:57,960 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:57,961 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-20 23:15:57,962 - root - INFO: \n", - "2021-09-20 23:15:57,963 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:57,963 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:57,963 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:57,964 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,006 - root - INFO: ... got raster of shape: (19, 30)\n", - "2021-09-20 23:15:58,015 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:58,044 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "2021-09-20 23:15:58,046 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:58,047 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-20 23:15:58,048 - root - INFO: \n", - "2021-09-20 23:15:58,048 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:58,048 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,049 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:58,050 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,090 - root - INFO: ... got raster of shape: (19, 30)\n", - "2021-09-20 23:15:58,099 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:58,129 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "2021-09-20 23:15:58,131 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:58,132 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-20 23:15:58,132 - root - INFO: \n", - "2021-09-20 23:15:58,133 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:58,133 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,134 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:58,134 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,176 - root - INFO: ... got raster of shape: (19, 30)\n", - "2021-09-20 23:15:58,184 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:30,740 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "2021-09-23 13:19:30,742 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:30,743 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-23 13:19:30,744 - root - INFO: \n", + "2021-09-23 13:19:30,744 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:30,745 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,745 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:30,746 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,787 - root - INFO: ... got raster of shape: (19, 30)\n", + "2021-09-23 13:19:30,796 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:30,827 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "2021-09-23 13:19:30,829 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:30,830 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-23 13:19:30,831 - root - INFO: \n", + "2021-09-23 13:19:30,832 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:30,833 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,833 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:30,834 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,882 - root - INFO: ... got raster of shape: (19, 30)\n", + "2021-09-23 13:19:30,893 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:30,929 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "2021-09-23 13:19:30,930 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:30,931 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-23 13:19:30,932 - root - INFO: \n", + "2021-09-23 13:19:30,933 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:30,933 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:30,934 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:30,935 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:30,977 - root - INFO: ... got raster of shape: (19, 30)\n", + "2021-09-23 13:19:30,985 - root - INFO: Masking to shape\n" ] }, { @@ -1460,42 +1462,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:58,215 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "2021-09-20 23:15:58,217 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:58,218 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-20 23:15:58,229 - root - INFO: \n", - "2021-09-20 23:15:58,229 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:58,230 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,230 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:58,234 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:58,235 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:58,298 - root - INFO: \n", - "2021-09-20 23:15:58,299 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:58,299 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,299 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:58,300 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,342 - root - INFO: ... got raster of shape: (117, 192)\n", - "2021-09-20 23:15:58,351 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:58,382 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "2021-09-20 23:15:58,384 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:58,385 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", - "2021-09-20 23:15:58,392 - root - INFO: \n", - "2021-09-20 23:15:58,393 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:58,393 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,394 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:58,395 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,436 - root - INFO: ... got raster of shape: (117, 192)\n", - "2021-09-20 23:15:58,445 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:58,476 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "2021-09-20 23:15:58,478 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:58,480 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", - "2021-09-20 23:15:58,484 - root - INFO: \n", - "2021-09-20 23:15:58,485 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:58,485 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,486 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:58,487 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,528 - root - INFO: ... got raster of shape: (117, 192)\n", - "2021-09-20 23:15:58,537 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:31,014 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", + "2021-09-23 13:19:31,017 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:31,018 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-23 13:19:31,030 - root - INFO: \n", + "2021-09-23 13:19:31,030 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:31,030 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,031 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:31,036 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:31,036 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:31,092 - root - INFO: \n", + "2021-09-23 13:19:31,093 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:31,093 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,094 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:31,095 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:31,138 - root - INFO: ... got raster of shape: (117, 192)\n", + "2021-09-23 13:19:31,147 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:31,177 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "2021-09-23 13:19:31,180 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:31,181 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", + "2021-09-23 13:19:31,184 - root - INFO: \n", + "2021-09-23 13:19:31,185 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:31,185 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,186 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:31,186 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:31,231 - root - INFO: ... got raster of shape: (117, 192)\n", + "2021-09-23 13:19:31,243 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:31,278 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "2021-09-23 13:19:31,280 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:31,281 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", + "2021-09-23 13:19:31,283 - root - INFO: \n", + "2021-09-23 13:19:31,284 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:31,284 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,284 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:31,285 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:31,328 - root - INFO: ... got raster of shape: (117, 192)\n", + "2021-09-23 13:19:31,336 - root - INFO: Masking to shape\n" ] }, { @@ -1511,32 +1513,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:58,568 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "2021-09-20 23:15:58,571 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:58,571 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", - "2021-09-20 23:15:58,576 - root - INFO: \n", - "2021-09-20 23:15:58,576 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:58,577 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,577 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:58,578 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,621 - root - INFO: ... got raster of shape: (117, 192)\n", - "2021-09-20 23:15:58,631 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:58,663 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "2021-09-20 23:15:58,666 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:58,666 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", - "2021-09-20 23:15:58,685 - root - INFO: \n", - "2021-09-20 23:15:58,686 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:58,686 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,687 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:58,692 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:58,692 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:58,747 - root - INFO: \n", - "2021-09-20 23:15:58,747 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:58,748 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,749 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:58,749 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,792 - root - INFO: ... got raster of shape: (95, 128)\n", - "2021-09-20 23:15:58,801 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:31,367 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "2021-09-23 13:19:31,369 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:31,370 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", + "2021-09-23 13:19:31,375 - root - INFO: \n", + "2021-09-23 13:19:31,375 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:31,376 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,376 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:31,377 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:31,419 - root - INFO: ... got raster of shape: (117, 192)\n", + "2021-09-23 13:19:31,427 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:31,457 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", + "2021-09-23 13:19:31,459 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:31,460 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", + "2021-09-23 13:19:31,476 - root - INFO: \n", + "2021-09-23 13:19:31,477 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:31,477 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,478 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:31,483 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:31,484 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:31,534 - root - INFO: \n", + "2021-09-23 13:19:31,534 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:31,535 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,536 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:31,536 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:31,581 - root - INFO: ... got raster of shape: (95, 128)\n", + "2021-09-23 13:19:31,589 - root - INFO: Masking to shape\n" ] }, { @@ -1551,36 +1553,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:58,832 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "2021-09-20 23:15:58,834 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:58,834 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", - "2021-09-20 23:15:58,838 - root - INFO: \n", - "2021-09-20 23:15:58,839 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:58,839 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,840 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:58,840 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,883 - root - INFO: ... got raster of shape: (95, 128)\n", - "2021-09-20 23:15:58,891 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:58,922 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "2021-09-20 23:15:58,923 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:58,924 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", - "2021-09-20 23:15:58,928 - root - INFO: \n", - "2021-09-20 23:15:58,929 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:58,929 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:58,929 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:58,930 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:58,974 - root - INFO: ... got raster of shape: (95, 128)\n", - "2021-09-20 23:15:58,983 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:59,013 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "2021-09-20 23:15:59,015 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:59,016 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", - "2021-09-20 23:15:59,019 - root - INFO: \n", - "2021-09-20 23:15:59,019 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:59,020 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,020 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:59,021 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:59,063 - root - INFO: ... got raster of shape: (95, 128)\n", - "2021-09-20 23:15:59,073 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:31,619 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "2021-09-23 13:19:31,621 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:31,622 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", + "2021-09-23 13:19:31,626 - root - INFO: \n", + "2021-09-23 13:19:31,626 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:31,627 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,627 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:31,628 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:31,673 - root - INFO: ... got raster of shape: (95, 128)\n", + "2021-09-23 13:19:31,682 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:31,712 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "2021-09-23 13:19:31,714 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:31,715 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", + "2021-09-23 13:19:31,718 - root - INFO: \n", + "2021-09-23 13:19:31,718 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:31,718 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,719 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:31,719 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:31,763 - root - INFO: ... got raster of shape: (95, 128)\n", + "2021-09-23 13:19:31,772 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:31,805 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "2021-09-23 13:19:31,807 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:31,808 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", + "2021-09-23 13:19:31,812 - root - INFO: \n", + "2021-09-23 13:19:31,813 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:31,813 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,814 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:31,815 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:31,856 - root - INFO: ... got raster of shape: (95, 128)\n", + "2021-09-23 13:19:31,864 - root - INFO: Masking to shape\n" ] }, { @@ -1596,42 +1598,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:59,103 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "2021-09-20 23:15:59,106 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:59,107 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", - "2021-09-20 23:15:59,125 - root - INFO: \n", - "2021-09-20 23:15:59,126 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:59,126 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,127 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:59,132 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:59,132 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:59,183 - root - INFO: \n", - "2021-09-20 23:15:59,184 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:59,185 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,185 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:59,186 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:59,228 - root - INFO: ... got raster of shape: (99, 206)\n", - "2021-09-20 23:15:59,237 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:59,266 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "2021-09-20 23:15:59,268 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:59,269 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", - "2021-09-20 23:15:59,272 - root - INFO: \n", - "2021-09-20 23:15:59,273 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:59,273 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,274 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:59,275 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:59,315 - root - INFO: ... got raster of shape: (99, 206)\n", - "2021-09-20 23:15:59,323 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:59,352 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "2021-09-20 23:15:59,354 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:59,355 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", - "2021-09-20 23:15:59,358 - root - INFO: \n", - "2021-09-20 23:15:59,359 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:59,359 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,360 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:59,360 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:59,401 - root - INFO: ... got raster of shape: (99, 206)\n", - "2021-09-20 23:15:59,411 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:31,897 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", + "2021-09-23 13:19:31,899 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:31,900 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", + "2021-09-23 13:19:31,911 - root - INFO: \n", + "2021-09-23 13:19:31,912 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:31,913 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,913 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:31,918 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:31,919 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:31,974 - root - INFO: \n", + "2021-09-23 13:19:31,974 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:31,975 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:31,975 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:31,976 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,018 - root - INFO: ... got raster of shape: (99, 206)\n", + "2021-09-23 13:19:32,028 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:32,061 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "2021-09-23 13:19:32,063 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:32,063 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", + "2021-09-23 13:19:32,069 - root - INFO: \n", + "2021-09-23 13:19:32,069 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:32,070 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,070 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:32,072 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,117 - root - INFO: ... got raster of shape: (99, 206)\n", + "2021-09-23 13:19:32,127 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:32,158 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "2021-09-23 13:19:32,160 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:32,161 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", + "2021-09-23 13:19:32,165 - root - INFO: \n", + "2021-09-23 13:19:32,165 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:32,165 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,166 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:32,166 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,208 - root - INFO: ... got raster of shape: (99, 206)\n", + "2021-09-23 13:19:32,216 - root - INFO: Masking to shape\n" ] }, { @@ -1647,32 +1649,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:59,441 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "2021-09-20 23:15:59,443 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:59,444 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", - "2021-09-20 23:15:59,448 - root - INFO: \n", - "2021-09-20 23:15:59,448 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:59,449 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,449 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:59,450 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:59,491 - root - INFO: ... got raster of shape: (99, 206)\n", - "2021-09-20 23:15:59,501 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:59,532 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "2021-09-20 23:15:59,534 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:59,535 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", - "2021-09-20 23:15:59,554 - root - INFO: \n", - "2021-09-20 23:15:59,555 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:59,555 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,555 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:59,560 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:59,561 - root - INFO: Converting to shapely\n", - "2021-09-20 23:15:59,614 - root - INFO: \n", - "2021-09-20 23:15:59,614 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:59,615 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,616 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:15:59,617 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:59,658 - root - INFO: ... got raster of shape: (68, 215)\n", - "2021-09-20 23:15:59,667 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:32,247 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "2021-09-23 13:19:32,249 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:32,249 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", + "2021-09-23 13:19:32,253 - root - INFO: \n", + "2021-09-23 13:19:32,254 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:32,254 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,254 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:32,255 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,296 - root - INFO: ... got raster of shape: (99, 206)\n", + "2021-09-23 13:19:32,305 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:32,337 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", + "2021-09-23 13:19:32,339 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:32,340 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", + "2021-09-23 13:19:32,353 - root - INFO: \n", + "2021-09-23 13:19:32,354 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:32,354 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,355 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:32,359 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:32,360 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:32,413 - root - INFO: \n", + "2021-09-23 13:19:32,413 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:32,414 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,414 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:32,415 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,457 - root - INFO: ... got raster of shape: (68, 215)\n", + "2021-09-23 13:19:32,467 - root - INFO: Masking to shape\n" ] }, { @@ -1687,36 +1689,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:59,701 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "2021-09-20 23:15:59,702 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:15:59,703 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", - "2021-09-20 23:15:59,707 - root - INFO: \n", - "2021-09-20 23:15:59,707 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:59,707 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,708 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:15:59,708 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:59,749 - root - INFO: ... got raster of shape: (68, 215)\n", - "2021-09-20 23:15:59,759 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:59,791 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "2021-09-20 23:15:59,793 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:15:59,794 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", - "2021-09-20 23:15:59,797 - root - INFO: \n", - "2021-09-20 23:15:59,798 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:59,798 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,798 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:15:59,799 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:59,842 - root - INFO: ... got raster of shape: (68, 215)\n", - "2021-09-20 23:15:59,851 - root - INFO: Masking to shape\n", - "2021-09-20 23:15:59,883 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "2021-09-20 23:15:59,885 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:15:59,885 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", - "2021-09-20 23:15:59,888 - root - INFO: \n", - "2021-09-20 23:15:59,889 - root - INFO: Loading Raster\n", - "2021-09-20 23:15:59,889 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,890 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:15:59,891 - root - INFO: Collecting raster\n", - "2021-09-20 23:15:59,931 - root - INFO: ... got raster of shape: (68, 215)\n", - "2021-09-20 23:15:59,940 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:32,498 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "2021-09-23 13:19:32,500 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:32,501 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", + "2021-09-23 13:19:32,505 - root - INFO: \n", + "2021-09-23 13:19:32,506 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:32,506 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,507 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:32,508 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,550 - root - INFO: ... got raster of shape: (68, 215)\n", + "2021-09-23 13:19:32,560 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:32,591 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "2021-09-23 13:19:32,593 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:32,594 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", + "2021-09-23 13:19:32,597 - root - INFO: \n", + "2021-09-23 13:19:32,597 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:32,598 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,598 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:32,599 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,640 - root - INFO: ... got raster of shape: (68, 215)\n", + "2021-09-23 13:19:32,648 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:32,679 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "2021-09-23 13:19:32,680 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:32,681 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", + "2021-09-23 13:19:32,685 - root - INFO: \n", + "2021-09-23 13:19:32,685 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:32,685 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,686 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:32,687 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,729 - root - INFO: ... got raster of shape: (68, 215)\n", + "2021-09-23 13:19:32,738 - root - INFO: Masking to shape\n" ] }, { @@ -1732,42 +1734,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:15:59,972 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "2021-09-20 23:15:59,974 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:15:59,975 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", - "2021-09-20 23:15:59,993 - root - INFO: \n", - "2021-09-20 23:15:59,994 - root - INFO: Loading shapes\n", - "2021-09-20 23:15:59,994 - root - INFO: ------------------------------\n", - "2021-09-20 23:15:59,994 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:15:59,999 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:15:59,999 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:00,051 - root - INFO: \n", - "2021-09-20 23:16:00,052 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:00,052 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,053 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:00,054 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:00,096 - root - INFO: ... got raster of shape: (86, 196)\n", - "2021-09-20 23:16:00,105 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:00,136 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "2021-09-20 23:16:00,138 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:00,139 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", - "2021-09-20 23:16:00,142 - root - INFO: \n", - "2021-09-20 23:16:00,143 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:00,143 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,144 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:00,145 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:00,188 - root - INFO: ... got raster of shape: (86, 196)\n", - "2021-09-20 23:16:00,197 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:00,228 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "2021-09-20 23:16:00,230 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:00,231 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", - "2021-09-20 23:16:00,235 - root - INFO: \n", - "2021-09-20 23:16:00,236 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:00,236 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,236 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:00,237 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:00,279 - root - INFO: ... got raster of shape: (86, 196)\n", - "2021-09-20 23:16:00,288 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:32,768 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", + "2021-09-23 13:19:32,770 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:32,771 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", + "2021-09-23 13:19:32,786 - root - INFO: \n", + "2021-09-23 13:19:32,787 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:32,787 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,788 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:32,793 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:32,794 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:32,846 - root - INFO: \n", + "2021-09-23 13:19:32,846 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:32,847 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,847 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:32,848 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,892 - root - INFO: ... got raster of shape: (86, 196)\n", + "2021-09-23 13:19:32,901 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:32,931 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "2021-09-23 13:19:32,933 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:32,934 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", + "2021-09-23 13:19:32,937 - root - INFO: \n", + "2021-09-23 13:19:32,937 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:32,938 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:32,938 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:32,939 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:32,984 - root - INFO: ... got raster of shape: (86, 196)\n", + "2021-09-23 13:19:32,993 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:33,024 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "2021-09-23 13:19:33,025 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:33,026 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", + "2021-09-23 13:19:33,029 - root - INFO: \n", + "2021-09-23 13:19:33,030 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,030 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,030 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:33,031 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:33,074 - root - INFO: ... got raster of shape: (86, 196)\n", + "2021-09-23 13:19:33,083 - root - INFO: Masking to shape\n" ] }, { @@ -1783,32 +1785,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:00,318 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "2021-09-20 23:16:00,320 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:00,321 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", - "2021-09-20 23:16:00,325 - root - INFO: \n", - "2021-09-20 23:16:00,325 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:00,326 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,326 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:00,327 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:00,367 - root - INFO: ... got raster of shape: (86, 196)\n", - "2021-09-20 23:16:00,376 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:00,406 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "2021-09-20 23:16:00,408 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:00,409 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", - "2021-09-20 23:16:00,427 - root - INFO: \n", - "2021-09-20 23:16:00,428 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:00,428 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,429 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:00,433 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:00,434 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:00,487 - root - INFO: \n", - "2021-09-20 23:16:00,488 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:00,489 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,489 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:00,490 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:00,532 - root - INFO: ... got raster of shape: (69, 203)\n", - "2021-09-20 23:16:00,540 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:33,116 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "2021-09-23 13:19:33,118 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:33,119 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", + "2021-09-23 13:19:33,123 - root - INFO: \n", + "2021-09-23 13:19:33,124 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,124 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,125 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:33,126 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:33,170 - root - INFO: ... got raster of shape: (86, 196)\n", + "2021-09-23 13:19:33,179 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:33,211 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", + "2021-09-23 13:19:33,213 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:33,214 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", + "2021-09-23 13:19:33,230 - root - INFO: \n", + "2021-09-23 13:19:33,230 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:33,231 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,231 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:33,236 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:33,237 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:33,290 - root - INFO: \n", + "2021-09-23 13:19:33,291 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,291 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,292 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:33,293 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:33,334 - root - INFO: ... got raster of shape: (69, 203)\n", + "2021-09-23 13:19:33,343 - root - INFO: Masking to shape\n" ] }, { @@ -1823,36 +1825,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:00,570 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "2021-09-20 23:16:00,572 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:00,574 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", - "2021-09-20 23:16:00,576 - root - INFO: \n", - "2021-09-20 23:16:00,577 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:00,577 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,578 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:00,578 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:00,619 - root - INFO: ... got raster of shape: (69, 203)\n", - "2021-09-20 23:16:00,628 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:00,659 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "2021-09-20 23:16:00,661 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:00,663 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", - "2021-09-20 23:16:00,666 - root - INFO: \n", - "2021-09-20 23:16:00,666 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:00,666 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,667 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:00,667 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:00,706 - root - INFO: ... got raster of shape: (69, 203)\n", - "2021-09-20 23:16:00,715 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:00,745 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "2021-09-20 23:16:00,747 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:00,748 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", - "2021-09-20 23:16:00,750 - root - INFO: \n", - "2021-09-20 23:16:00,751 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:00,751 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,751 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:00,752 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:00,794 - root - INFO: ... got raster of shape: (69, 203)\n", - "2021-09-20 23:16:00,803 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:33,372 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "2021-09-23 13:19:33,374 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:33,375 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", + "2021-09-23 13:19:33,378 - root - INFO: \n", + "2021-09-23 13:19:33,378 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,378 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,379 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:33,379 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:33,419 - root - INFO: ... got raster of shape: (69, 203)\n", + "2021-09-23 13:19:33,428 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:33,460 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "2021-09-23 13:19:33,461 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:33,462 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", + "2021-09-23 13:19:33,465 - root - INFO: \n", + "2021-09-23 13:19:33,465 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,466 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,466 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:33,467 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:33,507 - root - INFO: ... got raster of shape: (69, 203)\n", + "2021-09-23 13:19:33,516 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:33,546 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "2021-09-23 13:19:33,548 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:33,549 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", + "2021-09-23 13:19:33,551 - root - INFO: \n", + "2021-09-23 13:19:33,551 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,552 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,552 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:33,552 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:33,594 - root - INFO: ... got raster of shape: (69, 203)\n", + "2021-09-23 13:19:33,602 - root - INFO: Masking to shape\n" ] }, { @@ -1868,42 +1870,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:00,833 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "2021-09-20 23:16:00,835 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:00,836 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", - "2021-09-20 23:16:00,853 - root - INFO: \n", - "2021-09-20 23:16:00,854 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:00,854 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,854 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:00,859 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:00,860 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:00,914 - root - INFO: \n", - "2021-09-20 23:16:00,915 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:00,915 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:00,916 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:00,917 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:00,958 - root - INFO: ... got raster of shape: (89, 263)\n", - "2021-09-20 23:16:00,967 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:00,999 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "2021-09-20 23:16:01,001 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:01,002 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", - "2021-09-20 23:16:01,006 - root - INFO: \n", - "2021-09-20 23:16:01,007 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,007 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,008 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:01,009 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:01,053 - root - INFO: ... got raster of shape: (89, 263)\n", - "2021-09-20 23:16:01,064 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:01,095 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "2021-09-20 23:16:01,097 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:01,098 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", - "2021-09-20 23:16:01,101 - root - INFO: \n", - "2021-09-20 23:16:01,102 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,102 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,102 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:01,103 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:01,145 - root - INFO: ... got raster of shape: (89, 263)\n", - "2021-09-20 23:16:01,153 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:33,631 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", + "2021-09-23 13:19:33,633 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:33,634 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", + "2021-09-23 13:19:33,650 - root - INFO: \n", + "2021-09-23 13:19:33,650 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:33,651 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,651 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:33,656 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:33,657 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:33,708 - root - INFO: \n", + "2021-09-23 13:19:33,709 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,709 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,710 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:33,711 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:33,755 - root - INFO: ... got raster of shape: (89, 263)\n", + "2021-09-23 13:19:33,763 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:33,794 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "2021-09-23 13:19:33,796 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:33,796 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", + "2021-09-23 13:19:33,800 - root - INFO: \n", + "2021-09-23 13:19:33,800 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,800 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,801 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:33,801 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:33,845 - root - INFO: ... got raster of shape: (89, 263)\n", + "2021-09-23 13:19:33,853 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:33,883 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "2021-09-23 13:19:33,885 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:33,886 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", + "2021-09-23 13:19:33,889 - root - INFO: \n", + "2021-09-23 13:19:33,890 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,890 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,891 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:33,892 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:33,936 - root - INFO: ... got raster of shape: (89, 263)\n", + "2021-09-23 13:19:33,944 - root - INFO: Masking to shape\n" ] }, { @@ -1919,32 +1921,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:01,184 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "2021-09-20 23:16:01,186 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:01,187 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", - "2021-09-20 23:16:01,191 - root - INFO: \n", - "2021-09-20 23:16:01,191 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,192 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,192 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:01,193 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:01,237 - root - INFO: ... got raster of shape: (89, 263)\n", - "2021-09-20 23:16:01,247 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:01,279 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "2021-09-20 23:16:01,281 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:01,281 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", - "2021-09-20 23:16:01,300 - root - INFO: \n", - "2021-09-20 23:16:01,300 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:01,301 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,301 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:01,305 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:01,306 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:01,360 - root - INFO: \n", - "2021-09-20 23:16:01,361 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,361 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,362 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:01,363 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:01,406 - root - INFO: ... got raster of shape: (100, 191)\n", - "2021-09-20 23:16:01,415 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:33,973 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "2021-09-23 13:19:33,975 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:33,976 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", + "2021-09-23 13:19:33,980 - root - INFO: \n", + "2021-09-23 13:19:33,981 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:33,981 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:33,981 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:33,982 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:34,024 - root - INFO: ... got raster of shape: (89, 263)\n", + "2021-09-23 13:19:34,032 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:34,064 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", + "2021-09-23 13:19:34,065 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:34,066 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", + "2021-09-23 13:19:34,083 - root - INFO: \n", + "2021-09-23 13:19:34,084 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:34,084 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,084 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:34,090 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:34,091 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:34,143 - root - INFO: \n", + "2021-09-23 13:19:34,144 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:34,145 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,145 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:34,146 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:34,188 - root - INFO: ... got raster of shape: (100, 191)\n", + "2021-09-23 13:19:34,196 - root - INFO: Masking to shape\n" ] }, { @@ -1959,36 +1961,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:01,445 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "2021-09-20 23:16:01,448 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:01,448 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", - "2021-09-20 23:16:01,452 - root - INFO: \n", - "2021-09-20 23:16:01,452 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,453 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,453 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:01,454 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:01,497 - root - INFO: ... got raster of shape: (100, 191)\n", - "2021-09-20 23:16:01,506 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:01,537 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "2021-09-20 23:16:01,539 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:01,539 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", - "2021-09-20 23:16:01,543 - root - INFO: \n", - "2021-09-20 23:16:01,543 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,544 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,544 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:01,545 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:01,587 - root - INFO: ... got raster of shape: (100, 191)\n", - "2021-09-20 23:16:01,596 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:01,626 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "2021-09-20 23:16:01,628 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:01,629 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", - "2021-09-20 23:16:01,631 - root - INFO: \n", - "2021-09-20 23:16:01,632 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,632 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,633 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:01,634 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:01,676 - root - INFO: ... got raster of shape: (100, 191)\n", - "2021-09-20 23:16:01,685 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:34,226 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "2021-09-23 13:19:34,228 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:34,229 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", + "2021-09-23 13:19:34,232 - root - INFO: \n", + "2021-09-23 13:19:34,233 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:34,233 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,233 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:34,234 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:34,276 - root - INFO: ... got raster of shape: (100, 191)\n", + "2021-09-23 13:19:34,284 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:34,315 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "2021-09-23 13:19:34,317 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:34,318 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", + "2021-09-23 13:19:34,321 - root - INFO: \n", + "2021-09-23 13:19:34,321 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:34,322 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,322 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:34,323 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:34,363 - root - INFO: ... got raster of shape: (100, 191)\n", + "2021-09-23 13:19:34,372 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:34,401 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "2021-09-23 13:19:34,403 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:34,404 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", + "2021-09-23 13:19:34,406 - root - INFO: \n", + "2021-09-23 13:19:34,407 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:34,408 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,408 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:34,409 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:34,451 - root - INFO: ... got raster of shape: (100, 191)\n", + "2021-09-23 13:19:34,461 - root - INFO: Masking to shape\n" ] }, { @@ -2004,42 +2006,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:01,716 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "2021-09-20 23:16:01,718 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:01,718 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", - "2021-09-20 23:16:01,736 - root - INFO: \n", - "2021-09-20 23:16:01,737 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:01,737 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,738 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:01,743 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:01,744 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:01,795 - root - INFO: \n", - "2021-09-20 23:16:01,796 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,797 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,797 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:01,798 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:01,841 - root - INFO: ... got raster of shape: (92, 198)\n", - "2021-09-20 23:16:01,850 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:01,881 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "2021-09-20 23:16:01,883 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:01,884 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", - "2021-09-20 23:16:01,887 - root - INFO: \n", - "2021-09-20 23:16:01,888 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,888 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,889 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:01,890 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:01,932 - root - INFO: ... got raster of shape: (92, 198)\n", - "2021-09-20 23:16:01,941 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:01,972 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "2021-09-20 23:16:01,974 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:01,976 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", - "2021-09-20 23:16:01,979 - root - INFO: \n", - "2021-09-20 23:16:01,980 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:01,980 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:01,981 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:01,981 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,023 - root - INFO: ... got raster of shape: (92, 198)\n", - "2021-09-20 23:16:02,031 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:34,492 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", + "2021-09-23 13:19:34,494 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:34,495 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", + "2021-09-23 13:19:34,510 - root - INFO: \n", + "2021-09-23 13:19:34,511 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:34,511 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,512 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:34,516 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:34,517 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:34,570 - root - INFO: \n", + "2021-09-23 13:19:34,571 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:34,571 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,572 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:34,573 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:34,617 - root - INFO: ... got raster of shape: (92, 198)\n", + "2021-09-23 13:19:34,625 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:34,655 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "2021-09-23 13:19:34,657 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:34,659 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", + "2021-09-23 13:19:34,661 - root - INFO: \n", + "2021-09-23 13:19:34,662 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:34,662 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,662 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:34,663 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:34,708 - root - INFO: ... got raster of shape: (92, 198)\n", + "2021-09-23 13:19:34,716 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:34,747 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "2021-09-23 13:19:34,749 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:34,750 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", + "2021-09-23 13:19:34,753 - root - INFO: \n", + "2021-09-23 13:19:34,753 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:34,754 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,754 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:34,755 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:34,799 - root - INFO: ... got raster of shape: (92, 198)\n", + "2021-09-23 13:19:34,808 - root - INFO: Masking to shape\n" ] }, { @@ -2055,32 +2057,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:02,062 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "2021-09-20 23:16:02,065 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:02,065 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", - "2021-09-20 23:16:02,069 - root - INFO: \n", - "2021-09-20 23:16:02,069 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:02,070 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,070 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:02,071 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,114 - root - INFO: ... got raster of shape: (92, 198)\n", - "2021-09-20 23:16:02,123 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:02,154 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "2021-09-20 23:16:02,156 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:02,157 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", - "2021-09-20 23:16:02,174 - root - INFO: \n", - "2021-09-20 23:16:02,174 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:02,175 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,175 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:02,181 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:02,182 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:02,235 - root - INFO: \n", - "2021-09-20 23:16:02,236 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:02,236 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,237 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:02,238 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,281 - root - INFO: ... got raster of shape: (98, 188)\n", - "2021-09-20 23:16:02,290 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:34,839 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "2021-09-23 13:19:34,840 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:34,841 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", + "2021-09-23 13:19:34,845 - root - INFO: \n", + "2021-09-23 13:19:34,845 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:34,846 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,846 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:34,847 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:34,888 - root - INFO: ... got raster of shape: (92, 198)\n", + "2021-09-23 13:19:34,897 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:34,928 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", + "2021-09-23 13:19:34,930 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:34,931 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", + "2021-09-23 13:19:34,947 - root - INFO: \n", + "2021-09-23 13:19:34,948 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:34,948 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:34,949 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:34,954 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:34,954 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:35,009 - root - INFO: \n", + "2021-09-23 13:19:35,009 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,010 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,010 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:35,011 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,053 - root - INFO: ... got raster of shape: (98, 188)\n", + "2021-09-23 13:19:35,062 - root - INFO: Masking to shape\n" ] }, { @@ -2095,36 +2097,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:02,320 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "2021-09-20 23:16:02,322 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:02,323 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", - "2021-09-20 23:16:02,327 - root - INFO: \n", - "2021-09-20 23:16:02,328 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:02,328 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,328 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:02,329 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,370 - root - INFO: ... got raster of shape: (98, 188)\n", - "2021-09-20 23:16:02,379 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:02,409 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "2021-09-20 23:16:02,411 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:02,412 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", - "2021-09-20 23:16:02,417 - root - INFO: \n", - "2021-09-20 23:16:02,417 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:02,417 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,418 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:02,419 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,460 - root - INFO: ... got raster of shape: (98, 188)\n", - "2021-09-20 23:16:02,470 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:02,501 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "2021-09-20 23:16:02,503 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:02,504 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", - "2021-09-20 23:16:02,508 - root - INFO: \n", - "2021-09-20 23:16:02,508 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:02,508 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,509 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:02,510 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,552 - root - INFO: ... got raster of shape: (98, 188)\n", - "2021-09-20 23:16:02,562 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:35,092 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "2021-09-23 13:19:35,094 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:35,095 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", + "2021-09-23 13:19:35,099 - root - INFO: \n", + "2021-09-23 13:19:35,100 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,100 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,101 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:35,101 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,144 - root - INFO: ... got raster of shape: (98, 188)\n", + "2021-09-23 13:19:35,153 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:35,184 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "2021-09-23 13:19:35,185 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:35,186 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", + "2021-09-23 13:19:35,190 - root - INFO: \n", + "2021-09-23 13:19:35,191 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,191 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,191 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:35,192 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,233 - root - INFO: ... got raster of shape: (98, 188)\n", + "2021-09-23 13:19:35,241 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:35,271 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "2021-09-23 13:19:35,273 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:35,274 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", + "2021-09-23 13:19:35,277 - root - INFO: \n", + "2021-09-23 13:19:35,278 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,278 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,279 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:35,279 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,321 - root - INFO: ... got raster of shape: (98, 188)\n", + "2021-09-23 13:19:35,330 - root - INFO: Masking to shape\n" ] }, { @@ -2140,42 +2142,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:02,594 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "2021-09-20 23:16:02,596 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:02,596 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", - "2021-09-20 23:16:02,615 - root - INFO: \n", - "2021-09-20 23:16:02,616 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:02,616 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,617 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:02,621 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:02,622 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:02,675 - root - INFO: \n", - "2021-09-20 23:16:02,676 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:02,676 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,677 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:02,678 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,719 - root - INFO: ... got raster of shape: (79, 96)\n", - "2021-09-20 23:16:02,728 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:02,758 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "2021-09-20 23:16:02,760 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:02,761 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", - "2021-09-20 23:16:02,764 - root - INFO: \n", - "2021-09-20 23:16:02,765 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:02,765 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,765 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:02,767 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,808 - root - INFO: ... got raster of shape: (79, 96)\n", - "2021-09-20 23:16:02,817 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:02,848 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "2021-09-20 23:16:02,850 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:02,851 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", - "2021-09-20 23:16:02,854 - root - INFO: \n", - "2021-09-20 23:16:02,854 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:02,855 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,855 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:02,856 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,899 - root - INFO: ... got raster of shape: (79, 96)\n", - "2021-09-20 23:16:02,908 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:35,360 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", + "2021-09-23 13:19:35,362 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:35,363 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", + "2021-09-23 13:19:35,379 - root - INFO: \n", + "2021-09-23 13:19:35,379 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:35,379 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,380 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:35,385 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:35,385 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:35,438 - root - INFO: \n", + "2021-09-23 13:19:35,439 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,439 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,440 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:35,441 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,484 - root - INFO: ... got raster of shape: (79, 96)\n", + "2021-09-23 13:19:35,492 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:35,523 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "2021-09-23 13:19:35,525 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:35,525 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", + "2021-09-23 13:19:35,529 - root - INFO: \n", + "2021-09-23 13:19:35,529 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,529 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,530 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:35,531 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,571 - root - INFO: ... got raster of shape: (79, 96)\n", + "2021-09-23 13:19:35,580 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:35,612 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "2021-09-23 13:19:35,614 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:35,614 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", + "2021-09-23 13:19:35,617 - root - INFO: \n", + "2021-09-23 13:19:35,617 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,618 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,618 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:35,619 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,661 - root - INFO: ... got raster of shape: (79, 96)\n", + "2021-09-23 13:19:35,670 - root - INFO: Masking to shape\n" ] }, { @@ -2191,32 +2193,35 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:02,940 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "2021-09-20 23:16:02,941 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:02,942 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", - "2021-09-20 23:16:02,945 - root - INFO: \n", - "2021-09-20 23:16:02,945 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:02,946 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:02,946 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:02,948 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:02,990 - root - INFO: ... got raster of shape: (79, 96)\n", - "2021-09-20 23:16:03,000 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:03,031 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "2021-09-20 23:16:03,034 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:03,035 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", - "2021-09-20 23:16:03,052 - root - INFO: \n", - "2021-09-20 23:16:03,052 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:03,053 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,053 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:03,058 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:03,058 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:03,112 - root - INFO: \n", - "2021-09-20 23:16:03,113 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:03,114 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,114 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:03,115 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:03,157 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-20 23:16:03,166 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:35,700 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "2021-09-23 13:19:35,702 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:35,703 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", + "2021-09-23 13:19:35,706 - root - INFO: \n", + "2021-09-23 13:19:35,706 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,707 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,707 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:35,709 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,751 - root - INFO: ... got raster of shape: (79, 96)\n", + "2021-09-23 13:19:35,759 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:35,789 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", + "2021-09-23 13:19:35,792 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:35,792 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", + "2021-09-23 13:19:35,808 - root - INFO: \n", + "2021-09-23 13:19:35,808 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:35,809 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,809 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:35,814 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:35,814 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:35,866 - root - INFO: \n", + "2021-09-23 13:19:35,866 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,867 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,867 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:35,868 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,909 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-23 13:19:35,917 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:35,947 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "2021-09-23 13:19:35,949 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:35,950 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n" ] }, { @@ -2231,36 +2236,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:03,197 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "2021-09-20 23:16:03,199 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:03,199 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", - "2021-09-20 23:16:03,202 - root - INFO: \n", - "2021-09-20 23:16:03,203 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:03,203 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,203 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:03,204 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:03,245 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-20 23:16:03,254 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:03,284 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "2021-09-20 23:16:03,286 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:03,287 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", - "2021-09-20 23:16:03,288 - root - INFO: \n", - "2021-09-20 23:16:03,289 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:03,289 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,290 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:03,290 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:03,331 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-20 23:16:03,340 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:03,370 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "2021-09-20 23:16:03,372 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:03,373 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", - "2021-09-20 23:16:03,374 - root - INFO: \n", - "2021-09-20 23:16:03,375 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:03,376 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,376 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:03,377 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:03,419 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-20 23:16:03,427 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:35,952 - root - INFO: \n", + "2021-09-23 13:19:35,953 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:35,953 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:35,953 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:35,954 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:35,995 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-23 13:19:36,004 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:36,034 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "2021-09-23 13:19:36,036 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:36,037 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", + "2021-09-23 13:19:36,039 - root - INFO: \n", + "2021-09-23 13:19:36,040 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:36,041 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,041 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:36,042 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:36,084 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-23 13:19:36,092 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:36,122 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "2021-09-23 13:19:36,123 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:36,124 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", + "2021-09-23 13:19:36,126 - root - INFO: \n", + "2021-09-23 13:19:36,126 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:36,127 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,127 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:36,127 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:36,168 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-23 13:19:36,177 - root - INFO: Masking to shape\n" ] }, { @@ -2276,41 +2278,41 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:03,458 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "2021-09-20 23:16:03,460 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:03,461 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", - "2021-09-20 23:16:03,475 - root - INFO: \n", - "2021-09-20 23:16:03,475 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:03,476 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,476 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:03,482 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:03,482 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:03,543 - root - INFO: \n", - "2021-09-20 23:16:03,544 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:03,544 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,544 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:03,547 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:03,590 - root - INFO: ... got raster of shape: (122, 301)\n", - "2021-09-20 23:16:03,599 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:03,630 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "2021-09-20 23:16:03,633 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:03,634 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", - "2021-09-20 23:16:03,637 - root - INFO: \n", - "2021-09-20 23:16:03,638 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:03,638 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,638 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:03,642 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:03,686 - root - INFO: ... got raster of shape: (122, 301)\n", - "2021-09-20 23:16:03,695 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:03,728 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "2021-09-20 23:16:03,730 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:03,731 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", - "2021-09-20 23:16:03,733 - root - INFO: \n", - "2021-09-20 23:16:03,734 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:03,734 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,735 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:03,738 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:03,782 - root - INFO: ... got raster of shape: (122, 301)\n" + "2021-09-23 13:19:36,207 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", + "2021-09-23 13:19:36,208 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:36,209 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", + "2021-09-23 13:19:36,223 - root - INFO: \n", + "2021-09-23 13:19:36,223 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:36,224 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,224 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:36,229 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:36,230 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:36,282 - root - INFO: \n", + "2021-09-23 13:19:36,283 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:36,283 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,284 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:36,287 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:36,332 - root - INFO: ... got raster of shape: (122, 301)\n", + "2021-09-23 13:19:36,341 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:36,373 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "2021-09-23 13:19:36,376 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:36,376 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", + "2021-09-23 13:19:36,379 - root - INFO: \n", + "2021-09-23 13:19:36,380 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:36,380 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,380 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:36,384 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:36,428 - root - INFO: ... got raster of shape: (122, 301)\n", + "2021-09-23 13:19:36,437 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:36,469 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "2021-09-23 13:19:36,472 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:36,473 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", + "2021-09-23 13:19:36,475 - root - INFO: \n", + "2021-09-23 13:19:36,476 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:36,476 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,477 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:36,480 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:36,525 - root - INFO: ... got raster of shape: (122, 301)\n" ] }, { @@ -2326,33 +2328,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:03,792 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:03,824 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "2021-09-20 23:16:03,828 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:03,828 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", - "2021-09-20 23:16:03,834 - root - INFO: \n", - "2021-09-20 23:16:03,834 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:03,835 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,835 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:03,838 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:03,882 - root - INFO: ... got raster of shape: (122, 301)\n", - "2021-09-20 23:16:03,891 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:03,924 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "2021-09-20 23:16:03,926 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:03,927 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", - "2021-09-20 23:16:03,942 - root - INFO: \n", - "2021-09-20 23:16:03,943 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:03,944 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:03,944 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:03,950 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:03,951 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:04,001 - root - INFO: \n", - "2021-09-20 23:16:04,001 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,002 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,002 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:04,003 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:04,045 - root - INFO: ... got raster of shape: (69, 204)\n", - "2021-09-20 23:16:04,054 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:36,533 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:36,566 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "2021-09-23 13:19:36,568 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:36,569 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", + "2021-09-23 13:19:36,574 - root - INFO: \n", + "2021-09-23 13:19:36,575 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:36,575 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,576 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:36,580 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:36,622 - root - INFO: ... got raster of shape: (122, 301)\n", + "2021-09-23 13:19:36,631 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:36,663 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", + "2021-09-23 13:19:36,666 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:36,666 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", + "2021-09-23 13:19:36,695 - root - INFO: \n", + "2021-09-23 13:19:36,696 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:36,696 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,697 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:36,702 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:36,703 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:36,755 - root - INFO: \n", + "2021-09-23 13:19:36,756 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:36,757 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,757 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:36,758 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:36,800 - root - INFO: ... got raster of shape: (69, 204)\n", + "2021-09-23 13:19:36,808 - root - INFO: Masking to shape\n" ] }, { @@ -2367,36 +2369,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:04,085 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "2021-09-20 23:16:04,087 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:04,088 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", - "2021-09-20 23:16:04,091 - root - INFO: \n", - "2021-09-20 23:16:04,092 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,092 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,092 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:04,093 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:04,141 - root - INFO: ... got raster of shape: (69, 204)\n", - "2021-09-20 23:16:04,149 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:04,180 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "2021-09-20 23:16:04,182 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:04,183 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", - "2021-09-20 23:16:04,186 - root - INFO: \n", - "2021-09-20 23:16:04,187 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,187 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,187 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:04,188 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:04,230 - root - INFO: ... got raster of shape: (69, 204)\n", - "2021-09-20 23:16:04,239 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:04,270 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "2021-09-20 23:16:04,272 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:04,273 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", - "2021-09-20 23:16:04,275 - root - INFO: \n", - "2021-09-20 23:16:04,276 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,276 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,277 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:04,278 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:04,319 - root - INFO: ... got raster of shape: (69, 204)\n", - "2021-09-20 23:16:04,327 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:36,838 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "2021-09-23 13:19:36,840 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:36,841 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", + "2021-09-23 13:19:36,843 - root - INFO: \n", + "2021-09-23 13:19:36,844 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:36,844 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,845 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:36,845 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:36,888 - root - INFO: ... got raster of shape: (69, 204)\n", + "2021-09-23 13:19:36,897 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:36,927 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "2021-09-23 13:19:36,929 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:36,930 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", + "2021-09-23 13:19:36,932 - root - INFO: \n", + "2021-09-23 13:19:36,933 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:36,933 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:36,933 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:36,934 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:36,977 - root - INFO: ... got raster of shape: (69, 204)\n", + "2021-09-23 13:19:36,986 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:37,015 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "2021-09-23 13:19:37,017 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:37,018 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", + "2021-09-23 13:19:37,020 - root - INFO: \n", + "2021-09-23 13:19:37,021 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:37,021 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,022 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:37,023 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:37,065 - root - INFO: ... got raster of shape: (69, 204)\n", + "2021-09-23 13:19:37,075 - root - INFO: Masking to shape\n" ] }, { @@ -2412,42 +2414,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:04,357 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "2021-09-20 23:16:04,359 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:04,359 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", - "2021-09-20 23:16:04,377 - root - INFO: \n", - "2021-09-20 23:16:04,378 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:04,378 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,378 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:04,384 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:04,385 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:04,436 - root - INFO: \n", - "2021-09-20 23:16:04,437 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,437 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,438 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:04,440 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:04,483 - root - INFO: ... got raster of shape: (124, 328)\n", - "2021-09-20 23:16:04,493 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:04,525 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "2021-09-20 23:16:04,526 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:04,527 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", - "2021-09-20 23:16:04,530 - root - INFO: \n", - "2021-09-20 23:16:04,531 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,531 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,532 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:04,534 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:04,576 - root - INFO: ... got raster of shape: (124, 328)\n", - "2021-09-20 23:16:04,585 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:04,616 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "2021-09-20 23:16:04,618 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:04,619 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", - "2021-09-20 23:16:04,621 - root - INFO: \n", - "2021-09-20 23:16:04,622 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,622 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,623 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:04,625 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:04,665 - root - INFO: ... got raster of shape: (124, 328)\n", - "2021-09-20 23:16:04,673 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:37,107 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", + "2021-09-23 13:19:37,109 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:37,110 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", + "2021-09-23 13:19:37,126 - root - INFO: \n", + "2021-09-23 13:19:37,127 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:37,127 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,128 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:37,132 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:37,133 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:37,184 - root - INFO: \n", + "2021-09-23 13:19:37,185 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:37,185 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,186 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:37,188 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:37,228 - root - INFO: ... got raster of shape: (124, 328)\n", + "2021-09-23 13:19:37,237 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:37,266 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "2021-09-23 13:19:37,268 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:37,269 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", + "2021-09-23 13:19:37,272 - root - INFO: \n", + "2021-09-23 13:19:37,273 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:37,273 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,274 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:37,276 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:37,318 - root - INFO: ... got raster of shape: (124, 328)\n", + "2021-09-23 13:19:37,327 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:37,359 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "2021-09-23 13:19:37,361 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:37,362 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", + "2021-09-23 13:19:37,365 - root - INFO: \n", + "2021-09-23 13:19:37,366 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:37,366 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,366 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:37,368 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:37,409 - root - INFO: ... got raster of shape: (124, 328)\n", + "2021-09-23 13:19:37,417 - root - INFO: Masking to shape\n" ] }, { @@ -2463,32 +2465,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:04,705 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "2021-09-20 23:16:04,707 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:04,708 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", - "2021-09-20 23:16:04,713 - root - INFO: \n", - "2021-09-20 23:16:04,713 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,714 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,714 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:04,717 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:04,758 - root - INFO: ... got raster of shape: (124, 328)\n", - "2021-09-20 23:16:04,767 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:04,798 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "2021-09-20 23:16:04,800 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:04,801 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", - "2021-09-20 23:16:04,817 - root - INFO: \n", - "2021-09-20 23:16:04,818 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:04,818 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,818 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:04,823 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:04,824 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:04,877 - root - INFO: \n", - "2021-09-20 23:16:04,878 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,878 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,879 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:04,880 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:04,923 - root - INFO: ... got raster of shape: (95, 310)\n", - "2021-09-20 23:16:04,932 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:37,448 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "2021-09-23 13:19:37,450 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:37,451 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", + "2021-09-23 13:19:37,455 - root - INFO: \n", + "2021-09-23 13:19:37,456 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:37,456 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,456 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:37,458 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:37,500 - root - INFO: ... got raster of shape: (124, 328)\n", + "2021-09-23 13:19:37,509 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:37,542 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", + "2021-09-23 13:19:37,544 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:37,545 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", + "2021-09-23 13:19:37,566 - root - INFO: \n", + "2021-09-23 13:19:37,567 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:37,567 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,568 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:37,573 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:37,573 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:37,625 - root - INFO: \n", + "2021-09-23 13:19:37,626 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:37,627 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,627 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:37,629 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:37,672 - root - INFO: ... got raster of shape: (95, 310)\n", + "2021-09-23 13:19:37,680 - root - INFO: Masking to shape\n" ] }, { @@ -2503,40 +2505,43 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:04,964 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "2021-09-20 23:16:04,966 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:04,967 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", - "2021-09-20 23:16:04,970 - root - INFO: \n", - "2021-09-20 23:16:04,970 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:04,971 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:04,971 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:04,973 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:05,018 - root - INFO: ... got raster of shape: (95, 310)\n", - "2021-09-20 23:16:05,028 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:05,069 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "2021-09-20 23:16:05,071 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:05,072 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", - "2021-09-20 23:16:05,077 - root - INFO: \n", - "2021-09-20 23:16:05,078 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:05,079 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,080 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:05,082 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:05,133 - root - INFO: ... got raster of shape: (95, 310)\n", - "2021-09-20 23:16:05,143 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:05,177 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "2021-09-20 23:16:05,179 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:05,179 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", - "2021-09-20 23:16:05,183 - root - INFO: \n", - "2021-09-20 23:16:05,184 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:05,184 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,184 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:05,186 - root - INFO: Collecting raster\n" + "2021-09-23 13:19:37,711 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "2021-09-23 13:19:37,713 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:37,713 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", + "2021-09-23 13:19:37,716 - root - INFO: \n", + "2021-09-23 13:19:37,717 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:37,717 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,717 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:37,719 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:37,759 - root - INFO: ... got raster of shape: (95, 310)\n", + "2021-09-23 13:19:37,769 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:37,799 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "2021-09-23 13:19:37,801 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:37,802 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", + "2021-09-23 13:19:37,804 - root - INFO: \n", + "2021-09-23 13:19:37,805 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:37,805 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,805 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:37,807 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:37,850 - root - INFO: ... got raster of shape: (95, 310)\n", + "2021-09-23 13:19:37,859 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:37,890 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "2021-09-23 13:19:37,893 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:37,893 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", + "2021-09-23 13:19:37,897 - root - INFO: \n", + "2021-09-23 13:19:37,897 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:37,897 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:37,898 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:37,899 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:37,941 - root - INFO: ... got raster of shape: (95, 310)\n", + "2021-09-23 13:19:37,949 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ + "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n" ] @@ -2545,31 +2550,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:05,230 - root - INFO: ... got raster of shape: (95, 310)\n", - "2021-09-20 23:16:05,239 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:05,274 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "2021-09-20 23:16:05,276 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:05,278 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", - "2021-09-20 23:16:05,294 - root - INFO: \n", - "2021-09-20 23:16:05,294 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:05,295 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,295 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:05,300 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:05,301 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:05,358 - root - INFO: \n", - "2021-09-20 23:16:05,358 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:05,359 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,359 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:05,361 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:05,407 - root - INFO: ... got raster of shape: (67, 367)\n", - "2021-09-20 23:16:05,416 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:37,980 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "2021-09-23 13:19:37,982 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:37,983 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", + "2021-09-23 13:19:38,006 - root - INFO: \n", + "2021-09-23 13:19:38,007 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:38,008 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,008 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:38,013 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:38,014 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:38,065 - root - INFO: \n", + "2021-09-23 13:19:38,065 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:38,066 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,066 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:38,067 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:38,112 - root - INFO: ... got raster of shape: (67, 367)\n", + "2021-09-23 13:19:38,121 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:38,149 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "2021-09-23 13:19:38,151 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:38,152 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", + "2021-09-23 13:19:38,155 - root - INFO: \n", + "2021-09-23 13:19:38,156 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:38,156 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,157 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:38,158 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:38,203 - root - INFO: ... got raster of shape: (67, 367)\n", + "2021-09-23 13:19:38,211 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:38,241 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "2021-09-23 13:19:38,243 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:38,244 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", + "2021-09-23 13:19:38,247 - root - INFO: \n", + "2021-09-23 13:19:38,247 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:38,247 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,248 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:38,248 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:38,292 - root - INFO: ... got raster of shape: (67, 367)\n", + "2021-09-23 13:19:38,301 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", + "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n" ] }, @@ -2577,36 +2601,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:05,449 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "2021-09-20 23:16:05,452 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:05,453 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", - "2021-09-20 23:16:05,456 - root - INFO: \n", - "2021-09-20 23:16:05,456 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:05,457 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,457 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:05,459 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:05,503 - root - INFO: ... got raster of shape: (67, 367)\n", - "2021-09-20 23:16:05,512 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:05,545 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "2021-09-20 23:16:05,547 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:05,548 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", - "2021-09-20 23:16:05,551 - root - INFO: \n", - "2021-09-20 23:16:05,551 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:05,552 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,552 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:05,553 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:05,595 - root - INFO: ... got raster of shape: (67, 367)\n", - "2021-09-20 23:16:05,603 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:05,634 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "2021-09-20 23:16:05,636 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:05,637 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", - "2021-09-20 23:16:05,641 - root - INFO: \n", - "2021-09-20 23:16:05,642 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:05,642 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,643 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:05,644 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:05,685 - root - INFO: ... got raster of shape: (67, 367)\n", - "2021-09-20 23:16:05,694 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:38,331 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "2021-09-23 13:19:38,333 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:38,334 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", + "2021-09-23 13:19:38,337 - root - INFO: \n", + "2021-09-23 13:19:38,338 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:38,338 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,339 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:38,339 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:38,383 - root - INFO: ... got raster of shape: (67, 367)\n", + "2021-09-23 13:19:38,392 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:38,421 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", + "2021-09-23 13:19:38,424 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:38,425 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", + "2021-09-23 13:19:38,445 - root - INFO: \n", + "2021-09-23 13:19:38,445 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:38,446 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,446 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:38,451 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:38,451 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:38,503 - root - INFO: \n", + "2021-09-23 13:19:38,503 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:38,504 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,504 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:38,505 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:38,545 - root - INFO: ... got raster of shape: (53, 365)\n", + "2021-09-23 13:19:38,555 - root - INFO: Masking to shape\n" ] }, { @@ -2614,50 +2634,43 @@ "output_type": "stream", "text": [ "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n" + "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:05,727 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "2021-09-20 23:16:05,729 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:05,730 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", - "2021-09-20 23:16:05,750 - root - INFO: \n", - "2021-09-20 23:16:05,750 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:05,751 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,752 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:05,757 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:05,757 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:05,815 - root - INFO: \n", - "2021-09-20 23:16:05,815 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:05,816 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,816 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:05,817 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:05,860 - root - INFO: ... got raster of shape: (53, 365)\n", - "2021-09-20 23:16:05,869 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:05,899 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "2021-09-20 23:16:05,901 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:05,902 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", - "2021-09-20 23:16:05,906 - root - INFO: \n", - "2021-09-20 23:16:05,907 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:05,907 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,907 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:05,908 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:05,949 - root - INFO: ... got raster of shape: (53, 365)\n", - "2021-09-20 23:16:05,958 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:05,989 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "2021-09-20 23:16:05,991 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:05,992 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", - "2021-09-20 23:16:05,995 - root - INFO: \n", - "2021-09-20 23:16:05,996 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:05,996 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:05,996 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:05,997 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:06,040 - root - INFO: ... got raster of shape: (53, 365)\n", - "2021-09-20 23:16:06,050 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:38,585 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "2021-09-23 13:19:38,587 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:38,588 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", + "2021-09-23 13:19:38,592 - root - INFO: \n", + "2021-09-23 13:19:38,592 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:38,593 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,593 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:38,593 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:38,644 - root - INFO: ... got raster of shape: (53, 365)\n", + "2021-09-23 13:19:38,652 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:38,682 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "2021-09-23 13:19:38,684 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:38,685 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", + "2021-09-23 13:19:38,689 - root - INFO: \n", + "2021-09-23 13:19:38,690 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:38,690 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,691 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:38,692 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:38,733 - root - INFO: ... got raster of shape: (53, 365)\n", + "2021-09-23 13:19:38,741 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:38,772 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "2021-09-23 13:19:38,774 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:38,775 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", + "2021-09-23 13:19:38,778 - root - INFO: \n", + "2021-09-23 13:19:38,779 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:38,779 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,780 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:38,780 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:38,821 - root - INFO: ... got raster of shape: (53, 365)\n", + "2021-09-23 13:19:38,829 - root - INFO: Masking to shape\n" ] }, { @@ -2673,39 +2686,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:06,082 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "2021-09-20 23:16:06,085 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:06,086 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", - "2021-09-20 23:16:06,089 - root - INFO: \n", - "2021-09-20 23:16:06,089 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:06,090 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,091 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:06,092 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:06,138 - root - INFO: ... got raster of shape: (53, 365)\n", - "2021-09-20 23:16:06,148 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:06,179 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "2021-09-20 23:16:06,182 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:06,183 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", - "2021-09-20 23:16:06,201 - root - INFO: \n", - "2021-09-20 23:16:06,201 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:06,202 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,202 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:06,207 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:06,208 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:06,261 - root - INFO: \n", - "2021-09-20 23:16:06,262 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:06,262 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,263 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:06,267 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:06,312 - root - INFO: ... got raster of shape: (114, 209)\n", - "2021-09-20 23:16:06,321 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:38,858 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "2021-09-23 13:19:38,860 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:38,861 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", + "2021-09-23 13:19:38,882 - root - INFO: \n", + "2021-09-23 13:19:38,882 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:38,883 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,883 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:38,888 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:38,888 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:38,942 - root - INFO: \n", + "2021-09-23 13:19:38,943 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:38,944 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:38,944 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:38,948 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:38,991 - root - INFO: ... got raster of shape: (114, 209)\n", + "2021-09-23 13:19:38,999 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:39,032 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "2021-09-23 13:19:39,035 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:39,035 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", + "2021-09-23 13:19:39,037 - root - INFO: \n", + "2021-09-23 13:19:39,038 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,038 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,038 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:39,042 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:39,085 - root - INFO: ... got raster of shape: (114, 209)\n", + "2021-09-23 13:19:39,094 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:39,128 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "2021-09-23 13:19:39,130 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:39,131 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", + "2021-09-23 13:19:39,133 - root - INFO: \n", + "2021-09-23 13:19:39,133 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,134 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,134 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:39,137 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:39,179 - root - INFO: ... got raster of shape: (114, 209)\n", + "2021-09-23 13:19:39,187 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", + "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n" ] }, @@ -2713,35 +2737,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:06,356 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "2021-09-20 23:16:06,359 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:06,359 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", - "2021-09-20 23:16:06,362 - root - INFO: \n", - "2021-09-20 23:16:06,362 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:06,363 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,363 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:06,368 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:06,412 - root - INFO: ... got raster of shape: (114, 209)\n", - "2021-09-20 23:16:06,421 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:06,455 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "2021-09-20 23:16:06,458 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:06,459 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", - "2021-09-20 23:16:06,461 - root - INFO: \n", - "2021-09-20 23:16:06,461 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:06,462 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,462 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:06,466 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:06,511 - root - INFO: ... got raster of shape: (114, 209)\n", - "2021-09-20 23:16:06,519 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:06,554 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "2021-09-20 23:16:06,556 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:06,557 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", - "2021-09-20 23:16:06,560 - root - INFO: \n", - "2021-09-20 23:16:06,560 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:06,561 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,561 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:06,565 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:06,609 - root - INFO: ... got raster of shape: (114, 209)\n" + "2021-09-23 13:19:39,220 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "2021-09-23 13:19:39,223 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:39,223 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", + "2021-09-23 13:19:39,226 - root - INFO: \n", + "2021-09-23 13:19:39,227 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,227 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,228 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:39,231 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:39,274 - root - INFO: ... got raster of shape: (114, 209)\n", + "2021-09-23 13:19:39,283 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:39,315 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", + "2021-09-23 13:19:39,317 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:39,318 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", + "2021-09-23 13:19:39,336 - root - INFO: \n", + "2021-09-23 13:19:39,337 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:39,337 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,338 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:39,342 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:39,343 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:39,396 - root - INFO: \n", + "2021-09-23 13:19:39,397 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,397 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,398 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:39,399 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:39,440 - root - INFO: ... got raster of shape: (48, 192)\n", + "2021-09-23 13:19:39,448 - root - INFO: Masking to shape\n" ] }, { @@ -2749,51 +2770,43 @@ "output_type": "stream", "text": [ "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n" + "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:06,618 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:06,652 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "2021-09-20 23:16:06,655 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:06,656 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", - "2021-09-20 23:16:06,669 - root - INFO: \n", - "2021-09-20 23:16:06,670 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:06,670 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,671 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:06,675 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:06,676 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:06,730 - root - INFO: \n", - "2021-09-20 23:16:06,731 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:06,731 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,732 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:06,733 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:06,775 - root - INFO: ... got raster of shape: (48, 192)\n", - "2021-09-20 23:16:06,784 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:06,816 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "2021-09-20 23:16:06,817 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:06,818 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", - "2021-09-20 23:16:06,821 - root - INFO: \n", - "2021-09-20 23:16:06,822 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:06,822 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,822 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:06,823 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:06,865 - root - INFO: ... got raster of shape: (48, 192)\n", - "2021-09-20 23:16:06,874 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:06,908 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "2021-09-20 23:16:06,911 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:06,912 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", - "2021-09-20 23:16:06,916 - root - INFO: \n", - "2021-09-20 23:16:06,916 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:06,916 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:06,917 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:06,917 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:06,962 - root - INFO: ... got raster of shape: (48, 192)\n", - "2021-09-20 23:16:06,972 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:39,478 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "2021-09-23 13:19:39,480 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:39,481 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", + "2021-09-23 13:19:39,484 - root - INFO: \n", + "2021-09-23 13:19:39,484 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,485 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,485 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:39,486 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:39,528 - root - INFO: ... got raster of shape: (48, 192)\n", + "2021-09-23 13:19:39,536 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:39,566 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "2021-09-23 13:19:39,568 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:39,569 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", + "2021-09-23 13:19:39,572 - root - INFO: \n", + "2021-09-23 13:19:39,572 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,573 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,573 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:39,574 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:39,615 - root - INFO: ... got raster of shape: (48, 192)\n", + "2021-09-23 13:19:39,624 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:39,654 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "2021-09-23 13:19:39,657 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:39,658 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", + "2021-09-23 13:19:39,660 - root - INFO: \n", + "2021-09-23 13:19:39,661 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,662 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,662 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:39,663 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:39,706 - root - INFO: ... got raster of shape: (48, 192)\n", + "2021-09-23 13:19:39,715 - root - INFO: Masking to shape\n" ] }, { @@ -2809,39 +2822,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:07,006 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "2021-09-20 23:16:07,009 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:07,009 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", - "2021-09-20 23:16:07,013 - root - INFO: \n", - "2021-09-20 23:16:07,014 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:07,015 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,015 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:07,016 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:07,061 - root - INFO: ... got raster of shape: (48, 192)\n", - "2021-09-20 23:16:07,070 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:07,104 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "2021-09-20 23:16:07,106 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:07,107 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", - "2021-09-20 23:16:07,122 - root - INFO: \n", - "2021-09-20 23:16:07,122 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:07,123 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,123 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:07,128 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:07,128 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:07,192 - root - INFO: \n", - "2021-09-20 23:16:07,192 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:07,193 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,194 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:07,196 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:07,241 - root - INFO: ... got raster of shape: (66, 302)\n", - "2021-09-20 23:16:07,251 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:39,745 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "2021-09-23 13:19:39,747 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:39,748 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", + "2021-09-23 13:19:39,759 - root - INFO: \n", + "2021-09-23 13:19:39,759 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:39,760 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,760 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:39,765 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:39,766 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:39,817 - root - INFO: \n", + "2021-09-23 13:19:39,818 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,818 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,819 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:39,820 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:39,862 - root - INFO: ... got raster of shape: (66, 302)\n", + "2021-09-23 13:19:39,871 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:39,903 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "2021-09-23 13:19:39,904 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:39,905 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", + "2021-09-23 13:19:39,908 - root - INFO: \n", + "2021-09-23 13:19:39,908 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,908 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,909 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:39,910 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:39,951 - root - INFO: ... got raster of shape: (66, 302)\n", + "2021-09-23 13:19:39,960 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:39,990 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "2021-09-23 13:19:39,992 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:39,993 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", + "2021-09-23 13:19:39,996 - root - INFO: \n", + "2021-09-23 13:19:39,997 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:39,997 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:39,997 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:39,999 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:40,040 - root - INFO: ... got raster of shape: (66, 302)\n", + "2021-09-23 13:19:40,050 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", + "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n" ] }, @@ -2849,35 +2873,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:07,285 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "2021-09-20 23:16:07,286 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:07,287 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", - "2021-09-20 23:16:07,290 - root - INFO: \n", - "2021-09-20 23:16:07,290 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:07,291 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,291 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:07,293 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:07,338 - root - INFO: ... got raster of shape: (66, 302)\n", - "2021-09-20 23:16:07,348 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:07,382 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "2021-09-20 23:16:07,384 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:07,385 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", - "2021-09-20 23:16:07,388 - root - INFO: \n", - "2021-09-20 23:16:07,388 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:07,389 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,389 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:07,391 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:07,438 - root - INFO: ... got raster of shape: (66, 302)\n", - "2021-09-20 23:16:07,446 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:07,479 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "2021-09-20 23:16:07,481 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:07,482 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", - "2021-09-20 23:16:07,486 - root - INFO: \n", - "2021-09-20 23:16:07,487 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:07,487 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,487 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:07,489 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:07,533 - root - INFO: ... got raster of shape: (66, 302)\n" + "2021-09-23 13:19:40,083 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "2021-09-23 13:19:40,085 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:40,085 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", + "2021-09-23 13:19:40,089 - root - INFO: \n", + "2021-09-23 13:19:40,089 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:40,090 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,090 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:40,092 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:40,134 - root - INFO: ... got raster of shape: (66, 302)\n", + "2021-09-23 13:19:40,143 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:40,174 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", + "2021-09-23 13:19:40,176 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:40,177 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", + "2021-09-23 13:19:40,197 - root - INFO: \n", + "2021-09-23 13:19:40,197 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:40,198 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,198 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:40,203 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:40,204 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:40,255 - root - INFO: \n", + "2021-09-23 13:19:40,255 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:40,256 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,256 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:40,257 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:40,298 - root - INFO: ... got raster of shape: (75, 294)\n", + "2021-09-23 13:19:40,307 - root - INFO: Masking to shape\n" ] }, { @@ -2885,51 +2906,43 @@ "output_type": "stream", "text": [ "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n" + "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:07,542 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:07,575 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "2021-09-20 23:16:07,577 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:07,578 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", - "2021-09-20 23:16:07,594 - root - INFO: \n", - "2021-09-20 23:16:07,594 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:07,595 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,595 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:07,601 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:07,602 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:07,655 - root - INFO: \n", - "2021-09-20 23:16:07,656 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:07,656 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,657 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:07,658 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:07,699 - root - INFO: ... got raster of shape: (75, 294)\n", - "2021-09-20 23:16:07,707 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:07,737 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "2021-09-20 23:16:07,739 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:07,739 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", - "2021-09-20 23:16:07,743 - root - INFO: \n", - "2021-09-20 23:16:07,743 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:07,744 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,744 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:07,745 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:07,787 - root - INFO: ... got raster of shape: (75, 294)\n", - "2021-09-20 23:16:07,796 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:07,827 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "2021-09-20 23:16:07,829 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:07,829 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", - "2021-09-20 23:16:07,833 - root - INFO: \n", - "2021-09-20 23:16:07,834 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:07,834 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,834 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:07,835 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:07,875 - root - INFO: ... got raster of shape: (75, 294)\n", - "2021-09-20 23:16:07,884 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:40,337 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "2021-09-23 13:19:40,339 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:40,340 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", + "2021-09-23 13:19:40,343 - root - INFO: \n", + "2021-09-23 13:19:40,344 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:40,345 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,345 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:40,346 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:40,386 - root - INFO: ... got raster of shape: (75, 294)\n", + "2021-09-23 13:19:40,394 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:40,424 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "2021-09-23 13:19:40,425 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:40,426 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", + "2021-09-23 13:19:40,431 - root - INFO: \n", + "2021-09-23 13:19:40,432 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:40,432 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,433 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:40,433 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:40,475 - root - INFO: ... got raster of shape: (75, 294)\n", + "2021-09-23 13:19:40,484 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:40,513 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "2021-09-23 13:19:40,515 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:40,516 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", + "2021-09-23 13:19:40,519 - root - INFO: \n", + "2021-09-23 13:19:40,520 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:40,520 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,520 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:40,521 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:40,562 - root - INFO: ... got raster of shape: (75, 294)\n", + "2021-09-23 13:19:40,571 - root - INFO: Masking to shape\n" ] }, { @@ -2945,39 +2958,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:07,916 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "2021-09-20 23:16:07,918 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:07,919 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", - "2021-09-20 23:16:07,922 - root - INFO: \n", - "2021-09-20 23:16:07,922 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:07,923 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:07,923 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:07,924 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:07,967 - root - INFO: ... got raster of shape: (75, 294)\n", - "2021-09-20 23:16:07,976 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:08,008 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "2021-09-20 23:16:08,010 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:08,011 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", - "2021-09-20 23:16:08,029 - root - INFO: \n", - "2021-09-20 23:16:08,030 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:08,030 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,031 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:08,036 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:08,037 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:08,092 - root - INFO: \n", - "2021-09-20 23:16:08,093 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:08,094 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,094 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:08,095 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:08,139 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-20 23:16:08,148 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:40,601 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "2021-09-23 13:19:40,603 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:40,604 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", + "2021-09-23 13:19:40,619 - root - INFO: \n", + "2021-09-23 13:19:40,619 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:40,620 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,620 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:40,625 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:40,625 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:40,680 - root - INFO: \n", + "2021-09-23 13:19:40,681 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:40,681 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,682 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:40,683 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:40,724 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-23 13:19:40,733 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:40,763 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "2021-09-23 13:19:40,766 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:40,766 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-23 13:19:40,770 - root - INFO: \n", + "2021-09-23 13:19:40,770 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:40,771 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,771 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:40,772 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:40,813 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-23 13:19:40,822 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:40,852 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "2021-09-23 13:19:40,854 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:40,855 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-23 13:19:40,860 - root - INFO: \n", + "2021-09-23 13:19:40,861 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:40,862 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,863 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:40,864 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:40,914 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-23 13:19:40,924 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", + "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n" ] }, @@ -2985,36 +3009,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:08,180 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "2021-09-20 23:16:08,183 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:08,183 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-20 23:16:08,188 - root - INFO: \n", - "2021-09-20 23:16:08,188 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:08,189 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,189 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:08,190 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:08,232 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-20 23:16:08,241 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:08,271 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "2021-09-20 23:16:08,273 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:08,274 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-20 23:16:08,277 - root - INFO: \n", - "2021-09-20 23:16:08,278 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:08,278 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,278 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:08,279 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:08,323 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-20 23:16:08,333 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:08,364 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "2021-09-20 23:16:08,366 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:08,367 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-20 23:16:08,370 - root - INFO: \n", - "2021-09-20 23:16:08,371 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:08,371 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,372 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:08,373 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:08,416 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-20 23:16:08,425 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:40,957 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "2021-09-23 13:19:40,959 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:40,959 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-23 13:19:40,964 - root - INFO: \n", + "2021-09-23 13:19:40,964 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:40,965 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:40,965 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:40,966 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:41,010 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-23 13:19:41,019 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:41,050 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", + "2021-09-23 13:19:41,052 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:41,053 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-23 13:19:41,069 - root - INFO: \n", + "2021-09-23 13:19:41,070 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:41,071 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,071 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:41,076 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:41,077 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:41,130 - root - INFO: \n", + "2021-09-23 13:19:41,130 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:41,131 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,131 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:41,132 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:41,174 - root - INFO: ... got raster of shape: (107, 212)\n", + "2021-09-23 13:19:41,183 - root - INFO: Masking to shape\n" ] }, { @@ -3022,50 +3042,43 @@ "output_type": "stream", "text": [ "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n" + "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:08,456 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "2021-09-20 23:16:08,458 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:08,459 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-20 23:16:08,477 - root - INFO: \n", - "2021-09-20 23:16:08,478 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:08,478 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,479 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:08,485 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:08,485 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:08,538 - root - INFO: \n", - "2021-09-20 23:16:08,539 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:08,539 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,540 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:08,541 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:08,581 - root - INFO: ... got raster of shape: (107, 212)\n", - "2021-09-20 23:16:08,590 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:08,621 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "2021-09-20 23:16:08,623 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:08,624 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", - "2021-09-20 23:16:08,627 - root - INFO: \n", - "2021-09-20 23:16:08,628 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:08,628 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,629 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:08,630 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:08,673 - root - INFO: ... got raster of shape: (107, 212)\n", - "2021-09-20 23:16:08,683 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:08,714 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "2021-09-20 23:16:08,716 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:08,717 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", - "2021-09-20 23:16:08,720 - root - INFO: \n", - "2021-09-20 23:16:08,721 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:08,721 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,721 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:08,722 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:08,764 - root - INFO: ... got raster of shape: (107, 212)\n", - "2021-09-20 23:16:08,773 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:41,212 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "2021-09-23 13:19:41,215 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:41,215 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", + "2021-09-23 13:19:41,219 - root - INFO: \n", + "2021-09-23 13:19:41,219 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:41,220 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,220 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:41,221 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:41,266 - root - INFO: ... got raster of shape: (107, 212)\n", + "2021-09-23 13:19:41,275 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:41,305 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "2021-09-23 13:19:41,307 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:41,308 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", + "2021-09-23 13:19:41,312 - root - INFO: \n", + "2021-09-23 13:19:41,312 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:41,312 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,313 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:41,314 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:41,355 - root - INFO: ... got raster of shape: (107, 212)\n", + "2021-09-23 13:19:41,363 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:41,393 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "2021-09-23 13:19:41,395 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:41,396 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", + "2021-09-23 13:19:41,399 - root - INFO: \n", + "2021-09-23 13:19:41,400 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:41,400 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,401 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:41,401 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:41,444 - root - INFO: ... got raster of shape: (107, 212)\n", + "2021-09-23 13:19:41,453 - root - INFO: Masking to shape\n" ] }, { @@ -3081,39 +3094,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:08,806 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "2021-09-20 23:16:08,808 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:08,809 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", - "2021-09-20 23:16:08,813 - root - INFO: \n", - "2021-09-20 23:16:08,814 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:08,814 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,814 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:08,815 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:08,857 - root - INFO: ... got raster of shape: (107, 212)\n", - "2021-09-20 23:16:08,867 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:08,899 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "2021-09-20 23:16:08,901 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:08,902 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", - "2021-09-20 23:16:08,919 - root - INFO: \n", - "2021-09-20 23:16:08,920 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:08,921 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,921 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:08,926 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:08,927 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:08,984 - root - INFO: \n", - "2021-09-20 23:16:08,985 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:08,985 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:08,986 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:08,986 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:09,032 - root - INFO: ... got raster of shape: (130, 305)\n", - "2021-09-20 23:16:09,041 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:41,484 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "2021-09-23 13:19:41,486 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:41,487 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", + "2021-09-23 13:19:41,501 - root - INFO: \n", + "2021-09-23 13:19:41,501 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:41,501 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,502 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:41,506 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:41,507 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:41,562 - root - INFO: \n", + "2021-09-23 13:19:41,563 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:41,563 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,564 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:41,565 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:41,607 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-09-23 13:19:41,615 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:41,647 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-09-23 13:19:41,648 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:41,649 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-09-23 13:19:41,653 - root - INFO: \n", + "2021-09-23 13:19:41,653 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:41,654 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,654 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:41,655 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:41,698 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-09-23 13:19:41,707 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:41,736 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-09-23 13:19:41,739 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:41,740 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-09-23 13:19:41,744 - root - INFO: \n", + "2021-09-23 13:19:41,744 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:41,745 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,745 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:41,746 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:41,789 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-09-23 13:19:41,798 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n" ] }, @@ -3121,36 +3145,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:09,072 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "2021-09-20 23:16:09,075 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:09,075 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", - "2021-09-20 23:16:09,079 - root - INFO: \n", - "2021-09-20 23:16:09,079 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:09,080 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,080 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:09,081 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:09,123 - root - INFO: ... got raster of shape: (130, 305)\n", - "2021-09-20 23:16:09,133 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:09,164 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "2021-09-20 23:16:09,166 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:09,168 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", - "2021-09-20 23:16:09,172 - root - INFO: \n", - "2021-09-20 23:16:09,172 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:09,173 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,173 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:09,174 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:09,216 - root - INFO: ... got raster of shape: (130, 305)\n", - "2021-09-20 23:16:09,226 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:09,256 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "2021-09-20 23:16:09,259 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:09,259 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", - "2021-09-20 23:16:09,264 - root - INFO: \n", - "2021-09-20 23:16:09,265 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:09,265 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,266 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:09,267 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:09,311 - root - INFO: ... got raster of shape: (130, 305)\n", - "2021-09-20 23:16:09,320 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:41,829 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-09-23 13:19:41,831 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:41,832 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-09-23 13:19:41,836 - root - INFO: \n", + "2021-09-23 13:19:41,837 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:41,837 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,838 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:41,838 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:41,879 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-09-23 13:19:41,888 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:41,918 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-09-23 13:19:41,920 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:41,922 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-09-23 13:19:41,942 - root - INFO: \n", + "2021-09-23 13:19:41,942 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:41,943 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:41,943 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:41,949 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:41,950 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:42,001 - root - INFO: \n", + "2021-09-23 13:19:42,002 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,002 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,003 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:42,005 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:42,049 - root - INFO: ... got raster of shape: (122, 176)\n", + "2021-09-23 13:19:42,058 - root - INFO: Masking to shape\n" ] }, { @@ -3158,50 +3178,43 @@ "output_type": "stream", "text": [ "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n" + "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:09,352 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "2021-09-20 23:16:09,354 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:09,355 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", - "2021-09-20 23:16:09,374 - root - INFO: \n", - "2021-09-20 23:16:09,375 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:09,375 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,375 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:09,381 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:09,382 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:09,436 - root - INFO: \n", - "2021-09-20 23:16:09,437 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:09,437 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,437 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:09,439 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:09,484 - root - INFO: ... got raster of shape: (122, 176)\n", - "2021-09-20 23:16:09,493 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:09,525 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "2021-09-20 23:16:09,527 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:09,527 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", - "2021-09-20 23:16:09,530 - root - INFO: \n", - "2021-09-20 23:16:09,531 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:09,531 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,531 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:09,533 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:09,577 - root - INFO: ... got raster of shape: (122, 176)\n", - "2021-09-20 23:16:09,586 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:09,618 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "2021-09-20 23:16:09,620 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:09,621 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", - "2021-09-20 23:16:09,624 - root - INFO: \n", - "2021-09-20 23:16:09,624 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:09,625 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,625 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:09,627 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:09,670 - root - INFO: ... got raster of shape: (122, 176)\n", - "2021-09-20 23:16:09,679 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:42,090 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "2021-09-23 13:19:42,092 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:42,093 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", + "2021-09-23 13:19:42,096 - root - INFO: \n", + "2021-09-23 13:19:42,096 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,097 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,097 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:42,099 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:42,141 - root - INFO: ... got raster of shape: (122, 176)\n", + "2021-09-23 13:19:42,150 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:42,181 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "2021-09-23 13:19:42,184 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:42,184 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", + "2021-09-23 13:19:42,186 - root - INFO: \n", + "2021-09-23 13:19:42,187 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,187 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,188 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:42,190 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:42,230 - root - INFO: ... got raster of shape: (122, 176)\n", + "2021-09-23 13:19:42,238 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:42,269 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "2021-09-23 13:19:42,272 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:42,272 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", + "2021-09-23 13:19:42,275 - root - INFO: \n", + "2021-09-23 13:19:42,276 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,276 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,276 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:42,278 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:42,321 - root - INFO: ... got raster of shape: (122, 176)\n", + "2021-09-23 13:19:42,329 - root - INFO: Masking to shape\n" ] }, { @@ -3217,39 +3230,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:09,714 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "2021-09-20 23:16:09,716 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:09,716 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", - "2021-09-20 23:16:09,720 - root - INFO: \n", - "2021-09-20 23:16:09,720 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:09,721 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,721 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:09,723 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:09,767 - root - INFO: ... got raster of shape: (122, 176)\n", - "2021-09-20 23:16:09,776 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:09,808 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "2021-09-20 23:16:09,810 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:09,811 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", - "2021-09-20 23:16:09,825 - root - INFO: \n", - "2021-09-20 23:16:09,826 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:09,827 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,827 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:09,833 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:09,834 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:09,887 - root - INFO: \n", - "2021-09-20 23:16:09,887 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:09,888 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,888 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:09,889 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:09,935 - root - INFO: ... got raster of shape: (75, 333)\n", - "2021-09-20 23:16:09,945 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:42,360 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "2021-09-23 13:19:42,363 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:42,364 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", + "2021-09-23 13:19:42,384 - root - INFO: \n", + "2021-09-23 13:19:42,384 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:42,385 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,385 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:42,391 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:42,392 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:42,446 - root - INFO: \n", + "2021-09-23 13:19:42,447 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,447 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,448 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:42,449 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:42,490 - root - INFO: ... got raster of shape: (75, 333)\n", + "2021-09-23 13:19:42,499 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:42,529 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "2021-09-23 13:19:42,532 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:42,532 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", + "2021-09-23 13:19:42,536 - root - INFO: \n", + "2021-09-23 13:19:42,537 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,537 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,537 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:42,538 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:42,579 - root - INFO: ... got raster of shape: (75, 333)\n", + "2021-09-23 13:19:42,588 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:42,617 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "2021-09-23 13:19:42,619 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:42,620 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", + "2021-09-23 13:19:42,623 - root - INFO: \n", + "2021-09-23 13:19:42,623 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,624 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,624 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:42,625 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:42,665 - root - INFO: ... got raster of shape: (75, 333)\n", + "2021-09-23 13:19:42,674 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", + "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n" ] }, @@ -3257,36 +3281,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:09,976 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "2021-09-20 23:16:09,978 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:09,979 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", - "2021-09-20 23:16:09,984 - root - INFO: \n", - "2021-09-20 23:16:09,984 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:09,984 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:09,985 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:09,985 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:10,029 - root - INFO: ... got raster of shape: (75, 333)\n", - "2021-09-20 23:16:10,039 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:10,070 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "2021-09-20 23:16:10,072 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:10,073 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", - "2021-09-20 23:16:10,076 - root - INFO: \n", - "2021-09-20 23:16:10,077 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:10,077 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,077 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:10,078 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:10,121 - root - INFO: ... got raster of shape: (75, 333)\n", - "2021-09-20 23:16:10,130 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:10,161 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "2021-09-20 23:16:10,163 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:10,164 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", - "2021-09-20 23:16:10,167 - root - INFO: \n", - "2021-09-20 23:16:10,168 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:10,168 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,168 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:10,169 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:10,213 - root - INFO: ... got raster of shape: (75, 333)\n", - "2021-09-20 23:16:10,222 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:42,706 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "2021-09-23 13:19:42,708 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:42,709 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", + "2021-09-23 13:19:42,713 - root - INFO: \n", + "2021-09-23 13:19:42,713 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,714 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,714 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:42,715 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:42,756 - root - INFO: ... got raster of shape: (75, 333)\n", + "2021-09-23 13:19:42,765 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:42,796 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", + "2021-09-23 13:19:42,798 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:42,799 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", + "2021-09-23 13:19:42,815 - root - INFO: \n", + "2021-09-23 13:19:42,815 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:42,815 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,816 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:42,820 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:42,821 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:42,872 - root - INFO: \n", + "2021-09-23 13:19:42,872 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,873 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,873 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:42,874 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:42,915 - root - INFO: ... got raster of shape: (59, 297)\n", + "2021-09-23 13:19:42,925 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:42,954 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n" ] }, { @@ -3294,49 +3315,42 @@ "output_type": "stream", "text": [ "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n" + "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:10,254 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "2021-09-20 23:16:10,257 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:10,257 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", - "2021-09-20 23:16:10,275 - root - INFO: \n", - "2021-09-20 23:16:10,276 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:10,276 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,277 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:10,282 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:10,283 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:10,337 - root - INFO: \n", - "2021-09-20 23:16:10,338 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:10,339 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,339 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:10,340 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:10,385 - root - INFO: ... got raster of shape: (59, 297)\n", - "2021-09-20 23:16:10,394 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:10,428 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", - "2021-09-20 23:16:10,430 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:10,430 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", - "2021-09-20 23:16:10,434 - root - INFO: \n", - "2021-09-20 23:16:10,435 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:10,435 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,435 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:10,436 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:10,480 - root - INFO: ... got raster of shape: (59, 297)\n", - "2021-09-20 23:16:10,489 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:10,522 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", - "2021-09-20 23:16:10,524 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:10,525 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", - "2021-09-20 23:16:10,528 - root - INFO: \n", - "2021-09-20 23:16:10,529 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:10,529 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,530 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:10,531 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:10,578 - root - INFO: ... got raster of shape: (59, 297)\n" + "2021-09-23 13:19:42,956 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:42,957 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", + "2021-09-23 13:19:42,962 - root - INFO: \n", + "2021-09-23 13:19:42,962 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:42,963 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:42,963 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:42,964 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,005 - root - INFO: ... got raster of shape: (59, 297)\n", + "2021-09-23 13:19:43,013 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:43,044 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "2021-09-23 13:19:43,046 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:43,047 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", + "2021-09-23 13:19:43,050 - root - INFO: \n", + "2021-09-23 13:19:43,051 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,051 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,051 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:43,052 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,093 - root - INFO: ... got raster of shape: (59, 297)\n", + "2021-09-23 13:19:43,101 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:43,132 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "2021-09-23 13:19:43,134 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:43,135 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", + "2021-09-23 13:19:43,138 - root - INFO: \n", + "2021-09-23 13:19:43,139 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,139 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,139 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:43,140 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,182 - root - INFO: ... got raster of shape: (59, 297)\n", + "2021-09-23 13:19:43,190 - root - INFO: Masking to shape\n" ] }, { @@ -3352,40 +3366,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:10,588 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:10,623 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", - "2021-09-20 23:16:10,625 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:10,626 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", - "2021-09-20 23:16:10,631 - root - INFO: \n", - "2021-09-20 23:16:10,632 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:10,632 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,633 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:10,634 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:10,680 - root - INFO: ... got raster of shape: (59, 297)\n", - "2021-09-20 23:16:10,690 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:10,721 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", - "2021-09-20 23:16:10,724 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:10,725 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", - "2021-09-20 23:16:10,740 - root - INFO: \n", - "2021-09-20 23:16:10,740 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:10,741 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,741 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:10,747 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:10,748 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:10,804 - root - INFO: \n", - "2021-09-20 23:16:10,804 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:10,805 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,805 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:10,806 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:10,848 - root - INFO: ... got raster of shape: (103, 231)\n", - "2021-09-20 23:16:10,857 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:43,220 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "2021-09-23 13:19:43,222 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:43,222 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", + "2021-09-23 13:19:43,240 - root - INFO: \n", + "2021-09-23 13:19:43,241 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:43,241 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,242 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:43,247 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:43,248 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:43,299 - root - INFO: \n", + "2021-09-23 13:19:43,300 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,301 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,301 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:43,302 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,343 - root - INFO: ... got raster of shape: (103, 231)\n", + "2021-09-23 13:19:43,352 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:43,383 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "2021-09-23 13:19:43,385 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:43,386 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", + "2021-09-23 13:19:43,390 - root - INFO: \n", + "2021-09-23 13:19:43,390 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,390 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,391 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:43,391 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,434 - root - INFO: ... got raster of shape: (103, 231)\n", + "2021-09-23 13:19:43,442 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:43,471 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "2021-09-23 13:19:43,474 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:43,474 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", + "2021-09-23 13:19:43,479 - root - INFO: \n", + "2021-09-23 13:19:43,479 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,479 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,480 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:43,481 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,522 - root - INFO: ... got raster of shape: (103, 231)\n", + "2021-09-23 13:19:43,531 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", + "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n" ] }, @@ -3393,36 +3417,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:10,889 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "2021-09-20 23:16:10,890 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:10,891 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", - "2021-09-20 23:16:10,896 - root - INFO: \n", - "2021-09-20 23:16:10,897 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:10,897 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,897 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:10,898 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:10,941 - root - INFO: ... got raster of shape: (103, 231)\n", - "2021-09-20 23:16:10,951 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:10,981 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "2021-09-20 23:16:10,984 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:10,984 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", - "2021-09-20 23:16:10,987 - root - INFO: \n", - "2021-09-20 23:16:10,988 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:10,988 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:10,989 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:10,989 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:11,032 - root - INFO: ... got raster of shape: (103, 231)\n", - "2021-09-20 23:16:11,041 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:11,074 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "2021-09-20 23:16:11,076 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:11,077 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", - "2021-09-20 23:16:11,082 - root - INFO: \n", - "2021-09-20 23:16:11,082 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:11,083 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,083 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:11,084 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:11,126 - root - INFO: ... got raster of shape: (103, 231)\n", - "2021-09-20 23:16:11,135 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:43,561 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "2021-09-23 13:19:43,564 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:43,564 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", + "2021-09-23 13:19:43,569 - root - INFO: \n", + "2021-09-23 13:19:43,570 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,570 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,571 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:43,572 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,613 - root - INFO: ... got raster of shape: (103, 231)\n", + "2021-09-23 13:19:43,621 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:43,653 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", + "2021-09-23 13:19:43,655 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:43,655 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", + "2021-09-23 13:19:43,671 - root - INFO: \n", + "2021-09-23 13:19:43,671 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:43,672 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,672 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:43,677 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:43,678 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:43,728 - root - INFO: \n", + "2021-09-23 13:19:43,729 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,729 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,730 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:43,731 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,772 - root - INFO: ... got raster of shape: (50, 188)\n", + "2021-09-23 13:19:43,780 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:43,811 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n" ] }, { @@ -3430,50 +3451,42 @@ "output_type": "stream", "text": [ "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n" + "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:11,166 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "2021-09-20 23:16:11,168 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:11,169 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", - "2021-09-20 23:16:11,186 - root - INFO: \n", - "2021-09-20 23:16:11,186 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:11,187 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,187 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:11,193 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:11,193 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:11,249 - root - INFO: \n", - "2021-09-20 23:16:11,249 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:11,250 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,250 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:11,251 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:11,292 - root - INFO: ... got raster of shape: (50, 188)\n", - "2021-09-20 23:16:11,302 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:11,334 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "2021-09-20 23:16:11,336 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:11,337 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", - "2021-09-20 23:16:11,340 - root - INFO: \n", - "2021-09-20 23:16:11,340 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:11,341 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,341 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:11,342 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:11,384 - root - INFO: ... got raster of shape: (50, 188)\n", - "2021-09-20 23:16:11,392 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:11,424 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "2021-09-20 23:16:11,425 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:11,426 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", - "2021-09-20 23:16:11,429 - root - INFO: \n", - "2021-09-20 23:16:11,430 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:11,430 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,430 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:11,431 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:11,474 - root - INFO: ... got raster of shape: (50, 188)\n", - "2021-09-20 23:16:11,483 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:43,814 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:43,814 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", + "2021-09-23 13:19:43,816 - root - INFO: \n", + "2021-09-23 13:19:43,817 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,817 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,817 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:43,818 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,859 - root - INFO: ... got raster of shape: (50, 188)\n", + "2021-09-23 13:19:43,868 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:43,899 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "2021-09-23 13:19:43,901 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:43,902 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", + "2021-09-23 13:19:43,905 - root - INFO: \n", + "2021-09-23 13:19:43,906 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,906 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,906 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:43,907 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:43,948 - root - INFO: ... got raster of shape: (50, 188)\n", + "2021-09-23 13:19:43,957 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:43,986 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "2021-09-23 13:19:43,988 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:43,989 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", + "2021-09-23 13:19:43,991 - root - INFO: \n", + "2021-09-23 13:19:43,992 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:43,992 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:43,992 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:43,993 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:44,034 - root - INFO: ... got raster of shape: (50, 188)\n", + "2021-09-23 13:19:44,042 - root - INFO: Masking to shape\n" ] }, { @@ -3489,39 +3502,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:11,515 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "2021-09-20 23:16:11,517 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:11,518 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", - "2021-09-20 23:16:11,521 - root - INFO: \n", - "2021-09-20 23:16:11,521 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:11,521 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,522 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:11,522 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:11,564 - root - INFO: ... got raster of shape: (50, 188)\n", - "2021-09-20 23:16:11,573 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:11,604 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "2021-09-20 23:16:11,606 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:11,607 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", - "2021-09-20 23:16:11,622 - root - INFO: \n", - "2021-09-20 23:16:11,623 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:11,623 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,623 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:11,628 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:11,628 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:11,685 - root - INFO: \n", - "2021-09-20 23:16:11,686 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:11,687 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,687 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:11,689 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:11,732 - root - INFO: ... got raster of shape: (155, 254)\n", - "2021-09-20 23:16:11,741 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:44,073 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "2021-09-23 13:19:44,075 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:44,076 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", + "2021-09-23 13:19:44,091 - root - INFO: \n", + "2021-09-23 13:19:44,091 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:44,092 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,092 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:44,098 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:44,099 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:44,194 - root - INFO: \n", + "2021-09-23 13:19:44,195 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:44,195 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,196 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:44,197 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:44,240 - root - INFO: ... got raster of shape: (155, 254)\n", + "2021-09-23 13:19:44,249 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:44,279 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "2021-09-23 13:19:44,281 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:44,283 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", + "2021-09-23 13:19:44,287 - root - INFO: \n", + "2021-09-23 13:19:44,287 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:44,288 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,288 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:44,290 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:44,334 - root - INFO: ... got raster of shape: (155, 254)\n", + "2021-09-23 13:19:44,343 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:44,373 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "2021-09-23 13:19:44,375 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:44,376 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", + "2021-09-23 13:19:44,379 - root - INFO: \n", + "2021-09-23 13:19:44,380 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:44,380 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,381 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:44,382 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:44,425 - root - INFO: ... got raster of shape: (155, 254)\n", + "2021-09-23 13:19:44,434 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", + "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n" ] }, @@ -3529,35 +3553,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:11,773 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "2021-09-20 23:16:11,775 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:11,776 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", - "2021-09-20 23:16:11,780 - root - INFO: \n", - "2021-09-20 23:16:11,780 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:11,780 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,781 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:11,782 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:11,826 - root - INFO: ... got raster of shape: (155, 254)\n", - "2021-09-20 23:16:11,836 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:11,867 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "2021-09-20 23:16:11,870 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:11,870 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", - "2021-09-20 23:16:11,874 - root - INFO: \n", - "2021-09-20 23:16:11,874 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:11,875 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,875 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:11,877 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:11,921 - root - INFO: ... got raster of shape: (155, 254)\n", - "2021-09-20 23:16:11,930 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:11,963 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "2021-09-20 23:16:11,966 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:11,966 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", - "2021-09-20 23:16:11,972 - root - INFO: \n", - "2021-09-20 23:16:11,973 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:11,973 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:11,974 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:11,975 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:12,019 - root - INFO: ... got raster of shape: (155, 254)\n" + "2021-09-23 13:19:44,464 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "2021-09-23 13:19:44,467 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:44,467 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", + "2021-09-23 13:19:44,473 - root - INFO: \n", + "2021-09-23 13:19:44,474 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:44,474 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,474 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:44,476 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:44,519 - root - INFO: ... got raster of shape: (155, 254)\n", + "2021-09-23 13:19:44,528 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:44,559 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", + "2021-09-23 13:19:44,561 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:44,562 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", + "2021-09-23 13:19:44,586 - root - INFO: \n", + "2021-09-23 13:19:44,587 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:44,587 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,588 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:44,593 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:44,594 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:44,648 - root - INFO: \n", + "2021-09-23 13:19:44,648 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:44,649 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,649 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:44,650 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:44,690 - root - INFO: ... got raster of shape: (39, 185)\n", + "2021-09-23 13:19:44,699 - root - INFO: Masking to shape\n" ] }, { @@ -3565,51 +3586,43 @@ "output_type": "stream", "text": [ "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n" + "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:12,027 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:12,060 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "2021-09-20 23:16:12,062 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:12,062 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", - "2021-09-20 23:16:12,080 - root - INFO: \n", - "2021-09-20 23:16:12,081 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:12,082 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,082 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:12,134 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:12,135 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:12,190 - root - INFO: \n", - "2021-09-20 23:16:12,191 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:12,191 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,192 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:12,193 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:12,236 - root - INFO: ... got raster of shape: (39, 185)\n", - "2021-09-20 23:16:12,246 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:12,282 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "2021-09-20 23:16:12,285 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:12,286 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", - "2021-09-20 23:16:12,288 - root - INFO: \n", - "2021-09-20 23:16:12,288 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:12,289 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,289 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:12,290 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:12,329 - root - INFO: ... got raster of shape: (39, 185)\n", - "2021-09-20 23:16:12,338 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:12,367 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "2021-09-20 23:16:12,369 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:12,370 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", - "2021-09-20 23:16:12,372 - root - INFO: \n", - "2021-09-20 23:16:12,372 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:12,373 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,373 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:12,374 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:12,416 - root - INFO: ... got raster of shape: (39, 185)\n", - "2021-09-20 23:16:12,425 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:44,730 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "2021-09-23 13:19:44,732 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:44,733 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", + "2021-09-23 13:19:44,735 - root - INFO: \n", + "2021-09-23 13:19:44,736 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:44,736 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,737 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:44,737 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:44,779 - root - INFO: ... got raster of shape: (39, 185)\n", + "2021-09-23 13:19:44,787 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:44,820 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "2021-09-23 13:19:44,821 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:44,822 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", + "2021-09-23 13:19:44,824 - root - INFO: \n", + "2021-09-23 13:19:44,825 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:44,825 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,825 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:44,826 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:44,868 - root - INFO: ... got raster of shape: (39, 185)\n", + "2021-09-23 13:19:44,877 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:44,907 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "2021-09-23 13:19:44,909 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:44,909 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", + "2021-09-23 13:19:44,912 - root - INFO: \n", + "2021-09-23 13:19:44,912 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:44,913 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:44,913 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:44,914 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:44,956 - root - INFO: ... got raster of shape: (39, 185)\n", + "2021-09-23 13:19:44,966 - root - INFO: Masking to shape\n" ] }, { @@ -3625,39 +3638,50 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:12,458 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "2021-09-20 23:16:12,460 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:12,461 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", - "2021-09-20 23:16:12,463 - root - INFO: \n", - "2021-09-20 23:16:12,463 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:12,463 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,464 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:12,464 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:12,507 - root - INFO: ... got raster of shape: (39, 185)\n", - "2021-09-20 23:16:12,517 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:12,548 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "2021-09-20 23:16:12,550 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:12,551 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", - "2021-09-20 23:16:12,565 - root - INFO: \n", - "2021-09-20 23:16:12,566 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:12,566 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,566 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:12,572 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:12,573 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:12,637 - root - INFO: \n", - "2021-09-20 23:16:12,638 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:12,639 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,639 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:12,642 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:12,685 - root - INFO: ... got raster of shape: (121, 413)\n", - "2021-09-20 23:16:12,694 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:44,995 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "2021-09-23 13:19:44,997 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:44,998 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", + "2021-09-23 13:19:45,012 - root - INFO: \n", + "2021-09-23 13:19:45,012 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:45,013 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,013 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:45,018 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:45,019 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:45,072 - root - INFO: \n", + "2021-09-23 13:19:45,072 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:45,073 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,073 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:45,077 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:45,121 - root - INFO: ... got raster of shape: (121, 413)\n", + "2021-09-23 13:19:45,130 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:45,162 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "2021-09-23 13:19:45,165 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:45,166 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", + "2021-09-23 13:19:45,169 - root - INFO: \n", + "2021-09-23 13:19:45,169 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:45,170 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,170 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:45,173 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:45,216 - root - INFO: ... got raster of shape: (121, 413)\n", + "2021-09-23 13:19:45,224 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:45,254 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "2021-09-23 13:19:45,257 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:45,257 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", + "2021-09-23 13:19:45,260 - root - INFO: \n", + "2021-09-23 13:19:45,261 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:45,261 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,262 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:45,265 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:45,308 - root - INFO: ... got raster of shape: (121, 413)\n", + "2021-09-23 13:19:45,317 - root - INFO: Masking to shape\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", + "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n" ] }, @@ -3665,35 +3689,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:12,727 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "2021-09-20 23:16:12,730 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:12,730 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", - "2021-09-20 23:16:12,734 - root - INFO: \n", - "2021-09-20 23:16:12,734 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:12,735 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,735 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:12,739 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:12,785 - root - INFO: ... got raster of shape: (121, 413)\n", - "2021-09-20 23:16:12,794 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:12,828 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "2021-09-20 23:16:12,830 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:12,831 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", - "2021-09-20 23:16:12,834 - root - INFO: \n", - "2021-09-20 23:16:12,835 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:12,836 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,836 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:12,840 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:12,884 - root - INFO: ... got raster of shape: (121, 413)\n", - "2021-09-20 23:16:12,893 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:12,925 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "2021-09-20 23:16:12,928 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:12,929 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", - "2021-09-20 23:16:12,934 - root - INFO: \n", - "2021-09-20 23:16:12,935 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:12,935 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:12,936 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:12,939 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:12,982 - root - INFO: ... got raster of shape: (121, 413)\n" + "2021-09-23 13:19:45,349 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "2021-09-23 13:19:45,351 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:45,352 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", + "2021-09-23 13:19:45,357 - root - INFO: \n", + "2021-09-23 13:19:45,357 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:45,358 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,358 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:45,362 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:45,405 - root - INFO: ... got raster of shape: (121, 413)\n", + "2021-09-23 13:19:45,414 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:45,445 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", + "2021-09-23 13:19:45,448 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:45,449 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", + "2021-09-23 13:19:45,485 - root - INFO: \n", + "2021-09-23 13:19:45,486 - root - INFO: Loading shapes\n", + "2021-09-23 13:19:45,486 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,487 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-09-23 13:19:45,492 - root - INFO: ... found 44 shapes\n", + "2021-09-23 13:19:45,493 - root - INFO: Converting to shapely\n", + "2021-09-23 13:19:45,543 - root - INFO: \n", + "2021-09-23 13:19:45,544 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:45,545 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,545 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:45,546 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:45,587 - root - INFO: ... got raster of shape: (73, 306)\n", + "2021-09-23 13:19:45,596 - root - INFO: Masking to shape\n" ] }, { @@ -3701,51 +3722,43 @@ "output_type": "stream", "text": [ "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n" + "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:12,991 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:13,025 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "2021-09-20 23:16:13,027 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:13,028 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", - "2021-09-20 23:16:13,044 - root - INFO: \n", - "2021-09-20 23:16:13,045 - root - INFO: Loading shapes\n", - "2021-09-20 23:16:13,046 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:13,046 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-20 23:16:13,052 - root - INFO: ... found 44 shapes\n", - "2021-09-20 23:16:13,052 - root - INFO: Converting to shapely\n", - "2021-09-20 23:16:13,107 - root - INFO: \n", - "2021-09-20 23:16:13,108 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:13,109 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:13,110 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-20 23:16:13,110 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:13,154 - root - INFO: ... got raster of shape: (73, 306)\n", - "2021-09-20 23:16:13,163 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:13,193 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "2021-09-20 23:16:13,194 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-20 23:16:13,195 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", - "2021-09-20 23:16:13,199 - root - INFO: \n", - "2021-09-20 23:16:13,200 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:13,200 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:13,200 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-20 23:16:13,201 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:13,244 - root - INFO: ... got raster of shape: (73, 306)\n", - "2021-09-20 23:16:13,254 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:13,286 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "2021-09-20 23:16:13,288 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-20 23:16:13,289 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", - "2021-09-20 23:16:13,293 - root - INFO: \n", - "2021-09-20 23:16:13,293 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:13,294 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:13,294 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-20 23:16:13,295 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:13,338 - root - INFO: ... got raster of shape: (73, 306)\n", - "2021-09-20 23:16:13,348 - root - INFO: Masking to shape\n" + "2021-09-23 13:19:45,625 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "2021-09-23 13:19:45,627 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-09-23 13:19:45,628 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", + "2021-09-23 13:19:45,632 - root - INFO: \n", + "2021-09-23 13:19:45,632 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:45,632 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,633 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-09-23 13:19:45,633 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:45,676 - root - INFO: ... got raster of shape: (73, 306)\n", + "2021-09-23 13:19:45,685 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:45,715 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "2021-09-23 13:19:45,717 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-09-23 13:19:45,717 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", + "2021-09-23 13:19:45,721 - root - INFO: \n", + "2021-09-23 13:19:45,721 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:45,722 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,722 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-09-23 13:19:45,723 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:45,764 - root - INFO: ... got raster of shape: (73, 306)\n", + "2021-09-23 13:19:45,772 - root - INFO: Masking to shape\n", + "2021-09-23 13:19:45,802 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "2021-09-23 13:19:45,804 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-09-23 13:19:45,805 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", + "2021-09-23 13:19:45,808 - root - INFO: \n", + "2021-09-23 13:19:45,809 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:45,809 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:45,810 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:45,810 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:45,851 - root - INFO: ... got raster of shape: (73, 306)\n", + "2021-09-23 13:19:45,860 - root - INFO: Masking to shape\n" ] }, { @@ -3761,45 +3774,28 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-20 23:16:13,380 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "2021-09-20 23:16:13,382 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-20 23:16:13,383 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", - "2021-09-20 23:16:13,387 - root - INFO: \n", - "2021-09-20 23:16:13,388 - root - INFO: Loading Raster\n", - "2021-09-20 23:16:13,389 - root - INFO: ------------------------------\n", - "2021-09-20 23:16:13,389 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-20 23:16:13,390 - root - INFO: Collecting raster\n", - "2021-09-20 23:16:13,432 - root - INFO: ... got raster of shape: (73, 306)\n", - "2021-09-20 23:16:13,441 - root - INFO: Masking to shape\n", - "2021-09-20 23:16:13,473 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "2021-09-20 23:16:13,475 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-20 23:16:13,476 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n" + "2021-09-23 13:19:45,889 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", + "2021-09-23 13:19:45,892 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-09-23 13:19:45,893 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n" ] } ], "source": [ - "hillslope_pars = []\n", - "mesh_pars = []\n", - "subcatch_all_ids = 1+np.arange(len(subcatchments))\n", - "for subcatch_id in subcatch_all_ids:\n", - " hillslope_pars.append(hillslopes.parameterizeSubcatchment(\n", - " filenames, huc, subcatch_id,\n", - " target_crs=workflow.crs.default_alaska_crs(),\n", - " hillslope_keep_fraction=hillslope_keep_fraction,\n", - " hillslope_bin_dx=hillslope_bin_dx))\n", + "# hillslope_pars = []\n", + "# mesh_pars = []\n", + "# subcatch_all_ids = 1+np.arange(len(subcatchments))\n", + "# for subcatch_id in subcatch_all_ids:\n", + "# hillslope_pars.append(hillslopes.parameterizeSubcatchment(\n", + "# filenames, huc, subcatch_id,\n", + "# target_crs=target_crs,\n", + "# hillslope_keep_fraction=hillslope_keep_fraction,\n", + "# hillslope_bin_dx=hillslope_bin_dx))\n", " \n", - "for i in range(len(hillslope_pars)): \n", - " mesh_pars.append(mesh.parameterizeMesh(hillslope_pars[i], mesh_dx,\n", - " riparian_slope_min=riparian_slope_min,\n", - " hillslope_slope_min=hillslope_slope_min,\n", - " min_area_ratio=min_area_ratio))" + "# for i in range(len(hillslope_pars)): \n", + "# mesh_pars.append(meshing.parameterizeMesh(hillslope_pars[i], mesh_dx,\n", + "# riparian_slope_min=riparian_slope_min,\n", + "# hillslope_slope_min=hillslope_slope_min,\n", + "# min_area_ratio=min_area_ratio))" ] }, { @@ -3812,265 +3808,51 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "id": "789b2ed3", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:50,618 - root - INFO: BOUNDS: (-149.32346060296518, 68.18897673838367, -149.23401615851776, 68.20814340505098)\n", - "2021-09-20 23:18:50,723 - root - INFO: BOUNDS: (-149.32346060296518, 68.18897673838367, -149.23401615851776, 68.20814340505098)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:50,876 - root - INFO: BOUNDS: (-149.32346060296518, 68.1800878494945, -149.23151615851768, 68.19786562727286)\n", - "2021-09-20 23:18:50,982 - root - INFO: BOUNDS: (-149.32346060296518, 68.1800878494945, -149.23151615851768, 68.19786562727286)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:51,146 - root - INFO: BOUNDS: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "2021-09-20 23:18:51,256 - root - INFO: BOUNDS: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:51,408 - root - INFO: BOUNDS: (-149.27262726963016, 68.19925451616179, -149.2079050474058, 68.21564340505122)\n", - "2021-09-20 23:18:51,516 - root - INFO: BOUNDS: (-149.27262726963016, 68.19925451616179, -149.2079050474058, 68.21564340505122)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:51,672 - root - INFO: BOUNDS: (-149.2759606029636, 68.20731007171761, -149.17123838073792, 68.23453229394075)\n", - "2021-09-20 23:18:51,778 - root - INFO: BOUNDS: (-149.2759606029636, 68.20731007171761, -149.17123838073792, 68.23453229394075)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:51,930 - root - INFO: BOUNDS: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "2021-09-20 23:18:52,035 - root - INFO: BOUNDS: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:52,193 - root - INFO: BOUNDS: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "2021-09-20 23:18:52,304 - root - INFO: BOUNDS: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:52,465 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n", - "2021-09-20 23:18:52,571 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:52,721 - root - INFO: BOUNDS: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "2021-09-20 23:18:52,826 - root - INFO: BOUNDS: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:53,519 - root - INFO: BOUNDS: (-149.12262726962518, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "2021-09-20 23:18:53,628 - root - INFO: BOUNDS: (-149.12262726962518, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:53,792 - root - INFO: BOUNDS: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "2021-09-20 23:18:53,902 - root - INFO: BOUNDS: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:54,057 - root - INFO: BOUNDS: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25119896060797)\n", - "2021-09-20 23:18:54,170 - root - INFO: BOUNDS: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25119896060797)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:54,325 - root - INFO: BOUNDS: (-149.0859606029573, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "2021-09-20 23:18:54,437 - root - INFO: BOUNDS: (-149.0859606029573, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:54,595 - root - INFO: BOUNDS: (-149.0901272696241, 68.23231007171844, -149.0304050473999, 68.25119896060797)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-20 23:18:54,711 - root - INFO: BOUNDS: (-149.0901272696241, 68.23231007171844, -149.0304050473999, 68.25119896060797)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:54,871 - root - INFO: BOUNDS: (-149.0304050473999, 68.24425451616328, -148.97596060295365, 68.26814340505297)\n", - "2021-09-20 23:18:54,979 - root - INFO: BOUNDS: (-149.0304050473999, 68.24425451616328, -148.97596060295365, 68.26814340505297)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:55,146 - root - INFO: BOUNDS: (-149.03096060295547, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "2021-09-20 23:18:55,250 - root - INFO: BOUNDS: (-149.03096060295547, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:55,395 - root - INFO: BOUNDS: (-149.0134606029549, 68.25592118283033, -148.94040504739692, 68.28064340505338)\n", - "2021-09-20 23:18:55,502 - root - INFO: BOUNDS: (-149.0134606029549, 68.25592118283033, -148.94040504739692, 68.28064340505338)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:55,651 - root - INFO: BOUNDS: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "2021-09-20 23:18:55,870 - root - INFO: BOUNDS: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:56,033 - root - INFO: BOUNDS: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "2021-09-20 23:18:56,141 - root - INFO: BOUNDS: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:56,303 - root - INFO: BOUNDS: (-148.94012726961913, 68.26425451616394, -148.88790504739518, 68.29147673838708)\n", - "2021-09-20 23:18:56,402 - root - INFO: BOUNDS: (-148.94012726961913, 68.26425451616394, -148.88790504739518, 68.29147673838708)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:56,555 - root - INFO: BOUNDS: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29619896060946)\n", - "2021-09-20 23:18:56,666 - root - INFO: BOUNDS: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29619896060946)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:56,808 - root - INFO: BOUNDS: (-148.9109606029515, 68.29175451616486, -148.88707171406182, 68.30147673838741)\n", - "2021-09-20 23:18:56,914 - root - INFO: BOUNDS: (-148.9109606029515, 68.29175451616486, -148.88707171406182, 68.30147673838741)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:57,080 - root - INFO: BOUNDS: (-148.88596060295066, 68.27925451616444, -148.80234949183676, 68.31314340505446)\n", - "2021-09-20 23:18:57,184 - root - INFO: BOUNDS: (-148.88596060295066, 68.27925451616444, -148.80234949183676, 68.31314340505446)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:57,329 - root - INFO: BOUNDS: (-148.89096060295083, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "2021-09-20 23:18:57,429 - root - INFO: BOUNDS: (-148.89096060295083, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:57,590 - root - INFO: BOUNDS: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "2021-09-20 23:18:57,700 - root - INFO: BOUNDS: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:57,862 - root - INFO: BOUNDS: (-149.2034606029612, 68.22814340505164, -149.11734949184722, 68.25453229394141)\n", - "2021-09-20 23:18:57,974 - root - INFO: BOUNDS: (-149.2034606029612, 68.22814340505164, -149.11734949184722, 68.25453229394141)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:58,297 - root - INFO: BOUNDS: (-149.0434606029559, 68.30758784949873, -148.94151615850805, 68.32619896061045)\n", - "2021-09-20 23:18:58,409 - root - INFO: BOUNDS: (-149.0434606029559, 68.30758784949873, -148.94151615850805, 68.32619896061045)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:58,568 - root - INFO: BOUNDS: (-149.0434606029559, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-20 23:18:58,671 - root - INFO: BOUNDS: (-149.0434606029559, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:58,831 - root - INFO: BOUNDS: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "2021-09-20 23:18:58,940 - root - INFO: BOUNDS: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:59,102 - root - INFO: BOUNDS: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30953229394324)\n", - "2021-09-20 23:18:59,210 - root - INFO: BOUNDS: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30953229394324)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:59,369 - root - INFO: BOUNDS: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "2021-09-20 23:18:59,479 - root - INFO: BOUNDS: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:59,629 - root - INFO: BOUNDS: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "2021-09-20 23:18:59,740 - root - INFO: BOUNDS: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:18:59,896 - root - INFO: BOUNDS: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "2021-09-20 23:19:00,004 - root - INFO: BOUNDS: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:00,148 - root - INFO: BOUNDS: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "2021-09-20 23:19:00,242 - root - INFO: BOUNDS: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:00,403 - root - INFO: BOUNDS: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20453229393975)\n", - "2021-09-20 23:19:00,511 - root - INFO: BOUNDS: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20453229393975)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:00,670 - root - INFO: BOUNDS: (-149.2117939362948, 68.17675451616104, -149.1629050474043, 68.21064340505106)\n", - "2021-09-20 23:19:00,780 - root - INFO: BOUNDS: (-149.2117939362948, 68.17675451616104, -149.1629050474043, 68.21064340505106)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:00,943 - root - INFO: BOUNDS: (-149.21096060296145, 68.25869896060821, -149.11846060295838, 68.27953229394224)\n", - "2021-09-20 23:19:01,052 - root - INFO: BOUNDS: (-149.21096060296145, 68.25869896060821, -149.11846060295838, 68.27953229394224)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:01,218 - root - INFO: BOUNDS: (-149.2101272696281, 68.25314340505247, -149.12762726962535, 68.26953229394191)\n", - "2021-09-20 23:19:01,545 - root - INFO: BOUNDS: (-149.2101272696281, 68.25314340505247, -149.12762726962535, 68.26953229394191)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:01,693 - root - INFO: BOUNDS: (-149.12762726962535, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "2021-09-20 23:19:01,795 - root - INFO: BOUNDS: (-149.12762726962535, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:01,946 - root - INFO: BOUNDS: (-149.13179393629215, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "2021-09-20 23:19:02,049 - root - INFO: BOUNDS: (-149.13179393629215, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:02,204 - root - INFO: BOUNDS: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "2021-09-20 23:19:02,307 - root - INFO: BOUNDS: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:02,457 - root - INFO: BOUNDS: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-20 23:19:02,558 - root - INFO: BOUNDS: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:02,726 - root - INFO: BOUNDS: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "2021-09-20 23:19:02,842 - root - INFO: BOUNDS: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-20 23:19:03,008 - root - INFO: BOUNDS: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24036562727427)\n", - "2021-09-20 23:19:03,125 - root - INFO: BOUNDS: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24036562727427)\n", - ":38: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", - " plt.tight_layout()\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "fig = plt.figure(figsize=(20,30),dpi=80)\n", - "nx, ny = 6,8\n", - "sep=0.02\n", + "# fig = plt.figure(figsize=(20,30),dpi=80)\n", + "# nx, ny = 6,8\n", + "# sep=0.02\n", "\n", - "axs = []\n", - "for i in range(nx):\n", - " for j in range(ny):\n", - " sub_id = i*ny+j+1\n", - " if sub_id > len(subcatchments):\n", - " continue\n", + "# axs = []\n", + "# for i in range(nx):\n", + "# for j in range(ny):\n", + "# sub_id = i*ny+j+1\n", + "# if sub_id > len(subcatchments):\n", + "# continue\n", " \n", - " gs = gridspec.GridSpec(4,1,bottom=j/ny+sep, left=i/nx+sep, top=(j+1)/ny - sep, right=(i+1)/nx - sep)\n", - " ax1 = fig.add_subplot(gs[2,0])\n", - " ax2 = fig.add_subplot(gs[3,0])\n", - " axs = [ax1,ax2]\n", - " h_par = hillslope_pars[sub_id-1]\n", - " m_par = mesh_pars[sub_id-1] \n", - " plot.plot(h_par, m_par, fig=fig, axs=axs)\n", + "# gs = gridspec.GridSpec(4,1,bottom=j/ny+sep, left=i/nx+sep, top=(j+1)/ny - sep, right=(i+1)/nx - sep)\n", + "# ax1 = fig.add_subplot(gs[2,0])\n", + "# ax2 = fig.add_subplot(gs[3,0])\n", + "# axs = [ax1,ax2]\n", + "# h_par = hillslope_pars[sub_id-1]\n", + "# m_par = mesh_pars[sub_id-1] \n", + "# plot.plot(h_par, m_par, fig=fig, axs=axs)\n", " \n", - " ax0 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[0,0])\n", - " ax0.set_title(f'subcatchment {sub_id}')\n", - " workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", - " hillslope_pars[sub_id-1]['bins'], ax=ax0, cmap='prism')\n", - " subcatch = hillslope_pars[sub_id-1]['subcatchment']\n", - " workflow.plot.shply(subcatch, native_crs, ax=ax0, color='k')\n", + "# ax0 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[0,0])\n", + "# ax0.set_title(f'subcatchment {sub_id}')\n", + "# workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", + "# hillslope_pars[sub_id-1]['bins'], ax=ax0, cmap='prism')\n", + "# subcatch = hillslope_pars[sub_id-1]['subcatchment']\n", + "# subcatch_crs = hillslope_pars[sub_id-1]['subcatchment_target_crs'] \n", + "# workflow.plot.shply(subcatch, subcatch_crs, ax=ax0, color='k')\n", " \n", - " ax1 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[1,0])\n", - " vmin, vmax = min(hillslope_pars[sub_id-1]['land_cover']), max(hillslope_pars[sub_id-1]['land_cover'])\n", - " cmap = plt.get_cmap(('viridis'),vmax-vmin+1)\n", - " lc = workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", - " hillslope_pars[sub_id-1]['land_cover_raster'], \n", - " ax=ax1, vmin=vmin-0.5, vmax=vmax+0.5, cmap=cmap)\n", - " workflow.plot.shply(subcatch, native_crs, ax=ax1, color='k')\n", - " position=fig.add_axes([i/nx+sep+0.13, j/ny+sep+0.045, 0.006,0.04])\n", + "# ax1 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[1,0])\n", + "# vmin, vmax = min(hillslope_pars[sub_id-1]['land_cover']), max(hillslope_pars[sub_id-1]['land_cover'])\n", + "# cmap = plt.get_cmap(('viridis'),vmax-vmin+1)\n", + "# lc = workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", + "# hillslope_pars[sub_id-1]['land_cover_raster'], \n", + "# ax=ax1, vmin=vmin-0.5, vmax=vmax+0.5, cmap=cmap)\n", + "# workflow.plot.shply(subcatch, subcatch_crs, ax=ax1, color='k')\n", + "# position=fig.add_axes([i/nx+sep+0.13, j/ny+sep+0.045, 0.006,0.04])\n", "\n", - " fig.colorbar(lc,ticks=np.arange(vmin,vmax+1),cax=position)\n", + "# fig.colorbar(lc,ticks=np.arange(vmin,vmax+1),cax=position)\n", "\n", - "plt.tight_layout()\n", - "plt.show()" + "# plt.tight_layout()\n", + "# plt.show()" ] }, { @@ -4081,6 +3863,19 @@ "# Generate mesh" ] }, + { + "cell_type": "code", + "execution_count": 18, + "id": "4916162d", + "metadata": {}, + "outputs": [], + "source": [ + "layer_info = meshing.layeringStructure(organic_cells=30, organic_cell_dz=0.02, \n", + " increase2depth=9.4, increase_cells=20, largest_dz=2.0,\n", + " bottom_depth=46)\n", + "layer_types, layer_data, layer_ncells = layer_info" + ] + }, { "cell_type": "markdown", "id": "366f43ba", @@ -4091,23 +3886,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 19, "id": "d75f2a06", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening exodus file: ../huc/190604020404/mesh/column.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/column.exo\n" - ] - } - ], + "outputs": [], "source": [ "if os.path.isfile(os.path.join(mesh_dir,'column.exo')):\n", " os.remove(os.path.join(mesh_dir,'column.exo'))\n", - "colum_mesh = meshing.createColumnMesh(meshing.layeringStructure(), \n", + "colum_mesh = meshing.createColumnMesh(layer_info, \n", " os.path.join(mesh_dir,'column.exo'))" ] }, @@ -4116,182 +3902,3686 @@ "id": "973ad6c6", "metadata": {}, "source": [ - "## For a given subcatchment" + "## 2D for a given subcatchment" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 20, "id": "4396c703", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope8.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope8.exo\n" - ] - } - ], + "outputs": [], "source": [ "m2 = meshing.createHillslopeMesh2D(mesh_demo_pars)\n", - "m3 = meshing.createHillslopeMesh3D(m2, mesh_demo_pars, meshing.layeringStructure(),\n", + "m3 = meshing.createHillslopeMesh3D(m2, mesh_demo_pars, layer_info,\n", " os.path.join(mesh_dir,f'sag_hillslope{subcatch_demo_id}.exo'))" ] }, { "cell_type": "markdown", - "id": "d121163b", + "id": "889672f6", "metadata": {}, "source": [ - "## For all subcatchments" + "## 3D for a given subcatchment" ] }, { "cell_type": "code", - "execution_count": 25, - "id": "457de366", + "execution_count": 21, + "id": "4bf13c05", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:19:46,324 - root - INFO: \n", + "2021-09-23 13:19:46,324 - root - INFO: Meshing\n", + "2021-09-23 13:19:46,325 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:46,333 - root - INFO: Triangulating...\n", + "2021-09-23 13:19:46,333 - root - INFO: 8 points and 8 facets\n", + "2021-09-23 13:19:46,334 - root - INFO: checking graph consistency\n", + "2021-09-23 13:19:46,334 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:19:46,335 - root - INFO: building graph data structures\n", + "2021-09-23 13:19:46,336 - root - INFO: triangle.build...\n", + "2021-09-23 13:19:46,446 - root - INFO: ...built: 4932 mesh points and 9596 triangles\n", + "2021-09-23 13:19:46,447 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:19:46,676 - root - INFO: min area = 61.36431884765625\n", + "2021-09-23 13:19:46,677 - root - INFO: max area = 199.99404907226562\n", + "2021-09-23 13:19:46,800 - root - INFO: \n", + "2021-09-23 13:19:46,800 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:46,801 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:46,801 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:19:46,802 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:46,845 - root - INFO: ... got raster of shape: (46, 180)\n", + "2021-09-23 13:19:46,854 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n", + "2021-09-23 13:19:46,864 - root - INFO: \n", + "2021-09-23 13:19:46,865 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:19:46,865 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:46,939 - root - INFO: \n", + "2021-09-23 13:19:46,940 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:46,940 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:46,941 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:19:46,942 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:46,981 - root - INFO: ... got raster of shape: (46, 180)\n", + "2021-09-23 13:19:46,990 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope1.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope1.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope2.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope2.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope3.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope3.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope4.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope4.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope5.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope5.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope6.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope6.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope7.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope7.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope8.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope8.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope9.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope9.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope10.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope10.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope11.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope11.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope12.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope12.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope13.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope13.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope14.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope14.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope15.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope15.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope16.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope16.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope17.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope17.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope18.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope18.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope19.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope19.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope20.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope20.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope21.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope21.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope22.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope22.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope23.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope23.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope24.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope24.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope25.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope25.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope26.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope26.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope27.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope27.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope28.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope28.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope29.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope29.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope30.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope30.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope31.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope31.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope32.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope32.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope33.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope33.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope34.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope34.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope35.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope35.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope36.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope36.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope37.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope37.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope38.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope38.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope39.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope39.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope40.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope40.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope41.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope41.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope42.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope42.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope43.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope43.exo\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_hillslope44.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_hillslope44.exo\n" + "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n", + "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n" ] - } - ], - "source": [ - "subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", - "for subcatch_id in subcatch_all_ids:\n", - " index = subcatch_id - 1\n", - " m2 = meshing.createHillslopeMesh2D(mesh_pars[index])\n", - " m3 = meshing.createHillslopeMesh3D(m2, mesh_pars[index], meshing.layeringStructure(),\n", - " os.path.join(mesh_dir,f'sag_hillslope{subcatch_id}.exo'))" - ] - }, - { - "cell_type": "markdown", - "id": "bd6e1541", - "metadata": {}, - "source": [ - "# DayMet" - ] - }, - { - "cell_type": "markdown", - "id": "42957ce2", - "metadata": {}, + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:19:47,047 - root - INFO: \n", + "2021-09-23 13:19:47,047 - root - INFO: Loading Raster\n", + "2021-09-23 13:19:47,047 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:47,048 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:19:47,048 - root - INFO: Collecting raster\n", + "2021-09-23 13:19:47,091 - root - INFO: ... got raster of shape: (46, 180)\n", + "2021-09-23 13:19:47,100 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n", + "\n", + "You are using exodus.py v 1.20.5 (seacas-py3), a python wrapper of some of the exodus library.\n", + "\n", + "Copyright (c) 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 National Technology &\n", + "Engineering Solutions of Sandia, LLC (NTESS). Under the terms of\n", + "Contract DE-NA0003525 with NTESS, the U.S. Government retains certain\n", + "rights in this software.\n", + "\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment8.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment8.exo\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "subcatch_demo_smooth = hillslope_demo_pars['subcatchment_smooth']\n", + "m2, lc = meshing.createSubcatchmentMesh2D(filenames, subcatch_demo_smooth, subcatch_crs,\n", + " mesh_demo_pars, plot=True)\n", + "m3 = meshing.createSubcatchmentMesh3D(m2, lc, layer_info,\n", + " os.path.join(mesh_dir, f'sag_subcatchment{subcatch_demo_id}.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "d121163b", + "metadata": {}, + "source": [ + "## 2D for all subcatchments" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "457de366", + "metadata": {}, + "outputs": [], + "source": [ + "# subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", + "# for subcatch_id in subcatch_all_ids:\n", + "# index = subcatch_id - 1\n", + "# m2 = meshing.createHillslopeMesh2D(mesh_pars[index])\n", + "# m3 = meshing.createHillslopeMesh3D(m2, mesh_pars[index], meshing.layeringStructure(),\n", + "# os.path.join(mesh_dir,f'sag_hillslope{subcatch_id}.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "5e846eff", + "metadata": {}, + "source": [ + "## 3D for all subcatchments" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d32ea0e5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:19:59,872 - root - INFO: \n", + "2021-09-23 13:19:59,873 - root - INFO: Meshing\n", + "2021-09-23 13:19:59,874 - root - INFO: ------------------------------\n", + "2021-09-23 13:19:59,874 - root - INFO: Triangulating...\n", + "2021-09-23 13:19:59,875 - root - INFO: 18 points and 18 facets\n", + "2021-09-23 13:19:59,875 - root - INFO: checking graph consistency\n", + "2021-09-23 13:19:59,876 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:19:59,876 - root - INFO: building graph data structures\n", + "2021-09-23 13:19:59,877 - root - INFO: triangle.build...\n", + "2021-09-23 13:20:00,160 - root - INFO: ...built: 14261 mesh points and 28029 triangles\n", + "2021-09-23 13:20:00,161 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:20:00,821 - root - INFO: min area = 49.853485107421875\n", + "2021-09-23 13:20:00,822 - root - INFO: max area = 199.99191284179688\n", + "2021-09-23 13:20:01,146 - root - INFO: \n", + "2021-09-23 13:20:01,147 - root - INFO: Loading Raster\n", + "2021-09-23 13:20:01,148 - root - INFO: ------------------------------\n", + "2021-09-23 13:20:01,148 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:20:01,149 - root - INFO: Collecting raster\n", + "2021-09-23 13:20:01,195 - root - INFO: ... got raster of shape: (69, 319)\n", + "2021-09-23 13:20:01,204 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23484949185112, 68.18897673838367)\n", + "2021-09-23 13:20:01,215 - root - INFO: \n", + "2021-09-23 13:20:01,216 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:20:01,217 - root - INFO: ------------------------------\n", + "2021-09-23 13:20:01,371 - root - INFO: \n", + "2021-09-23 13:20:01,372 - root - INFO: Loading Raster\n", + "2021-09-23 13:20:01,372 - root - INFO: ------------------------------\n", + "2021-09-23 13:20:01,373 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:20:01,374 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.32333181192908, 68.18904867385021, -149.23495351407024, 68.20809989576648)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:20:01,416 - root - INFO: ... got raster of shape: (69, 319)\n", + "2021-09-23 13:20:01,424 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23484949185112, 68.18897673838367)\n", + "2021-09-23 13:20:01,518 - root - INFO: \n", + "2021-09-23 13:20:01,519 - root - INFO: Loading Raster\n", + "2021-09-23 13:20:01,520 - root - INFO: ------------------------------\n", + "2021-09-23 13:20:01,520 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:20:01,521 - root - INFO: Collecting raster\n", + "2021-09-23 13:20:01,562 - root - INFO: ... got raster of shape: (69, 319)\n", + "2021-09-23 13:20:01,572 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23484949185112, 68.18897673838367)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.32333181192908, 68.18904867385021, -149.23495351407024, 68.20809989576648)\n", + "bounds in my_crs: (-149.32333181192908, 68.18904867385021, -149.23495351407024, 68.20809989576648)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment1.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment1.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:20:35,175 - root - INFO: \n", + "2021-09-23 13:20:35,176 - root - INFO: Meshing\n", + "2021-09-23 13:20:35,176 - root - INFO: ------------------------------\n", + "2021-09-23 13:20:35,177 - root - INFO: Triangulating...\n", + "2021-09-23 13:20:35,178 - root - INFO: 19 points and 19 facets\n", + "2021-09-23 13:20:35,179 - root - INFO: checking graph consistency\n", + "2021-09-23 13:20:35,179 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:20:35,180 - root - INFO: building graph data structures\n", + "2021-09-23 13:20:35,181 - root - INFO: triangle.build...\n", + "2021-09-23 13:20:35,449 - root - INFO: ...built: 13807 mesh points and 27147 triangles\n", + "2021-09-23 13:20:35,450 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:20:36,100 - root - INFO: min area = 60.220672607421875\n", + "2021-09-23 13:20:36,101 - root - INFO: max area = 199.98150634765625\n", + "2021-09-23 13:20:36,382 - root - INFO: \n", + "2021-09-23 13:20:36,383 - root - INFO: Loading Raster\n", + "2021-09-23 13:20:36,383 - root - INFO: ------------------------------\n", + "2021-09-23 13:20:36,384 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:20:36,385 - root - INFO: Collecting raster\n", + "2021-09-23 13:20:36,433 - root - INFO: ... got raster of shape: (65, 330)\n", + "2021-09-23 13:20:36,443 - root - INFO: ... got raster bounds: (-149.32373838074298, 68.19786562727286, -149.23207171407327, 68.1798100717167)\n", + "2021-09-23 13:20:36,453 - root - INFO: \n", + "2021-09-23 13:20:36,454 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:20:36,455 - root - INFO: ------------------------------\n", + "2021-09-23 13:20:36,594 - root - INFO: \n", + "2021-09-23 13:20:36,595 - root - INFO: Loading Raster\n", + "2021-09-23 13:20:36,595 - root - INFO: ------------------------------\n", + "2021-09-23 13:20:36,596 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:20:36,597 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.32349899933536, 68.18007214137471, -149.23231844816064, 68.19760352339726)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:20:36,642 - root - INFO: ... got raster of shape: (65, 330)\n", + "2021-09-23 13:20:36,651 - root - INFO: ... got raster bounds: (-149.32373838074298, 68.19786562727286, -149.23207171407327, 68.1798100717167)\n", + "2021-09-23 13:20:36,746 - root - INFO: \n", + "2021-09-23 13:20:36,747 - root - INFO: Loading Raster\n", + "2021-09-23 13:20:36,747 - root - INFO: ------------------------------\n", + "2021-09-23 13:20:36,748 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:20:36,749 - root - INFO: Collecting raster\n", + "2021-09-23 13:20:36,794 - root - INFO: ... got raster of shape: (65, 330)\n", + "2021-09-23 13:20:36,803 - root - INFO: ... got raster bounds: (-149.32373838074298, 68.19786562727286, -149.23207171407327, 68.1798100717167)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.32349899933536, 68.18007214137471, -149.23231844816064, 68.19760352339726)\n", + "bounds in my_crs: (-149.32349899933536, 68.18007214137471, -149.23231844816064, 68.19760352339726)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment2.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment2.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:21:09,384 - root - INFO: \n", + "2021-09-23 13:21:09,385 - root - INFO: Meshing\n", + "2021-09-23 13:21:09,385 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:09,386 - root - INFO: Triangulating...\n", + "2021-09-23 13:21:09,387 - root - INFO: 16 points and 16 facets\n", + "2021-09-23 13:21:09,387 - root - INFO: checking graph consistency\n", + "2021-09-23 13:21:09,388 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:21:09,388 - root - INFO: building graph data structures\n", + "2021-09-23 13:21:09,389 - root - INFO: triangle.build...\n", + "2021-09-23 13:21:09,689 - root - INFO: ...built: 16183 mesh points and 31951 triangles\n", + "2021-09-23 13:21:09,690 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:21:10,365 - root - INFO: min area = 59.8853759765625\n", + "2021-09-23 13:21:10,366 - root - INFO: max area = 199.969482421875\n", + "2021-09-23 13:21:10,711 - root - INFO: \n", + "2021-09-23 13:21:10,712 - root - INFO: Loading Raster\n", + "2021-09-23 13:21:10,712 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:10,713 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:21:10,714 - root - INFO: Collecting raster\n", + "2021-09-23 13:21:10,761 - root - INFO: ... got raster of shape: (96, 235)\n", + "2021-09-23 13:21:10,771 - root - INFO: ... got raster bounds: (-149.25373838074066, 68.20536562727311, -149.1884606029607, 68.17869896060556)\n", + "2021-09-23 13:21:10,780 - root - INFO: \n", + "2021-09-23 13:21:10,780 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:21:10,781 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:10,952 - root - INFO: \n", + "2021-09-23 13:21:10,953 - root - INFO: Loading Raster\n", + "2021-09-23 13:21:10,953 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:10,954 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:21:10,955 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.25371456417372, 68.17875098194455, -149.18872340913728, 68.20521902133713)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:21:11,001 - root - INFO: ... got raster of shape: (96, 235)\n", + "2021-09-23 13:21:11,010 - root - INFO: ... got raster bounds: (-149.25373838074066, 68.20536562727311, -149.1884606029607, 68.17869896060556)\n", + "2021-09-23 13:21:11,113 - root - INFO: \n", + "2021-09-23 13:21:11,114 - root - INFO: Loading Raster\n", + "2021-09-23 13:21:11,114 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:11,115 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:21:11,116 - root - INFO: Collecting raster\n", + "2021-09-23 13:21:11,164 - root - INFO: ... got raster of shape: (96, 235)\n", + "2021-09-23 13:21:11,175 - root - INFO: ... got raster bounds: (-149.25373838074066, 68.20536562727311, -149.1884606029607, 68.17869896060556)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.25371456417372, 68.17875098194455, -149.18872340913728, 68.20521902133713)\n", + "bounds in my_crs: (-149.25371456417372, 68.17875098194455, -149.18872340913728, 68.20521902133713)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment3.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment3.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:21:47,979 - root - INFO: \n", + "2021-09-23 13:21:47,979 - root - INFO: Meshing\n", + "2021-09-23 13:21:47,980 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:47,981 - root - INFO: Triangulating...\n", + "2021-09-23 13:21:47,982 - root - INFO: 11 points and 11 facets\n", + "2021-09-23 13:21:47,982 - root - INFO: checking graph consistency\n", + "2021-09-23 13:21:47,982 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:21:47,983 - root - INFO: building graph data structures\n", + "2021-09-23 13:21:47,984 - root - INFO: triangle.build...\n", + "2021-09-23 13:21:48,194 - root - INFO: ...built: 10834 mesh points and 21327 triangles\n", + "2021-09-23 13:21:48,195 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:21:48,659 - root - INFO: min area = 58.8323974609375\n", + "2021-09-23 13:21:48,660 - root - INFO: max area = 199.98284912109375\n", + "2021-09-23 13:21:48,875 - root - INFO: \n", + "2021-09-23 13:21:48,875 - root - INFO: Loading Raster\n", + "2021-09-23 13:21:48,876 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:48,876 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:21:48,878 - root - INFO: Collecting raster\n", + "2021-09-23 13:21:48,922 - root - INFO: ... got raster of shape: (59, 231)\n", + "2021-09-23 13:21:48,931 - root - INFO: ... got raster bounds: (-149.2720717140746, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", + "2021-09-23 13:21:48,940 - root - INFO: \n", + "2021-09-23 13:21:48,941 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:21:48,941 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:49,053 - root - INFO: \n", + "2021-09-23 13:21:49,054 - root - INFO: Loading Raster\n", + "2021-09-23 13:21:49,055 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:49,055 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:21:49,056 - root - INFO: Collecting raster\n", + "2021-09-23 13:21:49,101 - root - INFO: ... got raster of shape: (59, 231)\n", + "2021-09-23 13:21:49,110 - root - INFO: ... got raster bounds: (-149.2720717140746, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.27179877026592, 68.19927082938099, -149.20801699376824, 68.21563762826689)\n", + "bounds in my_crs: (-149.27179877026592, 68.19927082938099, -149.20801699376824, 68.21563762826689)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:21:49,187 - root - INFO: \n", + "2021-09-23 13:21:49,188 - root - INFO: Loading Raster\n", + "2021-09-23 13:21:49,188 - root - INFO: ------------------------------\n", + "2021-09-23 13:21:49,189 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:21:49,189 - root - INFO: Collecting raster\n", + "2021-09-23 13:21:49,236 - root - INFO: ... got raster of shape: (59, 231)\n", + "2021-09-23 13:21:49,245 - root - INFO: ... got raster bounds: (-149.2720717140746, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.27179877026592, 68.19927082938099, -149.20801699376824, 68.21563762826689)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment4.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment4.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:22:14,429 - root - INFO: \n", + "2021-09-23 13:22:14,430 - root - INFO: Meshing\n", + "2021-09-23 13:22:14,430 - root - INFO: ------------------------------\n", + "2021-09-23 13:22:14,431 - root - INFO: Triangulating...\n", + "2021-09-23 13:22:14,431 - root - INFO: 18 points and 18 facets\n", + "2021-09-23 13:22:14,432 - root - INFO: checking graph consistency\n", + "2021-09-23 13:22:14,432 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:22:14,433 - root - INFO: building graph data structures\n", + "2021-09-23 13:22:14,433 - root - INFO: triangle.build...\n", + "2021-09-23 13:22:14,893 - root - INFO: ...built: 26624 mesh points and 52678 triangles\n", + "2021-09-23 13:22:14,894 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:22:15,974 - root - INFO: min area = 52.785980224609375\n", + "2021-09-23 13:22:15,974 - root - INFO: max area = 199.97225952148438\n", + "2021-09-23 13:22:16,437 - root - INFO: \n", + "2021-09-23 13:22:16,438 - root - INFO: Loading Raster\n", + "2021-09-23 13:22:16,439 - root - INFO: ------------------------------\n", + "2021-09-23 13:22:16,439 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:22:16,440 - root - INFO: Collecting raster\n", + "2021-09-23 13:22:16,486 - root - INFO: ... got raster of shape: (99, 374)\n", + "2021-09-23 13:22:16,496 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17207171407128, 68.20703229393983)\n", + "2021-09-23 13:22:16,506 - root - INFO: \n", + "2021-09-23 13:22:16,507 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:22:16,507 - root - INFO: ------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.27573517147246, 68.207289642888, -149.17231387605082, 68.23426687242299)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:22:16,724 - root - INFO: \n", + "2021-09-23 13:22:16,724 - root - INFO: Loading Raster\n", + "2021-09-23 13:22:16,725 - root - INFO: ------------------------------\n", + "2021-09-23 13:22:16,725 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:22:16,726 - root - INFO: Collecting raster\n", + "2021-09-23 13:22:16,769 - root - INFO: ... got raster of shape: (99, 374)\n", + "2021-09-23 13:22:16,778 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17207171407128, 68.20703229393983)\n", + "2021-09-23 13:22:16,913 - root - INFO: \n", + "2021-09-23 13:22:16,914 - root - INFO: Loading Raster\n", + "2021-09-23 13:22:16,914 - root - INFO: ------------------------------\n", + "2021-09-23 13:22:16,915 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:22:16,916 - root - INFO: Collecting raster\n", + "2021-09-23 13:22:16,960 - root - INFO: ... got raster of shape: (99, 374)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.27573517147246, 68.207289642888, -149.17231387605082, 68.23426687242299)\n", + "bounds in my_crs: (-149.27573517147246, 68.207289642888, -149.17231387605082, 68.23426687242299)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:22:16,969 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17207171407128, 68.20703229393983)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment5.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment5.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:23:17,638 - root - INFO: \n", + "2021-09-23 13:23:17,639 - root - INFO: Meshing\n", + "2021-09-23 13:23:17,640 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:17,640 - root - INFO: Triangulating...\n", + "2021-09-23 13:23:17,641 - root - INFO: 10 points and 10 facets\n", + "2021-09-23 13:23:17,641 - root - INFO: checking graph consistency\n", + "2021-09-23 13:23:17,642 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:23:17,643 - root - INFO: building graph data structures\n", + "2021-09-23 13:23:17,643 - root - INFO: triangle.build...\n", + "2021-09-23 13:23:17,773 - root - INFO: ...built: 6428 mesh points and 12588 triangles\n", + "2021-09-23 13:23:17,777 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:23:18,066 - root - INFO: min area = 30.5418701171875\n", + "2021-09-23 13:23:18,067 - root - INFO: max area = 199.99493408203125\n", + "2021-09-23 13:23:18,212 - root - INFO: \n", + "2021-09-23 13:23:18,213 - root - INFO: Loading Raster\n", + "2021-09-23 13:23:18,213 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:18,214 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:23:18,214 - root - INFO: Collecting raster\n", + "2021-09-23 13:23:18,261 - root - INFO: ... got raster of shape: (48, 152)\n", + "2021-09-23 13:23:18,270 - root - INFO: ... got raster bounds: (-149.21346060296153, 68.2098100717177, -149.17123838073792, 68.19647673838392)\n", + "2021-09-23 13:23:18,280 - root - INFO: \n", + "2021-09-23 13:23:18,280 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:23:18,281 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:18,363 - root - INFO: \n", + "2021-09-23 13:23:18,364 - root - INFO: Loading Raster\n", + "2021-09-23 13:23:18,364 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:18,365 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:23:18,365 - root - INFO: Collecting raster\n", + "2021-09-23 13:23:18,407 - root - INFO: ... got raster of shape: (48, 152)\n", + "2021-09-23 13:23:18,416 - root - INFO: ... got raster bounds: (-149.21346060296153, 68.2098100717177, -149.17123838073792, 68.19647673838392)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21318529930883, 68.19654310128655, -149.17137472521458, 68.20967710288205)\n", + "bounds in my_crs: (-149.21318529930883, 68.19654310128655, -149.17137472521458, 68.20967710288205)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:23:18,477 - root - INFO: \n", + "2021-09-23 13:23:18,478 - root - INFO: Loading Raster\n", + "2021-09-23 13:23:18,478 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:18,479 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:23:18,479 - root - INFO: Collecting raster\n", + "2021-09-23 13:23:18,522 - root - INFO: ... got raster of shape: (48, 152)\n", + "2021-09-23 13:23:18,531 - root - INFO: ... got raster bounds: (-149.21346060296153, 68.2098100717177, -149.17123838073792, 68.19647673838392)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21318529930883, 68.19654310128655, -149.17137472521458, 68.20967710288205)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment6.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment6.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:23:33,101 - root - INFO: \n", + "2021-09-23 13:23:33,102 - root - INFO: Meshing\n", + "2021-09-23 13:23:33,103 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:33,104 - root - INFO: Triangulating...\n", + "2021-09-23 13:23:33,104 - root - INFO: 10 points and 10 facets\n", + "2021-09-23 13:23:33,105 - root - INFO: checking graph consistency\n", + "2021-09-23 13:23:33,105 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:23:33,106 - root - INFO: building graph data structures\n", + "2021-09-23 13:23:33,107 - root - INFO: triangle.build...\n", + "2021-09-23 13:23:33,386 - root - INFO: ...built: 13061 mesh points and 25746 triangles\n", + "2021-09-23 13:23:33,387 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:23:33,952 - root - INFO: min area = 31.566497802734375\n", + "2021-09-23 13:23:33,953 - root - INFO: max area = 199.987060546875\n", + "2021-09-23 13:23:34,201 - root - INFO: \n", + "2021-09-23 13:23:34,202 - root - INFO: Loading Raster\n", + "2021-09-23 13:23:34,202 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:34,202 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:23:34,203 - root - INFO: Collecting raster\n", + "2021-09-23 13:23:34,249 - root - INFO: ... got raster of shape: (93, 190)\n", + "2021-09-23 13:23:34,258 - root - INFO: ... got raster bounds: (-149.17012726962676, 68.22425451616263, -149.11734949184722, 68.19842118282844)\n", + "2021-09-23 13:23:34,267 - root - INFO: \n", + "2021-09-23 13:23:34,268 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:23:34,268 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:34,396 - root - INFO: \n", + "2021-09-23 13:23:34,396 - root - INFO: Loading Raster\n", + "2021-09-23 13:23:34,397 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:34,397 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:23:34,398 - root - INFO: Collecting raster\n", + "2021-09-23 13:23:34,443 - root - INFO: ... got raster of shape: (93, 190)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17008126329404, 68.19860441435323, -149.11752268914583, 68.224084697891)\n", + "bounds in my_crs: (-149.17008126329404, 68.19860441435323, -149.11752268914583, 68.224084697891)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:23:34,452 - root - INFO: ... got raster bounds: (-149.17012726962676, 68.22425451616263, -149.11734949184722, 68.19842118282844)\n", + "2021-09-23 13:23:34,542 - root - INFO: \n", + "2021-09-23 13:23:34,543 - root - INFO: Loading Raster\n", + "2021-09-23 13:23:34,544 - root - INFO: ------------------------------\n", + "2021-09-23 13:23:34,544 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:23:34,545 - root - INFO: Collecting raster\n", + "2021-09-23 13:23:34,588 - root - INFO: ... got raster of shape: (93, 190)\n", + "2021-09-23 13:23:34,597 - root - INFO: ... got raster bounds: (-149.17012726962676, 68.22425451616263, -149.11734949184722, 68.19842118282844)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17008126329404, 68.19860441435323, -149.11752268914583, 68.224084697891)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment7.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment7.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:24:03,815 - root - INFO: \n", + "2021-09-23 13:24:03,816 - root - INFO: Meshing\n", + "2021-09-23 13:24:03,817 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:03,817 - root - INFO: Triangulating...\n", + "2021-09-23 13:24:03,818 - root - INFO: 8 points and 8 facets\n", + "2021-09-23 13:24:03,818 - root - INFO: checking graph consistency\n", + "2021-09-23 13:24:03,819 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:24:03,820 - root - INFO: building graph data structures\n", + "2021-09-23 13:24:03,820 - root - INFO: triangle.build...\n", + "2021-09-23 13:24:03,924 - root - INFO: ...built: 4932 mesh points and 9596 triangles\n", + "2021-09-23 13:24:03,927 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:24:04,147 - root - INFO: min area = 61.36431884765625\n", + "2021-09-23 13:24:04,147 - root - INFO: max area = 199.99404907226562\n", + "2021-09-23 13:24:04,264 - root - INFO: \n", + "2021-09-23 13:24:04,265 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:04,265 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:04,266 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:24:04,267 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:04,308 - root - INFO: ... got raster of shape: (46, 180)\n", + "2021-09-23 13:24:04,316 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n", + "2021-09-23 13:24:04,326 - root - INFO: \n", + "2021-09-23 13:24:04,326 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:24:04,327 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:04,399 - root - INFO: \n", + "2021-09-23 13:24:04,400 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:04,401 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:04,401 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:24:04,402 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:04,441 - root - INFO: ... got raster of shape: (46, 180)\n", + "2021-09-23 13:24:04,449 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n", + "2021-09-23 13:24:04,504 - root - INFO: \n", + "2021-09-23 13:24:04,505 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:04,505 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:04,506 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n", + "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:24:04,507 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:04,551 - root - INFO: ... got raster of shape: (46, 180)\n", + "2021-09-23 13:24:04,560 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment8.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment8.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:24:15,607 - root - INFO: \n", + "2021-09-23 13:24:15,607 - root - INFO: Meshing\n", + "2021-09-23 13:24:15,608 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:15,608 - root - INFO: Triangulating...\n", + "2021-09-23 13:24:15,609 - root - INFO: 5 points and 5 facets\n", + "2021-09-23 13:24:15,609 - root - INFO: checking graph consistency\n", + "2021-09-23 13:24:15,610 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:24:15,610 - root - INFO: building graph data structures\n", + "2021-09-23 13:24:15,611 - root - INFO: triangle.build...\n", + "2021-09-23 13:24:15,633 - root - INFO: ...built: 943 mesh points and 1765 triangles\n", + "2021-09-23 13:24:15,634 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:24:15,683 - root - INFO: min area = 64.89346313476562\n", + "2021-09-23 13:24:15,684 - root - INFO: max area = 199.94284057617188\n", + "2021-09-23 13:24:15,736 - root - INFO: \n", + "2021-09-23 13:24:15,737 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:15,737 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:15,738 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:24:15,739 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:15,780 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-23 13:24:15,788 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-23 13:24:15,797 - root - INFO: \n", + "2021-09-23 13:24:15,798 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:24:15,799 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:15,844 - root - INFO: \n", + "2021-09-23 13:24:15,845 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:15,846 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:15,846 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:24:15,847 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:15,887 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-23 13:24:15,896 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", + "2021-09-23 13:24:15,938 - root - INFO: \n", + "2021-09-23 13:24:15,939 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:15,939 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:15,940 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:24:15,940 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.12195772397504, 68.2146470306309, -149.11469670554692, 68.22476698259781)\n", + "bounds in my_crs: (-149.12195772397504, 68.2146470306309, -149.11469670554692, 68.22476698259781)\n", + "bounds in my_crs: (-149.12195772397504, 68.2146470306309, -149.11469670554692, 68.22476698259781)" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:24:15,982 - root - INFO: ... got raster of shape: (37, 27)\n", + "2021-09-23 13:24:15,991 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment9.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:24:18,174 - root - INFO: \n", + "2021-09-23 13:24:18,175 - root - INFO: Meshing\n", + "2021-09-23 13:24:18,176 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:18,176 - root - INFO: Triangulating...\n", + "2021-09-23 13:24:18,177 - root - INFO: 4 points and 4 facets\n", + "2021-09-23 13:24:18,178 - root - INFO: checking graph consistency\n", + "2021-09-23 13:24:18,178 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:24:18,180 - root - INFO: building graph data structures\n", + "2021-09-23 13:24:18,180 - root - INFO: triangle.build...\n", + "2021-09-23 13:24:18,190 - root - INFO: ...built: 403 mesh points and 740 triangles\n", + "2021-09-23 13:24:18,191 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:24:18,218 - root - INFO: min area = 63.197265625\n", + "2021-09-23 13:24:18,219 - root - INFO: max area = 197.10922241210938\n", + "2021-09-23 13:24:18,265 - root - INFO: \n", + "2021-09-23 13:24:18,266 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:18,266 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:18,266 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:24:18,267 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:18,309 - root - INFO: ... got raster of shape: (19, 28)\n", + "2021-09-23 13:24:18,318 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-23 13:24:18,327 - root - INFO: \n", + "2021-09-23 13:24:18,328 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:24:18,329 - root - INFO: ------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment9.exo\n", + "bounds in my_crs: (-149.1220145604678, 68.224633298062, -149.11450991948863, 68.22964545511863)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:24:18,374 - root - INFO: \n", + "2021-09-23 13:24:18,375 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:18,375 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:18,375 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:24:18,376 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:18,421 - root - INFO: ... got raster of shape: (19, 28)\n", + "2021-09-23 13:24:18,430 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", + "2021-09-23 13:24:18,471 - root - INFO: \n", + "2021-09-23 13:24:18,471 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:18,472 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:18,473 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:24:18,473 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:18,514 - root - INFO: ... got raster of shape: (19, 28)\n", + "2021-09-23 13:24:18,523 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.1220145604678, 68.224633298062, -149.11450991948863, 68.22964545511863)\n", + "bounds in my_crs: (-149.1220145604678, 68.224633298062, -149.11450991948863, 68.22964545511863)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:24:19,504 - root - INFO: \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment10.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment10.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:24:19,505 - root - INFO: Meshing\n", + "2021-09-23 13:24:19,505 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:19,506 - root - INFO: Triangulating...\n", + "2021-09-23 13:24:19,507 - root - INFO: 17 points and 17 facets\n", + "2021-09-23 13:24:19,507 - root - INFO: checking graph consistency\n", + "2021-09-23 13:24:19,507 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:24:19,508 - root - INFO: building graph data structures\n", + "2021-09-23 13:24:19,509 - root - INFO: triangle.build...\n", + "2021-09-23 13:24:19,825 - root - INFO: ...built: 17219 mesh points and 33992 triangles\n", + "2021-09-23 13:24:19,826 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:24:20,547 - root - INFO: min area = 62.965301513671875\n", + "2021-09-23 13:24:20,548 - root - INFO: max area = 199.99411010742188\n", + "2021-09-23 13:24:20,902 - root - INFO: \n", + "2021-09-23 13:24:20,903 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:20,904 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:20,904 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:24:20,905 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:20,952 - root - INFO: ... got raster of shape: (117, 191)\n", + "2021-09-23 13:24:20,961 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07234949184576, 68.19953229393958)\n", + "2021-09-23 13:24:20,976 - root - INFO: \n", + "2021-09-23 13:24:20,977 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:24:20,978 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:21,136 - root - INFO: \n", + "2021-09-23 13:24:21,136 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:21,137 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:21,137 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:24:21,138 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.1252712902553, 68.19958418193676, -149.0724953180663, 68.23194119249688)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:24:21,180 - root - INFO: ... got raster of shape: (117, 191)\n", + "2021-09-23 13:24:21,189 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07234949184576, 68.19953229393958)\n", + "2021-09-23 13:24:21,291 - root - INFO: \n", + "2021-09-23 13:24:21,291 - root - INFO: Loading Raster\n", + "2021-09-23 13:24:21,292 - root - INFO: ------------------------------\n", + "2021-09-23 13:24:21,292 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:24:21,293 - root - INFO: Collecting raster\n", + "2021-09-23 13:24:21,335 - root - INFO: ... got raster of shape: (117, 191)\n", + "2021-09-23 13:24:21,344 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07234949184576, 68.19953229393958)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.1252712902553, 68.19958418193676, -149.0724953180663, 68.23194119249688)\n", + "bounds in my_crs: (-149.1252712902553, 68.19958418193676, -149.0724953180663, 68.23194119249688)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment11.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment11.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:25:00,161 - root - INFO: \n", + "2021-09-23 13:25:00,162 - root - INFO: Meshing\n", + "2021-09-23 13:25:00,163 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:00,164 - root - INFO: Triangulating...\n", + "2021-09-23 13:25:00,164 - root - INFO: 7 points and 7 facets\n", + "2021-09-23 13:25:00,165 - root - INFO: checking graph consistency\n", + "2021-09-23 13:25:00,165 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:25:00,166 - root - INFO: building graph data structures\n", + "2021-09-23 13:25:00,166 - root - INFO: triangle.build...\n", + "2021-09-23 13:25:00,404 - root - INFO: ...built: 11500 mesh points and 22655 triangles\n", + "2021-09-23 13:25:00,406 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:25:00,925 - root - INFO: min area = 39.735809326171875\n", + "2021-09-23 13:25:00,927 - root - INFO: max area = 199.99679565429688\n", + "2021-09-23 13:25:01,157 - root - INFO: \n", + "2021-09-23 13:25:01,158 - root - INFO: Loading Raster\n", + "2021-09-23 13:25:01,159 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:01,159 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:25:01,160 - root - INFO: Collecting raster\n", + "2021-09-23 13:25:01,206 - root - INFO: ... got raster of shape: (94, 128)\n", + "2021-09-23 13:25:01,215 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25092118283018, -149.08040504740157, 68.22481007171821)\n", + "2021-09-23 13:25:01,224 - root - INFO: \n", + "2021-09-23 13:25:01,225 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:25:01,226 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:01,342 - root - INFO: \n", + "2021-09-23 13:25:01,343 - root - INFO: Loading Raster\n", + "2021-09-23 13:25:01,343 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:01,344 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:25:01,345 - root - INFO: Collecting raster\n", + "2021-09-23 13:25:01,388 - root - INFO: ... got raster of shape: (94, 128)\n", + "2021-09-23 13:25:01,397 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25092118283018, -149.08040504740157, 68.22481007171821)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.1159483824004, 68.2248164661218, -149.0804188841349, 68.25091454444949)\n", + "bounds in my_crs: (-149.1159483824004, 68.2248164661218, -149.0804188841349, 68.25091454444949)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:25:01,476 - root - INFO: \n", + "2021-09-23 13:25:01,477 - root - INFO: Loading Raster\n", + "2021-09-23 13:25:01,477 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:01,478 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:25:01,478 - root - INFO: Collecting raster\n", + "2021-09-23 13:25:01,523 - root - INFO: ... got raster of shape: (94, 128)\n", + "2021-09-23 13:25:01,531 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25092118283018, -149.08040504740157, 68.22481007171821)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.1159483824004, 68.2248164661218, -149.0804188841349, 68.25091454444949)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment12.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment12.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:25:28,597 - root - INFO: \n", + "2021-09-23 13:25:28,598 - root - INFO: Meshing\n", + "2021-09-23 13:25:28,598 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:28,599 - root - INFO: Triangulating...\n", + "2021-09-23 13:25:28,600 - root - INFO: 12 points and 12 facets\n", + "2021-09-23 13:25:28,600 - root - INFO: checking graph consistency\n", + "2021-09-23 13:25:28,601 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:25:28,601 - root - INFO: building graph data structures\n", + "2021-09-23 13:25:28,602 - root - INFO: triangle.build...\n", + "2021-09-23 13:25:28,852 - root - INFO: ...built: 14357 mesh points and 28318 triangles\n", + "2021-09-23 13:25:28,853 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:25:29,519 - root - INFO: min area = 57.526275634765625\n", + "2021-09-23 13:25:29,520 - root - INFO: max area = 199.99566650390625\n", + "2021-09-23 13:25:29,790 - root - INFO: \n", + "2021-09-23 13:25:29,791 - root - INFO: Loading Raster\n", + "2021-09-23 13:25:29,792 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:29,792 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:25:29,793 - root - INFO: Collecting raster\n", + "2021-09-23 13:25:29,837 - root - INFO: ... got raster of shape: (96, 205)\n", + "2021-09-23 13:25:29,847 - root - INFO: ... got raster bounds: (-149.08568282517953, 68.2439767383855, -149.0287383807332, 68.21731007171795)\n", + "2021-09-23 13:25:29,856 - root - INFO: \n", + "2021-09-23 13:25:29,856 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:25:29,856 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:29,996 - root - INFO: \n", + "2021-09-23 13:25:29,997 - root - INFO: Loading Raster\n", + "2021-09-23 13:25:29,998 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:29,998 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:25:29,999 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08555398967127, 68.21735876156187, -149.02887005478019, 68.24383919593815)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:25:30,038 - root - INFO: ... got raster of shape: (96, 205)\n", + "2021-09-23 13:25:30,048 - root - INFO: ... got raster bounds: (-149.08568282517953, 68.2439767383855, -149.0287383807332, 68.21731007171795)\n", + "2021-09-23 13:25:30,138 - root - INFO: \n", + "2021-09-23 13:25:30,139 - root - INFO: Loading Raster\n", + "2021-09-23 13:25:30,139 - root - INFO: ------------------------------\n", + "2021-09-23 13:25:30,140 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:25:30,141 - root - INFO: Collecting raster\n", + "2021-09-23 13:25:30,183 - root - INFO: ... got raster of shape: (96, 205)\n", + "2021-09-23 13:25:30,191 - root - INFO: ... got raster bounds: (-149.08568282517953, 68.2439767383855, -149.0287383807332, 68.21731007171795)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08555398967127, 68.21735876156187, -149.02887005478019, 68.24383919593815)\n", + "bounds in my_crs: (-149.08555398967127, 68.21735876156187, -149.02887005478019, 68.24383919593815)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment13.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment13.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:26:05,227 - root - INFO: \n", + "2021-09-23 13:26:05,228 - root - INFO: Meshing\n", + "2021-09-23 13:26:05,228 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:05,228 - root - INFO: Triangulating...\n", + "2021-09-23 13:26:05,231 - root - INFO: 7 points and 7 facets\n", + "2021-09-23 13:26:05,233 - root - INFO: checking graph consistency\n", + "2021-09-23 13:26:05,234 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:26:05,235 - root - INFO: building graph data structures\n", + "2021-09-23 13:26:05,236 - root - INFO: triangle.build...\n", + "2021-09-23 13:26:05,579 - root - INFO: ...built: 12402 mesh points and 24442 triangles\n", + "2021-09-23 13:26:05,580 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:26:06,126 - root - INFO: min area = 39.55126953125\n", + "2021-09-23 13:26:06,127 - root - INFO: max area = 199.97433471679688\n", + "2021-09-23 13:26:06,416 - root - INFO: \n", + "2021-09-23 13:26:06,417 - root - INFO: Loading Raster\n", + "2021-09-23 13:26:06,417 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:06,418 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:26:06,419 - root - INFO: Collecting raster\n", + "2021-09-23 13:26:06,474 - root - INFO: ... got raster of shape: (68, 218)\n", + "2021-09-23 13:26:06,485 - root - INFO: ... got raster bounds: (-149.0904050474019, 68.25092118283018, -149.02984949184435, 68.23203229394066)\n", + "2021-09-23 13:26:06,498 - root - INFO: \n", + "2021-09-23 13:26:06,499 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:26:06,499 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:06,641 - root - INFO: \n", + "2021-09-23 13:26:06,642 - root - INFO: Loading Raster\n", + "2021-09-23 13:26:06,643 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:06,644 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:26:06,644 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.09027776606652, 68.2321531453996, -149.02999166915717, 68.25089018150955)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:26:06,695 - root - INFO: ... got raster of shape: (68, 218)\n", + "2021-09-23 13:26:06,708 - root - INFO: ... got raster bounds: (-149.0904050474019, 68.25092118283018, -149.02984949184435, 68.23203229394066)\n", + "2021-09-23 13:26:06,800 - root - INFO: \n", + "2021-09-23 13:26:06,801 - root - INFO: Loading Raster\n", + "2021-09-23 13:26:06,802 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:06,802 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:26:06,803 - root - INFO: Collecting raster\n", + "2021-09-23 13:26:06,858 - root - INFO: ... got raster of shape: (68, 218)\n", + "2021-09-23 13:26:06,867 - root - INFO: ... got raster bounds: (-149.0904050474019, 68.25092118283018, -149.02984949184435, 68.23203229394066)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.09027776606652, 68.2321531453996, -149.02999166915717, 68.25089018150955)\n", + "bounds in my_crs: (-149.09027776606652, 68.2321531453996, -149.02999166915717, 68.25089018150955)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment14.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment14.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:26:36,122 - root - INFO: \n", + "2021-09-23 13:26:36,123 - root - INFO: Meshing\n", + "2021-09-23 13:26:36,123 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:36,124 - root - INFO: Triangulating...\n", + "2021-09-23 13:26:36,125 - root - INFO: 11 points and 11 facets\n", + "2021-09-23 13:26:36,125 - root - INFO: checking graph consistency\n", + "2021-09-23 13:26:36,126 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:26:36,127 - root - INFO: building graph data structures\n", + "2021-09-23 13:26:36,127 - root - INFO: triangle.build...\n", + "2021-09-23 13:26:36,466 - root - INFO: ...built: 14740 mesh points and 29109 triangles\n", + "2021-09-23 13:26:36,467 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:26:37,094 - root - INFO: min area = 60.285186767578125\n", + "2021-09-23 13:26:37,095 - root - INFO: max area = 199.97903442382812\n", + "2021-09-23 13:26:37,369 - root - INFO: \n", + "2021-09-23 13:26:37,370 - root - INFO: Loading Raster\n", + "2021-09-23 13:26:37,370 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:37,371 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:26:37,372 - root - INFO: Collecting raster\n", + "2021-09-23 13:26:37,413 - root - INFO: ... got raster of shape: (88, 198)\n", + "2021-09-23 13:26:37,422 - root - INFO: ... got raster bounds: (-149.0306828251777, 68.26842118283076, -148.97568282517588, 68.24397673838551)\n", + "2021-09-23 13:26:37,431 - root - INFO: \n", + "2021-09-23 13:26:37,432 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:26:37,432 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:37,565 - root - INFO: \n", + "2021-09-23 13:26:37,565 - root - INFO: Loading Raster\n", + "2021-09-23 13:26:37,566 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:37,566 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:26:37,567 - root - INFO: Collecting raster\n", + "2021-09-23 13:26:37,606 - root - INFO: ... got raster of shape: (88, 198)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.03048446793935, 68.24422492626324, -148.97588227121466, 68.26816107683497)\n", + "bounds in my_crs: (-149.03048446793935, 68.24422492626324, -148.97588227121466, 68.26816107683497)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:26:37,615 - root - INFO: ... got raster bounds: (-149.0306828251777, 68.26842118283076, -148.97568282517588, 68.24397673838551)\n", + "2021-09-23 13:26:37,701 - root - INFO: \n", + "2021-09-23 13:26:37,702 - root - INFO: Loading Raster\n", + "2021-09-23 13:26:37,702 - root - INFO: ------------------------------\n", + "2021-09-23 13:26:37,703 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:26:37,704 - root - INFO: Collecting raster\n", + "2021-09-23 13:26:37,743 - root - INFO: ... got raster of shape: (88, 198)\n", + "2021-09-23 13:26:37,752 - root - INFO: ... got raster bounds: (-149.0306828251777, 68.26842118283076, -148.97568282517588, 68.24397673838551)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.03048446793935, 68.24422492626324, -148.97588227121466, 68.26816107683497)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment15.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment15.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:27:13,827 - root - INFO: \n", + "2021-09-23 13:27:13,828 - root - INFO: Meshing\n", + "2021-09-23 13:27:13,829 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:13,829 - root - INFO: Triangulating...\n", + "2021-09-23 13:27:13,831 - root - INFO: 12 points and 12 facets\n", + "2021-09-23 13:27:13,831 - root - INFO: checking graph consistency\n", + "2021-09-23 13:27:13,832 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:27:13,833 - root - INFO: building graph data structures\n", + "2021-09-23 13:27:13,834 - root - INFO: triangle.build...\n", + "2021-09-23 13:27:13,971 - root - INFO: ...built: 6756 mesh points and 13181 triangles\n", + "2021-09-23 13:27:13,974 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:27:14,311 - root - INFO: min area = 56.0380859375\n", + "2021-09-23 13:27:14,311 - root - INFO: max area = 199.96469116210938\n", + "2021-09-23 13:27:14,459 - root - INFO: \n", + "2021-09-23 13:27:14,459 - root - INFO: Loading Raster\n", + "2021-09-23 13:27:14,460 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:14,461 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:27:14,461 - root - INFO: Collecting raster\n", + "2021-09-23 13:27:14,500 - root - INFO: ... got raster of shape: (69, 200)\n", + "2021-09-23 13:27:14,508 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.25453229394141, -148.97484949184252, 68.2353656272741)\n", + "2021-09-23 13:27:14,518 - root - INFO: \n", + "2021-09-23 13:27:14,518 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:27:14,519 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:14,602 - root - INFO: \n", + "2021-09-23 13:27:14,602 - root - INFO: Loading Raster\n", + "2021-09-23 13:27:14,603 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:14,603 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:27:14,604 - root - INFO: Collecting raster\n", + "2021-09-23 13:27:14,644 - root - INFO: ... got raster of shape: (69, 200)\n", + "2021-09-23 13:27:14,653 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.25453229394141, -148.97484949184252, 68.2353656272741)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.030312656111, 68.23544774934933, -148.97494286142927, 68.25448400386779)\n", + "bounds in my_crs: (-149.030312656111, 68.23544774934933, -148.97494286142927, 68.25448400386779)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:27:14,716 - root - INFO: \n", + "2021-09-23 13:27:14,716 - root - INFO: Loading Raster\n", + "2021-09-23 13:27:14,717 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:14,717 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:27:14,718 - root - INFO: Collecting raster\n", + "2021-09-23 13:27:14,756 - root - INFO: ... got raster of shape: (69, 200)\n", + "2021-09-23 13:27:14,765 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.25453229394141, -148.97484949184252, 68.2353656272741)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.030312656111, 68.23544774934933, -148.97494286142927, 68.25448400386779)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment16.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment16.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:27:30,881 - root - INFO: \n", + "2021-09-23 13:27:30,882 - root - INFO: Meshing\n", + "2021-09-23 13:27:30,883 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:30,883 - root - INFO: Triangulating...\n", + "2021-09-23 13:27:30,884 - root - INFO: 13 points and 13 facets\n", + "2021-09-23 13:27:30,885 - root - INFO: checking graph consistency\n", + "2021-09-23 13:27:30,885 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:27:30,886 - root - INFO: building graph data structures\n", + "2021-09-23 13:27:30,887 - root - INFO: triangle.build...\n", + "2021-09-23 13:27:31,228 - root - INFO: ...built: 19301 mesh points and 38159 triangles\n", + "2021-09-23 13:27:31,229 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:27:32,157 - root - INFO: min area = 33.711090087890625\n", + "2021-09-23 13:27:32,158 - root - INFO: max area = 199.98992919921875\n", + "2021-09-23 13:27:32,521 - root - INFO: \n", + "2021-09-23 13:27:32,522 - root - INFO: Loading Raster\n", + "2021-09-23 13:27:32,522 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:32,523 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:27:32,523 - root - INFO: Collecting raster\n", + "2021-09-23 13:27:32,568 - root - INFO: ... got raster of shape: (91, 264)\n", + "2021-09-23 13:27:32,577 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28092118283118, -148.94012726961913, 68.25564340505257)\n", + "2021-09-23 13:27:32,587 - root - INFO: \n", + "2021-09-23 13:27:32,588 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:27:32,588 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:32,758 - root - INFO: \n", + "2021-09-23 13:27:32,759 - root - INFO: Loading Raster\n", + "2021-09-23 13:27:32,760 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:32,760 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:27:32,761 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.01323342717478, 68.25590210213116, -148.9403544805741, 68.28066175352585)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:27:32,813 - root - INFO: ... got raster of shape: (91, 264)\n", + "2021-09-23 13:27:32,822 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28092118283118, -148.94012726961913, 68.25564340505257)\n", + "2021-09-23 13:27:32,929 - root - INFO: \n", + "2021-09-23 13:27:32,930 - root - INFO: Loading Raster\n", + "2021-09-23 13:27:32,930 - root - INFO: ------------------------------\n", + "2021-09-23 13:27:32,931 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:27:32,932 - root - INFO: Collecting raster\n", + "2021-09-23 13:27:32,975 - root - INFO: ... got raster of shape: (91, 264)\n", + "2021-09-23 13:27:32,984 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28092118283118, -148.94012726961913, 68.25564340505257)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.01323342717478, 68.25590210213116, -148.9403544805741, 68.28066175352585)\n", + "bounds in my_crs: (-149.01323342717478, 68.25590210213116, -148.9403544805741, 68.28066175352585)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment17.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment17.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:28:19,449 - root - INFO: \n", + "2021-09-23 13:28:19,450 - root - INFO: Meshing\n", + "2021-09-23 13:28:19,451 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:19,452 - root - INFO: Triangulating...\n", + "2021-09-23 13:28:19,452 - root - INFO: 11 points and 11 facets\n", + "2021-09-23 13:28:19,453 - root - INFO: checking graph consistency\n", + "2021-09-23 13:28:19,453 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:28:19,454 - root - INFO: building graph data structures\n", + "2021-09-23 13:28:19,454 - root - INFO: triangle.build...\n", + "2021-09-23 13:28:19,690 - root - INFO: ...built: 10157 mesh points and 19949 triangles\n", + "2021-09-23 13:28:19,691 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:28:20,197 - root - INFO: min area = 40.16156005859375\n", + "2021-09-23 13:28:20,197 - root - INFO: max area = 199.96157836914062\n", + "2021-09-23 13:28:20,414 - root - INFO: \n", + "2021-09-23 13:28:20,415 - root - INFO: Loading Raster\n", + "2021-09-23 13:28:20,415 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:20,416 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:28:20,416 - root - INFO: Collecting raster\n", + "2021-09-23 13:28:20,463 - root - INFO: ... got raster of shape: (100, 187)\n", + "2021-09-23 13:28:20,472 - root - INFO: ... got raster bounds: (-148.97568282517588, 68.27564340505322, -148.9237383807297, 68.24786562727452)\n", + "2021-09-23 13:28:20,481 - root - INFO: \n", + "2021-09-23 13:28:20,482 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:28:20,483 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:20,593 - root - INFO: \n", + "2021-09-23 13:28:20,594 - root - INFO: Loading Raster\n", + "2021-09-23 13:28:20,594 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:20,595 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:28:20,595 - root - INFO: Collecting raster\n", + "2021-09-23 13:28:20,640 - root - INFO: ... got raster of shape: (100, 187)\n", + "2021-09-23 13:28:20,649 - root - INFO: ... got raster bounds: (-148.97568282517588, 68.27564340505322, -148.9237383807297, 68.24786562727452)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.97544054998755, 68.24802136627605, -148.92374290221164, 68.2754465236705)\n", + "bounds in my_crs: (-148.97544054998755, 68.24802136627605, -148.92374290221164, 68.2754465236705)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:28:20,723 - root - INFO: \n", + "2021-09-23 13:28:20,723 - root - INFO: Loading Raster\n", + "2021-09-23 13:28:20,724 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:20,725 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:28:20,726 - root - INFO: Collecting raster\n", + "2021-09-23 13:28:20,773 - root - INFO: ... got raster of shape: (100, 187)\n", + "2021-09-23 13:28:20,781 - root - INFO: ... got raster bounds: (-148.97568282517588, 68.27564340505322, -148.9237383807297, 68.24786562727452)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.97544054998755, 68.24802136627605, -148.92374290221164, 68.2754465236705)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment18.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment18.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:28:45,494 - root - INFO: \n", + "2021-09-23 13:28:45,495 - root - INFO: Meshing\n", + "2021-09-23 13:28:45,496 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:45,496 - root - INFO: Triangulating...\n", + "2021-09-23 13:28:45,497 - root - INFO: 11 points and 11 facets\n", + "2021-09-23 13:28:45,497 - root - INFO: checking graph consistency\n", + "2021-09-23 13:28:45,498 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:28:45,498 - root - INFO: building graph data structures\n", + "2021-09-23 13:28:45,499 - root - INFO: triangle.build...\n", + "2021-09-23 13:28:45,749 - root - INFO: ...built: 13602 mesh points and 26815 triangles\n", + "2021-09-23 13:28:45,750 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:28:46,346 - root - INFO: min area = 62.41168212890625\n", + "2021-09-23 13:28:46,347 - root - INFO: max area = 199.99432373046875\n", + "2021-09-23 13:28:46,609 - root - INFO: \n", + "2021-09-23 13:28:46,611 - root - INFO: Loading Raster\n", + "2021-09-23 13:28:46,611 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:46,612 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:28:46,612 - root - INFO: Collecting raster\n", + "2021-09-23 13:28:46,659 - root - INFO: ... got raster of shape: (94, 200)\n", + "2021-09-23 13:28:46,667 - root - INFO: ... got raster bounds: (-148.95207171406398, 68.30231007172077, -148.89651615850659, 68.2761989606088)\n", + "2021-09-23 13:28:46,677 - root - INFO: \n", + "2021-09-23 13:28:46,678 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:28:46,678 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:46,809 - root - INFO: \n", + "2021-09-23 13:28:46,809 - root - INFO: Loading Raster\n", + "2021-09-23 13:28:46,810 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:46,811 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:28:46,812 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.95191254087308, 68.27643226672154, -148.89667548409713, 68.3020752808257)\n", + "bounds in my_crs: (-148.95191254087308, 68.27643226672154, -148.89667548409713, 68.3020752808257)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:28:46,857 - root - INFO: ... got raster of shape: (94, 200)\n", + "2021-09-23 13:28:46,866 - root - INFO: ... got raster bounds: (-148.95207171406398, 68.30231007172077, -148.89651615850659, 68.2761989606088)\n", + "2021-09-23 13:28:46,954 - root - INFO: \n", + "2021-09-23 13:28:46,955 - root - INFO: Loading Raster\n", + "2021-09-23 13:28:46,955 - root - INFO: ------------------------------\n", + "2021-09-23 13:28:46,956 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:28:46,957 - root - INFO: Collecting raster\n", + "2021-09-23 13:28:47,011 - root - INFO: ... got raster of shape: (94, 200)\n", + "2021-09-23 13:28:47,020 - root - INFO: ... got raster bounds: (-148.95207171406398, 68.30231007172077, -148.89651615850659, 68.2761989606088)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.95191254087308, 68.27643226672154, -148.89667548409713, 68.3020752808257)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment19.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment19.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:29:18,162 - root - INFO: \n", + "2021-09-23 13:29:18,163 - root - INFO: Meshing\n", + "2021-09-23 13:29:18,164 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:18,164 - root - INFO: Triangulating...\n", + "2021-09-23 13:29:18,165 - root - INFO: 12 points and 12 facets\n", + "2021-09-23 13:29:18,166 - root - INFO: checking graph consistency\n", + "2021-09-23 13:29:18,166 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:29:18,167 - root - INFO: building graph data structures\n", + "2021-09-23 13:29:18,167 - root - INFO: triangle.build...\n", + "2021-09-23 13:29:18,400 - root - INFO: ...built: 13447 mesh points and 26529 triangles\n", + "2021-09-23 13:29:18,401 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:29:18,958 - root - INFO: min area = 30.117584228515625\n", + "2021-09-23 13:29:18,960 - root - INFO: max area = 199.97067260742188\n", + "2021-09-23 13:29:19,221 - root - INFO: \n", + "2021-09-23 13:29:19,222 - root - INFO: Loading Raster\n", + "2021-09-23 13:29:19,222 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:19,223 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:29:19,224 - root - INFO: Collecting raster\n", + "2021-09-23 13:29:19,268 - root - INFO: ... got raster of shape: (100, 187)\n", + "2021-09-23 13:29:19,277 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29175451616487, -148.88818282517295, 68.26397673838618)\n", + "2021-09-23 13:29:19,285 - root - INFO: \n", + "2021-09-23 13:29:19,286 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:29:19,286 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:19,415 - root - INFO: \n", + "2021-09-23 13:29:19,416 - root - INFO: Loading Raster\n", + "2021-09-23 13:29:19,416 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:19,417 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:29:19,417 - root - INFO: Collecting raster\n", + "2021-09-23 13:29:19,457 - root - INFO: ... got raster of shape: (100, 187)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.93997970821187, 68.2642068923835, -148.88833346973985, 68.29151277341492)\n", + "bounds in my_crs: (-148.93997970821187, 68.2642068923835, -148.88833346973985, 68.29151277341492)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:29:19,466 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29175451616487, -148.88818282517295, 68.26397673838618)\n", + "2021-09-23 13:29:19,552 - root - INFO: \n", + "2021-09-23 13:29:19,553 - root - INFO: Loading Raster\n", + "2021-09-23 13:29:19,553 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:19,554 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:29:19,554 - root - INFO: Collecting raster\n", + "2021-09-23 13:29:19,596 - root - INFO: ... got raster of shape: (100, 187)\n", + "2021-09-23 13:29:19,603 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29175451616487, -148.88818282517295, 68.26397673838618)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.93997970821187, 68.2642068923835, -148.88833346973985, 68.29151277341492)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment20.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment20.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:29:50,329 - root - INFO: \n", + "2021-09-23 13:29:50,330 - root - INFO: Meshing\n", + "2021-09-23 13:29:50,331 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:50,332 - root - INFO: Triangulating...\n", + "2021-09-23 13:29:50,332 - root - INFO: 7 points and 7 facets\n", + "2021-09-23 13:29:50,332 - root - INFO: checking graph consistency\n", + "2021-09-23 13:29:50,333 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:29:50,334 - root - INFO: building graph data structures\n", + "2021-09-23 13:29:50,334 - root - INFO: triangle.build...\n", + "2021-09-23 13:29:50,508 - root - INFO: ...built: 6608 mesh points and 12970 triangles\n", + "2021-09-23 13:29:50,510 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:29:50,785 - root - INFO: min area = 43.099029541015625\n", + "2021-09-23 13:29:50,785 - root - INFO: max area = 199.95602416992188\n", + "/Users/3hg/opt/watershed_workflow/workflow/hilev.py:823: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n", + " plt.figure()\n", + "2021-09-23 13:29:50,945 - root - INFO: \n", + "2021-09-23 13:29:50,946 - root - INFO: Loading Raster\n", + "2021-09-23 13:29:50,946 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:50,947 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:29:50,948 - root - INFO: Collecting raster\n", + "2021-09-23 13:29:50,990 - root - INFO: ... got raster of shape: (76, 97)\n", + "2021-09-23 13:29:50,999 - root - INFO: ... got raster bounds: (-148.89734949183995, 68.2953656272761, -148.8704050473946, 68.27425451616429)\n", + "2021-09-23 13:29:51,008 - root - INFO: \n", + "2021-09-23 13:29:51,009 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:29:51,009 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:51,092 - root - INFO: \n", + "2021-09-23 13:29:51,093 - root - INFO: Loading Raster\n", + "2021-09-23 13:29:51,093 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:51,094 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:29:51,095 - root - INFO: Collecting raster\n", + "2021-09-23 13:29:51,135 - root - INFO: ... got raster of shape: (76, 97)\n", + "2021-09-23 13:29:51,145 - root - INFO: ... got raster bounds: (-148.89734949183995, 68.2953656272761, -148.8704050473946, 68.27425451616429)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.89718738747706, 68.2742911759621, -148.87057232368306, 68.29525279044076)\n", + "bounds in my_crs: (-148.89718738747706, 68.2742911759621, -148.87057232368306, 68.29525279044076)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:29:51,206 - root - INFO: \n", + "2021-09-23 13:29:51,207 - root - INFO: Loading Raster\n", + "2021-09-23 13:29:51,207 - root - INFO: ------------------------------\n", + "2021-09-23 13:29:51,207 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:29:51,208 - root - INFO: Collecting raster\n", + "2021-09-23 13:29:51,248 - root - INFO: ... got raster of shape: (76, 97)\n", + "2021-09-23 13:29:51,256 - root - INFO: ... got raster bounds: (-148.89734949183995, 68.2953656272761, -148.8704050473946, 68.27425451616429)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.89718738747706, 68.2742911759621, -148.87057232368306, 68.29525279044076)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment21.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment21.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:30:06,124 - root - INFO: \n", + "2021-09-23 13:30:06,125 - root - INFO: Meshing\n", + "2021-09-23 13:30:06,125 - root - INFO: ------------------------------\n", + "2021-09-23 13:30:06,126 - root - INFO: Triangulating...\n", + "2021-09-23 13:30:06,127 - root - INFO: 7 points and 7 facets\n", + "2021-09-23 13:30:06,127 - root - INFO: checking graph consistency\n", + "2021-09-23 13:30:06,128 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:30:06,128 - root - INFO: building graph data structures\n", + "2021-09-23 13:30:06,129 - root - INFO: triangle.build...\n", + "2021-09-23 13:30:06,187 - root - INFO: ...built: 2742 mesh points and 5329 triangles\n", + "2021-09-23 13:30:06,192 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:30:06,317 - root - INFO: min area = 70.24395751953125\n", + "2021-09-23 13:30:06,318 - root - INFO: max area = 199.92208862304688\n", + "2021-09-23 13:30:06,405 - root - INFO: \n", + "2021-09-23 13:30:06,405 - root - INFO: Loading Raster\n", + "2021-09-23 13:30:06,406 - root - INFO: ------------------------------\n", + "2021-09-23 13:30:06,406 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:30:06,407 - root - INFO: Collecting raster\n", + "2021-09-23 13:30:06,447 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-23 13:30:06,456 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", + "2021-09-23 13:30:06,464 - root - INFO: \n", + "2021-09-23 13:30:06,465 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:30:06,465 - root - INFO: ------------------------------\n", + "2021-09-23 13:30:06,523 - root - INFO: \n", + "2021-09-23 13:30:06,523 - root - INFO: Loading Raster\n", + "2021-09-23 13:30:06,524 - root - INFO: ------------------------------\n", + "2021-09-23 13:30:06,524 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:30:06,525 - root - INFO: Collecting raster\n", + "2021-09-23 13:30:06,564 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-23 13:30:06,573 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", + "2021-09-23 13:30:06,621 - root - INFO: \n", + "2021-09-23 13:30:06,622 - root - INFO: Loading Raster\n", + "2021-09-23 13:30:06,622 - root - INFO: ------------------------------\n", + "2021-09-23 13:30:06,623 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:30:06,624 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.910918589009, 68.29176938492151, -148.88725686690233, 68.30146371124668)\n", + "bounds in my_crs: (-148.910918589009, 68.29176938492151, -148.88725686690233, 68.30146371124668)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:30:06,663 - root - INFO: ... got raster of shape: (35, 86)\n", + "2021-09-23 13:30:06,672 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.910918589009, 68.29176938492151, -148.88725686690233, 68.30146371124668)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment22.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:30:13,043 - root - INFO: \n", + "2021-09-23 13:30:13,044 - root - INFO: Meshing\n", + "2021-09-23 13:30:13,045 - root - INFO: ------------------------------\n", + "2021-09-23 13:30:13,045 - root - INFO: Triangulating...\n", + "2021-09-23 13:30:13,046 - root - INFO: 11 points and 11 facets\n", + "2021-09-23 13:30:13,047 - root - INFO: checking graph consistency\n", + "2021-09-23 13:30:13,047 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:30:13,048 - root - INFO: building graph data structures\n", + "2021-09-23 13:30:13,049 - root - INFO: triangle.build...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment22.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:30:13,560 - root - INFO: ...built: 25109 mesh points and 49729 triangles\n", + "2021-09-23 13:30:13,561 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:30:14,626 - root - INFO: min area = 33.818603515625\n", + "2021-09-23 13:30:14,627 - root - INFO: max area = 199.98837280273438\n", + "2021-09-23 13:30:15,098 - root - INFO: \n", + "2021-09-23 13:30:15,099 - root - INFO: Loading Raster\n", + "2021-09-23 13:30:15,100 - root - INFO: ------------------------------\n", + "2021-09-23 13:30:15,100 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:30:15,101 - root - INFO: Collecting raster\n", + "2021-09-23 13:30:15,147 - root - INFO: ... got raster of shape: (118, 299)\n", + "2021-09-23 13:30:15,156 - root - INFO: ... got raster bounds: (-148.8854050473951, 68.3123100717211, -148.8023494918368, 68.27953229394224)\n", + "2021-09-23 13:30:15,166 - root - INFO: \n", + "2021-09-23 13:30:15,167 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:30:15,167 - root - INFO: ------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.88521273906292, 68.27969771246877, -148.8025928025057, 68.31223501391474)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:30:15,377 - root - INFO: \n", + "2021-09-23 13:30:15,377 - root - INFO: Loading Raster\n", + "2021-09-23 13:30:15,378 - root - INFO: ------------------------------\n", + "2021-09-23 13:30:15,378 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:30:15,379 - root - INFO: Collecting raster\n", + "2021-09-23 13:30:15,422 - root - INFO: ... got raster of shape: (118, 299)\n", + "2021-09-23 13:30:15,431 - root - INFO: ... got raster bounds: (-148.8854050473951, 68.3123100717211, -148.8023494918368, 68.27953229394224)\n", + "2021-09-23 13:30:15,558 - root - INFO: \n", + "2021-09-23 13:30:15,559 - root - INFO: Loading Raster\n", + "2021-09-23 13:30:15,559 - root - INFO: ------------------------------\n", + "2021-09-23 13:30:15,560 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:30:15,561 - root - INFO: Collecting raster\n", + "2021-09-23 13:30:15,604 - root - INFO: ... got raster of shape: (118, 299)\n", + "2021-09-23 13:30:15,612 - root - INFO: ... got raster bounds: (-148.8854050473951, 68.3123100717211, -148.8023494918368, 68.27953229394224)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.88521273906292, 68.27969771246877, -148.8025928025057, 68.31223501391474)\n", + "bounds in my_crs: (-148.88521273906292, 68.27969771246877, -148.8025928025057, 68.31223501391474)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment23.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment23.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:31:12,622 - root - INFO: \n", + "2021-09-23 13:31:12,623 - root - INFO: Meshing\n", + "2021-09-23 13:31:12,623 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:12,624 - root - INFO: Triangulating...\n", + "2021-09-23 13:31:12,625 - root - INFO: 12 points and 12 facets\n", + "2021-09-23 13:31:12,625 - root - INFO: checking graph consistency\n", + "2021-09-23 13:31:12,626 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:31:12,627 - root - INFO: building graph data structures\n", + "2021-09-23 13:31:12,627 - root - INFO: triangle.build...\n", + "2021-09-23 13:31:12,810 - root - INFO: ...built: 8381 mesh points and 16425 triangles\n", + "2021-09-23 13:31:12,812 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:31:13,170 - root - INFO: min area = 57.891387939453125\n", + "2021-09-23 13:31:13,170 - root - INFO: max area = 199.97000122070312\n", + "2021-09-23 13:31:13,346 - root - INFO: \n", + "2021-09-23 13:31:13,347 - root - INFO: Loading Raster\n", + "2021-09-23 13:31:13,347 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:13,348 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:31:13,348 - root - INFO: Collecting raster\n", + "2021-09-23 13:31:13,396 - root - INFO: ... got raster of shape: (69, 198)\n", + "2021-09-23 13:31:13,404 - root - INFO: ... got raster bounds: (-148.89068282517306, 68.31536562727676, -148.83568282517123, 68.29619896060946)\n", + "2021-09-23 13:31:13,414 - root - INFO: \n", + "2021-09-23 13:31:13,415 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:31:13,415 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:13,511 - root - INFO: \n", + "2021-09-23 13:31:13,512 - root - INFO: Loading Raster\n", + "2021-09-23 13:31:13,512 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:13,513 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:31:13,513 - root - INFO: Collecting raster\n", + "2021-09-23 13:31:13,558 - root - INFO: ... got raster of shape: (69, 198)\n", + "2021-09-23 13:31:13,566 - root - INFO: ... got raster bounds: (-148.89068282517306, 68.31536562727676, -148.83568282517123, 68.29619896060946)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.89050828534556, 68.29630970675676, -148.83569652200882, 68.31529633597262)\n", + "bounds in my_crs: (-148.89050828534556, 68.29630970675676, -148.83569652200882, 68.31529633597262)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:31:13,634 - root - INFO: \n", + "2021-09-23 13:31:13,635 - root - INFO: Loading Raster\n", + "2021-09-23 13:31:13,635 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:13,635 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:31:13,636 - root - INFO: Collecting raster\n", + "2021-09-23 13:31:13,680 - root - INFO: ... got raster of shape: (69, 198)\n", + "2021-09-23 13:31:13,689 - root - INFO: ... got raster bounds: (-148.89068282517306, 68.31536562727676, -148.83568282517123, 68.29619896060946)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.89050828534556, 68.29630970675676, -148.83569652200882, 68.31529633597262)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment24.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment24.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:31:32,748 - root - INFO: \n", + "2021-09-23 13:31:32,749 - root - INFO: Meshing\n", + "2021-09-23 13:31:32,749 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:32,750 - root - INFO: Triangulating...\n", + "2021-09-23 13:31:32,751 - root - INFO: 14 points and 14 facets\n", + "2021-09-23 13:31:32,751 - root - INFO: checking graph consistency\n", + "2021-09-23 13:31:32,752 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:31:32,752 - root - INFO: building graph data structures\n", + "2021-09-23 13:31:32,753 - root - INFO: triangle.build...\n", + "2021-09-23 13:31:33,082 - root - INFO: ...built: 17656 mesh points and 34733 triangles\n", + "2021-09-23 13:31:33,083 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:31:33,812 - root - INFO: min area = 45.799346923828125\n", + "2021-09-23 13:31:33,813 - root - INFO: max area = 199.99880981445312\n", + "2021-09-23 13:31:34,144 - root - INFO: \n", + "2021-09-23 13:31:34,145 - root - INFO: Loading Raster\n", + "2021-09-23 13:31:34,146 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:34,146 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:31:34,147 - root - INFO: Collecting raster\n", + "2021-09-23 13:31:34,194 - root - INFO: ... got raster of shape: (122, 323)\n", + "2021-09-23 13:31:34,204 - root - INFO: ... got raster bounds: (-149.20234949185007, 68.26036562727494, -149.11262726962488, 68.22647673838492)\n", + "2021-09-23 13:31:34,214 - root - INFO: \n", + "2021-09-23 13:31:34,215 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:31:34,215 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:34,373 - root - INFO: \n", + "2021-09-23 13:31:34,374 - root - INFO: Loading Raster\n", + "2021-09-23 13:31:34,374 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:34,375 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:31:34,376 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.2023114423899, 68.22649059997109, -149.11282179624425, 68.26026451666776)\n", + "bounds in my_crs: (-149.2023114423899, 68.22649059997109, -149.11282179624425, 68.26026451666776)" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:31:34,429 - root - INFO: ... got raster of shape: (122, 323)\n", + "2021-09-23 13:31:34,439 - root - INFO: ... got raster bounds: (-149.20234949185007, 68.26036562727494, -149.11262726962488, 68.22647673838492)\n", + "2021-09-23 13:31:34,544 - root - INFO: \n", + "2021-09-23 13:31:34,545 - root - INFO: Loading Raster\n", + "2021-09-23 13:31:34,546 - root - INFO: ------------------------------\n", + "2021-09-23 13:31:34,546 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:31:34,547 - root - INFO: Collecting raster\n", + "2021-09-23 13:31:34,591 - root - INFO: ... got raster of shape: (122, 323)\n", + "2021-09-23 13:31:34,601 - root - INFO: ... got raster bounds: (-149.20234949185007, 68.26036562727494, -149.11262726962488, 68.22647673838492)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "bounds in my_crs: (-149.2023114423899, 68.22649059997109, -149.11282179624425, 68.26026451666776)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment25.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment25.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:32:15,189 - root - INFO: \n", + "2021-09-23 13:32:15,190 - root - INFO: Meshing\n", + "2021-09-23 13:32:15,190 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:15,191 - root - INFO: Triangulating...\n", + "2021-09-23 13:32:15,192 - root - INFO: 16 points and 16 facets\n", + "2021-09-23 13:32:15,193 - root - INFO: checking graph consistency\n", + "2021-09-23 13:32:15,193 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:32:15,194 - root - INFO: building graph data structures\n", + "2021-09-23 13:32:15,194 - root - INFO: triangle.build...\n", + "2021-09-23 13:32:15,416 - root - INFO: ...built: 12325 mesh points and 24185 triangles\n", + "2021-09-23 13:32:15,416 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:32:15,931 - root - INFO: min area = 54.143829345703125\n", + "2021-09-23 13:32:15,932 - root - INFO: max area = 199.97232055664062\n", + "2021-09-23 13:32:16,166 - root - INFO: \n", + "2021-09-23 13:32:16,167 - root - INFO: Loading Raster\n", + "2021-09-23 13:32:16,167 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:16,168 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:32:16,169 - root - INFO: Collecting raster\n", + "2021-09-23 13:32:16,214 - root - INFO: ... got raster of shape: (91, 304)\n", + "2021-09-23 13:32:16,223 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.25425451616363, -149.11846060295838, 68.22897673838501)\n", + "2021-09-23 13:32:16,233 - root - INFO: \n", + "2021-09-23 13:32:16,234 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:32:16,234 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:16,355 - root - INFO: \n", + "2021-09-23 13:32:16,356 - root - INFO: Loading Raster\n", + "2021-09-23 13:32:16,357 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:16,357 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:32:16,358 - root - INFO: Collecting raster\n", + "2021-09-23 13:32:16,398 - root - INFO: ... got raster of shape: (91, 304)\n", + "2021-09-23 13:32:16,406 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.25425451616363, -149.11846060295838, 68.22897673838501)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.2027125613783, 68.22906514462669, -149.11872166444675, 68.25409188894433)\n", + "bounds in my_crs: (-149.2027125613783, 68.22906514462669, -149.11872166444675, 68.25409188894433)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:32:16,487 - root - INFO: \n", + "2021-09-23 13:32:16,488 - root - INFO: Loading Raster\n", + "2021-09-23 13:32:16,489 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:16,489 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:32:16,490 - root - INFO: Collecting raster\n", + "2021-09-23 13:32:16,532 - root - INFO: ... got raster of shape: (91, 304)\n", + "2021-09-23 13:32:16,541 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.25425451616363, -149.11846060295838, 68.22897673838501)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.2027125613783, 68.22906514462669, -149.11872166444675, 68.25409188894433)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment26.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment26.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:32:43,976 - root - INFO: \n", + "2021-09-23 13:32:43,977 - root - INFO: Meshing\n", + "2021-09-23 13:32:43,978 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:43,978 - root - INFO: Triangulating...\n", + "2021-09-23 13:32:43,979 - root - INFO: 15 points and 15 facets\n", + "2021-09-23 13:32:43,980 - root - INFO: checking graph consistency\n", + "2021-09-23 13:32:43,980 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:32:43,981 - root - INFO: building graph data structures\n", + "2021-09-23 13:32:43,982 - root - INFO: triangle.build...\n", + "2021-09-23 13:32:44,317 - root - INFO: ...built: 17860 mesh points and 35224 triangles\n", + "2021-09-23 13:32:44,318 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:32:45,076 - root - INFO: min area = 49.17083740234375\n", + "2021-09-23 13:32:45,077 - root - INFO: max area = 199.99969482421875\n", + "2021-09-23 13:32:45,399 - root - INFO: \n", + "2021-09-23 13:32:45,400 - root - INFO: Loading Raster\n", + "2021-09-23 13:32:45,400 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:45,400 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:32:45,401 - root - INFO: Collecting raster\n", + "2021-09-23 13:32:45,444 - root - INFO: ... got raster of shape: (67, 366)\n", + "2021-09-23 13:32:45,452 - root - INFO: ... got raster bounds: (-149.04318282517812, 68.32619896061045, -148.94151615850808, 68.30758784949873)\n", + "2021-09-23 13:32:45,462 - root - INFO: \n", + "2021-09-23 13:32:45,462 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:32:45,463 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:45,619 - root - INFO: \n", + "2021-09-23 13:32:45,620 - root - INFO: Loading Raster\n", + "2021-09-23 13:32:45,621 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:45,621 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:32:45,622 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.04318244732482, 68.3075879275871, -148.9415163590378, 68.32619886093677)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:32:45,664 - root - INFO: ... got raster of shape: (67, 366)\n", + "2021-09-23 13:32:45,673 - root - INFO: ... got raster bounds: (-149.04318282517812, 68.32619896061045, -148.94151615850808, 68.30758784949873)\n", + "2021-09-23 13:32:45,776 - root - INFO: \n", + "2021-09-23 13:32:45,777 - root - INFO: Loading Raster\n", + "2021-09-23 13:32:45,778 - root - INFO: ------------------------------\n", + "2021-09-23 13:32:45,778 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:32:45,779 - root - INFO: Collecting raster\n", + "2021-09-23 13:32:45,823 - root - INFO: ... got raster of shape: (67, 366)\n", + "2021-09-23 13:32:45,832 - root - INFO: ... got raster bounds: (-149.04318282517812, 68.32619896061045, -148.94151615850808, 68.30758784949873)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.04318244732482, 68.3075879275871, -148.9415163590378, 68.32619886093677)\n", + "bounds in my_crs: (-149.04318244732482, 68.3075879275871, -148.9415163590378, 68.32619886093677)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment27.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment27.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:33:25,933 - root - INFO: \n", + "2021-09-23 13:33:25,934 - root - INFO: Meshing\n", + "2021-09-23 13:33:25,934 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:25,935 - root - INFO: Triangulating...\n", + "2021-09-23 13:33:25,936 - root - INFO: 16 points and 16 facets\n", + "2021-09-23 13:33:25,936 - root - INFO: checking graph consistency\n", + "2021-09-23 13:33:25,937 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:33:25,937 - root - INFO: building graph data structures\n", + "2021-09-23 13:33:25,938 - root - INFO: triangle.build...\n", + "2021-09-23 13:33:26,129 - root - INFO: ...built: 10247 mesh points and 20021 triangles\n", + "2021-09-23 13:33:26,131 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:33:26,559 - root - INFO: min area = 32.547149658203125\n", + "2021-09-23 13:33:26,560 - root - INFO: max area = 199.9788818359375\n", + "2021-09-23 13:33:26,759 - root - INFO: \n", + "2021-09-23 13:33:26,760 - root - INFO: Loading Raster\n", + "2021-09-23 13:33:26,761 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:26,761 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:33:26,762 - root - INFO: Collecting raster\n", + "2021-09-23 13:33:26,806 - root - INFO: ... got raster of shape: (54, 366)\n", + "2021-09-23 13:33:26,816 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94179393628585, 68.29786562727618)\n", + "2021-09-23 13:33:26,826 - root - INFO: \n", + "2021-09-23 13:33:26,826 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:33:26,827 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:26,932 - root - INFO: \n", + "2021-09-23 13:33:26,933 - root - INFO: Loading Raster\n", + "2021-09-23 13:33:26,934 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:26,934 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:33:26,935 - root - INFO: Collecting raster\n", + "2021-09-23 13:33:26,976 - root - INFO: ... got raster of shape: (54, 366)\n", + "2021-09-23 13:33:26,984 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94179393628585, 68.29786562727618)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.04326109267967, 68.29809678948162, -148.9420293378915, 68.31282624167491)\n", + "bounds in my_crs: (-149.04326109267967, 68.29809678948162, -148.9420293378915, 68.31282624167491)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:33:27,060 - root - INFO: \n", + "2021-09-23 13:33:27,061 - root - INFO: Loading Raster\n", + "2021-09-23 13:33:27,061 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:27,062 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:33:27,063 - root - INFO: Collecting raster\n", + "2021-09-23 13:33:27,105 - root - INFO: ... got raster of shape: (54, 366)\n", + "2021-09-23 13:33:27,115 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94179393628585, 68.29786562727618)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.04326109267967, 68.29809678948162, -148.9420293378915, 68.31282624167491)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment28.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment28.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:33:49,630 - root - INFO: \n", + "2021-09-23 13:33:49,631 - root - INFO: Meshing\n", + "2021-09-23 13:33:49,632 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:49,632 - root - INFO: Triangulating...\n", + "2021-09-23 13:33:49,633 - root - INFO: 10 points and 10 facets\n", + "2021-09-23 13:33:49,634 - root - INFO: checking graph consistency\n", + "2021-09-23 13:33:49,634 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:33:49,635 - root - INFO: building graph data structures\n", + "2021-09-23 13:33:49,635 - root - INFO: triangle.build...\n", + "2021-09-23 13:33:49,862 - root - INFO: ...built: 11915 mesh points and 23383 triangles\n", + "2021-09-23 13:33:49,863 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:33:50,360 - root - INFO: min area = 23.0093994140625\n", + "2021-09-23 13:33:50,361 - root - INFO: max area = 199.97549438476562\n", + "2021-09-23 13:33:50,590 - root - INFO: \n", + "2021-09-23 13:33:50,591 - root - INFO: Loading Raster\n", + "2021-09-23 13:33:50,592 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:50,592 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:33:50,593 - root - INFO: Collecting raster\n", + "2021-09-23 13:33:50,638 - root - INFO: ... got raster of shape: (112, 205)\n", + "2021-09-23 13:33:50,647 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.8848494918395, 68.29258784949823)\n", + "2021-09-23 13:33:50,656 - root - INFO: \n", + "2021-09-23 13:33:50,657 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:33:50,658 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:50,778 - root - INFO: \n", + "2021-09-23 13:33:50,779 - root - INFO: Loading Raster\n", + "2021-09-23 13:33:50,779 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:50,780 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:33:50,780 - root - INFO: Collecting raster\n", + "2021-09-23 13:33:50,823 - root - INFO: ... got raster of shape: (112, 205)\n", + "2021-09-23 13:33:50,833 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.8848494918395, 68.29258784949823)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.94155418719984, 68.29263214767145, -148.8849378668285, 68.32350695237726)\n", + "bounds in my_crs: (-148.94155418719984, 68.29263214767145, -148.8849378668285, 68.32350695237726)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:33:50,928 - root - INFO: \n", + "2021-09-23 13:33:50,929 - root - INFO: Loading Raster\n", + "2021-09-23 13:33:50,929 - root - INFO: ------------------------------\n", + "2021-09-23 13:33:50,930 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:33:50,930 - root - INFO: Collecting raster\n", + "2021-09-23 13:33:50,973 - root - INFO: ... got raster of shape: (112, 205)\n", + "2021-09-23 13:33:50,982 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.8848494918395, 68.29258784949823)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.94155418719984, 68.29263214767145, -148.8849378668285, 68.32350695237726)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment29.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment29.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:34:17,858 - root - INFO: \n", + "2021-09-23 13:34:17,859 - root - INFO: Meshing\n", + "2021-09-23 13:34:17,860 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:17,860 - root - INFO: Triangulating...\n", + "2021-09-23 13:34:17,861 - root - INFO: 8 points and 8 facets\n", + "2021-09-23 13:34:17,862 - root - INFO: checking graph consistency\n", + "2021-09-23 13:34:17,862 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:34:17,863 - root - INFO: building graph data structures\n", + "2021-09-23 13:34:17,863 - root - INFO: triangle.build...\n", + "2021-09-23 13:34:17,967 - root - INFO: ...built: 5451 mesh points and 10614 triangles\n", + "2021-09-23 13:34:17,969 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:34:18,210 - root - INFO: min area = 62.992156982421875\n", + "2021-09-23 13:34:18,211 - root - INFO: max area = 199.96957397460938\n", + "2021-09-23 13:34:18,339 - root - INFO: \n", + "2021-09-23 13:34:18,340 - root - INFO: Loading Raster\n", + "2021-09-23 13:34:18,340 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:18,341 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:34:18,342 - root - INFO: Collecting raster\n", + "2021-09-23 13:34:18,383 - root - INFO: ... got raster of shape: (49, 194)\n", + "2021-09-23 13:34:18,392 - root - INFO: ... got raster bounds: (-148.9431828251748, 68.30953229394324, -148.88929393628413, 68.29592118283168)\n", + "2021-09-23 13:34:18,401 - root - INFO: \n", + "2021-09-23 13:34:18,402 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:34:18,402 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:18,479 - root - INFO: \n", + "2021-09-23 13:34:18,480 - root - INFO: Loading Raster\n", + "2021-09-23 13:34:18,481 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:18,481 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:34:18,482 - root - INFO: Collecting raster\n", + "2021-09-23 13:34:18,522 - root - INFO: ... got raster of shape: (49, 194)\n", + "2021-09-23 13:34:18,531 - root - INFO: ... got raster bounds: (-148.9431828251748, 68.30953229394324, -148.88929393628413, 68.29592118283168)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.9429899607772, 68.29616867587684, -148.88945611412026, 68.3092619420527)\n", + "bounds in my_crs: (-148.9429899607772, 68.29616867587684, -148.88945611412026, 68.3092619420527)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:34:18,590 - root - INFO: \n", + "2021-09-23 13:34:18,591 - root - INFO: Loading Raster\n", + "2021-09-23 13:34:18,591 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:18,592 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:34:18,592 - root - INFO: Collecting raster\n", + "2021-09-23 13:34:18,633 - root - INFO: ... got raster of shape: (49, 194)\n", + "2021-09-23 13:34:18,641 - root - INFO: ... got raster bounds: (-148.9431828251748, 68.30953229394324, -148.88929393628413, 68.29592118283168)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.9429899607772, 68.29616867587684, -148.88945611412026, 68.3092619420527)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment30.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment30.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:34:30,436 - root - INFO: \n", + "2021-09-23 13:34:30,437 - root - INFO: Meshing\n", + "2021-09-23 13:34:30,437 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:30,438 - root - INFO: Triangulating...\n", + "2021-09-23 13:34:30,438 - root - INFO: 11 points and 11 facets\n", + "2021-09-23 13:34:30,439 - root - INFO: checking graph consistency\n", + "2021-09-23 13:34:30,439 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:34:30,440 - root - INFO: building graph data structures\n", + "2021-09-23 13:34:30,441 - root - INFO: triangle.build...\n", + "2021-09-23 13:34:30,735 - root - INFO: ...built: 15583 mesh points and 30785 triangles\n", + "2021-09-23 13:34:30,736 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:34:31,424 - root - INFO: min area = 26.471435546875\n", + "2021-09-23 13:34:31,425 - root - INFO: max area = 199.99542236328125\n", + "2021-09-23 13:34:31,736 - root - INFO: \n", + "2021-09-23 13:34:31,736 - root - INFO: Loading Raster\n", + "2021-09-23 13:34:31,737 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:31,738 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:34:31,739 - root - INFO: Collecting raster\n", + "2021-09-23 13:34:31,782 - root - INFO: ... got raster of shape: (65, 294)\n", + "2021-09-23 13:34:31,791 - root - INFO: ... got raster bounds: (-149.0823494918461, 68.2995322939429, -149.0006828251767, 68.28147673838674)\n", + "2021-09-23 13:34:31,801 - root - INFO: \n", + "2021-09-23 13:34:31,802 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:34:31,802 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:31,949 - root - INFO: \n", + "2021-09-23 13:34:31,950 - root - INFO: Loading Raster\n", + "2021-09-23 13:34:31,950 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:31,951 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:34:31,952 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.0822999104471, 68.28165869208681, -149.000694989483, 68.29927283191988)\n", + "bounds in my_crs: (-149.0822999104471, 68.28165869208681, -149.000694989483, 68.29927283191988)" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:34:31,998 - root - INFO: ... got raster of shape: (65, 294)\n", + "2021-09-23 13:34:32,007 - root - INFO: ... got raster bounds: (-149.0823494918461, 68.2995322939429, -149.0006828251767, 68.28147673838674)\n", + "2021-09-23 13:34:32,108 - root - INFO: \n", + "2021-09-23 13:34:32,109 - root - INFO: Loading Raster\n", + "2021-09-23 13:34:32,109 - root - INFO: ------------------------------\n", + "2021-09-23 13:34:32,109 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:34:32,110 - root - INFO: Collecting raster\n", + "2021-09-23 13:34:32,151 - root - INFO: ... got raster of shape: (65, 294)\n", + "2021-09-23 13:34:32,160 - root - INFO: ... got raster bounds: (-149.0823494918461, 68.2995322939429, -149.0006828251767, 68.28147673838674)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "bounds in my_crs: (-149.0822999104471, 68.28165869208681, -149.000694989483, 68.29927283191988)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment31.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment31.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:35:07,609 - root - INFO: \n", + "2021-09-23 13:35:07,610 - root - INFO: Meshing\n", + "2021-09-23 13:35:07,610 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:07,611 - root - INFO: Triangulating...\n", + "2021-09-23 13:35:07,612 - root - INFO: 11 points and 11 facets\n", + "2021-09-23 13:35:07,612 - root - INFO: checking graph consistency\n", + "2021-09-23 13:35:07,613 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:35:07,613 - root - INFO: building graph data structures\n", + "2021-09-23 13:35:07,614 - root - INFO: triangle.build...\n", + "2021-09-23 13:35:07,844 - root - INFO: ...built: 12043 mesh points and 23643 triangles\n", + "2021-09-23 13:35:07,845 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:35:08,350 - root - INFO: min area = 64.85797119140625\n", + "2021-09-23 13:35:08,351 - root - INFO: max area = 199.99276733398438\n", + "2021-09-23 13:35:08,578 - root - INFO: \n", + "2021-09-23 13:35:08,579 - root - INFO: Loading Raster\n", + "2021-09-23 13:35:08,580 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:08,580 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:35:08,581 - root - INFO: Collecting raster\n", + "2021-09-23 13:35:08,624 - root - INFO: ... got raster of shape: (75, 293)\n", + "2021-09-23 13:35:08,633 - root - INFO: ... got raster bounds: (-149.079849491846, 68.3123100717211, -148.99846060295442, 68.29147673838708)\n", + "2021-09-23 13:35:08,642 - root - INFO: \n", + "2021-09-23 13:35:08,643 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:35:08,643 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:08,763 - root - INFO: \n", + "2021-09-23 13:35:08,764 - root - INFO: Loading Raster\n", + "2021-09-23 13:35:08,764 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:08,765 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:35:08,766 - root - INFO: Collecting raster\n", + "2021-09-23 13:35:08,806 - root - INFO: ... got raster of shape: (75, 293)\n", + "2021-09-23 13:35:08,815 - root - INFO: ... got raster bounds: (-149.079849491846, 68.3123100717211, -148.99846060295442, 68.29147673838708)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.07981036634234, 68.29168072407305, -148.99867185565884, 68.31220554044705)\n", + "bounds in my_crs: (-149.07981036634234, 68.29168072407305, -148.99867185565884, 68.31220554044705)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:35:08,898 - root - INFO: \n", + "2021-09-23 13:35:08,899 - root - INFO: Loading Raster\n", + "2021-09-23 13:35:08,899 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:08,900 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:35:08,901 - root - INFO: Collecting raster\n", + "2021-09-23 13:35:08,940 - root - INFO: ... got raster of shape: (75, 293)\n", + "2021-09-23 13:35:08,948 - root - INFO: ... got raster bounds: (-149.079849491846, 68.3123100717211, -148.99846060295442, 68.29147673838708)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.07981036634234, 68.29168072407305, -148.99867185565884, 68.31220554044705)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment32.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment32.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:35:35,463 - root - INFO: \n", + "2021-09-23 13:35:35,464 - root - INFO: Meshing\n", + "2021-09-23 13:35:35,465 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:35,465 - root - INFO: Triangulating...\n", + "2021-09-23 13:35:35,466 - root - INFO: 18 points and 18 facets\n", + "2021-09-23 13:35:35,466 - root - INFO: checking graph consistency\n", + "2021-09-23 13:35:35,467 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:35:35,468 - root - INFO: building graph data structures\n", + "2021-09-23 13:35:35,468 - root - INFO: triangle.build...\n", + "2021-09-23 13:35:35,764 - root - INFO: ...built: 16988 mesh points and 33461 triangles\n", + "2021-09-23 13:35:35,765 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:35:36,451 - root - INFO: min area = 37.18145751953125\n", + "2021-09-23 13:35:36,452 - root - INFO: max area = 199.98504638671875\n", + "2021-09-23 13:35:36,766 - root - INFO: \n", + "2021-09-23 13:35:36,766 - root - INFO: Loading Raster\n", + "2021-09-23 13:35:36,767 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:36,767 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:35:36,768 - root - INFO: Collecting raster\n", + "2021-09-23 13:35:36,814 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-23 13:35:36,822 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-23 13:35:36,831 - root - INFO: \n", + "2021-09-23 13:35:36,832 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:35:36,833 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:36,987 - root - INFO: \n", + "2021-09-23 13:35:36,987 - root - INFO: Loading Raster\n", + "2021-09-23 13:35:36,988 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:36,989 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:35:36,989 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.0345521774872, 68.27509463587238, -148.9401525596163, 68.29702461236208)\n", + "bounds in my_crs: (-149.0345521774872, 68.27509463587238, -148.9401525596163, 68.29702461236208)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:35:37,029 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-23 13:35:37,039 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", + "2021-09-23 13:35:37,143 - root - INFO: \n", + "2021-09-23 13:35:37,143 - root - INFO: Loading Raster\n", + "2021-09-23 13:35:37,144 - root - INFO: ------------------------------\n", + "2021-09-23 13:35:37,144 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:35:37,145 - root - INFO: Collecting raster\n", + "2021-09-23 13:35:37,186 - root - INFO: ... got raster of shape: (79, 340)\n", + "2021-09-23 13:35:37,194 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.0345521774872, 68.27509463587238, -148.9401525596163, 68.29702461236208)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment33.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment33.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:36:15,458 - root - INFO: \n", + "2021-09-23 13:36:15,459 - root - INFO: Meshing\n", + "2021-09-23 13:36:15,459 - root - INFO: ------------------------------\n", + "2021-09-23 13:36:15,460 - root - INFO: Triangulating...\n", + "2021-09-23 13:36:15,460 - root - INFO: 10 points and 10 facets\n", + "2021-09-23 13:36:15,461 - root - INFO: checking graph consistency\n", + "2021-09-23 13:36:15,461 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:36:15,462 - root - INFO: building graph data structures\n", + "2021-09-23 13:36:15,462 - root - INFO: triangle.build...\n", + "2021-09-23 13:36:15,699 - root - INFO: ...built: 13474 mesh points and 26516 triangles\n", + "2021-09-23 13:36:15,700 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:36:16,255 - root - INFO: min area = 40.51702880859375\n", + "2021-09-23 13:36:16,255 - root - INFO: max area = 199.99880981445312\n", + "2021-09-23 13:36:16,517 - root - INFO: \n", + "2021-09-23 13:36:16,517 - root - INFO: Loading Raster\n", + "2021-09-23 13:36:16,518 - root - INFO: ------------------------------\n", + "2021-09-23 13:36:16,519 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:36:16,519 - root - INFO: Collecting raster\n", + "2021-09-23 13:36:16,564 - root - INFO: ... got raster of shape: (104, 209)\n", + "2021-09-23 13:36:16,573 - root - INFO: ... got raster bounds: (-148.99818282517663, 68.30619896060979, -148.94012726961915, 68.27731007171994)\n", + "2021-09-23 13:36:16,581 - root - INFO: \n", + "2021-09-23 13:36:16,581 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:36:16,582 - root - INFO: ------------------------------\n", + "2021-09-23 13:36:16,710 - root - INFO: \n", + "2021-09-23 13:36:16,711 - root - INFO: Loading Raster\n", + "2021-09-23 13:36:16,712 - root - INFO: ------------------------------\n", + "2021-09-23 13:36:16,713 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:36:16,714 - root - INFO: Collecting raster\n", + "2021-09-23 13:36:16,756 - root - INFO: ... got raster of shape: (104, 209)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.997934749547, 68.27740223437527, -148.94026169165255, 68.30600280906724)\n", + "bounds in my_crs: (-148.997934749547, 68.27740223437527, -148.94026169165255, 68.30600280906724)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:36:16,764 - root - INFO: ... got raster bounds: (-148.99818282517663, 68.30619896060979, -148.94012726961915, 68.27731007171994)\n", + "2021-09-23 13:36:16,849 - root - INFO: \n", + "2021-09-23 13:36:16,849 - root - INFO: Loading Raster\n", + "2021-09-23 13:36:16,850 - root - INFO: ------------------------------\n", + "2021-09-23 13:36:16,850 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:36:16,851 - root - INFO: Collecting raster\n", + "2021-09-23 13:36:16,895 - root - INFO: ... got raster of shape: (104, 209)\n", + "2021-09-23 13:36:16,903 - root - INFO: ... got raster bounds: (-148.99818282517663, 68.30619896060979, -148.94012726961915, 68.27731007171994)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-148.997934749547, 68.27740223437527, -148.94026169165255, 68.30600280906724)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment34.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment34.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:36:47,298 - root - INFO: \n", + "2021-09-23 13:36:47,299 - root - INFO: Meshing\n", + "2021-09-23 13:36:47,299 - root - INFO: ------------------------------\n", + "2021-09-23 13:36:47,300 - root - INFO: Triangulating...\n", + "2021-09-23 13:36:47,300 - root - INFO: 18 points and 18 facets\n", + "2021-09-23 13:36:47,301 - root - INFO: checking graph consistency\n", + "2021-09-23 13:36:47,301 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:36:47,302 - root - INFO: building graph data structures\n", + "2021-09-23 13:36:47,303 - root - INFO: triangle.build...\n", + "2021-09-23 13:36:47,734 - root - INFO: ...built: 22599 mesh points and 44577 triangles\n", + "2021-09-23 13:36:47,735 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:36:48,697 - root - INFO: min area = 38.10565185546875\n", + "2021-09-23 13:36:48,698 - root - INFO: max area = 199.99783325195312\n", + "2021-09-23 13:36:49,119 - root - INFO: \n", + "2021-09-23 13:36:49,120 - root - INFO: Loading Raster\n", + "2021-09-23 13:36:49,120 - root - INFO: ------------------------------\n", + "2021-09-23 13:36:49,121 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:36:49,121 - root - INFO: Collecting raster\n", + "2021-09-23 13:36:49,167 - root - INFO: ... got raster of shape: (130, 307)\n", + "2021-09-23 13:36:49,175 - root - INFO: ... got raster bounds: (-149.21540504740605, 68.20425451616197, -149.13012726962543, 68.16814340504966)\n", + "2021-09-23 13:36:49,185 - root - INFO: \n", + "2021-09-23 13:36:49,186 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:36:49,186 - root - INFO: ------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21528825036145, 68.16836076034137, -149.1302441086783, 68.20423048506441)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:36:49,379 - root - INFO: \n", + "2021-09-23 13:36:49,380 - root - INFO: Loading Raster\n", + "2021-09-23 13:36:49,380 - root - INFO: ------------------------------\n", + "2021-09-23 13:36:49,381 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:36:49,381 - root - INFO: Collecting raster\n", + "2021-09-23 13:36:49,426 - root - INFO: ... got raster of shape: (130, 307)\n", + "2021-09-23 13:36:49,435 - root - INFO: ... got raster bounds: (-149.21540504740605, 68.20425451616197, -149.13012726962543, 68.16814340504966)\n", + "2021-09-23 13:36:49,553 - root - INFO: \n", + "2021-09-23 13:36:49,554 - root - INFO: Loading Raster\n", + "2021-09-23 13:36:49,554 - root - INFO: ------------------------------\n", + "2021-09-23 13:36:49,555 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:36:49,556 - root - INFO: Collecting raster\n", + "2021-09-23 13:36:49,600 - root - INFO: ... got raster of shape: (130, 307)\n", + "2021-09-23 13:36:49,608 - root - INFO: ... got raster bounds: (-149.21540504740605, 68.20425451616197, -149.13012726962543, 68.16814340504966)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21528825036145, 68.16836076034137, -149.1302441086783, 68.20423048506441)\n", + "bounds in my_crs: (-149.21528825036145, 68.16836076034137, -149.1302441086783, 68.20423048506441)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment35.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment35.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:37:40,746 - root - INFO: \n", + "2021-09-23 13:37:40,747 - root - INFO: Meshing\n", + "2021-09-23 13:37:40,748 - root - INFO: ------------------------------\n", + "2021-09-23 13:37:40,748 - root - INFO: Triangulating...\n", + "2021-09-23 13:37:40,749 - root - INFO: 10 points and 10 facets\n", + "2021-09-23 13:37:40,749 - root - INFO: checking graph consistency\n", + "2021-09-23 13:37:40,750 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:37:40,751 - root - INFO: building graph data structures\n", + "2021-09-23 13:37:40,751 - root - INFO: triangle.build...\n", + "2021-09-23 13:37:40,987 - root - INFO: ...built: 11036 mesh points and 21668 triangles\n", + "2021-09-23 13:37:40,989 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:37:41,462 - root - INFO: min area = 63.3148193359375\n", + "2021-09-23 13:37:41,463 - root - INFO: max area = 199.98712158203125\n", + "2021-09-23 13:37:41,677 - root - INFO: \n", + "2021-09-23 13:37:41,678 - root - INFO: Loading Raster\n", + "2021-09-23 13:37:41,678 - root - INFO: ------------------------------\n", + "2021-09-23 13:37:41,679 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:37:41,680 - root - INFO: Collecting raster\n", + "2021-09-23 13:37:41,724 - root - INFO: ... got raster of shape: (113, 172)\n", + "2021-09-23 13:37:41,733 - root - INFO: ... got raster bounds: (-149.21123838073925, 68.20842118282877, -149.16346060295987, 68.17703229393884)\n", + "2021-09-23 13:37:41,742 - root - INFO: \n", + "2021-09-23 13:37:41,743 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:37:41,743 - root - INFO: ------------------------------\n", + "2021-09-23 13:37:41,857 - root - INFO: \n", + "2021-09-23 13:37:41,858 - root - INFO: Loading Raster\n", + "2021-09-23 13:37:41,859 - root - INFO: ------------------------------\n", + "2021-09-23 13:37:41,859 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:37:41,860 - root - INFO: Collecting raster\n", + "2021-09-23 13:37:41,905 - root - INFO: ... got raster of shape: (113, 172)\n", + "2021-09-23 13:37:41,915 - root - INFO: ... got raster bounds: (-149.21123838073925, 68.20842118282877, -149.16346060295987, 68.17703229393884)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21111680470045, 68.17708998948528, -149.16368676757662, 68.20835557380545)\n", + "bounds in my_crs: (-149.21111680470045, 68.17708998948528, -149.16368676757662, 68.20835557380545)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:37:41,990 - root - INFO: \n", + "2021-09-23 13:37:41,991 - root - INFO: Loading Raster\n", + "2021-09-23 13:37:41,992 - root - INFO: ------------------------------\n", + "2021-09-23 13:37:41,992 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:37:41,993 - root - INFO: Collecting raster\n", + "2021-09-23 13:37:42,037 - root - INFO: ... got raster of shape: (113, 172)\n", + "2021-09-23 13:37:42,046 - root - INFO: ... got raster bounds: (-149.21123838073925, 68.20842118282877, -149.16346060295987, 68.17703229393884)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21111680470045, 68.17708998948528, -149.16368676757662, 68.20835557380545)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment36.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment36.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:38:06,530 - root - INFO: \n", + "2021-09-23 13:38:06,531 - root - INFO: Meshing\n", + "2021-09-23 13:38:06,531 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:06,532 - root - INFO: Triangulating...\n", + "2021-09-23 13:38:06,533 - root - INFO: 14 points and 14 facets\n", + "2021-09-23 13:38:06,533 - root - INFO: checking graph consistency\n", + "2021-09-23 13:38:06,534 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:38:06,534 - root - INFO: building graph data structures\n", + "2021-09-23 13:38:06,535 - root - INFO: triangle.build...\n", + "2021-09-23 13:38:06,823 - root - INFO: ...built: 15671 mesh points and 30843 triangles\n", + "2021-09-23 13:38:06,824 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:38:07,490 - root - INFO: min area = 40.692535400390625\n", + "2021-09-23 13:38:07,491 - root - INFO: max area = 199.9931640625\n", + "2021-09-23 13:38:07,787 - root - INFO: \n", + "2021-09-23 13:38:07,788 - root - INFO: Loading Raster\n", + "2021-09-23 13:38:07,788 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:07,789 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:38:07,790 - root - INFO: Collecting raster\n", + "2021-09-23 13:38:07,834 - root - INFO: ... got raster of shape: (74, 332)\n", + "2021-09-23 13:38:07,843 - root - INFO: ... got raster bounds: (-149.21068282518368, 68.27925451616446, -149.1184606029584, 68.25869896060821)\n", + "2021-09-23 13:38:07,852 - root - INFO: \n", + "2021-09-23 13:38:07,853 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:38:07,853 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:07,998 - root - INFO: \n", + "2021-09-23 13:38:07,999 - root - INFO: Loading Raster\n", + "2021-09-23 13:38:07,999 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:08,000 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:38:08,001 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21058383854665, 68.25875188874285, -149.11858107162087, 68.27921603669684)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:38:08,045 - root - INFO: ... got raster of shape: (74, 332)\n", + "2021-09-23 13:38:08,054 - root - INFO: ... got raster bounds: (-149.21068282518368, 68.27925451616446, -149.1184606029584, 68.25869896060821)\n", + "2021-09-23 13:38:08,149 - root - INFO: \n", + "2021-09-23 13:38:08,150 - root - INFO: Loading Raster\n", + "2021-09-23 13:38:08,150 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:08,151 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:38:08,152 - root - INFO: Collecting raster\n", + "2021-09-23 13:38:08,196 - root - INFO: ... got raster of shape: (74, 332)\n", + "2021-09-23 13:38:08,206 - root - INFO: ... got raster bounds: (-149.21068282518368, 68.27925451616446, -149.1184606029584, 68.25869896060821)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21058383854665, 68.25875188874285, -149.11858107162087, 68.27921603669684)\n", + "bounds in my_crs: (-149.21058383854665, 68.25875188874285, -149.11858107162087, 68.27921603669684)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment37.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment37.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:38:44,210 - root - INFO: \n", + "2021-09-23 13:38:44,211 - root - INFO: Meshing\n", + "2021-09-23 13:38:44,212 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:44,213 - root - INFO: Triangulating...\n", + "2021-09-23 13:38:44,213 - root - INFO: 15 points and 15 facets\n", + "2021-09-23 13:38:44,214 - root - INFO: checking graph consistency\n", + "2021-09-23 13:38:44,214 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:38:44,215 - root - INFO: building graph data structures\n", + "2021-09-23 13:38:44,215 - root - INFO: triangle.build...\n", + "2021-09-23 13:38:44,440 - root - INFO: ...built: 12033 mesh points and 23616 triangles\n", + "2021-09-23 13:38:44,441 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:38:44,950 - root - INFO: min area = 36.9022216796875\n", + "2021-09-23 13:38:44,951 - root - INFO: max area = 199.97848510742188\n", + "2021-09-23 13:38:45,181 - root - INFO: \n", + "2021-09-23 13:38:45,182 - root - INFO: Loading Raster\n", + "2021-09-23 13:38:45,183 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:45,184 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:38:45,184 - root - INFO: Collecting raster\n", + "2021-09-23 13:38:45,227 - root - INFO: ... got raster of shape: (60, 295)\n", + "2021-09-23 13:38:45,236 - root - INFO: ... got raster bounds: (-149.20929393629473, 68.26953229394191, -149.12734949184755, 68.25286562727469)\n", + "2021-09-23 13:38:45,246 - root - INFO: \n", + "2021-09-23 13:38:45,246 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:38:45,247 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:45,368 - root - INFO: \n", + "2021-09-23 13:38:45,368 - root - INFO: Loading Raster\n", + "2021-09-23 13:38:45,369 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:45,370 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:38:45,371 - root - INFO: Collecting raster\n", + "2021-09-23 13:38:45,413 - root - INFO: ... got raster of shape: (60, 295)\n", + "2021-09-23 13:38:45,421 - root - INFO: ... got raster bounds: (-149.20929393629473, 68.26953229394191, -149.12734949184755, 68.25286562727469)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.2090664982718, 68.2531278493561, -149.12758580017228, 68.26926522876465)\n", + "bounds in my_crs: (-149.2090664982718, 68.2531278493561, -149.12758580017228, 68.26926522876465)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:38:45,505 - root - INFO: \n", + "2021-09-23 13:38:45,505 - root - INFO: Loading Raster\n", + "2021-09-23 13:38:45,506 - root - INFO: ------------------------------\n", + "2021-09-23 13:38:45,506 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:38:45,507 - root - INFO: Collecting raster\n", + "2021-09-23 13:38:45,547 - root - INFO: ... got raster of shape: (60, 295)\n", + "2021-09-23 13:38:45,556 - root - INFO: ... got raster bounds: (-149.20929393629473, 68.26953229394191, -149.12734949184755, 68.25286562727469)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.2090664982718, 68.2531278493561, -149.12758580017228, 68.26926522876465)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment38.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment38.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:39:13,121 - root - INFO: \n", + "2021-09-23 13:39:13,122 - root - INFO: Meshing\n", + "2021-09-23 13:39:13,122 - root - INFO: ------------------------------\n", + "2021-09-23 13:39:13,123 - root - INFO: Triangulating...\n", + "2021-09-23 13:39:13,124 - root - INFO: 13 points and 13 facets\n", + "2021-09-23 13:39:13,124 - root - INFO: checking graph consistency\n", + "2021-09-23 13:39:13,125 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:39:13,125 - root - INFO: building graph data structures\n", + "2021-09-23 13:39:13,126 - root - INFO: triangle.build...\n", + "2021-09-23 13:39:13,620 - root - INFO: ...built: 24931 mesh points and 49387 triangles\n", + "2021-09-23 13:39:13,621 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:39:14,693 - root - INFO: min area = 26.36248779296875\n", + "2021-09-23 13:39:14,694 - root - INFO: max area = 199.99612426757812\n", + "2021-09-23 13:39:15,139 - root - INFO: \n", + "2021-09-23 13:39:15,140 - root - INFO: Loading Raster\n", + "2021-09-23 13:39:15,141 - root - INFO: ------------------------------\n", + "2021-09-23 13:39:15,141 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:39:15,142 - root - INFO: Collecting raster\n", + "2021-09-23 13:39:15,186 - root - INFO: ... got raster of shape: (103, 224)\n", + "2021-09-23 13:39:15,195 - root - INFO: ... got raster bounds: (-149.12734949184758, 68.28703229394249, -149.0651272696233, 68.25842118283043)\n", + "2021-09-23 13:39:15,204 - root - INFO: \n", + "2021-09-23 13:39:15,204 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:39:15,205 - root - INFO: ------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.12712334902193, 68.25851002377757, -149.06535466536658, 68.28694002551227)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:39:15,414 - root - INFO: \n", + "2021-09-23 13:39:15,415 - root - INFO: Loading Raster\n", + "2021-09-23 13:39:15,415 - root - INFO: ------------------------------\n", + "2021-09-23 13:39:15,415 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:39:15,416 - root - INFO: Collecting raster\n", + "2021-09-23 13:39:15,458 - root - INFO: ... got raster of shape: (103, 224)\n", + "2021-09-23 13:39:15,466 - root - INFO: ... got raster bounds: (-149.12734949184758, 68.28703229394249, -149.0651272696233, 68.25842118283043)\n", + "2021-09-23 13:39:15,591 - root - INFO: \n", + "2021-09-23 13:39:15,592 - root - INFO: Loading Raster\n", + "2021-09-23 13:39:15,593 - root - INFO: ------------------------------\n", + "2021-09-23 13:39:15,593 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:39:15,594 - root - INFO: Collecting raster\n", + "2021-09-23 13:39:15,637 - root - INFO: ... got raster of shape: (103, 224)\n", + "2021-09-23 13:39:15,646 - root - INFO: ... got raster bounds: (-149.12734949184758, 68.28703229394249, -149.0651272696233, 68.25842118283043)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.12712334902193, 68.25851002377757, -149.06535466536658, 68.28694002551227)\n", + "bounds in my_crs: (-149.12712334902193, 68.25851002377757, -149.06535466536658, 68.28694002551227)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment39.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment39.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:40:15,248 - root - INFO: \n", + "2021-09-23 13:40:15,249 - root - INFO: Meshing\n", + "2021-09-23 13:40:15,250 - root - INFO: ------------------------------\n", + "2021-09-23 13:40:15,250 - root - INFO: Triangulating...\n", + "2021-09-23 13:40:15,251 - root - INFO: 8 points and 8 facets\n", + "2021-09-23 13:40:15,251 - root - INFO: checking graph consistency\n", + "2021-09-23 13:40:15,252 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:40:15,253 - root - INFO: building graph data structures\n", + "2021-09-23 13:40:15,253 - root - INFO: triangle.build...\n", + "2021-09-23 13:40:15,421 - root - INFO: ...built: 8334 mesh points and 16395 triangles\n", + "2021-09-23 13:40:15,424 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:40:15,780 - root - INFO: min area = 45.765380859375\n", + "2021-09-23 13:40:15,781 - root - INFO: max area = 199.96609497070312\n", + "2021-09-23 13:40:15,952 - root - INFO: \n", + "2021-09-23 13:40:15,953 - root - INFO: Loading Raster\n", + "2021-09-23 13:40:15,953 - root - INFO: ------------------------------\n", + "2021-09-23 13:40:15,954 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:40:15,955 - root - INFO: Collecting raster\n", + "2021-09-23 13:40:16,002 - root - INFO: ... got raster of shape: (52, 187)\n", + "2021-09-23 13:40:16,010 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26231007171944, -149.07984949184598, 68.24786562727452)\n", + "2021-09-23 13:40:16,020 - root - INFO: \n", + "2021-09-23 13:40:16,021 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:40:16,021 - root - INFO: ------------------------------\n", + "2021-09-23 13:40:16,117 - root - INFO: \n", + "2021-09-23 13:40:16,117 - root - INFO: Loading Raster\n", + "2021-09-23 13:40:16,118 - root - INFO: ------------------------------\n", + "2021-09-23 13:40:16,119 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:40:16,120 - root - INFO: Collecting raster\n", + "2021-09-23 13:40:16,170 - root - INFO: ... got raster of shape: (52, 187)\n", + "2021-09-23 13:40:16,179 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26231007171944, -149.07984949184598, 68.24786562727452)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.13165740523283, 68.24808995964166, -149.08004542148709, 68.26204188665757)\n", + "bounds in my_crs: (-149.13165740523283, 68.24808995964166, -149.08004542148709, 68.26204188665757)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:40:16,245 - root - INFO: \n", + "2021-09-23 13:40:16,246 - root - INFO: Loading Raster\n", + "2021-09-23 13:40:16,246 - root - INFO: ------------------------------\n", + "2021-09-23 13:40:16,247 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:40:16,248 - root - INFO: Collecting raster\n", + "2021-09-23 13:40:16,293 - root - INFO: ... got raster of shape: (52, 187)\n", + "2021-09-23 13:40:16,301 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26231007171944, -149.07984949184598, 68.24786562727452)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.13165740523283, 68.24808995964166, -149.08004542148709, 68.26204188665757)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment40.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment40.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:40:35,244 - root - INFO: \n", + "2021-09-23 13:40:35,245 - root - INFO: Meshing\n", + "2021-09-23 13:40:35,246 - root - INFO: ------------------------------\n", + "2021-09-23 13:40:35,247 - root - INFO: Triangulating...\n", + "2021-09-23 13:40:35,247 - root - INFO: 11 points and 11 facets\n", + "2021-09-23 13:40:35,247 - root - INFO: checking graph consistency\n", + "2021-09-23 13:40:35,248 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:40:35,249 - root - INFO: building graph data structures\n", + "2021-09-23 13:40:35,249 - root - INFO: triangle.build...\n", + "2021-09-23 13:40:35,685 - root - INFO: ...built: 26111 mesh points and 51680 triangles\n", + "2021-09-23 13:40:35,686 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:40:36,742 - root - INFO: min area = 43.3514404296875\n", + "2021-09-23 13:40:36,743 - root - INFO: max area = 199.99447631835938\n", + "2021-09-23 13:40:37,204 - root - INFO: \n", + "2021-09-23 13:40:37,205 - root - INFO: Loading Raster\n", + "2021-09-23 13:40:37,205 - root - INFO: ------------------------------\n", + "2021-09-23 13:40:37,206 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:40:37,207 - root - INFO: Collecting raster\n", + "2021-09-23 13:40:37,253 - root - INFO: ... got raster of shape: (143, 252)\n", + "2021-09-23 13:40:37,262 - root - INFO: ... got raster bounds: (-149.0792939362904, 68.28703229394249, -149.0092939362881, 68.24731007171894)\n", + "2021-09-23 13:40:37,271 - root - INFO: \n", + "2021-09-23 13:40:37,272 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:40:37,272 - root - INFO: ------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.07918774814783, 68.24755074395696, -149.00951023659192, 68.28685749523802)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:40:37,491 - root - INFO: \n", + "2021-09-23 13:40:37,492 - root - INFO: Loading Raster\n", + "2021-09-23 13:40:37,492 - root - INFO: ------------------------------\n", + "2021-09-23 13:40:37,493 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:40:37,493 - root - INFO: Collecting raster\n", + "2021-09-23 13:40:37,536 - root - INFO: ... got raster of shape: (143, 252)\n", + "2021-09-23 13:40:37,545 - root - INFO: ... got raster bounds: (-149.0792939362904, 68.28703229394249, -149.0092939362881, 68.24731007171894)\n", + "2021-09-23 13:40:37,675 - root - INFO: \n", + "2021-09-23 13:40:37,675 - root - INFO: Loading Raster\n", + "2021-09-23 13:40:37,676 - root - INFO: ------------------------------\n", + "2021-09-23 13:40:37,677 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:40:37,678 - root - INFO: Collecting raster\n", + "2021-09-23 13:40:37,719 - root - INFO: ... got raster of shape: (143, 252)\n", + "2021-09-23 13:40:37,728 - root - INFO: ... got raster bounds: (-149.0792939362904, 68.28703229394249, -149.0092939362881, 68.24731007171894)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.07918774814783, 68.24755074395696, -149.00951023659192, 68.28685749523802)\n", + "bounds in my_crs: (-149.07918774814783, 68.24755074395696, -149.00951023659192, 68.28685749523802)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment41.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment41.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:41:37,013 - root - INFO: \n", + "2021-09-23 13:41:37,014 - root - INFO: Meshing\n", + "2021-09-23 13:41:37,014 - root - INFO: ------------------------------\n", + "2021-09-23 13:41:37,015 - root - INFO: Triangulating...\n", + "2021-09-23 13:41:37,016 - root - INFO: 5 points and 5 facets\n", + "2021-09-23 13:41:37,016 - root - INFO: checking graph consistency\n", + "2021-09-23 13:41:37,017 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:41:37,017 - root - INFO: building graph data structures\n", + "2021-09-23 13:41:37,018 - root - INFO: triangle.build...\n", + "2021-09-23 13:41:37,117 - root - INFO: ...built: 4598 mesh points and 8931 triangles\n", + "2021-09-23 13:41:37,120 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:41:37,320 - root - INFO: min area = 31.330963134765625\n", + "2021-09-23 13:41:37,321 - root - INFO: max area = 199.88494873046875\n", + "2021-09-23 13:41:37,434 - root - INFO: \n", + "2021-09-23 13:41:37,435 - root - INFO: Loading Raster\n", + "2021-09-23 13:41:37,436 - root - INFO: ------------------------------\n", + "2021-09-23 13:41:37,436 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:41:37,437 - root - INFO: Collecting raster\n", + "2021-09-23 13:41:37,481 - root - INFO: ... got raster of shape: (41, 187)\n", + "2021-09-23 13:41:37,490 - root - INFO: ... got raster bounds: (-149.08318282517945, 68.25842118283043, -149.03123838073327, 68.24703229394116)\n", + "2021-09-23 13:41:37,499 - root - INFO: \n", + "2021-09-23 13:41:37,499 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:41:37,500 - root - INFO: ------------------------------\n", + "2021-09-23 13:41:37,569 - root - INFO: \n", + "2021-09-23 13:41:37,569 - root - INFO: Loading Raster\n", + "2021-09-23 13:41:37,570 - root - INFO: ------------------------------\n", + "2021-09-23 13:41:37,570 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:41:37,571 - root - INFO: Collecting raster\n", + "2021-09-23 13:41:37,615 - root - INFO: ... got raster of shape: (41, 187)\n", + "2021-09-23 13:41:37,623 - root - INFO: ... got raster bounds: (-149.08318282517945, 68.25842118283043, -149.03123838073327, 68.24703229394116)\n", + "2021-09-23 13:41:37,678 - root - INFO: \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08304453156916, 68.24726363416434, -149.03129198917352, 68.25815882709514)\n", + "bounds in my_crs: (-149.08304453156916, 68.24726363416434, -149.03129198917352, 68.25815882709514)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:41:37,679 - root - INFO: Loading Raster\n", + "2021-09-23 13:41:37,679 - root - INFO: ------------------------------\n", + "2021-09-23 13:41:37,680 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:41:37,680 - root - INFO: Collecting raster\n", + "2021-09-23 13:41:37,724 - root - INFO: ... got raster of shape: (41, 187)\n", + "2021-09-23 13:41:37,732 - root - INFO: ... got raster bounds: (-149.08318282517945, 68.25842118283043, -149.03123838073327, 68.24703229394116)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.08304453156916, 68.24726363416434, -149.03129198917352, 68.25815882709514)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment42.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment42.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:41:47,679 - root - INFO: \n", + "2021-09-23 13:41:47,680 - root - INFO: Meshing\n", + "2021-09-23 13:41:47,680 - root - INFO: ------------------------------\n", + "2021-09-23 13:41:47,681 - root - INFO: Triangulating...\n", + "2021-09-23 13:41:47,682 - root - INFO: 19 points and 19 facets\n", + "2021-09-23 13:41:47,682 - root - INFO: checking graph consistency\n", + "2021-09-23 13:41:47,683 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:41:47,683 - root - INFO: building graph data structures\n", + "2021-09-23 13:41:47,684 - root - INFO: triangle.build...\n", + "2021-09-23 13:41:48,060 - root - INFO: ...built: 21748 mesh points and 42873 triangles\n", + "2021-09-23 13:41:48,060 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:41:48,953 - root - INFO: min area = 33.698883056640625\n", + "2021-09-23 13:41:48,954 - root - INFO: max area = 199.99661254882812\n", + "2021-09-23 13:41:49,351 - root - INFO: \n", + "2021-09-23 13:41:49,352 - root - INFO: Loading Raster\n", + "2021-09-23 13:41:49,352 - root - INFO: ------------------------------\n", + "2021-09-23 13:41:49,353 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:41:49,354 - root - INFO: Collecting raster\n", + "2021-09-23 13:41:49,401 - root - INFO: ... got raster of shape: (119, 408)\n", + "2021-09-23 13:41:49,409 - root - INFO: ... got raster bounds: (-149.23179393629547, 68.25397673838583, -149.11846060295838, 68.22092118282917)\n", + "2021-09-23 13:41:49,419 - root - INFO: \n", + "2021-09-23 13:41:49,419 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:41:49,420 - root - INFO: ------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.23159565302103, 68.22111530657942, -149.118589984177, 68.25376279024279)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:41:49,607 - root - INFO: \n", + "2021-09-23 13:41:49,607 - root - INFO: Loading Raster\n", + "2021-09-23 13:41:49,608 - root - INFO: ------------------------------\n", + "2021-09-23 13:41:49,609 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:41:49,609 - root - INFO: Collecting raster\n", + "2021-09-23 13:41:49,652 - root - INFO: ... got raster of shape: (119, 408)\n", + "2021-09-23 13:41:49,661 - root - INFO: ... got raster bounds: (-149.23179393629547, 68.25397673838583, -149.11846060295838, 68.22092118282917)\n", + "2021-09-23 13:41:49,777 - root - INFO: \n", + "2021-09-23 13:41:49,777 - root - INFO: Loading Raster\n", + "2021-09-23 13:41:49,778 - root - INFO: ------------------------------\n", + "2021-09-23 13:41:49,778 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:41:49,779 - root - INFO: Collecting raster\n", + "2021-09-23 13:41:49,823 - root - INFO: ... got raster of shape: (119, 408)\n", + "2021-09-23 13:41:49,832 - root - INFO: ... got raster bounds: (-149.23179393629547, 68.25397673838583, -149.11846060295838, 68.22092118282917)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.23159565302103, 68.22111530657942, -149.118589984177, 68.25376279024279)\n", + "bounds in my_crs: (-149.23159565302103, 68.22111530657942, -149.118589984177, 68.25376279024279)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment43.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment43.exo\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:42:39,129 - root - INFO: \n", + "2021-09-23 13:42:39,130 - root - INFO: Meshing\n", + "2021-09-23 13:42:39,130 - root - INFO: ------------------------------\n", + "2021-09-23 13:42:39,131 - root - INFO: Triangulating...\n", + "2021-09-23 13:42:39,132 - root - INFO: 11 points and 11 facets\n", + "2021-09-23 13:42:39,132 - root - INFO: checking graph consistency\n", + "2021-09-23 13:42:39,132 - root - INFO: tolerance is set to 1\n", + "2021-09-23 13:42:39,133 - root - INFO: building graph data structures\n", + "2021-09-23 13:42:39,133 - root - INFO: triangle.build...\n", + "2021-09-23 13:42:39,336 - root - INFO: ...built: 11453 mesh points and 22492 triangles\n", + "2021-09-23 13:42:39,337 - root - INFO: Plotting triangulation diagnostics\n", + "2021-09-23 13:42:39,811 - root - INFO: min area = 55.202911376953125\n", + "2021-09-23 13:42:39,812 - root - INFO: max area = 199.9888916015625\n", + "2021-09-23 13:42:40,032 - root - INFO: \n", + "2021-09-23 13:42:40,033 - root - INFO: Loading Raster\n", + "2021-09-23 13:42:40,033 - root - INFO: ------------------------------\n", + "2021-09-23 13:42:40,034 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", + "2021-09-23 13:42:40,035 - root - INFO: Collecting raster\n", + "2021-09-23 13:42:40,075 - root - INFO: ... got raster of shape: (72, 308)\n", + "2021-09-23 13:42:40,085 - root - INFO: ... got raster bounds: (-149.23234949185107, 68.24036562727427, -149.14679393629268, 68.22036562727361)\n", + "2021-09-23 13:42:40,094 - root - INFO: \n", + "2021-09-23 13:42:40,095 - root - INFO: Elevating Triangulation to DEM\n", + "2021-09-23 13:42:40,096 - root - INFO: ------------------------------\n", + "2021-09-23 13:42:40,214 - root - INFO: \n", + "2021-09-23 13:42:40,215 - root - INFO: Loading Raster\n", + "2021-09-23 13:42:40,215 - root - INFO: ------------------------------\n", + "2021-09-23 13:42:40,216 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-09-23 13:42:40,217 - root - INFO: Collecting raster\n", + "2021-09-23 13:42:40,256 - root - INFO: ... got raster of shape: (72, 308)\n", + "2021-09-23 13:42:40,265 - root - INFO: ... got raster bounds: (-149.23234949185107, 68.24036562727427, -149.14679393629268, 68.22036562727361)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.23208710974703, 68.2206396935597, -149.1470597859579, 68.24009278991055)\n", + "bounds in my_crs: (-149.23208710974703, 68.2206396935597, -149.1470597859579, 68.24009278991055)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-09-23 13:42:40,345 - root - INFO: \n", + "2021-09-23 13:42:40,346 - root - INFO: Loading Raster\n", + "2021-09-23 13:42:40,346 - root - INFO: ------------------------------\n", + "2021-09-23 13:42:40,347 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-09-23 13:42:40,348 - root - INFO: Collecting raster\n", + "2021-09-23 13:42:40,387 - root - INFO: ... got raster of shape: (72, 308)\n", + "2021-09-23 13:42:40,395 - root - INFO: ... got raster bounds: (-149.23234949185107, 68.24036562727427, -149.14679393629268, 68.22036562727361)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.23208710974703, 68.2206396935597, -149.1470597859579, 68.24009278991055)\n", + "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment44.exo\n", + "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment44.exo\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxp0lEQVR4nO3de7xUdb3/8ddbUMQLCIileIEILUVFIS94xUuilVh5zZLM8nIs0+qUHPPShd/RskwrTURDy2teEjtqXsujiQiKICqhgrqVI5SIYIoBn98f6zuw2MzsPXvvmT2z2e/n4zGPvea71nfNZ2bW7M+6fNf3q4jAzMysGtapdQBmZrb2cpIxM7OqcZIxM7OqcZIxM7OqcZIxM7Oq6VrrANrbpptuGv379691GLaWmjp16j8iom8tXtvbtlVTa7ftTpdk+vfvz5QpU2odhq2lJL1Sq9f2tm3V1Npt26fLzMysapxkzMysapxkzMysapxkzMysapxkzKzTmHT36g0jVqxYsUaZVVana11m1t4kbQVcB3wYWAGMi4hLJfUGbgb6A3OBoyNiYaozBjgJWA6cERF/rkHoa5WD1zkKgG123JLxz1zCihUrOKTrMQDse8yenHvjt2oZ3lrLRzJm1bcM+HZEfBzYAzhd0vbA2cCDETEIeDA9J807FtgBGAlcLqlLTSJfC70yo4Gv7nzWygQD8MjNj9cworWbk4xZlUXEvIh4Kk0vBp4H+gGjgGvTYtcCR6TpUcBNEbE0IuYALwK7tWvQa7lXZjTUOoROw0nGrB1J6g/sAjwBfCgi5kGWiIDN0mL9gNdy1RpSWbH1nSxpiqQpCxYsqFrcZq3lazLWpP5n/0+r6s298FMVjqTjk7QRcBtwZkS8I6nkokXKio4uGBHjgHEAw4YN8wiEVnd8JGPWDiStS5Zgro+I21Pxm5I2T/M3B+an8gZgq1z1LYE32itWs0pykjGrMmWHLFcDz0fEz3OzJgKj0/Ro4M5c+bGSukkaAAwCJrdXvGaV5NNlZtW3F/AlYIakaansv4ALgVsknQS8ChwFEBEzJd0CPEfWMu30iFje7lGbVYCTjFmVRcSjFL/OAnBgiTpjgbFVC8qsnfh0mZmZVY2TjJmZVY2TjJmZVY2TjJmZVU3VkoykrSQ9LOl5STMlfTOV95Z0v6TZ6W+vXJ0xkl6UNEvSIbnyoZJmpHmXpSahpCaeN6fyJ9Ld1GZmVieqeSRTyU4BrwBOJrtfYFCaD1kvtQsj4qPAJcBFVXw/ZmbWQlVLMpXqFDDdCd0jIh6PiCDrMj1fp7CuW4EDC0c5ZmZWe+1yTaaNnQL2S9ONy1erExHLgEVAn6q8CTMza7GqJ5nGnQI2tWiRsmiivKk6jWNwT7VmZjVQ1SRToU4BG9J04/LV6kjqCvQE3mocR0SMi4hhETGsb9++lXhrZmZWhmq2LqtIp4DplNpiSXukdZ7QqE5hXUcCD6XrNmZmVgeq2XdZJTsFPA2YAHQH7kkPyJLY7yS9SHYEc2wV34+ZmbVQ1ZJMJTsFjIgpwOAi5e+TkpSZmdUf3/FvZmZV4yRjZmZV4yRjZmZV4yRjZmZV4yRjZmZV4yRjZmZV4yRj1g4kXSNpvqRnc2VDJE2SNC11e7Rbbl7RYS/MOhonGbP2MYFVQ1QU/AT4QUQMAc5Lz5sb9sKsQ3GSMWsHEfEIa/arF0CPNN2TVX3yFR32ol0CNauwanYrY2ZNOxP4s6SLyXb4hqfyfsCk3HL54S1WI+lksgH92HrrrasWqFlr+UjGrHZOA86KiK2As8j64oMyh7AA9zBu9c9Jxqx2RgOFITD+wKpTYqWGvTDrcJxkzGrnDWC/NH0AMDtNFx32ogbxmbWZr8mYtQNJNwL7A5tKagDOB74GXJoG3HufdG2lmWEvzDoUJxmzdhARx5WYNbTE8kWHvTDraHy6zMzMqqaawy8Xu8P55nR38zRJcwsjZkrqL+m93Lzf5OoMlTQj3f18WRqCmXS++uZU/oSk/tV6L2Zm1jrVPJKZQKM7nCPimIgYku5wvo1VLWsAXirMi4hTc+VXkJ2rHpQehXWeBCyMiI8ClwAXVeVdmJlZq1UtyZS4wxmAdDRyNHBjU+uQtDnQIyIej4gArgOOSLNHAdem6VuBAwtHOWZmVh9qdU1mH+DNiJidKxsg6WlJf5W0TyrrR3bPQEH+zud+wGsAEbEMWAT0KfZikk5OHRBOWbBgQSXfh5mZNaFWSeY4Vj+KmQdsHRG7AN8CbpDUg6bvfPZd0WZmda7dmzCnewI+R67pZkQsBZam6amSXgK2JTty2TJXPX/nc+Gu6Ia0zp6UOD1nZma1UYsjmYOAFyJi5WkwSX0LXZlL+gjZBf6XI2IesFjSHul6ywnAnanaRLJuOQCOBB5K123MzKxOVLMJ843A48B2khoknZRmHcuaF/z3BaZLeobsIv6pEVE4KjkNGE/W3flLwD2p/Gqgj6QXyU6xnV2t92JmZq1TtdNlpe5wjogvFym7jaxJc7HlpwCDi5S/DxzVtijNzKyafMe/mZlVjZOMmZlVjZOMmZlVjZOMmZlVjZOMmZlVjZOMmZlVjZOMmZlVjZOMmZlVjYdfNivD4Ycf3uwyvXv3bodIzDoWJxmzMjz//POMHz++5PyI4PTTTy85X9I1wKeB+RExOFf+DeDrwDLgfyLiu6l8DNnAfMuBMyLiz5V4H2btzUnGrAxjx45lv/32a3KZ888/n2OOOabU7AnAr8gG3gNA0giywfd2ioilkjZL5duT9fG3A7AF8ICkbSNieVvfh1l78zUZszIcffTRbVqmxEixpwEXpqEuiIj5qXwUcFNELI2IOWSdw+7WirDNas5JxqwMy5cv58orr+Tcc8/lscceW23ej3/849audltgH0lPpBFhP5HKV476muRHhF2NR321euckY1aGU045hb/+9a/06dOHM844g29961sr591+++2tXW1XoBewB/CfwC1p3CSP+mprDScZszJMnjyZG264gTPPPJMnnniCJUuW8LnPfY6lS5fShrHyGoDbIzMZWAFsyqpRXwvyI8KadSjVHLTsGknzJT2bK7tA0uuSpqXHYbl5YyS9KGmWpENy5UMlzUjzLkt7ekjqJunmVP6EpP7Vei9mH3zwwcrprl27Mm7cOIYMGcIBBxzAkiVLWrvaPwIHAEjaFlgP+AfZqK/Hpm18ANlIsZPbEL5ZzVTzSGYCMLJI+SURMSQ97oY1WtOMBC4vDMcMXAGcTPZDG5Rb50nAwoj4KHAJcFG13ojZsGHDuPfee1crO++88zjxxBOZO3dus/VLjBR7DfCRtCN2EzA6HdXMBG4BngPuBU53yzLrqKo5MuYjLTi6WNmaBpiThlTeTdJcoEdEPA4g6TrgCLIhmEcBF6T6twK/kqRow7kLs1J+//vfFy3/6le/yle/+tVm65caKRb4YonlxwJjy43PrF7V4prM1yVNT6fTeqWyUq1p+qXpxuWr1YmIZcAioE+xF3QLHKuU5ct9QGHWEu2dZK4ABgJDgHnAz1J5qdY0TbWycQsca1eLFy9m1KhRtQ7DrENp1yQTEW9GxPKIWAFcxaobzEq1pmlI043LV6sjqSvQkzVvdjOriHnz5nHQQQdx8skn1zoUsw6lXZOMpM1zTz8LFFqeFW1NExHzgMWS9kityk4A7szVGZ2mjwQe8vUYq5Z99tmHs88+u6yOMs1slapd+E+tafYHNpXUAJwP7C9pCNlprbnAKQARMVNSoTXNMlZvTXMaWUu17mQX/O9J5VcDv0uNBN4ia51mVhW9evXi9ddfr3UYZh1ONVuXFWtNc3UTyxdtTRMRU4DBRcrfB45qS4xm5frLX/7C0UcfjaQme1s2s9X5jn+zMmy44YZMnDiRp59+utahmHUoTjJmZerSpUuTY8qY2Zo8noxZK7zzzjssW7Zs5XOPimlWnJOMWQtceeWVnHfeeXTv3p3UjR6SePnll2scmVl9cpIxa4GLL76YmTNnsummm9Y6FLMOwddkzFpg4MCBbLDBBrUOw6zD8JGMWQv893//N8OHD2f33XenW7duK8svu+yyGkZlVr+cZMxa4JRTTuGAAw5gxx13ZJ11fCLArDlOMmYt0LVrV37+85/XOgyzDsO7YmYtMGLECMaNG8e8efN46623Vj7MrDgfyZi1wA033ABk12YK3ITZrDQnGbMWmDNnTq1DMOtQmjxdJumdZh6LJf29vYI1q5WnnnqqIsuYdTbNXZN5KSJ6NPHYGHi3PQI1q6UTTzyRhQsXrnYdpvHjpJNOKlk/DTc+X9KzReZ9R1JI2jRXNkbSi5JmSTqkSm/LrOqaO132+TLWUc4yZh3aokWLGDp0KE2Ni9fM0N4TgF8B1+ULJW0FHAy8mivbnmx8pB2ALYAHJG2bG2PJrMNoMslExBpXMyV9OiL+1NQyablrgE8D8yNicCr7KfAZ4APgJeDEiHhbUn/geWBWqj4pIk5NdYayatCyu4FvRkRI6kb2gx0K/BM4JiLmlve2zVpm7ty5ZS1X6M+ssYh4JG3njV0CfJdVI74CjAJuioilwJw0MN9uwOPlR2xWH1rThPmHZS43ARjZqOx+YHBE7AT8HRiTm/dSRAxJj1Nz5VcAJ5MNyTwot86TgIUR8VGyH+pFLXoXZjUm6XDg9Yh4ptGsfsBruecNqazYOk6WNEXSlAULFlQpUrPWa02SKb6r1khEPEI2LHK+7L6IKPSPPgnYsskXkjYHekTE45Gdp7gOOCLNHgVcm6ZvBQ5Uqd1IszojaQPgHOC8YrOLlBU9TxcR4yJiWEQMa+Z0nVlNtCbJnFKh1/4KcE/u+QBJT0v6q6R9Ulk/sr24gvwe3cq9vZS4FgF9ir2Q9/asDg0EBgDPSJpLtsP1lKQPk23nW+WW3RJ4o90jNKuAJq/JSNo1IlZrlxkRk5tbpjmSzgGWAdenonnA1hHxz3QN5o+SdqDpPboW7e0B4wCGDRtW+sqtWRkWLlzI7Nmzef/991eW7bvvvi1aR0TMADYrPE+JZlhE/EPSROAGST8nu/A/CJhcdEVmda651mW/lbQ/TZ8iuxrYpdwXlDSarEHAgekUGOkC59I0PVXSS8C2ZHt0+VNq+T26wt5eg6SuQE8anZ4zq7Tx48dz6aWX0tDQwJAhQ5g0aRJ77rknDz30UJP1JN0I7A9sKqkBOD8iri62bETMlHQL8BzZztjpbllmHVVzSaYnMJWmk0zZ558kjQS+B+wXEf/KlfcF3oqI5ZI+Qrbn9nJEvJVu+NwDeAI4AfhlqjYRGE3W4uZI4KFC0jKrlksvvZQnn3ySPfbYg4cffpgXXniB888/v9l6EXFcM/P7N3o+FhjbpmDN6kBzTZj7t3bFxfbcyFqTdQPuT9foC02V9wV+KGkZsBw4NSIKRyWnsaoJ8z2suo5zNfC71LzzLbL7Csyqav3112f99dcHYOnSpXzsYx9j1qxZzdQy67yq1ndZiT23UqcHbgNuKzFvCjC4SPn7wFFtidGspbbcckvefvttjjjiCA4++GB69erFFltsUeuwzOqWO8g0a4E77rgDgAsuuIARI0awaNEiRo5sfDuYmRU4yZi10KOPPsrs2bM58cQTWbBgAa+//joDBgyodVhmdams+2QkPVhOmdna7gc/+AEXXXTRyvFk/v3vf/PFL36xxlGZ1a/m7pNZH9iA7OJ9L1a1MutB1n7frFO54447ePrpp9l1110B2GKLLVi8eHGNozKrX82dLjsFOJMsoeSbMr8D/Lp6YZnVp/XWWw9JKzvCfPddj3Rh1pQmT5dFxKURMQD4TkR8JCIGpMfOEfGrdorRrG4cffTRnHLKKbz99ttcddVVHHTQQXzta1+rdVhmdausC/8R8UtJw4H++ToRcV3JSmZrmYjgmGOO4YUXXqBHjx7MmjWLH/7whxx88MG1Ds2sbpWVZCT9jqxDv2lkN0tC1k+Yk4x1GpI44ogjmDp1qhOLWZnKbcI8DNje3bZYZ7fHHnvw5JNP8olPfKLWoZh1COUmmWeBD5P1lmzWaT388MNceeWVbLPNNmy44YZEBJKYPn16rUMzq0vlJplNgeckTSb1lgwQEYdXJSqzOnXPPfc0v5CZrVRukrmgmkGYdRTbbLMNAPPnz19tPBkzK67c1mV/rXYgZh3BxIkT+fa3v80bb7zBZpttxiuvvMLHP/5xZs6cWevQzOpSud3KLJb0Tnq8L2m5pHeqHZxZvTn33HOZNGkS2267LXPmzOHBBx9kr732qnVYZnWrrCQTERtHRI/0WB/4POCbMa3TWXfddenTpw8rVqxgxYoVjBgxgmnTptU6LLO61apemCPij5LOrnQwZvVuk002YcmSJey7774cf/zxbLbZZnTt6s7MzUop93TZ53KPIyVdSHYzZlN1rpE0X9KzubLeku6XNDv97ZWbN0bSi5JmSTokVz5U0ow07zKlTqMkdZN0cyp/QlL/lr55s5a688472WCDDbjkkksYOXIkAwcO5K677qp1WGZ1q6wkA3wm9zgEWAyMaqbOBKDxaE5nAw9GxCDgwfQcSduTDZ+8Q6pzuaQuqc4VwMnAoPQorPMkYGFEfBS4BLiozPdi1mobbrgh66yzDl27dmX06NGcccYZ9OnTp9l6JXa6firpBUnTJd0haZPcvKI7XWYdTbnXZE7MPb4WEWMjYn4zdR4B3mpUPAq4Nk1fCxyRK78pIpZGxBzgRWA3SZsDPSLi8dTbwHWN6hTWdStwYOEox6wOTWDNna77gcERsRPwd2AMNLvTZdahlHu6bMu0pzVf0puSbpO0ZSte70MRMQ8g/d0slfcDXsst15DK+qXpxuWr1YmIZcAioOgupaSTJU2RNGXBggWtCNusbYrtdEXEfWnbBZgEFH5TRXe62i1Yswoq93TZb4GJZOPK9APuSmWVUuwIJJoob6rOmoUR4yJiWEQM69u3bytDNMu89957zJo1q9Kr/QpQ6E6g1E7XGrwDZfWu3CTTNyJ+GxHL0mMC0Jr/1m+mU2Ckv4VTbg3AVrnltgTeSOVbFilfrY6krkBP1jw9Z1ZRd911F0OGDGHkyOzM17Rp0zj88Lb1riTpHGAZcH2hqMhi3oGyDqncJPMPSV+U1CU9vgj8sxWvNxEYnaZHA3fmyo9NLcYGkF3gn5xOqS2WtEe63nJCozqFdR0JPOReoq3aLrjgAiZPnswmm2wCwJAhQ5g7d26r1ydpNPBp4Pjc9ltqp8uswyk3yXwFOBr4P7KemI9MZSVJuhF4HNhOUoOkk4ALgYMlzQYOTs+JiJnALcBzwL3A6RFRGLfmNGA82Xnpl1h1SuFqoI+kF4FvkVqqmVVT165d6dmzZ0XWJWkk8D3g8Ij4V25W0Z2uiryoWTsrt++yV4EWnROIiONKzDqwxPJjgbFFyqcAg4uUvw8c1ZKYzNpq8ODB3HDDDSxfvpzZs2dz2WWXMXz48GbrpZ2u/YFNJTUA55O1JusG3J8aRk6KiFMjYqakwk7XMlbf6TLrUMptXXZtozb8vSRdU7WozOrUL3/5S2bOnEm3bt047rjj6NGjB7/4xS+arRcRx0XE5hGxbkRsGRFXR8RHI2KriBiSHqfmlh8bEQMjYruI8PgC1mGV2x/GThHxduFJRCyUtEt1QjKrXxtssAFjx45l7Ng1DrrNrIhyk8w6knpFxELIuodpQV2zDu8zn/kMTd3rO3HixHaMxqzjKDdR/Az4m6RbyZpSHk2R6ydma6vvfOc7tQ7BrEMq98L/dZKmAAeQteH/XEQ8V9XIzOrIfvvtV+sQzDqksk95paTixGKd2o477rjGabOePXsybNgwvv/979coKrP65esqZi1w6KGH0qVLF77whS8AcNNNNxER9OzZky9/+cu1Dc6sDjnJmLXAY489xmOPPbby+Y477shee+3FY489xu9///saRmZWn8q949/MgCVLlvDEE0+sfD558mSWLFkC4BEyzYrwr8KsBcaPH89XvvIVlixZQkTQo0cPxo8fz7vvvsuYMWM45phjah2iWV1xkjFrgU984hPMmDGDRYsWERErO8oEOProo51kzBpxkjFrgaVLl3Lbbbcxd+5cli1btrL8vPPOq2FUZvXLScasBUaNGkXPnj0ZOnQo3bp1q3U4ZnXPScasBRoaGrj33ntrHYZZh+HWZWYtMHz4cGbMmFHrMMw6jHZPMpK2kzQt93hH0pmSLpD0eq78sFydMZJelDRL0iG58qGSZqR5l6mpHgzNKuDRRx9l6NChbLfdduy0007suOOO7LTTTrUOy6xutfvpsoiYBQwBkNQFeB24AzgRuCQiLs4vL2l74FhgB2AL4AFJ26ZBnK4ATgYmAXcDI1k1cqZZxd1zjzcvs5ao9emyA4GXIuKVJpYZBdwUEUsjYg7ZMMy7Sdoc6BERj6ex0a8Djqh6xNapbbPNNmyzzTZ0794dSSsfZlZcrZPMscCNuedflzRd0jWSeqWyfsBruWUaUlm/NN24fA2STpY0RdKUBQsWVC5663QmTpzIoEGDGDBgAPvttx/9+/fn0EMPrXVYZnWrZklG0nrA4cAfUtEVwECyU2nzyMawgWxogcaiifI1CyPGRcSwiBjWt2/ftoRtndy5557LpEmT2HbbbZkzZw4PPvgge+21V63DMqtbtTySORR4KiLeBIiINyNieUSsAK4CdkvLNQBb5eptCbyRyrcsUm5WNeuuuy59+vRhxYoVrFixghEjRjBt2rRm66Wj8/mSns2V9ZZ0v6TZ6W+v3LyijV3MOppaJpnjyJ0qS9dYCj4LFH6ME4FjJXWTNAAYBEyOiHnAYkl7pFZlJwB3tk/o1lltsskmLFmyhH333Zfjjz+eb37zm+V2jDmBrGFK3tnAgxExCHgwPW/c2GUkcHlqJGPW4dQkyUjaADgYuD1X/JPUHHk6MAI4CyAiZgK3kA2Ydi9wempZBnAaMJ6sMcBLuGWZVdmdd95J9+7dueSSSxg5ciQDBw7krrvuarZeRDwCvNWoeBRwbZq+llUNV4o2dqnIGzBrZzW54z8i/gX0aVT2pSaWHwuMLVI+BRhc8QDNSthwww1XTo8ePbqtq/tQOiInIuZJ2iyV9yNrll/QZKMWsmb8bL311m2Nx6ziat26zKxD2HvvvQHYeOON6dGjx8pH4XmFuVGLrTXcd5lZGR599FEAFi9eXMnVvilp83QUszkwP5WXauxi1uH4SMasTCtWrGDw4IqenZ0IFM65jWZVw5WijV0q+cJm7cVJxqxM66yzDjvvvDOvvvpqi+tKuhF4HNhOUoOkk4ALgYMlzSZrCHMhNNvYxaxD8ekysxaYN28eO+ywA7vttttqjQAmTpzYZL2IOK7ErANLLF+0sYtZR+MkY9YC559/fq1DMOtQnGTMWuDuu+/moosuWq3se9/7Hvvtt1+NIjKrb74mY9YC999//xpl7v7frDQfyZiV4YorruDyyy/n5ZdfXm2QssWLF7uDTLMmOMmYleELX/gChx56KGPGjOHCCy9cWb7xxhvTu3fvGkZmVt+cZMzK0LNnT3r27MmNN97Y/MJmtpKvyZiZWdU4yZiZWdU4yZiZWdU4yZiZWdXUatCyuWmAsmmSpqSyFg9FK2loWs+Lki5LI2SamVmdqOWRzIiIGBIRw9Lz1gxFewXZgE2D0qPx8LZmZlZD9XS6rEVD0abxN3pExOMREcB1uTpmZlYHapVkArhP0tQ0fCw0GooWyA9F+1qubmEo2n5punH5GiSdLGmKpCkLFiyo4NswM7Om1OpmzL0i4o00pvn9kl5oYtlSQ9G2aIhaYBzAsGHDii5jZmaVV5MjmYh4I/2dD9wB7EYaihagzKFoG9J043IzM6sT7Z5kJG0oaePCNPBJ4FlaOBRtOqW2WNIeqVXZCbk6ZmZWB2pxuuxDwB2ptXFX4IaIuFfSk8AtaVjaV4GjIBuKVlJhKNplrD4U7WnABKA7cE96mJlZnWj3JBMRLwM7Fyn/Jy0cijYipgCDKx2jmZlVRj01YTbrlCSdJWmmpGcl3Shp/aZuTjbrSJxkzGpIUj/gDGBYRAwGupDdfFz05mSzjsZJxqz2ugLdJXUFNiBrJVnq5mSzDsVJxqyGIuJ14GKyxi7zgEURcR+lb05ejW80tnrnJGNWQ+layyhgALAFsKGkL5ZbPyLGRcSwiBjWt2/faoVp1mpOMma1dRAwJyIWRMS/gduB4ZS+OdmsQ3GSMautV4E9JG2Qbio+EHie0jcnm3Uoteq7zMyAiHhC0q3AU2Q3Gz9N1s/eRhS5Odmso3GSMauxiDgfOL9R8VJK3Jxs1pH4dJmZmVWNk4yZmQdurxonGTMzXzioGicZM+v0NurRvdYhrLWcZMys01vh8XKrxknGzDq9ATts1fxC1iq1GBlzK0kPS3o+dW/+zVR+gaTXJU1Lj8NydcZIelHSLEmH5MqHSpqR5l2WbmYzM2uRd99eUusQ1lq1uNy1DPh2RDyVhmGeKun+NO+SiLg4v7Ck7cm6Pt+BrG+nByRtm0bHvAI4GZgE3A2MxKNjmlkL9R/cv9YhrLXa/UgmIuZFxFNpejFZFxr9mqgyCrgpIpZGxBzgRWC31J9Tj4h4PCICuA53h25mJWzQa4OS8w792kHtGEnnUtNrMpL6A7sAT6Sir0uaLuma3EiA/YDXctUaUlm/NN243MxsDe+9817JebMe/3s7RtK51CzJSNoIuA04MyLeITv1NRAYQjauxs8KixapHk2UF3stj7lh1sl9aOvSQyF8fM/t2jGSzqUmSUbSumQJ5vqIuB0gIt6MiOURsQK4CtgtLd4A5Jt+bEk2cmBDmm5cvgaPuWFm818tvYM5Z/qr7RhJ51KL1mUCrgaej4if58o3zy32WeDZND0ROFZSN0kDgEHA5DRa4GJJe6R1noC7QzezErpvtH7JeRv12bAdI+lcanEksxfwJeCARs2Vf5KaI08HRgBnAUTETOAW4DngXuD01LIM4DRgPFljgJdwyzIzK2HkSVmn1rsevOPKsu332hbWgV1G7FiqmrVRuzdhjohHKX495e4m6owFxhYpnwIMrlx0Zra2emVm1n7oqftn0OtDPVmy8F2eeyy74P/2/EVsukXvWoa31vId/2bW6WzYc0OyOx8yWsf/CqvFn6yZdQon/uhYem++CQANf3+DZf/OzrrvetBO9N9hyyZqWls4yZhZp7DtsI/yo4nfI9/51Ed22ob/d89/0aVLl9oFtpZzkjGzTmHOjFc5c+/zyJ0l4+Xpr3DOp/6b5cuXl65obeIkY1ZjkjaRdKukF1LHsXtK6i3pfkmz099eza/JmnLV937Hv5f+G4DvXfcNhhyQtRmaet8zzJ3Z0FRVawMnGbPauxS4NyI+BuxM1p/f2cCDETEIeDA9tzbY+uPZdZdzb/kWB31xX8b+aQyD9/k466wjNunbo8bRrb2cZMxqSFIPYF+yG5SJiA8i4m2yjmGvTYtdizt/bbPuG3UD4J9vLARg6Xsf8P6S9+nS1ddjqskjW5vV1keABcBvJe0MTAW+CXwo9WpBRMyTtFmxypJOJhvugq233rp9Iu6gjv/+kcyd2cDlZ/6WJQvf5fE/TeGVma9x/u3/SZ/NfTayWnwkY1ZbXYFdgSsiYhfgXVpwasz98pWv67pdOefGMxlywGCu+8EtzJ76Muff/p/sftiutQ5treYkY1ZbDUBDRBSGu7iVLOm8WejPL/2dX6P41irvLXmfd/6xeOXzN178vxpG0zk4yZjVUET8H/CapEJf8weS9dM3ERidykbjzl/bbPHCJXzvkz/itRde5wd3fJe9P7c7l5/5W+64rGSPVlYBviZjVnvfAK6XtB7wMnAi2Q7gLZJOAl4FjqphfGuFib/+M3NnvLryFNluh+3C2ON+wTXn3MC+R+3p6zJV4iRjVmMRMQ0YVmTWge0cylrt2DFHsPunduWjuwwAVl2jeeW5BieYKvLpMjPrFLp06bIywRR0XbcrA3fuX5uAOgknGTMzqxonGTMzq5oOn2QkjZQ0S9KLktz1hplZHenQSUZSF+DXwKHA9sBxkravbVRmZlbQoZMMsBvwYkS8HBEfADeR9flkZmZ1oKM3Ye4HvJZ73gDs3nihfP9OwBJJs0qsb1PgHxWNsPXqJZZWxaGLqhBJx/hMtmnPQPKmTp36D0mvlJjdET679lYvsdRLHFCFbbujJxkVKYs1CiLGAeOaXZk0JSKK3a/Q7uollnqJA+onlnqJo7GIKNl5Wb3EXC9xQP3EUi9xQHVi6einyxqArXLPtwTeqFEsZmbWSEdPMk8CgyQNSF1yHEvW55OZmdWBDn26LCKWSfo68GegC3BNRMxswyqbPaXWjuollnqJA+onlnqJoyXqJeZ6iQPqJ5Z6iQOqEIsi1riEYWZmVhEd/XSZmZnVMScZMzOrmk6XZCT1lnS/pNnpb9E+viXNlTRD0jRJU1pavxJxSNpK0sOSnpc0U9I3c/MukPR6im+apMNaEUOTXfIoc1maP13SruXWrXAcx6fXny7pb5J2zs0r+j1VMZb9JS3Kfe7nlVu30lqwLReNq6ltSNKYtPwsSYe0Qyw/lfRC+o7vkLRJKu8v6b1cjL9pyXpz81u8Lbf2t97aWCr9e2/jZ1K5/38R0akewE+As9P02cBFJZabC2za2vqViAPYHNg1TW8M/B3YPj2/APhOGz6HLsBLwEeA9YBnCuvOLXMYcA/Z/Uh7AE+UW7fCcQwHeqXpQwtxNPU9VTGW/YE/taZuLbblpuIqtQ2RddH0DNANGJDqd6lyLJ8Euqbpiwr1gf7As7XYlst5TxWOpWK/97bE0dTvqjWfSac7kiHrdubaNH0tcEQ71y97PRExLyKeStOLgefJejmohHK65BkFXBeZScAmysabr2R3Ps2uKyL+FhEL09NJZPdDVUNb3lctujgqZ1tsTVyjgJsiYmlEzAFeTOupWiwRcV9ELEvLtfQ7rta23JrfeqtjqfDvvS2fSVNa/Jl0xiTzoYiYB9k/cWCzEssFcJ+kqcq6pWlp/UrFAWSnDYBdgCdyxV9Ph7nXlHson1OsS57GG3SpZcqpW8k48k4i2/sqKPU9VTOWPSU9I+keSTu0sG4llbMNNRdXsW2oNe+lErEUfIXVv+MBkp6W9FdJ+7Ryva3ZllvzW29LLCtV4Pfe1jgq9v+vQ98nU4qkB4APF5l1TgtWs1dEvCFpM+B+SS9ExCM1iANJGwG3AWdGxDup+ArgR2Qbw4+An5H9OMtebZGyxu3ZSy1TVnc+FYwjW1AaQZZk9s4Vt/l7amEsTwHbRMSSdF78j8CgMuu2PKC2b0NNxVVqGypap8qxZAtI5wDLgOtT0Txg64j4p6ShwB8l7ZD7HZS13iaWqfT31pZYspmV+b23NY6K/a7WyiQTEQeVmifpzcKhaTo0nF9iHW+kv/Ml3UF2+PkIUFb9SsUhaV2yDe76iLg9t+43c8tcBfyp1GuVUE6XPKWWWa+MupWMA0k7AeOBQyPin4XyJr6nqsSS/+cWEXdLulzSpuW+j5aqwDZUMq4mtqGidaoZS1rHaODTwIGRTvpHxFJgaZqeKuklYFsg38ijWtty2b/1CsVSyd97m+KoxP+/lZq7aLO2PYCfsvqFq58UWWZDYOPc9N+AkeXWr2AcAq4DflFk3ua56bPIzqG35PW7Ai+TXdgtXBjcodEyn2L1C4OTy61b4Ti2JrsuMLzc76mKsXyYVTcx7wa8mj6fin0mFd6GSsZVahsCdmD1C/8v0/yF/7bGMhJ4DujbqE7fwmuTXcR+HejdHttyOe+pwr+riv3e2xhHRf//Ve0HUK8PoA/wIDA7/e2dyrcA7s5tzM+kx0zgnObqVymOvckOX6cD09LjsDTvd8CMNG9ifiNsQQyHkbVgeanwHoFTgVNzG/2v0/wZwLCm6rbhO2kujvHAwtxnMKW576mKsXw9vdYzZBeohzdVt9bbclNxNbUNkZ0CewmYRXb0WO1YXiS7PlD4jn+Tyj+f+7yfAj7TXttyqfdUrd8VFf69tyGOiv7/c7cyZmZWNZ2xdZmZmbUTJxkzM6saJxkzM6saJxkzM6saJxkzM6uamiWZ1Kvod9L0DyU1daPXEZK2b7/oVnvtbpIeSL2RHtPOr/23dn69o1IPsA83Ku8v6QtN1NtC0q1ViOfLkn5V6fWW8bpDyunltki9UyWdUKS8v6RnW7Ce5Wl726IFdfaR9FxLXsesPdTFkUxEnBcRDzSxyBFkPcPWwi7AuhExJCJuzs+Q1KUaL1hYb0QMr9S6ynQS8B8RMaJReX+gaJKR1DUi3oiII1sZYj0aQnaPwRoklewlIyJ+ExHXVeD130vbW9k9BkTE/1Ii5o6iA+14Frrd/2EL610v6S1Ja9NvpVntmmQknaNsfIMHgO1y5RMKH7ykC9Me2XRJF0saDhwO/DTt3Q2U9DVJTyrrpPA2SRvk1nOZsjFHXs5/mZK+q2x8hGckXZjKBkq6V1kncP8r6WON4t0M+D0wJPfacyWdJ+lR4ChJx6X1PivpolzdJZIuSut+QNJukv6S4jq8yGezv7KxJG4guzEKSUvS35u1+lgfEyR9XlIXZeNwPJk+r1NKravRa60Rs7JxUfYGfiPpp42qXAjskz6Ds9IRxh8k3UXWid7KPfU0/b+SnkqP4bmY/iLpVmXjhlwvSWneYans0fT9rdFlhqS+6bt+Mj32KrJMl7TNzEifxzdS+VBlnStOlfRnpZ5mUzwXSZos6e/KjgbWA34IHJPe7zHpn8o4SfcB10naRtKD6TUelLR1Wl/+n+TQtK09Dpyei3GH9HrTUv1Bjd9HkffVom1pbVDnO54Al0TEec0vtkpEHE92I2XnUu27knN3ig4l+4e3AdCD7A7f76R5E4Ajgd5kdxgXbhLdJD8/f9dpbvrHwDdyy/2BLHluT9bVNWRjkPwN2CA9L9yN/CAwKE3vDjxUJO79yY0fQjbOwndzdzO/Stb1RVfgIeCINC9Id0oDdwD3AesCOwPTSrzOu8CAXNmS9PezwLVpej2yO6O7AycD30/l3cj6cxpQbF25dTYV81/I3QndxGfwZbJ+jwqfY3/SmB/p+10/TQ9i1d35+wOLyPpHWgd4nCyprZ/ez4C03I2F10qv86s0fQOwd5reGni+SJynkfX7VBiXpHf6zP9G6q4EOAa4Jvd+f5a7O/qBxq+bnl8ATAW6p+d3AaPT9FeAP+aWK2zT04H90vRPc5/PL4Hjc99l9yLvY0mj52VtS5Qx9kq9Pch6FpgFPJC++9X+J6TpC8m6nJkOXEw2vtBbwByyu+IHAl8DniS7S/02Vv3WJwCXpW3gZVb/P/Jdsv9JzwAXprKBwL3p+/5f4GNFYl75PeeeX5u+l7nA58jGXZmR1rVubtkJ+Rg6w6M9O8jcB7gjIv4FIKlYRn8HeB8YL+l/KN0J3GBJPwY2ATYC/pyb98eIWAE8J+lDqewg4LeF146It5T1dDoc+EPaoYbsH3U5CqfNPgH8JSIWpPd0PbAvWc+8H5BtYJBtbEsj4t+SZpD9MyhmcmTjdzR2D3CZpG5kfTw9EhHvSfoksJNWHbH1JPvH/kET62oq5pa4PyLeKlK+LvArSUOA5WSdGebfX0N63Wlkn8MS4OVcrDeSJc/GDgK2z31XPSRtHNm4G/llfhNpXJL0PQ8GBpP1JAvZYE7zcnUKnRBOpfT3AjAxIt5L03uS/SOBrLuPn+QXlNSTbAfpr7llDk3TjwPnSNoSuD0iZjfxmgWt2ZbqnrJelY8lOyXdlazbmKmNlulNtpP1sYgISZtExNvp/8efIuLWtNzbEXFVmv4x2anfX6bVbE62Q/MxsiOJWyUdSnY0tHtE/Cu9DsA4sm5XZkvaHbgcOKCMtzMQGEG2c/s48PmI+K6yziU/Rct/X2uN9u6Fuck+bCJimaTdgAPJNr6vU/wLnkC29/2MpC+T7SUXLM1NK/e38WuvA7wdEUPKjD3v3UbrL+bfkXZdgBWs6kl2hUqf13+3WGFEvC/pL8AhZHviN+Ze/xsRkU+ySNq/1LqaibklSq3/LOBNsr3sdch2Ggry381ysu2v3HjWAfbM/aMvptj3LGBmROxZok4hpkI8pZR6v5R4zaLbekTcIOkJsn88f5b01Yh4qIl1Q+u2pY5gbdrxvCeX+Luw+k5B/zLXsVZqz2syjwCfldRd0sbAZxovkL7knhFxN3Am2QVYgMVkw5EWbAzMU9Yt9vFlvPZ9wFe06tpN78i6bJ8j6ahUJuXGji/TE8B+kjZVdoH9OOCvzdRprZuAE8l+mIUf0J+B09LngKRtJW1YhZgbf/5N6QnMSz/qL5H94JryAvARZYM0QZZEi7mPbKcDyFqAlVjm1MI/3rR3OgvoK2nPVLauVg00Vkpz7/dvZDtBkG1/j+ZnRsTbwCJJe+eWKcT9EbIjt8vI9qp3aiaWtV2zO55kvV3fRnbkcW+JRScAX4+IHYEfkJ2GLWjxjmfu8fFy3gS5xM+aOwUdeUegzdotyUQ2rOjNZOdQbyM739nYxsCfJE0n+8d3Viq/CfhPZaPjDQTOJftneT/ZP6nmXvtesh/0lHSa5jtp1vHASZIKvY2OauF7mgeMAR4m9RIbEXe2ZB0tcB/Zaa0HIhtOFbLeiZ8DnlJ24f1KmtmgWxnzdGBZupB9VjPLXg6MljSJ7FRZU0cApCOT/wDuVdaY4k2yazeNnQEMSxfLnyPrTbax8WTXm6an7/QL6bM6ErgolU0j21ttysNkp+ZKNVs/AzgxbadfAr5ZZJkTgV+nC//5o69jgGfTdvgxsq7dO6u1ccfTGnEvzFZzkjaKbKTJQtfjsyPiklrHVSuSlkTERq2o15/sOsXgykdVHcpGwjwBeIWsMclzEXGxpAlkp8YeA+4kOzIRcHFEXKusdeFVZEcQRwKfJLuQ/wrZKaqNI+LLhfXkrt2s/GwlnZ1e+wOy4Qj+S9IAslEoNye7vnhTRKzWVFnSBWSNMy4u8Tz/Go3nrRZPZ+AkYzWXjo5Gk7W2ehr4WuFceWck6Q2yEQcPizLvlZG0D9lR5D8jYv8qhtfpNU4cLaw7AScZMzMrRdm9UCeTHeWUfa9Mask5nKyxTkuHS++wnGTMzKxq6qJbGTMzWzs5yZiZWdU4yZiZWdU4yZiZWdX8f9xitXu8TqIPAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZMAAAEGCAYAAACgt3iRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAvL0lEQVR4nO3deZwU1bn/8c93ZmDYh92wCcSLcUElMhpFo+ISMYtws7gnuCQYr1n06i/qNYrJDa9g9MbEJBoJMeh1i4kaMTeoSFziiqAIohJQUBEiLmzDMizz/P6oM1A03TM9Pd1TM93P+/XqV1ef2p6uru6nq+rUOTIznHPOueYoSzoA55xzbZ8nE+ecc83mycQ551yzeTJxzjnXbJ5MnHPONVtF0gEUSu/evW3IkCFJh+GK1Ny5cz80sz4tvV7fr10hNWe/LtpkMmTIEObMmZN0GK5ISXo7ifX6fu0KqTn7tZ/mcs4512yeTJxzzjWbJxPnnHPN5snEOedcs3kycc4VlaWvvcO61et3KfvnS29Su7k2oYhKgycT5/JE0iBJj0t6XdJCSd8P5T0lzZS0ODz3iM1zhaQlkhZJOjG56IvD6g/WMGH4JXyl17k7Esrcma9wYfXlfLHTWQlHV9w8mTiXP9uAS8xsX+Aw4EJJ+wGXA7PMbBgwK7wmjDsN2B8YA9wkqTyRyIvEhrU1O4a/0utcnpk+m8tP/EmCEZUOTybO5YmZrTSzl8LweuB1YAAwFrgtTHYbMC4MjwXuMbNaM1sKLAEObdGgi0xZ2a4/adeMuy6hSEqPJxPnCkDSEODTwAvAHma2EqKEA/QNkw0A3o3NtjyUpS5rgqQ5kuZ88MEHBY27rTO8f6akFO0d8K5phlz+fznNt2zyF/IcSdsnqQtwH3CRma2TlHHSNGW7/Rqa2RRgCkB1dbX/WjagdqNfZE+KH5k4l0eS2hElkjvN7P5Q/L6kfmF8P2BVKF8ODIrNPhBY0VKxFqOttVuTDqFkeTJxLk8UHYL8HnjdzH4eGzUdGB+GxwMPxspPk1QpaSgwDJjdUvEWIz/NlRw/zeVc/hwBfB1YIGleKPsvYDJwr6TzgHeArwGY2UJJ9wKvEdUEu9DMtrd41EWkZs3GpEMoWZ5MnMsTM3ua9NdBAI7LMM8kYFLBgiox27fVJR1CyfLTXM65orH6o/WNT+QKwpOJc65o9OrbLekQSpYnE+dc0VC5/6Qlxbe8c65obN28LekQSlZBk4mkZZIWSJonaU4oa3Kjd5JGhuUskXSjGrgLzDlXujZt2Jx0CCWrJY5MRpvZCDOrDq9zafTuZmACUT38YWG8c87twu8ySU4Sp7ma1OhduGO4m5k9Z2YG3B6bxznndujQuTLpEEpWoZOJAY9KmitpQihraqN3A8JwavluvEE850rbho83JB1CySr0TYtHmNkKSX2BmZLeaGDaTI3eZdUYHniDeM6VurL2XqcoKQXd8ma2IjyvAh4g6quhqY3eLQ/DqeXOObeLjp06JB1CySpYMpHUWVLX+mHgc8CrNLHRu3AqbL2kw0Itrm/E5nHOuR22bPGmzZJSyNNcewAPhFq8FcBdZvawpBdpeqN3FwDTgI7AjPBwzrldeTuZiSlYMjGzt4CD0pR/RBMbvTOzOcDwfMfonCsu6z+uaXwiVxB+tco5VzTad/CqwUnxZOKcKxoduvgF+KR4MnHOFY0Pl/n9ZUnxZOKcKxrd+3VPOoSS5cnEOVc0Vr/3cdIhlCxPJs65otGpV+ekQyhZnkycc0Vj9YrVSYdQsjyZOOeKRs/+PZMOoWR5MnEuTyTdKmmVpFdjZSMkPV/fQZykQ2Pj0nYG53LXrrJd0iGULE8mzuXPNHbvuO1nwI/MbARwdXjdWGdwLkdLFyxLOoSS5cnEuTwxs6eA1OpEBnQLw1XsbPE6bWdwLRJoEeu5R/ekQyhZhe7PxLlSdxHwiKTrif68jQrlA4DnY9Nl7PTNZa/GO8dKjB+ZOFdYFwAXm9kg4GLg96E8607fvAfR7PXfp3/SIZQsTybOFdZ44P4w/Cd2nsrK1BncbsxsiplVm1l1nz59ChZoMdi4ZmPSIZQsTybOFdYK4OgwfCywOAyn7QwugfiKypr3/T6TpPg1E+fyRNLdwDFAb0nLgYnAt4BfSqoANgMToNHO4FyOytt51eCkeDJxLk/M7PQMo0ZmmD5tZ3Aud127d0k6hJLlp7mcc0Vja+2WpEMoWZ5MnHNFo6zMf9KS4lveOVc00tatdi3Ck4lzrmjU1PhNi0nxZOKcKxpdq/wCfFI8mTjnikbddj/RlRRPJs65orFlU23SIZQsTybOuaKxdfO2pEMoWZ5MnHNFY3Pt5qRDKFmeTJxzRaN9ZfukQyhZnkycc0WjS4/OSYdQsjyZOOeKxoYPa5IOoWR5MnHOFY31Gz2ZJKXgyURSuaSXJf01vO4paaakxeG5R2zaKyQtkbRI0omx8pGSFoRxN0pK10udc67E9ejZo/GJXEG0xJHJ94HXY68vB2aZ2TBgVniNpP2A04D9gTHATZLKwzw3E/UDMSw8xrRA3M65Nsa8da7EFDSZSBoIfAGYGiseC9wWhm8DxsXK7zGzWjNbCiwBDpXUD+hmZs+ZmQG3x+ZxzrkdPvrAe1pMSqE7x/oF8AOga6xsDzNbCWBmKyX1DeUDgOdj0y0PZVvDcGr5biRNIPRkt+eee+YhfFdKTj755Ean6dmzJ9OmTSt8MC4n7cq9v7+kFGzLS/oisMrM5ko6JptZ0pRZA+W7F5pNAaYAVFdX+/Gua5LXX3+dqVOnZhxvZlx44YUtGJFrqm3btyYdQskqZBo/AjhZ0ueBDkA3SXcA70vqF45K+gGrwvTLgUGx+QcCK0L5wDTlzuXVpEmTOProoxucZuLEiS0UjctFv6H9kw6hZBXsmomZXWFmA81sCNGF9b+b2VnAdGB8mGw88GAYng6cJqlS0lCiC+2zwymx9ZIOC7W4vhGbx7m8OeWUU/IyjUvOe2+9l3QIJSuJ+0wmAydIWgycEF5jZguBe4HXgIeBC81se5jnAqKL+EuAN4EZLR20K37bt2/nlltu4aqrruKZZ57ZZdxPfvKThKJyTVFbu73xiVxBtEgyMbMnzOyLYfgjMzvOzIaF549j000ys73M7FNmNiNWPsfMhodx3wm1upzLq/PPP58nn3ySXr168b3vfY///M//3DHu/vvvTzAyl60Kv/6eGL8D3rlg9uzZ3HXXXVx00UW88MIL1NTU8OUvf5na2lqy+f8i6VZJqyS9mlL+3XAj7kJJP4uVp71J1zWH/6Qlxbe8c8GWLVt2DFdUVDBlyhRGjBjBscceS01NVs10TCPlhlpJo4nuoTrQzPYHrg/lDd2k63LUs0dV0iGULE8mzgXV1dU8/PDDu5RdffXVnHPOOSxbtqzR+c3sKeDjlOILgMlmVhumqa+9mPYm3ea9A/feex8kHULJ8mTiXHDHHXcwZszuLfV885vfZOvWnO9f2Bv4rKQXJD0p6ZBQPgB4NzZdgzfjSpojac4HH/iPZUPqtnlPi0nxZOJciu3b81ojqALoARwG/D/g3lDFvUk345pZtZlV9+nTJ5+xFZ1u3b0/k6R4MnEuZv369YwdOzafi1wO3G+R2UAd0JvMN+m6Zti4ye+AT4onE+eClStXcvzxxzNhwoR8LvYvwLEAkvYG2gMfkuEm3XyuuBT17u0X4JPitbKdCz772c9y3XXXZdXgYzqS7gaOAXpLWg5MBG4Fbg3VhbcA48N9Ugsl1d+ku41db9J1OVq/zjvHSoonE+eCHj168N57uTfHYWanZxh1VobpJwGTcl6h282qZd4EfVL8NJdzwRNPPMGMGTP4zW9+k3QoLkcDPuUVFJLiycS5oHPnzkyfPp2XX3456VBcjj5asT7pEEqWJxPnYsrLyxvs08S1bh26+Zn7pPiWdy6DdevWsS12E1zPnj0TjMZlx/8fJ8WTiXMpbrnlFq6++mo6duxIdH8hSOKtt95KODLXmE2rNycdQsnyZOJciuuvv56FCxfSu3fvpENxTbRt+5bGJ3IF4ceEzqXYa6+96NSpU9JhuByUlXnDy0nxIxPnUvz0pz9l1KhRfOYzn6GysnJH+Y033phgVC4b5ZWeTJLiycS5FOeffz7HHnssBxxwAGVlfvDelqx5d03SIZQsTybOpaioqODnP/950mG4HHTu7qcnk+J/u5xLMXr0aKZMmcLKlSv5+OOPdzxc67fybW94OSl+ZOJcirvuuguIrp3U86rBbUOXrlXs3tmlawmeTJxLsXTp0qRDcDnqPbgX/3zWP78kNHiaS9K6Rh7rJf2zpYJ1rpBeeumlvEzjkvPmvCVJh1CyGjsyedPMPt3QBJK8VTxXFM455xyeeOIJou5G0jvvvPO8IchWrEOnjsCapMMoSY0lk69ksYxspnGu1Vu7di0jR45sMJl4H+yt26aNG5MOoWQ1mEzMbLcrjpK+aGZ/bWga59qiZcuWJR2Ca6Z+g/qz6vW1SYdRknKpGvzjvEfhnHN5YN40V2JySSbKexTOOZcHH364KukQSlYuyeT8vEfhnHN50LVHt6RDKFkNXjORdLCZ7VIX0sxmNzaNc23d6tWrWbx4MZs37+wf46ijjkowIpeNctolHULJauzI5A+SekjqmekB/D7djJI6SJot6RVJCyX9KJT3lDRT0uLw3CM2zxWSlkhaJOnEWPlISQvCuBtV32ORcwUwdepUjjrqKE488UQmTpzIiSeeyDXXXNPofJJulbRK0qtpxl0qyST1jpWl3d9d7nrs2T3pEEpWY8mkCpjbyGNrhnlrgWPN7CBgBDBG0mHA5cAsMxsGzAqvkbQfcBqwPzAGuElSfXvSNwMTgGHhMaapb9S5bP3yl7/kxRdfZPDgwTz++OO8/PLL2VYJnkaafVPSIOAE4J1YWUP7u8vRpo82JB1CyWqsavCQXBdsUWX9mvCyXXgYMBY4JpTfBjwBXBbK7zGzWmCppCXAoZKWAd3M7DkASbcD44AZucbmXEM6dOhAhw4dAKitrWWfffZh0aJFjc5nZk9JGpJm1A3AD4AHY2Vp93fguWaGX9I+/NcHSYdQsgraarCkcknzgFXATDN7AdjDzFYChOe+YfIBwLux2ZeHsgFhOLU83fomSJojac4HH/hO5XIzcOBA1qxZw7hx4zjhhBMYO3Ys/fv3z2lZkk4G3jOzV1JGZdrfXTP0HORdLSeloA09mtl2YISk7sADkoY3MHm66yDWQHm69U0BpgBUV1dnvo3ZuQY88MADAFxzzTWMHj2atWvXMmZM08+sSuoEXAl8Lt3oNGVp91lJE4hO87Lnnns2OY5Ssm1dprPurtBapD8TM1tDdDprDPC+pH4A4bm+YvhyYFBstoHAilA+ME25cwXz9NNP84c//IGjjz6aww8/nPfeey+XxewFDAVeCadrBwIvSfoEmff33ZjZFDOrNrNqb86lYdu2bk86hJKVVTKRNCubspTxfcIRCZI6AscDbwDTgfFhsvHsPI88HThNUqWkoUQX2meHU2HrJR0WanF9g13PPTuXVz/60Y+49tprd/RnsnXrVs4666wmL8fMFphZXzMbEq4/LgcONrN/kWF/z9ubKFEVHbxXjaQ0dp9JB6AT0DtU4a0/NO8GNHYSuR9wW6ihUgbca2Z/lfQccK+k84hqt3wNwMwWSroXeA3YBlwYTpMBXEBUU6Yj0YV3v/juCuaBBx7g5Zdf5uCDDwagf//+rF+/vtH5JN1NVLmkt6TlwEQzS1t1vpH93eVo04ZNSYdQshpL4+cDFxEljrnsTCbrgN80NKOZzQd2a77ezD4CjsswzyRgUpryOUBD11ucy5v27dsjifrbmTZsyK66qZmd3sj4ISmv0+7vLneVHSqTDqFkNXiay8x+aWZDgUvN7JNmNjQ8DjKzX7dQjM61qFNOOYXzzz+fNWvW8Lvf/Y7jjz+eb33rW0mH5bKwedPmxidyBZHVCUYz+5WkUcCQ+DxmdnuB4nIuEWbGqaeeyhtvvEG3bt1YtGgRP/7xjznhhBOSDs1lYev2bUmHULKySiaS/peoZso8oP68rgGeTFxRkcS4ceOYO3euJ5A2qG5rXdIhlKxsqz5UA/tZQ13QOVckDjvsMF588UUOOeSQpENxTVTndRgSk20yeRX4BLCygLE41yo8/vjj3HLLLQwePJjOnTtjZkhi/vz5SYfmGtGjqicr+SjpMEpStsmkN/CapNlEDTgCYGYnFyQq5xI0Y4bXPG+rPv74w6RDKFnZJpNrChmEc63J4MGDAVi1atUu/Zm41m/Dpo1Jh1Cysq3N9WShA3GutZg+fTqXXHIJK1asoG/fvrz99tvsu+++LFy4MOnQXCPatWtP7OSJa0HZNqeyXtK68NgsabukdYUOzrkkXHXVVTz//PPsvffeLF26lFmzZnHEEUckHZbLQmUH72kxKVklEzPrambdwqMD8BXAb1p0Raldu3b06tWLuro66urqGD16NPPmzUs6LJeFcrx/saTk1Cqamf1F0uX5Dsa51qB79+7U1NRw1FFHceaZZ9K3b18qKrwBwbZgu/l9JknJ9qbFL8delhHdd+L3nLii9OCDD9KxY0duuOEG7rzzTtauXcvVV1+ddFguC/9a6dWCk5Lt360vxYa3AcuIuh11ruh07twZgLKyMsaPH9/I1K416d+vF+996AklCdnW5jqn0IE451xzlZX5BfikZFuba6CkByStkvS+pPskDWx8Tuecaznb67zb3qRk223vH4h6husPDAAeCmXOFaVNmzaxaNGipMNwTVRR4bW5kpJtMuljZn8ws23hMQ3wzqhdUXrooYcYMWIEY8aMAWDevHmcfLK3HNQWqMyTSVKyTSYfSjpLUnl4nAXemporTtdccw2zZ8+me/fuAIwYMYJly5YlGpPLTm2t3/2elGyTybnAKcC/iFoO/mooc67oVFRUUFVVlXQYLgedO3ZOOoSSlW1trncAP853JWH48OHcddddbN++ncWLF3PjjTcyatSopMNyWdi2zXtaTEq2tbluk9Q99rqHpFsLFpVzCfrVr37FwoULqays5PTTT6dbt2784he/SDos51q1bG9aPNDM1tS/MLPVkj5dmJCcS1anTp2YNGkSkyZNSjoU10QVlX6fSVKyTSZlknqY2WoAST2bMK9zbcKXvvQlJGUcP3369AbnD0frXwRWmdnwUHYdUQsSW4A3gXPq/5hJugI4D9gOfM/MHmn+uyhty5e/l3QIJSvbhPA/wLOS/kzUJtcpgP9tc0Xl0ksvbe4iphG1pn17rGwmcIWZbZN0LXAFcJmk/YDTgP2J7t96TNLeZt6JeXP06d2b5cvfTzqMkpTtBfjbJc0BjgUEfNnMXitoZM61sKOPPrpZ85vZU5KGpJQ9Gnv5PFFNSIjatrvHzGqBpZKWAIcCzzUriBJXV+cX4JOS9amqkDw8gbiid8ABB+x2uquqqorq6mp++MMf0qtXr1wXfS7wxzA8gCi51FseynYjaQIwAWDPPffMdd0lYeNG72Y5KX7dw7kUJ510EuXl5ZxxxhkA3HPPPZgZVVVVnH322Tz00ENNXqakK4la3L6zvijNZGm7dTCzKcAUgOrqau/6oQHtvN+ZxPiWdy7FM888wzPPPLPj9QEHHMARRxzBM888wx133NHk5UkaT3Rh/jgzq08Gy4FBsckGAityj9oBrF23NukQSla2d8A7VzJqamp44YUXdryePXs2NTU1AE3ucVHSGOAy4GQz2xgbNR04TVKlpKHAMGB2M0MveR06dkg6hJLlRybOpZg6dSrnnnsuNTU1mBndunVj6tSpbNiwgSuuuCLjfJLuBo4BektaDkwkqr1VCcwM12GeN7Nvm9lCSfcSXYfcBlzoNbmab+sW34RJKVgykTSIqIrkJ4A6YIqZ/TLco/JHYAhRj42nxO5fSVvvXtJIomqXHYG/Ad+PnS5wLq8OOeQQFixYwNq1azGzHQ0+ApxyyikZ5zOz09MU/76B6SfhVezzakut92eSlEIemWwDLjGzlyR1BeZKmgmcDcwys8mSLgcup/F69zcT1WZ5niiZjAFmFDB2V8Jqa2u57777WLZs2S5tPXk/8K1fjx5d+XDV+qTDKEkFSyZmtpKohWHMbL2k14mqPo4lOhUAcBvwBNE55bT17iUtA7qZ2XMAkm4HxuHJxBXI2LFjqaqqYuTIkVRWViYdjmuCDz/yRJKUFrlmEm7k+jTwArBHSDSY2UpJfcNkmerdbw3DqeXp1uP18V2zLV++nIcffjjpMFwO2reL2q1xLa/gtbkkdQHuAy4ys3UNTZqmzBoo373QbIqZVZtZdZ8+3hGky82oUaNYsGBB0mG4HLRr53WKklLQLS+pHVEiudPM7g/F70vqF45K+gGrQnmmevfLw3BquXMF8fTTTzNt2jSGDh1KZWUlZoYk5s+fn3RorhEb1ntzKkkpZG0uEdVked3Mfh4bNR0YD0wOzw/Gyu+S9HOiC/DDgNlmtl3SekmHEZ0m+wbwq0LF7dyMGX45rq1q38FPcyWlkEcmRwBfBxZImhfK/osoidwr6TzgHeBrAI3Uu7+AnVWDZ+AX310BDR48GIBVq1axebO39dSWbNmUdASlq5C1uZ4m/fUOgOMyzJO23r2ZzQGG5y865zKbPn06l1xyCStWrKBv3768/fbb7LvvvixcuDDp0FwjOnVtx8Y1fq9JErw5FedSXHXVVTz//PPsvffeLF26lFmzZnHEEUckHZbLQkW7zJ2bucLyZOJcinbt2tGrVy/q6uqoq6tj9OjRzJs3L+mwXBbWveVXTJLi9eicS9G9e3dqamo46qijOPPMM+nbt2+TG3h0CekGNHQDgisYPzJxLsWDDz5Ix44dueGGGxgzZgx77bVXTn2YuJZX0S3pCEqX/91yLkXnzp13DI8fPz7BSFxTbduQdASly49MnAuOPPJIALp27Uq3bt12POpfu9avc1dvSy0pfmTiXPD0008DsH69NxbYVm14pzbpEEqWH5k4F1NXV8fw4X5LU5vVPekASpcnE+diysrKOOigg3jnnXeSDsXloMzPciXGT3M5l2LlypXsv//+HHroobtcjJ8+fXqCUbls1K1JOoLS5cnEuRQTJ05MOgSXo6792rN+md+4mARPJs6l+Nvf/sa11167S9lll13G0UcfnVBELlsV7drj7QYnw6+ZOJdi5syZu5V5s/Rtw+p3apIOoWR5MnEuuPnmmznggANYtGgRBx544I7H0KFDOfDAAxudX9KtklZJejVW1lPSTEmLw3OP2LgrJC2RtEjSiQV6WyWlyx7tkg6hZPlpLueCM844g5NOOokrrriCyZMn7yjv2rUrPXv2zGYR04BfA7fHyi4HZpnZZEmXh9eXSdoPOA3Yn6gzuMck7R3rw8floOYdb34+KZ5MnAuqqqqoqqri7rvvzml+M3tK0pCU4rHAMWH4NuAJ4LJQfo+Z1QJLJS0BDgWey2nlLrIH8H7SQZQmP83lXGHtYWYrAcJz31A+AHg3Nt3yUOaaoVdVVdIhlCxPJs4lI10vTpZ2QmmCpDmS5nzwwQcFDqtt++j9tUmHULI8mThXWO9L6gcQnleF8uXAoNh0A4EV6RZgZlPMrNrMqvv06VPQYNu6Xnt0STqEkuXJxLnCmg7Ut2M/HngwVn6apEpJQ4FhwOwE4isqH/3LqwYnxS/AO5cnku4mutjeW9JyYCIwGbhX0nnAO8DXAMxsoaR7gdeAbcCFXpOr+TpVlbNxnW/GJHgycS5PzOz0DKOOyzD9JGBS4SIqPYMGDWLRu8uSDqMk+Wku51zRqNmwMekQSpYnE+dc0Xh/5arGJ3IF4cnEOVc0/m3vTyYdQsnyZOKcKxpbNnq3vUnxZOKcKxpdenVNOoSS5cnEOVc0ysvTNSzgWoInE+dc0Vj21ruNT+QKwpOJc65oDBzobWUmpWDJJF8dBUkaKWlBGHejJD+Odc6ltXnD5qRDKFmFPDKZBoxJKavvKGgYMCu8JqWjoDHATZLKwzw3AxOI2i4almaZzjkHQLf+3ZIOoWQVLJmY2VPAxynFY4k6CCI8j4uV32NmtWa2FFgCHBpaWe1mZs+ZmRH1YDcO55xLo9z8zH1SWnrLN7WjoAFhOLU8Le/3wbnStmm9n+ZKSmtJ45k6Csq6AyHwfh+cK3Xd9+zR+ESuIFo6mTS1o6DlYTi13DnndlO3ZVvSIZSslk4mTeooKJwKWy/psFCL6xuxeZxzbhd79OuddAglq2D9meSxo6ALiGqGdQRmhIdzzu3m/ZUfJR1CySpYMslXR0FmNgcYnsfQnHNFqlOXDkmHULJaywV455xrtr1H/FvSIZQsTybOuaJhyljZ0xWYJxPnXNFY7ddMEuPJxDlXNCo7dEw6hJLlycQ5VzQ6VXkySYonE+dagKSLJS2U9KqkuyV1aKgVbZebPoO85YukeDJxrsAkDQC+B1Sb2XCgnKiV7LStaLvc1W2rSzqEkuXJxLmWUQF0lFQBdCJqFihTK9ouR1u3eXMqSfFk4lyBmdl7wPVErT6sBNaa2aNkbkV7F94advaGfKp/0iGULE8mzhVYuBYyFhgK9Ac6Szor2/m9NezsLX11eeMTuYLwZOJc4R0PLDWzD8xsK3A/MIrMrWi7HPX6RFXSIZQsTybOFd47wGGSOoXWr48DXidzK9ouR527dUo6hJJVsIYenXMRM3tB0p+Bl4haxX4ZmAJ0IU0r2i53lZ0qkw6hZHkyca4FmNlEom4Y4mrJ0Iq2y037yvZJh1Cy/DSXc65orHrXa7slxZOJc65o9PyENyKQFE8mzrmi0al7l6RDKFmeTJxzRcPqtjc+kSsITybOuaJRXtEu6RBKlicT51zRqK3ZlHQIJcuTiXOuaLTv6FWDk+LJxDlXNDp1zXwHfHk7/7krJN+6zrmiUVZWRnlF+p+17n283a5C8mTinCsa7Tu0598O/mTacUd99fAWjqa0eDJxzhWNTTWbWDR7CQDlFWV899fn7Rg3/eZHkgqrJHjbXM65olFeUY7KRFmZ+P3CXzBgWD/6DOrF1WN/RscuHZIOr6h5MnHOFY32Hdpz/d8n0qtfTwYM6wfA4V86hJ/OuJLB+w9KOLri5snEOVdUDjxq/93Kqk8c0fKBlBi/ZuKcc67ZPJk455xrtjaTTCSNkbRI0hJJlycdj3POuZ3aRDKRVA78BjgJ2A84XdJ+yUblnHOuXptIJsChwBIze8vMtgD3AGMTjsk551zQVmpzDQDejb1eDnwmdSJJE4AJ4WWNpEUZltcb+DCvEeamtcQBOcaia1tHHAXSUCyDWzKQenPnzv1Q0tsZRreVbdeSWksc0DZiyXm/bivJRGnKbLcCsynAlEYXJs0xs+p8BNYcrSUOaD2xtJY4oHXFUs/M+mQa15ribS2xtJY4oPhjaSunuZYD8TuOBgIrEorFOedciraSTF4EhkkaKqk9cBowPeGYnHPOBW3iNJeZbZP0HeARoBy41cwWNmORjZ4KayGtJQ5oPbG0ljigdcWSjdYUb2uJpbXEAUUei8x2u/TgnHPONUlbOc3lnHOuFfNk4pxzrtmKMplI6ilppqTF4blHhumWSVogaZ6kOU2dP1+xSBok6XFJr0taKOn7sXHXSHovxDhP0uebuP4Gm6FR5MYwfr6kg7Odt6myiOXMEMN8Sc9KOig2Lu1nVaA4jpG0NrbNr8523kJowv6cNraG9iFJV4TpF0k6scBxXCfpjfD5PiCpeygfImlTLL7fNhBD3vfnXL7vucZRiO96M7dJ/n4DzazoHsDPgMvD8OXAtRmmWwb0znX+fMUC9AMODsNdgX8C+4XX1wCX5rjucuBN4JNAe+CV+uXGpvk8MIPoXp7DgBeynbcAsYwCeoThk+pjaeizKlAcxwB/zWXepPbnhmLLtA8RNU30ClAJDA3zlxcwjs8BFWH42vr5gSHAq0ntz9m8rzzGkdfvenNiaeh71dRtYmbFeWRC1NTKbWH4NmBcC8/fpGWZ2UozeykMrwdeJ7rrv7myaYZmLHC7RZ4Hukvql+W8eY3FzJ41s9Xh5fNE9xPlW3PeV1LN+mSzP+YS21jgHjOrNbOlwJKwnILEYWaPmtm2MF0un2+h9uemft9zjqMA3/XmbJOGNPk3sFiTyR5mthKiH2qgb4bpDHhU0lxFTbE0df58xgJEh/zAp4EXYsXfCYent2Z1uLlTumZoUnfcTNNkM29TNHV55xH9m6qX6bMqVByHS3pF0gxJ9b0t5XubZCubfaix2NLtQ019P/mIo9657Pr5DpX0sqQnJX02w/oLtT839fvenDh2yNN3vbmx5O03sE3cZ5KOpMeAT6QZdWUTFnOEma2Q1BeYKekNM3sqoViQ1AW4D7jIzNaF4puB/yb60P8b+B+iL2JWi0xTlloXPNM0WTVh0wRZL0/SaKJkcmSsOC+fVZZxvAQMNrOacN76L8CwLOfNSR72oYZiy7QPpZvnaknXFCiOaALpSmAbcGcoWgnsaWYfSRoJ/EXS/rHvQNbLbmCafH52zYkjGpm/73pzY8nX96rtJhMzOz7TOEnv1x9ShsO5VRmWsSI8r5L0ANEh41NAVvPnMxZJ7Yh2rjvN7P7Yst+PTfM74K8NxZIim2ZoMk3TPot5myKrJnEkHQhMBU4ys4/qyxv4rPIeR/xHzMz+JukmSb2zfQ+5yMM+lDG2BvahdPOcb2bPFSKOsIzxwBeB4yyckDezWqA2DM+V9CawN5Ba0aJQ+3OTvu/NjCPf3/VmxZKv38D6N1B0D+A6dr149LM003QGusaGnwXGZDt/nmMRcDvwizTj+sWGLyY6x53tuiuAt4gurtZfnNs/ZZovsOvFudnZztvE7ZBNLHsSnbcfle1nVaA4PsHOG3oPBd4J2yev2yTP+1DG2DLtQ8D+7HoB/i0avgDf3DjGAK8BfVLm6VO/XqILye8BPVtqf87mfeUxjrx+15sZS15/Awv6JUjqAfQCZgGLw3PPUN4f+Ftsp30lPBYCVzY2fwFjOZLosHM+MC88Ph/G/S+wIIybHt/hslz/54lqjLxZ/x6BbwPfju3cvwnjFwDVDc3bzM+lsVimAqtj22BOY59VgeL4TljPK0QXikc1NG9r2J8biq2hfYjo9NWbwCKio8FCxrGE6Nx9/ef721D+ldj2fgn4Ukvuz5neVyG+VxTgu96MWPL6G+jNqTjnnGu2Yq3N5ZxzrgV5MnHOOddsnkycc841mycT55xzzebJxDnnXLMVPJmEljAvDcM/ltTQzVnjJO1X6JgyrLtS0mOh9cxTW3jdz7bw+r4WWi19PKV8iKQzGpivv6Q/FyCesyX9Ot/LzWK9I7JtmTVlvm9L+kaa8iGSXm3CcraH/a1/E+b5rKTXmrIe51pCix6ZmNnVZvZYA5OMI2rJNAmfBtqZ2Qgz+2N8hKTyQqywfrlmNipfy8rSecB/mNnolPIhQNpkIqnCzFaY2VdzDLE1GkFUR383kjK2DmFmvzWz2/Ow/k1hf8v6Lnoz+wcZYm4r2tAfzPom4X/cxPnulPSxpGL6rjSqIMlE0pWK2td/DPhUrHxa/QaWNDn8w5ov6XpJo4CTgevCv7W9JH1L0ouKGty7T1Kn2HJuVNTnxVvxD03SDxS1z/+KpMmhbC9JDytqzOwfkvZJibcvcAcwIrbuZZKulvQ08DVJp4flvirp2ti8NZKuDct+TNKhkp4IcZ2cZtsco6g/g7uIbiBCUk14/qN27WtimqSvSCpX1BfEi2F7nZ9pWSnr2i1mRX1zHAn8VtJ1KbNMBj4btsHF4YjhT5IeImoMbsc/7zD8D0kvhceoWExPSPqzor4r7pSkMO7zoezp8Pnt1lyEpD7hs34xPI5IM0152GcWhO3x3VA+UlFDgXMlPaLQMmqI51pJsyX9U9G/+/bAj4FTw/s9Nfx4TJH0KHC7pMGSZoV1zJK0Z1he/MdwZNjXngMujMW4f1jfvDD/sNT3keZ9NWlfKgat/A8mwA1mdnXjk+1kZmcS3XRYWgpwt+5Ioh+2TkA3orteLw3jpgFfBXoS3XFbf9Nk9/j4+F2YseGfAN+NTfcnomS4H1ETzBD1gfEs0Cm8rr9DdxYwLAx/Bvh7mriPIdaHBVE7/z+I3eH7DlGzDxXA34FxYZwR7hwGHgAeBdoBBwHzMqxnAzA0VlYTnv8duC0Mtye6W7gjMAH4YSivJGqzaGi6ZcWW2VDMTxC7M7iBbXA2Ubs+9dtxCKHfifD5dgjDw9h5t/oxwFqi9n/KgOeIkleH8H6Ghunurl9XWM+vw/BdwJFheE/g9TRxXkDUtlF93xg9wzZ/ltBUB3AqcGvs/f5P7G7hx1LXG15fA8wFOobXDwHjw/C5wF9i09Xv0/OBo8PwdbHt8yvgzNhn2THN+6hJeZ3VvkSW/X+0pgfRnfaLgMfCZ7/Lb0IYnkzU3Mp84Hqi/m0+BpYS3Sm+F/At4EWiu7bvY+d3fRpwY9gH3mLX35EfEP0mvQJMDmV7AQ+Hz/sfwD5pYt7xOcde3xY+l2XAl4n6/VgQltUuNu20eAyl8ChEQ4+fBR4ws40AktJl6HXAZmCqpP8jc4NmwyX9BOgOdAEeiY37i5nVAa9J2iOUHQ/8oX7dZvaxotY5RwF/Cn+QIfpBzkb96a5DgCfM7IPwnu4EjiJqTXYL0Y4E0U5Va2ZbJS0g+tKnM9ui/iNSzQBulFRJ1I7RU2a2SdLngAO18wisiugHfEsDy2oo5qaYaWYfpylvB/xa0ghgO1HDfPH3tzysdx7RdqgB3orFejdRkkx1PLBf7LPqJqmrRX0/xKf5rYW+McLnPBwYTtTyKUSdBq2MzVPfoN5cMn8uANPNbFMYPpzoBwOipi5+Fp9QUhXRH6EnY9OcFIafA66UNBC438wWN7DOernsS62eopaATyM6lVxB1GTK3JRpehL9mdrHzExSdzNbE34//mpmfw7TrTGz34XhnxCdsv1VWEw/oj8u+xAdGfxZ0klERzefMbONYT0AU4iaG1ks6TPATcCxWbydvYDRRH9inwO+YmY/UNRI4hdo+veraBSq1eAG22gxs22SDgWOI9rJvkP6D3Ia0b/pVySdTfSvt15tbFix59R1lwFrzGxElrHHbUhZfjpbLfwVAerY2fppnTKfd9+QrtDMNkt6AjiR6J/13bH1f9fM4skUScdkWlYjMTdFpuVfDLxP9K+5jOjPQb34Z7OdaD/LNp4y4PDYD3o66T5nAQvN7PAM89THVB9PJpneLxnWmXZfN7O7JL1A9APziKRvmtnfG1g25LYvtQXF9AdzRizBl7Nr8h+S5TKKUiGumTwF/LukjpK6Al9KnSB8mFVm9jfgIqILoQDribqyrNcVWKmoyeYzs1j3o8C52nltpadFzYkvlfS1UCbF+hbP0gvA0ZJ6K7rQfTrwZCPz5Ooe4ByiL2D9F+UR4IKwHZC0t6TOBYg5dfs3pApYGb68Xyf6YjXkDeCTijoEgihZpvMo0Z8LIKpxlWGab9f/wIZ/m4uAPpIOD2XttLNTq0wae7/PEv3ZgWj/ezo+0szWAGslHRmbpj7uTxIdid1I9C/5wEZiKXaN/sEkaqH5PqIjiYczTDoN+I6ZHQD8iOj0ab0m/8GMPfbN5k0QS/DsnvzbcsJvtrwnE4u6pPwj0TnO+4jOR6bqCvxV0nyiH7iLQ/k9wP9T1OPaXsBVRD+KM4l+jBpb98NEX9w54fTKpWHUmcB5kupbxxzbxPe0ErgCeJzQsqmZPdiUZTTBo0Snox6zqBtOiFrTfQ14SdEF8FtoZMfNMeb5wLZwQfniRqa9CRgv6XmiU1wN/aMnHGn8B/CwokoN7xNdW0n1PaA6XLR+jaj101RTia4HzQ+f6RlhW30VuDaUzSP699mQx4lOqWWqDv494Jywn34d+H6aac4BfhMuwMePpk4FXg374T5EzY6XqmL8g+lSeKvBrsVI6mJR74X1TWIvNrMbko4rKZJqzKxLDvMNIbqOMDz/URWGot4VvwG8TVSp4zUzu17SNKJTWs8ADxIdaQi43sxuU1Sb73dERwRfBT5HdEH9baJTS13N7Oz65cSurezYtpIuD+veQtRU/n9JGkrUs2E/out/95jZLlWAFfU4WWNm12d4HV9H6rhd4ikFnkxciwlHO+OJaje9DHyr/lx2KZK0gqgHu89blveaKOof/SbgIzM7poDhlbzUBNHEeafhycQ555yie4kmEB21ZH2vSag5OYqo0kxTutlu0zyZOOecazZv6NE551yzeTJxzjnXbJ5MnHPONZsnE+ecc832/wE/BEiKunUjdgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwzUlEQVR4nO3de7xUZd338c+XgygKCIqGR4iwbo8YpOb5WGC3QuXZyjyE9dhddnhSMpW840nTtKg08RBYeUoz0dRCPKWpCIrgiUAhQ0nwhGwTCvg9f6xrcNjM3ntm7732zN77+3695jVrrrWuNb+ZWTO/WWtd67oUEZiZmeWhS7UDMDOzjstJxszMcuMkY2ZmuXGSMTOz3DjJmJlZbrpVO4C2tvnmm8fAgQOrHYZ1UDNnznw9IvpX47m9bVuemrttd7okM3DgQGbMmFHtMKyDkvT3aj23t23LU3O3bR8uMzOz3DjJmJlZbpxkzMwsN04yZmaWGycZM+s0fnnWpHUer169er0ya11OMmY5k7StpPslPS/pWUlfT+X9JE2VNC/d9y2qM1bSfElzJX2yetF3HId1OZpbL/4jh3U5GsgSzIjux3HrxX/kqK1PqXJ0HVena8JsVgWrgG9FxJOSegEzJU0FvghMi4gLJZ0NnA2cJWlH4DhgJ2Ar4F5JO0TE6irF3+EUEk3BssXLqxRJx+c9GbOcRcTiiHgyTS8Hnge2BkYBk9Nik4HRaXoUcGNErIyIBcB8YI82DdqslTjJmLUhSQOB3YHHgS0jYjFkiQjYIi22NfCPomqLUlmp9Y2RNEPSjKVLl+YWt1lz+XCZNWrg2X9sVr2FF36qlSNp/yRtAtwKnBkR70hqcNESZSVHF4yIicBEgOHDh3sEQqs53pMxawOSupMlmN9GxO9T8WuSBqT5A4AlqXwRsG1R9W2AV9sqVrPWlFuSkbShpOmSnk4tar6fyituUSNpmKQ5ad4Epb+AknpIuimVP54ORZjVlLS9XgM8HxGXFs2aApyUpk8Cbi8qPy5t34OAIcD0torXrDXluSezEjg4InYDhgIjJO1F1oJmWkQMAaalx9RrUTMCuFxS17SuK4AxZF+2IWk+wKnAWxHxIeAy4KIcX49Zc+0DfB44WNKsdDscuBA4TNI84LD0mIh4FrgZeA64BzjDLcusvcrtnExEBFCXHnZPtyBrOXNgKp8MPACcRVGLGmCBpPnAHpIWAr0j4lEASdeRtcK5O9UZl9Z1C/BzSUrPbVYTIuJhSp9nATikgTrjgfG5BWXWRnI9JyOpq6RZZMeap0ZEc1rUbJ2m65evUyciVgHLgM1KxOEWOGZmVZBrkomI1RExlOzE5R6Sdm5k8YZa1DTW0qasVjgRMTEihkfE8P79qzKelJlZp9Qmrcsi4m2yw2IjqLxFzaI0Xb98nTqSugF9gDfzeA1mZla5PFuX9Ze0aZreCDgUeIEKW9SkQ2rLJe2VWul8oV6dwrqOAu7z+Rgzs9qR58WYA4DJqYVYF+DmiLhT0qPAzZJOBV4GjoasRY2kQouaVazbouYrwCRgI7IT/nen8muAX6dGAm+StU4zM7MakWfrstlk3WfUL3+DClvURMQMYL3zORGxgpSkzMys9viKfzMzy42TjJmZ5cZJxszMcuMkY2ZmuXGSMTOz3DjJmJlZbpxkzMwsN04yZmaWGycZMzPLjZOMmZnlxknGzMxy4yRjZma5cZIxM7PcOMmYmVlunGTM2oCkayUtkfRMUdlNkmal20JJs1L5QEnvFc37ZdUCN2uhPActM7P3TQJ+DlxXKIiIYwvTkn4MLCta/sWIGNpWwZnlxUnGrA1ExEOSBpaal4YVPwY4uE2DMmsDPlxmVn37Aa9FxLyiskGSnpL0oKT9GqooaYykGZJmLF26NP9IzSrkJGNWfccDNxQ9XgxsFxG7A98ErpfUu1TFiJgYEcMjYnj//v3bIFSzyjjJmFWRpG7AZ4CbCmURsTIi3kjTM4EXgR2qE6FZyzjJmFXXocALEbGoUCCpv6SuafqDwBDgpSrFZ9YiTjJmbUDSDcCjwIclLZJ0app1HOseKgPYH5gt6WngFuDLEfFm20Vr1nrcusysDUTE8Q2Uf7FE2a3ArXnHZNYWvCdjZma5yS3JSNpW0v2Snpf0rKSvp/Jxkl4pupr58KI6YyXNlzRX0ieLyodJmpPmTUjXFSCpR7pqer6kxxu6DsHMzKojzz2ZVcC3IuK/gL2AMyTtmOZdFhFD0+0ugDTvOGAnYARweeHkJ3AFMIbsBOiQNB/gVOCtiPgQcBlwUY6vx8zMKpRbkomIxRHxZJpeDjwPbN1IlVHAjan55gJgPrCHpAFA74h4NCKCrFuO0UV1JqfpW4BDCns5ZmZWfW1yTiYdxtodeDwVfVXS7NRpYN9UtjXwj6Jqi1LZ1mm6fvk6dSJiFVnfT5vl8RrMzKxyuScZSZuQtZQ5MyLeITv0NRgYSnZl848Li5aoHo2UN1anfgzuesPMrApyTTKSupMlmN9GxO8BIuK1iFgdEWuAq4A90uKLgG2Lqm8DvJrKtylRvk6ddOV0H2C96wnc9YaZWXXk2bpMwDXA8xFxaVH5gKLFPg0UxteYAhyXWowNIjvBPz0iFgPLJe2V1vkF4PaiOiel6aOA+9J5GzMzqwF5Xoy5D/B5YE5hMCbgu8DxkoaSHdZaCJwOEBHPSroZeI6sZdoZEbE61fsK2XgcGwF3pxtkSezXkuaT7cEcl+PrMTOzCuWWZCLiYUqfM7mrkTrjgfElymcAO5coXwEc3YIwzcwsR77i38zMcuMkY2ZmuXGSMTOz3DjJmJlZbpxkzMwsN04yZmaWGycZMzPLjUfGNCvDkUce2eQy/fr1a4NIzNoXJxmzMjz//PNcffXVDc6PCM4444w2jMisfXCSMSvD+PHjOeCAAxpd5vzzz+fYY48tOU/StcB/A0siYudUNg74ElDoGvy7RYP4jSUblG818LWI+FMrvAyzNudzMmZlOOaYY1q6zCTeH9G1WKWjxJq1K04yZmVYvXo1V155Jeeeey6PPPLIOvN+8IMfNFk/Ih6ixDAUDSg5SmyFIZvVBCcZszKcfvrpPPjgg2y22WZ87Wtf45vf/Obaeb///e9bsupKRoldjwfks1rnJGNWhunTp3P99ddz5pln8vjjj1NXV8dnPvMZVq5cSQuGMKp0lNj1Cz0gn9U4JxmzMvz73/9eO92tWzcmTpzI0KFDOfjgg6mrq2vWOpsxSqxZu+MkY1aG4cOHc88996xTdt5553HyySezcOHCZq2z0lFim/UkZlXmJsxmZfjNb35Tsvy0007jtNNOa7K+pBuAA4HNJS0CzgcObMYosWbtipOMWQVWr15N166VtyaOiONLFF/TyPIlR4k1a298uMysTMuXL2fUqFHVDsOsXXGSMSvD4sWLOfTQQxkzZky1QzFrV3y4zKwM++23HxdffHFZHWWa2fu8J2NWhr59+/LKK69UOwyzdsdJxqwMDzzwAHfffTe/+MUvqh2KWbviJGNWho033pgpU6bw1FNPVTsUs3bFScasTF27dm10TBkzW19uSUbStpLul/S8pGclfT2V95M0VdK8dN+3qM5YSfMlzZX0yaLyYZLmpHkTJCmV95B0Uyp/XNLAvF6PWbF33nmHN998c+3NzErLc09mFfCtiPgvYC/gjDROxtnAtIgYAkxLj5saQ+MKYAxZ9xpDeH9cjlOBtyLiQ8BlwEU5vh4zrrzySrbcckt23XVXhg0bxrBhwxg+fHi1wzKrWbk1YY6IxWQ9yxIRyyU9T9Zd+Siy7jUAJgMPAGdRNIYGsEDSfGAPSQuB3hHxKICk64DRwN2pzri0rluAn0tStKBbXLPGXHLJJTz77LNsvvnm1Q7FrF1ok3My6TDW7sDjwJYpARUS0RZpsYbG0Ng6TdcvX6dORKwClgGblXh+j7lhrWLw4MH07Nmz2mGYtRu5X4wpaRPgVuDMiHgnnU4puWiJsmikvLE66xZETAQmAgwfPtx7OdZsP/zhD9l7773Zc8896dGjx9ryCRMmVDEqs9qVa5KR1J0swfw2IgrDB74maUBELE5dnS9J5Q2NobEoTdcvL66zSFI3oA/lD3FrVrHTTz+dgw8+mF122YUuXdw406wpuSWZ1ALsGuD5iLi0aNYU4CTgwnR/e1H59ZIuBbYijaEREaslLZe0F9nhti8AP6u3rkeBo4D7fD7G8tStWzcuvfTSphc0MyDfPZl9gM8DcyTNSmXfJUsuN0s6FXgZOBqaHEPjK8AkYCOyE/53p/JrgF+nRgJvkrVOM8vNQQcdxMSJEzniiCPWOVzWr1+/KkZlVrvybF32MKXPmQAc0kCdkmNoRMQMYOcS5StIScqsLVx//fVAdm6mQBIvvfRStUIyq2nuhdmsAgsWLKh2CGbtSqNnLiW908RtuaS/tVWwZtXy5JNPtsoyZp1NU3syL0bE7o0tIMk9BlqHd/LJJ/PAAw/QWLuSU089tQ0jMmsfmkoyny1jHeUsY9auLVu2jGHDhjWaZPr379+GEZm1D40mmYhY72ympP+OiDsbW8aso1m4cGFZyzV0sbGka4H/BpZExM6p7GLgCODfwIvAyRHxduoh43lgbqr+WER8uQXhm1VNc64mu6DVozDr+CbxfseuBVOBnSNiV+BvwNiieS9GxNB0c4Kxdqs5SabBfmHMrLSIeIh6vVFExJ9Tn3sAj7FuzxZmHUJzkszprR6FmZ3C+xcZAwyS9JSkByXt11Ald/5qta7RczKSPhoR67TLjIjpTS1j1pG99dZbzJs3jxUrVqwt23///Zu9PknnkPVy8dtUtBjYLiLekDQM+IOknSLinfp13fmr1bqmWpf9StKBNH6I7BqybvzNOryrr76an/70pyxatIihQ4fy2GOP8fGPf5z77ruvWeuTdBJZg4BDCv3upTGVVqbpmZJeBHYAZrTOqzBrO00dLusDzGzi9p88AzSrJT/96U954okn2H777bn//vt56qmnmt10WdIIsgH7joyIfxWV9y+MCivpg2SdxboVp7VLTTVhHthGcZi1CxtuuCEbbrghACtXruQjH/kIc+fObaIWSLqBbETYzSUtAs4na03WA5iamj4XmirvD1wgaRWwGvhyRHgIC2uX3HeZWQW22WYb3n77bUaPHs1hhx1G37592WqrrZqsFxHHlyi+poFlbyUbh8ms3XOSMavAbbfdBsC4ceM46KCDWLZsGSNG1L/8xcwKnGTMKvTwww8zb948Tj75ZJYuXcorr7zCoEGDqh2WWU0q6zoZSdPKKTPr6L7//e9z0UUXrR1P5j//+Q+f+9znqhyVWe1q6jqZDYGeZCcr+/J+U+beZEMkm3Uqt912G0899RQf/ehHAdhqq61Yvnx5laMyq11NHS47HTiTLKHM5P0k8w7wi/zCMqtNG2ywAZLWdoT57rvvVjkis9rW6OGyiPhpRAwCvh0RH4yIQem2W0T8vI1iNKsZxxxzDKeffjpvv/02V111FYceeihf+tKXqh2WWc0q68R/RPxM0t7AwOI6EXFdTnGZ1ZyI4Nhjj+WFF16gd+/ezJ07lwsuuIDDDjus2qGZ1ayykoykXwODgVlkF4cBBOAkY52GJEaPHs3MmTOdWMzKVG4T5uHAjoW+lcw6q7322osnnniCj33sY9UOxaxdKDfJPAN8gKx3WLNO6/777+fKK69k++23Z+ONNyYikMTs2bOrHZpZTSo3yWwOPCdpOql3WICIODKXqMxq1N133930Qma2VrlJZlyeQZi1F9tvvz0AS5YsWWc8GTMrrawr/iPiwVK3xupIulbSEknPFJWNk/SKpFnpdnjRvLGS5kuaK+mTReXDJM1J8yYoXaAgqYekm1L545IGVvzqzSo0ZcoUhgwZwqBBgzjggAMYOHAgI0eOrHZYZjWr3G5llkt6J91WSFotab1R+uqZBJTqOfCyiBiabnel9e8IHAfslOpcXhhPA7gCGEM2psaQonWeCrwVER8CLgMuKue1mLXEueeey2OPPcYOO+zAggULmDZtGvvss0+1wzKrWeXuyfSKiN7ptiHwWaDRizEj4iGg3DEwRgE3RsTKiFgAzAf2kDQA6B0Rj6aWbdcBo4vqTE7TtwCHFPZyzPLSvXt3NttsM9asWcOaNWs46KCDmDVrVrXDMqtZzeqFOSL+IOnsZj7nVyV9gWwo2W9FxFvA1sBjRcssSmX/SdP1y0n3/0jxrJK0DNgMeL3+E0oaQ7Y3xHbbbdfMsM1g0003pa6ujv33358TTzyRLbbYgm7d3Jm5WUPKPVz2maLbUZIuJLsYs1JXkF3UOZSsOfSPC09RYtlopLyxOusXRkyMiOERMby5Q+WaAdx+++307NmTyy67jBEjRjB48GDuuOOOaodlVrPK/Qt2RNH0KmAh2eGqikTEa4VpSVcBd6aHi4BtixbdBng1lW9Tory4ziJJ3YA+lH94zqxZNt54YwC6dOnCSSedVOVozGpfuX2XndwaTyZpQEQULuj8NNlFngBTgOslXUrW4/MQYHpErE6NDvYCHge+APysqM5JwKPAUcB97pHAzKy2lHu4bBtJt6Umya9JulXSNk3UuYEsAXxY0iJJpwI/Ss2RZwMHAd8AiIhngZuB54B7gDMiotBH2leAq8kaA7wIFK6GuwbYTNJ84JtAc88RmeWugSb9/SRNlTQv3fctmleySb9Ze1Pu4bJfAdcDR6fHn0tlDfYSGBHHlyi+ppHlxwPjS5TPAHYuUb6iKB6zNvPee+/x8ssv8+EPf7iSapPIWmQWdyp7NjAtIi5MDWnOBs6q16R/K+BeSTsU/fEyazfK2pMB+kfEryJiVbpNAnwG3TqdO+64g6FDhzJiRHa51qxZszjyyKZ7V2qgSX9xM/zJrNs8f70m/S2P3qztlZtkXpf0OUld0+1zwBt5BmZWi8aNG8f06dPZdNNNARg6dCgLFy5s7uq2LJyjTPdbpPK1zfOT4qb765A0RtIMSTOWLl3a3DjMclNukjkFOAb4J1nT46NSmVmn0q1bN/r06ZP307h5vnUY5bYuexlwj8vW6e28885cf/31rF69mnnz5jFhwgT23nvv5q7utUKLy9S7xZJU3lCTfrN2p9zWZZMlbVr0uK+ka3OLyqxG/exnP+PZZ5+lR48eHH/88fTu3Zuf/OQnzV1doRk+6f72ovLjUiewg0hN+lsSt1m1lNu6bNeIeLvwICLekrR7PiGZ1a6ePXsyfvx4xo9fryFko1KT/gOBzSUtAs4HLgRuTs37Xya1loyIZyUVmvSvYt0m/WbtSrlJpoukvqmfMST1q6CuWbt3xBFH0Fj/q1OmTGm0fgNN+gEOaWD5kk36zdqbchPFj4G/SrqF7ATkMfgLYJ3It7/97WqHYNYulXvi/zpJM4CDyVq+fCYinss1MrMacsABB1Q7BLN2qexDXimpOLFYp7bLLrusd9isT58+DB8+nO9973tVisqsdvm8ilkFRo4cSdeuXTnhhBMAuPHGG4kI+vTpwxe/+MXqBmdWg5xkzCrwyCOP8Mgjj6x9vMsuu7DPPvvwyCOP8Jvf/KaKkZnVpnKv+DczoK6ujscff3zt4+nTp1NXVwfgETLNSvC3wqwCV199Naeccgp1dXVEBL179+bqq6/m3XffZezYsRx77LHVDtGspjjJmFXgYx/7GHPmzGHZsmVExNqOMgGOOeYYJxmzepxkzCqwcuVKbr31VhYuXMiqVavWlp933nlVjMqsdjnJmFVg1KhR9OnTh2HDhtGjR49qh2NW85xkzCqwaNEi7rnnnmqHYdZuuHWZWQX23ntv5syZU+0wzNoN78mYVeDhhx9m0qRJDBo0iB49ehARSGL27NnVDs2sJjnJmFXg7rvvrnYIZu2Kk4xZBbbffnsAlixZwooVK6ocjVnt8zkZswpMmTKFIUOGMGjQIA444AAGDhzIyJEjqx2WWc1ykjGrwLnnnstjjz3GDjvswIIFC5g2bRr77LNPtcMyq1m5JRlJ10paIumZorJ+kqZKmpfu+xbNGytpvqS5kj5ZVD5M0pw0b4JSP+tp/PObUvnjkgbm9VrMCrp3785mm23GmjVrWLNmDQcddBCzZs2qdlhmNSvPPZlJwIh6ZWcD0yJiCDAtPUbSjsBxwE6pzuWSuqY6VwBjgCHpVljnqcBbEfEh4DLgotxeiVmy6aabUldXx/7778+JJ57I17/+dXeMadaI3JJMRDwEvFmveBQwOU1PBkYXld8YESsjYgEwH9hD0gCgd0Q8GhEBXFevTmFdtwCHqLFB2M1awe23385GG23EZZddxogRIxg8eDB33HFHs9cn6cOSZhXd3pF0pqRxkl4pKj+8FV+GWZtp679gW0bEYoCIWCxpi1S+NfBY0XKLUtl/0nT98kKdf6R1rZK0DNgMeD2/8K2z23jjjddOn3TSSS1eX0TMBYYCpL33V4DbgJOByyLikhY/iVkV1cqJ/1J7INFIeWN11l+5NEbSDEkzli5d2swQrTPbd999AejVqxe9e/deeys8biWHAC9GxN9ba4Vm1dbWSea1dAiMdL8klS8Cti1abhvg1VS+TYnydepI6gb0Yf3DcwBExMSIGB4Rw/v3799KL8U6k4cffhiA5cuX884776y9FR63kuOAG4oef1XS7NSIpm9DlcxqWVsnmSlA4RjDScDtReXHpRZjg8hO8E9Ph9aWS9ornW/5Qr06hXUdBdyXztuY5WLNmjXsvPPOuaxb0gbAkcDvUtEVwGCyQ2mLgR83UM976VbT8mzCfAPwKPBhSYsknQpcCBwmaR5wWHpMRDwL3Aw8B9wDnBERq9OqvgJcTdYY4EWg0K/HNcBmkuYD3yS1VDPLS5cuXdhtt914+eWX81j9SODJiHgNICJei4jVEbEGuArYo1Ql76VbrcvtxH9EHN/ArEMaWH48ML5E+Qxgvb+PEbECOLolMZpVavHixey0007sscce6zQCmDJlSktXfTxFh8okDSg0kgE+DTxTspZZjXMDf7MKnH/++a2+Tkk9yfbsTy8q/pGkoWSNWRbWm2fWbjjJmFXgrrvu4qKL1r3u96yzzuKAAw5o9joj4l9kze+Lyz7f7BVaxbpt5J/CvNRKE2azdmHq1Knrlbn7//Zv863deC8vTt9mZbjiiiu4/PLLeemll9h1113Xli9fvtwdZHYAvfpu3PRC1ixOMmZlOOGEExg5ciRjx47lwgsvXFveq1cv+vXrV8XIrDW8/dqyaofQYTnJmJWhT58+9OnThxtuuKHpha3d2XKgm3/nxedkzKzT+doVp9Gzz0ZrH2/ca5MqRtOxOcmYWaew1ZAPrJ1+atozbNKn59rHx37nyGqE1Cn4cJmZdQqTXpjA/FkL+c0Fv+Mvt2Sdvk94dDwbbLgBg3cbWN3gOjAnGTPrFB665TEmnXsDK/+1cm3Z5PNuYtnry7lo6rn07teritF1XD5cZmadwvK36lj0t8W8/upbjP/jWHY/eGdmTp3NPxcsYYMNu1c7vA7LezJm1ik89LtHAejSRZzzqR8CoC6i7u13+cfcxQzZfVA1w+uwvCdjZp3CkGEfBGD1qjVry2JN0K1HNzbdotUGnrN6nGTMrFP4wMAtSpZv0mdjunb1T2Fe/M6aWafw5j/fKlm+4t0VrFm9puQ8azknGTPrFN5b/l7J8lX/WU3gQXXz4iRjZp1Cj54blizv0kVI/inMi99ZM+sUIrK9lQ022mDdGRKxxofL8uImzGbWKWwzZACbbtGbfy1fsbZs6yEDWL16Dd17+DqZvHhPxsw6hS237897dSsZMGgLbl58Fd+Z/FVenf9PttxuczbcuPShNGs578mYWadQ9/a7bD3kA1x4z/fou+WmHPb5bMjsKb+4h1X/XgU9e1Q5wo7JScbMOoV9Ru/BXkcMo2vXrmvLDvv8ARx8wr7rlFnrcpIxqzJJC4HlwGpgVUQMl9QPuAkYCCwEjomI0hd6WNlKJRMnmHz5nIxZbTgoIoZGxPD0+GxgWkQMAaalx2btjpOMWW0aBUxO05OB0dULxaz5qpJkJC2UNEfSLEkzUlk/SVMlzUv3fYuWHytpvqS5kj5ZVD4srWe+pAmSVI3XY9ZCAfxZ0kxJY1LZlhGxGCDdl+x4S9IYSTMkzVi6dGkbhWtWvmruyZR1eEDSjsBxwE7ACOBySYWDqFcAY4Ah6TaiDeM3ay37RMRHgZHAGZL2L7diREyMiOERMbx///75RWjWTLV0uKyhwwOjgBsjYmVELADmA3tIGgD0johHI7uU9zp8SMHaoYh4Nd0vAW4D9gBeS9s46X5J9SI0a75qJZlKDg9sDfyjqO6iVLZ1mq5fvh4fUrBaJWljSb0K08AngGeAKcBJabGTgNurE6FZy1SrCfM+EfGqpC2AqZJeaGTZUudZopHy9QsjJgITAYYPH+7uVq2WbAnclk4ndgOuj4h7JD0B3CzpVOBl4OgqxmjWbFVJMsWHByStc3ggIhbXOzywCNi2qPo2wKupfJsS5WbtRkS8BOxWovwN4JC2j8isdbX54bJmHB6YAhwnqYekQWQn+KenQ2rLJe2VWpV9AR9SMDOrKdXYk6no8EBEPCvpZuA5YBVwRkSsTuv6CjAJ2Ai4O93MzKxGtHmSac7hgYgYD4wvUT4D2Lm1YzQzs9ZRS02Yzcysg3GSMTOz3DjJmJlZbpxkzKzTWLNmTVll1nqcZMysU7j1J3dy1BansnTRG2vLrht3E8cM+BJvv/5OFSPr2JxkzKxTeOu1ZSx/s45TdzyTpYve4LpxN/HrC25hxbsrWfnuimqH12F5ZEwz6xRO++GJANx00R84YbsvA9CjZw+umvNjtty+5EgK1gq8J2NmncZpPzyRbT+81drHP5p6LgMGbVnFiDo+Jxkz6zSuG3cT/5j7fheHZ3/yB+uco7HW5yRjZp1C4RxMj549uO7Fn3PsWaN5r27F2nM0lg+fkzGzTmGDDTegZ++N+OVTFzNg0JZrz9H8ceJUunbz/+28+J01s07huLM/zW1vTlrnHMxpPzyRW5deS78P9K1iZB2bk4yZdRpduqz/k1eqzFqP310zM8uNk4yZdQrv1b3Hg797dJ2y5W/V8cgfplcpos7BScbMOoVbfnwnPzj2Um6bcBeQJZizPvG//L8TfsIbi9+qcnQdl1uXmVWRpG2B64APAGuAiRHxU0njgC8BS9Oi342Iu6oTZcdw/Hc/zUtz/s7lZ/6Kurfe5dE7Z7Bwzsuc//v/y2YDfOI/L04yZtW1CvhWRDwpqRcwU9LUNO+yiLikirF1KN26d+OcG85k7MjxXPf9mwH4wZ1j2fPwj1Y5so7NScasiiJiMbA4TS+X9DywdXWj6rjeq1vBO68vX/v41fn/rGI0nYPPyZjVCEkDgd2Bx1PRVyXNlnStJB/PaaHCOZh/vPAK37/tO+z7mT25/MxfrT1HY/lwkjGrAZI2AW4FzoyId4ArgMHAULI9nR83UG+MpBmSZixdurTUIpZM+cWf1p6D2XvUxzjnhjPZ9zN7cu051/vEf458uMysyiR1J0swv42I3wNExGtF868C7ixVNyImAhMBhg8fHvlH234dN3Y0e37qo3xo90HA++do/v7cIp/4z5H3ZMyqSJKAa4DnI+LSovIBRYt9GnimrWPraLp27bo2wRR0696NwbsNrE5AnYT3ZMyqax/g88AcSbNS2XeB4yUNBQJYCJxejeDMWspJxqyKIuJhQCVm+Wy0dQjt/nCZpBGS5kqaL+nsasdjZmbva9dJRlJX4BfASGBHskMMO1Y3KjMzK2jXSQbYA5gfES9FxL+BG4FRVY7JzMyS9n5OZmvgH0WPFwF71l9I0hhgTHpYJ2luA+vbHHi9VSNsvlqJpVlx6KIcImkf78n2bRlIsZkzZ74u6e8NzG4P711bq5VYaiUOyGHbbu9JptQJ0/WuFSi+lqDRlUkzImJ4awTWUrUSS63EAbUTS63EUV9E9G9oXq3EXCtxQO3EUitxQD6xtPfDZYuAbYsebwO8WqVYzMysnvaeZJ4AhkgaJGkD4DhgSpVjMjOzpF0fLouIVZK+CvwJ6ApcGxHPtmCVTR5Sa0O1EkutxAG1E0utxFGJWom5VuKA2omlVuKAHGJRhLs7MjOzfLT3w2VmZlbDnGTMzCw3nS7JSOonaaqkeem+ZB/fkhZKmiNplqQZldZvjTgkbSvpfknPS3pW0teL5o2T9EqKb5akw5sRQ6Nd8igzIc2fLemj5dZt5ThOTM8/W9JfJe1WNK/k55RjLAdKWlb0vp9Xbt3WVsG2XDKuxrYhSWPT8nMlfbINYrlY0gvpM75N0qapfKCk94pi/GUl6y2aX/G23NzvenNjae3vewvfk9b7/YuITnUDfgScnabPBi5qYLmFwObNrd8acQADgI+m6V7A34Ad0+NxwLdb8D50BV4EPghsADxdWHfRMocDd5Ndj7QX8Hi5dVs5jr2Bvml6ZCGOxj6nHGM5ELizOXWrsS03FldD2xBZF01PAz2AQal+15xj+QTQLU1fVKgPDASeqca2XM5rauVYWu373pI4GvteNec96XR7MmTdzkxO05OB0W1cv+z1RMTiiHgyTS8HWnP893K65BkFXBeZx4BNlY1z0prd+TS5roj4a0QUhi58jOx6qDy05HVVo4ujcrbF5sQ1CrgxIlZGxAJgflpPbrFExJ8jYlVartLPOK9tuTnf9WbH0srf95a8J42p+D3pjElmy4hYDNmPOLBFA8sF8GdJM5V1S1Np/daKAyg5/ju0bAz4Ul3y1N+gG1qmnLqtGUexU8n+fRU09DnlGcvHJT0t6W5JO1VYtzWVsw01FVepbag5r6U1Yik4hXU/40GSnpL0oKT9mrne5mzLzfmutySWtVrh+97SOFrt969dXyfTEEn3Ah8oMeucClazT0S8KmkLYKqkFyLioSrEUWr8d8jGgP9fso3hf8nGgD+lktWWKKvfnr2hZcrqzqcV48gWlA4iSzL7FhW3+HOqMJYnge0joi4dF/8DMKTMupUH1PJtqLG4GtqGStbJOZZsAekcYBXw21S0GNguIt6QNAz4g6Sdir4HZa23kWVa+3NrSSzZzNb5vrc0jlb7XnXIJBMRhzY0T9JrhV3TtGu4pIF1vJrul0i6jWz38yGgrPqtFYdKjP+e1l3WGPCNKKdLnoaW2aCMuq0ZB5J2Ba4GRkbEG4XyRj6nXGIp/nGLiLskXS5p83JfR6VaYRtqMK5GtqGSdfKMJa3jJOC/gUMiHfSPiJXAyjQ9U9KLwA5AcSOPvLblsr/rrRRLa37fWxRHa/z+rdXUSZuOdgMuZt0TVz8qsczGQK+i6b8CI8qt34pxCLgO+EmJeQOKpr9Bdgy9kufvBrxEdmK3cGJwp3rLfIp1TwxOL7duK8exHdl5gb3L/ZxyjOUDvH8R8x7Ay+n9abX3pJW3oQbjamgbAnZi3RP/L9H0if+WxjICeA7oX69O/8Jzk53EfgXo1xbbcjmvqZW/V632fW9hHK36+5fbF6BWb8BmwDRgXrrvl8q3Au4q2pifTrdngXOaqp9THPuS7b7OBmal2+Fp3q+BOWnelOKNsIIYDidrwfJi4TUCXwa+XLTR/yLNnwMMb6xuCz6TpuK4Gnir6D2Y0dTnlGMsX03P9TTZCeq9G6tb7W25sbga24bIDoG9CMwl23vMO5b5ZOcHCp/xL1P5Z4ve7yeBI9pqW27oNeX1vaKVv+8tiKNVf//crYyZmeWmM7YuMzOzNuIkY2ZmuXGSMTOz3DjJmJlZbpxkzMwsN1VLMqlX0W+n6QskNXah12hJO7ZddOs8dw9J96beSI9t4+f+axs/39GpB9j765UPlHRCI/W2knRLDvF8UdLPW3u9ZTzv0HJ6uS1R78uSvlCifKCkZypYz+q0vW1VQZ39JD1XyfOYtYWa2JOJiPMi4t5GFhlN1jNsNewOdI+IoRFxU/EMSV3zeMLCeiNi79ZaV5lOBf5PRBxUr3wgUDLJSOoWEa9GxFHNDLEWDSW7xmA9khrsJSMifhkR17XC87+XtreyewyIiL/QQMztRTv641nodv+CCuv9VtKbkjrSd6VJbZpkJJ2jbHyDe4EPF5VPKrzxki5M/8hmS7pE0t7AkcDF6d/dYElfkvSEsk4Kb5XUs2g9E5SNOfJS8Ycp6TvKxkd4WtKFqWywpHuUdQL3F0kfqRfvFsBvgKFFz71Q0nmSHgaOlnR8Wu8zki4qqlsn6aK07nsl7SHpgRTXkSXemwOVjSVxPdmFUUiqS/c3ad2xPiZJ+qykrsrG4XgivV+nN7Sues+1XszKxkXZF/ilpIvrVbkQ2C+9B99Iexi/k3QHWSd6a/+pp+m/SHoy3fYuiukBSbcoGzfkt5KU5h2eyh5On996XWZI6p8+6yfSbZ8Sy3RN28yc9H78TyofpqxzxZmS/qTU02yK5yJJ0yX9TdnewAbABcCx6fUem35UJkr6M3CdpO0lTUvPMU3Sdml9xT+Sw9K29ihwRlGMO6Xnm5XqD6n/Okq8roq2pY6gxv94AlwWEec1vdj7IuJEsgspO5e8r0ouulJ0GNkPXk+gN9kVvt9O8yYBRwH9yK4wLlwkumnx/OKrToumfwD8T9FyvyNLnjuSdXUN2RgkfwV6pseFq5GnAUPS9J7AfSXiPpCi8UPIxln4TtHVzC+TdX3RDbgPGJ3mBelKaeA24M9Ad2A3YFYDz/MuMKiorC7dfxqYnKY3ILsyeiNgDPC9VN6DrD+nQaXWVbTOxmJ+gKIroRt5D75I1u9R4X0cSBrzI32+G6bpIbx/df6BwDKy/pG6AI+SJbUN0+sZlJa7ofBc6Xl+nqavB/ZN09sBz5eI8ytk/T4VxiXpl97zv5K6KwGOBa4ter0/Lro6+t76z5sejwNmAhulx3cAJ6XpU4A/FC1X2KZnAwek6YuL3p+fAScWfZYblXgddfUel7UtUcbYK7V2I+tZYC5wb/rs1/lNSNMXknU5Mxu4hGx8oTeBBWRXxQ8GvgQ8QXaV+q28/12fBExI28BLrPs78h2y36SngQtT2WDgnvR5/wX4SImY137ORY8np89lIfAZsnFX5qR1dS9adlJxDJ3h1pYdZO4H3BYR/wKQVCqjvwOsAK6W9Eca7gRuZ0k/ADYFNgH+VDTvDxGxBnhO0pap7FDgV4Xnjog3lfV0ujfwu/SHGrIf6nIUDpt9DHggIpam1/RbYH+ynnn/TbaBQbaxrYyI/0iaQ/ZjUMr0yMbvqO9uYIKkHmR9PD0UEe9J+gSwq97fY+tD9sP+70bW1VjMlZgaEW+WKO8O/FzSUGA1WWeGxa9vUXreWWTvQx3wUlGsN5Alz/oOBXYs+qx6S+oV2bgbxcv8MtK4JOlz3hnYmawnWcgGc1pcVKfQCeFMGv5cAKZExHtp+uNkPySQdffxo+IFJfUh+4P0YNEyI9P0o8A5krYBfh8R8xp5zoLmbEs1T1mvyseRHZLuRtZtzMx6y/Qj+5P1kYgISZtGxNvp9+POiLglLfd2RFyVpn9Aduj3Z2k1A8j+0HyEbE/iFkkjyfaG9oyIf6XnAZhI1u3KPEl7ApcDB5fxcgYDB5H9uX0U+GxEfEdZ55KfovLvV4fR1r0wN9qHTUSskrQHcAjZxvdVSn/Ak8j+fT8t6Ytk/5ILVhZNq+i+/nN3Ad6OiKFlxl7s3XrrL+U/kf66AGt4vyfZNWr4uP67pQojYoWkB4BPkv0Tv6Ho+f8nIoqTLJIObGhdTcRciYbW/w3gNbJ/2V3I/jQUFH82q8m2v3Lj6QJ8vOiHvpRSn7OAZyPi4w3UKcRUiKchDb1eGnjOktt6RFwv6XGyH54/STotIu5rZN3QvG2pPehIfzzvLkr8XVn3T8HAMtfRIbXlOZmHgE9L2khSL+CI+gukD7lPRNwFnEl2AhZgOdlwpAW9gMXKusU+sYzn/jNwit4/d9Mvsi7bF0g6OpVJRWPHl+lx4ABJmys7wX488GATdZrrRuBksi9m4Qv0J+Ar6X1A0g6SNs4h5vrvf2P6AIvTl/rzZF+4xrwAfFDZIE2QJdFS/kz2pwPIWoA1sMyXCz+86d/pXKC/pI+nsu56f6CxhjT1ev9K9icIsu3v4eKZEfE2sEzSvkXLFOL+INme2wSyf9W7NhFLR9fkH0+y3q5vJdvzuKeBRScBX42IXYDvkx2GLaj4j2fR7b/KeREUJX7W/1PQnv8ItFibJZnIhhW9iewY6q1kxzvr6wXcKWk22Q/fN1L5jcD/VTY63mDgXLIfy6lkP1JNPfc9ZF/oGekwzbfTrBOBUyUVehsdVeFrWgyMBe4n9RIbEbdXso4K/JnssNa9kQ2nClnvxM8BTyo78X4lTWzQzYx5NrAqncj+RhPLXg6cJOkxskNlje0BkPZM/g9wj7LGFK+Rnbup72vA8HSy/Dmy3mTru5rsfNPs9JmekN6ro4CLUtkssn+rjbmf7NBcQ83WvwacnLbTzwNfL7HMycAv0on/4r2vY4Fn0nb4EbKu3TurjvjH0+pxL8xWdZI2iWykyULX4/Mi4rJqx1UtkuoiYpNm1BtIdp5i59aPKh/KRsL8AvB3ssYkz0XEJZImkR0aewS4nWzPRMAlETFZWevCq8j2II4CPkF2Iv/vZIeoekXEFwvrKTp3s/a9lXR2eu5/kw1H8F1Jg8hGoRxAdn7xxohYp6mypHFkjTMuaeBx8XPUn7dOPJ2Bk4xVXdo7OomstdVTwJcKx8o7I0mvko04eHiUea2MpP3I9iLfiIgDcwyv06ufOCqsOwknGTMza4iya6HGkO3llH2tTGrJuTdZY51Kh0tvt5xkzMwsNzXRrYyZmXVMTjJmZpYbJxkzM8uNk4yZmeXm/wP9VOunmQVXfQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAurklEQVR4nO3de7xUdb3/8dcbUFQSFAGPN4QMj3dJdl7Q8l5YKR7LW3ois7B+drGjlRxL7eLjaFqWlhahonnPS2KJqaiZJiAogagkCRpCgnkDUxT4/P5Y343DZmbvmc2sPTN7v5+PxzxmzXet75rPzKw1n3X9fhURmJmZ5aFbrQMwM7POy0nGzMxy4yRjZma5cZIxM7PcOMmYmVluetQ6gI7Wr1+/GDRoUK3DsE5q+vTpL0dE/1q8t5dty1N7l+0ul2QGDRrEtGnTah2GdVKSnq/Ve3vZtjy1d9n24TIzM8uNk4yZmeXGScbMzHLjJGNmZrlxkjGzLuPa/7t1jdcrVqzguvNvLTG1VYOTjFnOJG0j6QFJT0uaLenrqbyvpHslPZueNy2oM0bSXElzJH2sdtF3Hod2O5qrz7qRozY/CcgSzGHrH8/4/72Rr+9/Vo2j67ycZMzytwI4PSJ2BPYGTpW0E3AmMCkihgCT0mvSuOOAnYERwGWSutck8k5o6ZJlHLX5SRy2/vGry576899qGFHn5iRjlrOIWBQRj6fhpcDTwFbASODqNNnVwJFpeCRwY0Qsj4h5wFxgzw4NupNbumRZrUPoMpxkzDqQpEHAB4EpwOYRsQiyRAQMSJNtBfyjoNqCVFZsfqMlTZM0bcmSJbnFbdZeXe6Of6vMoDP/0K5688//RJUjaXyS3gfcCpwWEW9IKjlpkbKivQtGxFhgLEBTU5N7ILS64z0Zsw4gaT2yBHNdRNyWil+StEUavwWwOJUvALYpqL41sLCjYjWrJicZs5wp22W5Ang6In5SMGoCMCoNjwLuKCg/TlJPSYOBIcDUjorXrJp8uMwsf/sC/w3MkjQjlf0vcD5ws6STgReAowEiYrakm4GnyK5MOzUiVnZ41GZV4CRjlrOIeJji51kADi5R5zzgvNyCMusgPlxmZma5cZIxM7PcOMmYmVlucksyrbTXdK6kFyXNSI+PF9Qp2l6TpGGSZqVxl6SrdUhX39yUyqekG93MzKxO5LknU6q9JoCLI2JoetwFbbbXdDkwmuxSziFpPMDJwKsR8QHgYuCCHD+PmZlVKLck00p7TaUUba8p3aTWOyIejYgArmHNNp6a2366BTi4eS/HzMxqr0POybRorwngK5JmSrqyoHnzUu01bZWGW5avUSciVgCvA5vl8RnMzKxyuSeZlu01kR362g4YCiwCftw8aZHq0Up5a3VaxuBGBM3MaiDXJFOsvaaIeCkiVkbEKuDXvNeEean2mhak4Zbla9SR1APoA7zSMo6IGBsRTRHR1L9//2p9PDMza0OeV5cVba+puUHA5L+AJ9Nw0faaUhPoSyXtneb5WdZs46m57adPA/en8zZmZlYH8mxWplR7TcdLGkp2WGs+cAq02V7Tl4HxwIbAxPSALIn9RtJcsj2Y43L8PGZmVqHckkwr7TXd1Uqdou01RcQ0YJci5W+TGhU0M7P64zv+zcwsN04yZmaWGycZMzPLjZOMmZnlxknGrAOk1i0WS3qyoGyopMmpodhpkvYsGFe0sVizRuMkY9YxxvNew67NfgR8LyKGAmen1201FmvWUJxkzDpARDzE2q1RBNA7DffhvZYsijYW2yGBmlVZnjdjmlnrTgP+KOkisg2+4al8K2BywXSFjcKuQdJosm4wGDhwYG6BmrWX92TMaufLwDciYhvgG2QtWECZDb+C2+Wz+uckY1Y7o4Db0vBvabuxWLOG4yRjVjsLgf3T8EHAs2m4aGOxNYjPbJ35nIxZB5B0A3AA0E/SAuAc4IvAz1I3FW+Tzq200VisWUNxkjHrABFxfIlRw0pMX7SxWLNG48NlZmaWGycZMzPLjZOMmZnlxknGzMxy4yRjZma5cZIxM7PcOMmYmVlunGTMzCw3TjJmZpYbJxkzM8uNk4yZmeXGScbMzHLjJGNmZrlxkjEzs9w4yZiZWW6cZMzMLDdOMmYdQNKVkhZLerJF+VclzZE0W9KPCsrHSJqbxn2s4yM2q47ckoykbSQ9IOnptAJ9PZX3lXSvpGfT86YFdYquWJKGSZqVxl0iSam8p6SbUvkUSYPy+jxm62g8MKKwQNKBwEhgt4jYGbgole8EHAfsnOpcJql7h0ZrViV57smsAE6PiB2BvYFT08pzJjApIoYAk9Lrtlasy8n6Px+SHs0r68nAqxHxAeBi4IIcP49Zu0XEQ8ArLYq/DJwfEcvTNItT+UjgxohYHhHzgLnAnh0WrFkV5ZZkImJRRDyehpcCTwNbka1AV6fJrgaOTMNFVyxJWwC9I+LRiAjgmhZ1mud1C3Bw816OWQPYHvhw2gv/k6QPpfKtgH8UTLcgla1F0mhJ0yRNW7JkSc7hmlWuQ87JpMNYHwSmAJtHxCLIEhEwIE1WasXaKg23LF+jTkSsAF4HNsvlQ5hVXw9gU7I9/W8CN6eNpGIbSlFsBhExNiKaIqKpf//++UVq1k498n4DSe8DbgVOi4g3WtnRKLVitbbClbUyShpNdriNgQMHthWy2VqOOOKINqfp27dvpbNdANyW9tCnSloF9Evl2xRMtzWwsNKZm9WDXJOMpPXIEsx1EXFbKn5J0hYRsSgdCms+Dl1qxVqQhluWF9ZZIKkH0Ie1j3sTEWOBsQBNTU1FtwjNWvP0008zbty4kuMjglNPPbXS2f4OOAh4UNL2wPrAy8AE4HpJPwG2JDsPObUdYZvVXG5JJu32XwE8HRE/KRg1ARgFnJ+e7ygoX2vFioiVkpZK2pvscNtngUtbzOtR4NPA/Wmr0KyqzjvvPPbff/9WpznnnHM49thji46TdANwANBP0gLgHOBK4Mp0WfM7wKi0/M6WdDPwFNkFNKdGxMpqfRazjpTnnsy+wH8DsyTNSGX/S5ZcbpZ0MvACcDRARLS2Yn2Z7BLQDYGJ6QFZEvuNpLlkezDH5fh5rAs75phjypqmVJKJiONLVDuxxPTnAeeVG59ZvcotyUTEwxQ/ZwJwcIk6RVesiJgG7FKk/G1SkjLL08qVKxk3bhwLFixgxIgR7LvvvqvH/fCHP+Q73/lODaMzq1++49+sDKeccgp/+tOf2Gyzzfja177G//zP/6wed9ttt7VS06xrc5IxK8PUqVO5/vrrOe2005gyZQrLli3jqKOOYvny5fg0oFlpTjJmZXjnnXdWD/fo0YOxY8cydOhQDjroIJYtW1bDyMzqm5OMWRmampq4++671yg7++yzOemkk5g/f35tgjJrAE4yZmW49tprGTFixFrlX/jCF3j33XdrEJFZY3CSMavAypW+XcWsEk4yZmVaunQpI0eOrHUYZg3FScasDIsWLeKQQw5h9OjRtQ7FrKHk3kCmWWfw4Q9/mAsvvLCshjLN7D3ekzErw6abbsqLL75Y6zDMGo6TjFkZHnzwQSZOnMgvfvGLWodi1lCcZMzK0KtXLyZMmMATTzxR61DMGoqTjFmZunfv3mqfMma2Np/4N2uHN954gxUrVqx+3Y5eMc26BO/JmFXgV7/6FZtvvjm77bYbw4YNY9iwYTQ1NbVZT9KVkhanDspajjtDUkjqV1A2RtJcSXMkfazKH8Osw3hPxqwCF110EbNnz6Zfv35tT7ym8cDPgWsKCyVtAxxK1oFfc9lOZB3w7UzWS+x9krZ375jWiLwnY1aB7bbbjo022qjiehHxEFnvrS1dDHwLKOwvYCRwY0Qsj4h5wFxgz3aEa1Zz3pMxq8D//d//MXz4cPbaay969uy5uvySSy6peF6SjgBejIi/Smt0IrsVMLng9YJUZtZwnGTMKnDKKadw0EEHseuuu9KtW/sPBEjaCDgL+Gix0UXKivaMJmk0MBpg4MCB7Y7HLC9OMmYV6NGjBz/5yU+qMavtgMFA817M1sDjkvYk23PZpmDarYGFxWYSEWOBsQBNTU3uotPqjs/JmFXgwAMPZOzYsSxatIhXXnll9aNSETErIgZExKCIGESWWPaIiH8CE4DjJPWUNBgYAkyt5ucw6yjekzGrwPXXXw9k52aaSeK5555rtZ6kG4ADgH6SFgDnRMQVxaaNiNmSbgaeAlYAp/rKMmtUTjJmFZg3b1676kXE8W2MH9Ti9XnAee16M7M60urhMklvtPFYKulvHRWsWa08/vjjVZnGrKtpa0/m7xHxwdYmkOQWA63TO+mkk3jwwQeJKH1u/eSTT+7AiMwaQ1tJ5lNlzKOcacwa2uuvv86wYcNaTTL9+/fvwIjMGkOrSSYi1jqbKemTEfH71qYx62zmz59f1nQtbqo06/Lacwnz96sehZmZdUrtSTLeVDMzs7K0J8mcUvUozMysU2rrEuY9WpZFxNS2pknla/WfIelcSS9KmpEeHy8YV7T/DEnDJM1K4y5ROuid7oa+KZVPkTSo7E9ttg5effVVpk6dykMPPbT6YWbFtXV12VWSDqD1Q2RXAMUucx5Pkf4zgIsj4qLCgjb6z7icrAHAycBdwAhgInAy8GpEfEDSccAFwLFtfB6zdTJu3Dh+9rOfsWDBAoYOHcrkyZPZZ599uP/++2sdmlldautwWR9gehuPd4tVbKX/jGKK9p8haQugd0Q8Gtm1o9cARxbUuToN3wIcLF/aYzn72c9+xmOPPca2227LAw88wBNPPOFLl81a0dYlzINyeM+vSPosMA04PSJepXT/Ge+m4ZblpOd/pDhXSHod2Ax4OYeYzQDYYIMN2GCDDQBYvnw5O+ywA3PmzKlxVGb1q6NbYb6crInzocAi4MepvFT/Ga31q1FRnxuSpkmatmTJkooCNiu09dZb89prr3HkkUdy6KGHMnLkSLbccstah2VWtzq0gcyIeKl5WNKvgeabOkv1n7EgDbcsL6yzQFIPskN7RQ/Puc8Nq5bbb78dgHPPPZcDDzyQ119/nREjRtQ4KrP61aF7MukcS7P/ApqvPCvaf0ZELAKWSto7nW/5LHBHQZ1RafjTwP3RWpsfZlXy8MMPc9VVV7H//vuzzz778OKLL9Y6JLO6VdaejKRJEXFwW2Utxq/VfwZwgKShZIe15pPuuWmj/4wvk12ptiHZVWUTU/kVwG8kzSXbgzmunM9iti6+973vMW3aNObMmcNJJ53Eu+++y4knnsgjjzxS69DM6lKrSUbSBsBGZIliU947D9Kb7FLjkkr0n1G0k6Y0fdH+MyJiGrBLkfK3gaNbi8Gs2m6//XaeeOIJ9tgjuz1syy23ZOnSpTWOyqx+tXW47BSyy5R3YM3Llu8AfpFvaGb1Z/3110fS6oYw33zzzbLqlbg5+UJJz0iaKel2SZsUjCt6c7JZo2k1yUTEzyJiMHBGRLw/Iganx+4R8fMOitGsbhxzzDGccsopvPbaa/z617/mkEMO4Ytf/GI5VceT3Uhc6F5gl4jYDfgbMAbWujl5BHCZpO7V+gxmHamsczIRcamk4cCgwjoR0fJufrNOKyI49thjeeaZZ+jduzdz5szh+9//Poceemg5dR9q2fRRRNxT8HIy2QUsUHBzMjAvnXfcE3i0Kh/ErAOVe+L/N2T3t8wAmk/IN9+Bb9YlSOLII49k+vTpZSWWCn0euCkNl7o5uVhMo8maXWLgwIHVjslsnZV7n0wTsJMvEbaubu+99+axxx7jQx/6UNXmKekssqsqr2suKjJZ0XXP94BZvSs3yTwJ/AfZXfpmXdYDDzzAr371K7bddlt69epFRCCJmTNntmt+kkYBnwQOLtiIK3VzslnDKTfJ9AOekjQVWN5cGBFH5BKVWZ2aOHFi2xOVSdII4NvA/hHx74JRE4DrJf2E7FaBIcDUIrMwq3vlJplz8wzCrFFsu+22ACxevJi333677Holbk4eA/QE7k2XRE+OiC+1cXOyWUMp9+qyP+UdiFkjmDBhAqeffjoLFy5kwIABPP/88+y4447Mnj271XrVujnZrNGU1XaZpKWS3kiPtyWtlPRG3sGZ1Zvvfve7TJ48me2335558+YxadIk9t1331qHZVa3ykoyEbFxRPROjw2AT5H1emnWpay33npsttlmrFq1ilWrVnHggQcyY8aMWodlVrfa1dR/RPxO0pnVDsas3m2yySYsW7aMj3zkI5xwwgkMGDCAHj06tMcMs4ZS7s2YRxW87EZ234yvybcu54477mDDDTfk4osv5rrrruP111/n7LPPrnVYZnWr3E2wwwuGV5A10z+y6tGY1blevXoB0K1bN0aNGtXG1GZW7tVlJ+UdiJmZdT7lXl22dWqKfLGklyTdKmnrtmuamVlXVm73y1eR3YW8JVlDfXemMrMu56233mLOnDm1DsOsIZSbZPpHxFURsSI9xgP9c4zLrC7deeedDB06lBEjsq5hZsyYwRFHuHUls1LKTTIvSzpRUvf0OBH4V56BmdWjc889l6lTp7LJJpsAMHToUObPn1/TmMzqWblJ5vPAMcA/yVpi/nQqM+tSevToQZ8+fWodhlnDKPfqshcAHxOwLm+XXXbh+uuvZ+XKlTz77LNccsklDB8+vNZhmdWtcq8uu1rSJgWvN5V0ZW5RmdWpSy+9lNmzZ9OzZ0+OP/54evfuzU9/+tNah2VWt8q9GXO3iHit+UVEvCrpg/mEZFa/NtpoI8477zzOO88NJJuVo9wk003SphHxKoCkvhXUNWt4hx9+OKnPl6ImTJjQgdGYNY5yE8WPgb9IuoWszbJjcF8X1oWcccYZtQ7BrCGVe+L/GknTgIMAAUdFxFO5RmZWR/bff/91qp/OYX4SWBwRu6SyvsBNwCCy9gCPKThaMAY4GVgJfC0i/rhOAZjVSNmHvFJScWKxLm3XXXdd67BZnz59aGpq4jvf+U5rVceT9cF0TUHZmcCkiDg/dZ1xJvBtSTsBxwE7k7WycZ+k7d0FszUin1cxq8Bhhx1G9+7d+cxnPgPAjTfeSETQp08fPve5z5WsFxEPSRrUongkcEAavhp4EPh2Kr8xIpYD8yTNBfYEHq3eJzHrGE4yZhV45JFHeOSRR1a/3nXXXdl333155JFHuPbaayud3eYRsQggIhZJGpDKtwImF0y3IJWtRdJoYDTAwIEDK31/s9yVe8e/mQHLli1jypQpq19PnTqVZcuWAVSzh8xil7EV7SQwIsZGRFNENPXv7+YErf54T8asAuPGjePzn/88y5YtIyLo3bs348aN480332TMmDEce+yxlczuJUlbpL2YLYDFqXwBsE3BdFsDC6v0Ecw6VG57MpKuTP3PPFlQ1lfSvZKeTc+bFowbI2mupDmSPlZQPkzSrDTuEqWzrpJ6SroplU8pcrzbrOo+9KEPMWvWLGbMmMGMGTOYOXMme+65J7169eKYY46pdHYTgObuNUcBdxSUH5eW8cHAEGBqVT6AWQfLc09mPNW5muZysmPOk4G7gBHARLLLO1+NiA9IOg64AKhoM9KsUsuXL+fWW29l/vz5rFixYnX52Wef3Wo9STeQneTvJ2kBcA5wPnCzpJOBF4CjASJitqSbya7mXAGc6ivLrFHllmSqcTWNpPlA74h4FEDSNcCRZElmJHBumtctwM8lKSKKHrs2q4aRI0fSp08fhg0bRs+ePcuuFxHHlxh1cInpz8M3PFsn0NHnZCq9mubdNNyyvLnOP9K8Vkh6HdgMeLnlm/oKHKuWBQsWcPfdd9c6DLOGUS9Xl5W6mqa1q2x8BY51uOHDhzNr1qxah2HWMDp6T6bSq2kWpOGW5YV1FkjqAfQBXskzeLOHH36Y8ePHM3jwYHr27ElEIImZM2fWOjSzutTRSab5aprzWftqmusl/YTsxP8QYGpErJS0VNLewBTgs8ClLeb1KFlPnff7fIzlbeLEibUOwayh5JZkqng1zZfJrlTbkOyEf/NafgXwm3SRwCtkV6eZ5WrbbbcFYPHixbz99ts1jsas/uV5dVlVrqaJiGnALkXK3yYlKbOOMmHCBE4//XQWLlzIgAEDeP7559lxxx2ZPXt2rUMzq0v1cuLfrCF897vfZfLkyWy//fbMmzePSZMmse+++9Y6LLO65SRjVoH11luPzTbbjFWrVrFq1SoOPPBAZsyYUeuwzOqW2y4zq8Amm2zCsmXL+MhHPsIJJ5zAgAEDqtkwplmn4z0ZswrccccdbLjhhlx88cWMGDGC7bbbjjvvvLPWYZnVLW+CmVWgV69eq4dHjRrVypRmBt6TMSvLfvvtB8DGG29M7969Vz+aX5tZcd6TMSvDww8/DMDSpUtrHIlZY/GejFmZVq1axS67rHXLlpm1wknGrEzdunVj991354UXXqh1KGYNw4fLzCqwaNEidt5559W9YTabMGFCDaMyq19OMmYVOOecc6o+T0nfAL5A1lXFLOAkYCPgJmAQMB84JiJerfqbm+XMh8vMKnDXXXex//77r/G466672j0/SVsBXwOaImIXoDtZY6/NXZUPASal12YNx0nGrAL33nvvWmVVaP6/B7Bh6hdpI7I+k0aSdVFOej5yXd/ErBZ8uMysDJdffjmXXXYZzz33HLvtttvq8qVLl65TA5kR8aKki8i6vngLuCci7pFUqqvyNbhrcat3TjJmZfjMZz7DYYcdxpgxYzj//PNXl2+88cb07du33fOVtCnZXstg4DXgt5JOLLd+RIwFxgI0NTW50z6rO04yZmXo06cPffr04YYbbqj2rA8B5kXEEgBJtwHDKd1VuVlD8TkZs9p6Adhb0kaSRNap39O81704rNlVuVlD8Z6MWQ1FxBRJtwCPk3U9/gTZ4a/3UaSrcrNG4yRjVmMRcQ7Q8gac5ZToqtyskfhwmZmZ5cZJxszMcuMkY2ZmuXGSMbMur0cv/xXmxd+smXV563Vbv9YhdFpOMmbW5fXbpv2tNljrnGTMrMt7X59ebU9k7eIkY2ZdXp8BfWodQqflJGNmXV63bqp1CJ2Wk4yZdQndupdOJDvsOaQDI+lanGTMrEvouVHPkuN69+/dgZF0LTVJMpLmS5olaYakaamsr6R7JT2bnjctmH6MpLmS5kj6WEH5sDSfuZIuSa3Ympmt5f27Dyo5bifvyeSmlnsyB0bE0IhoSq+L9mkuaSeyPs93BkYAl0nqnupcTtYr4JD0GNGB8ZtZA/nXwldKjnvj5dc7MJKupZ4Ol5Xq03wkcGNELI+IecBcYM/UkVPviHg0IgK4BveDbmYlvLX0LSA7bHbTorF84YL3OiB9dfEbtQqr06tVkgngHknTUx/lAGv0aQ4092m+FfCPgroLUtlWabhl+VokjZY0TdK0JUuWVPFjmFmjOOmHn6FP/95c8/dL6bv5phz7zZF84YIT6bvFpjR9dGitw+u0atWfzL4RsVDSAOBeSc+0Mm2x8yzRSvnahe4H3azL+8QXD+Gwkw+iW7f3tq2P/eZIjj798DXKrLpq8s1GxML0vBi4HdiT1Kc5QIs+zRcA2xRU3xpYmMq3LlJu1lAkbSLpFknPSHpa0j6tXQhj7VcsmTjB5KvDv11JvSRt3DwMfBR4ktJ9mk8AjpPUU9JgshP8U9MhtaWS9k5XlX0W94NujelnwN0RsQOwO/A0JS6EMWs0tThctjlwe7rauAdwfUTcLekxivRpHhGzJd0MPEXWB/qpEbEyzevLwHhgQ2Biepg1DEm9gY8AnwOIiHeAdySNBA5Ik10NPAh8u+MjNFs3HZ5kIuI5sq21luX/okSf5hFxHnBekfJpwC7VjtGsA70fWAJcJWl3YDrwdVpcCJPOX64lXTgzGmDgwIEdE7FZBXww0qy2egB7AJdHxAeBN6ng0FhEjI2Ipoho6t+/f14xmrWbk4xZbS0AFkTElPT6FrKkU+pCGLOG4iRjVkMR8U/gH5L+MxUdTHb+sdSFMGYNpVb3yZjZe74KXCdpfeA54CSyDcC1LoQxazROMmY1FhEzgKYio4peCGPWSHy4zMzMcuMkY2ZmuXGSMTOz3DjJmJlZbpxkzMwsN04yZmaWGycZMzPLjZOMmZnlxknGzMxy4yRjZma5cZIxsy7hX4te5cYLfkdErC775/zF3Hrx79cos+pykjGzLuG+3zzEFWOu4/JvjCci+Of8xZxx4Llc98NbeOWfr9U6vE7LDWSaWZdwzDeP4NV/vsqtP/0DLz2/hL/PmM+/3/g3F9x7NpttsWmtw+u0nGTMrEuQxCk/HsU/n1/CI7dPBeCyaRcwZI/31ziyzs2Hy8ysS3hr2VtMuPyPzH183uqyP4y9j4dvn9JKLVtXTjJmNSapu6QnJP0+ve4r6V5Jz6ZnH8upgqu+eyM//8oVvLb4dS6bdgGHf+mj/GHsvfzgmJ/w8sJXah1ep+UkY1Z7XweeLnh9JjApIoYAk9JrW0f9t+5Hj/W6s/ytd5h853SeeWwu3bp3Y6ONN0BSrcPrtJxkzGpI0tbAJ4BxBcUjgavT8NXAkR0cVqd09OmHM/7ZSxl60C5c872beXb6c3z/d9/iiqd+6hP/OXKSMautnwLfAlYVlG0eEYsA0vOAGsTVKW208Ya88fLS1a8X/v0l+v6HE0yenGTMakTSJ4HFETF9HeYxWtI0SdOWLFlSxeg6n6WvLuPbH/0B/3jmRb53+7fY76i9uOy0q7j9krtqHVqn5iRjVjv7AkdImg/cCBwk6VrgJUlbAKTnxaVmEBFjI6IpIpr69+/fETE3rAm/+CPzZ73AObd9k+EjP8RZN5zGfkftxZVnXc+/Fr1a6/A6Ld8nY1YjETEGGAMg6QDgjIg4UdKFwCjg/PR8R61i7EyOG3Mke31iDz7wwcEA9FivB2fdcBrPP7XA52Ry5D0Zs/pzPnCopGeBQ9NrW0fdu3dfnWCa9VivB9vtPqg2AXUR3pMxqwMR8SDwYBr+F3BwLeMxqxbvyZiZWW4aPslIGiFpjqS5knzTmplZHWnoJCOpO/AL4DBgJ+B4STvVNiozM2vW0EkG2BOYGxHPRcQ7ZJeBjqxxTGZmljT6if+tgH8UvF4A7NVyIkmjgdHp5TJJc0rMrx/wclUjbL96iaVdceiCHCJpjO9k244MpND06dNflvR8idGN8N11tHqJpV7igByW7UZPMsVatVurH9WIGAuMbXNm0rSIaKpGYOuqXmKplzigfmKplzhaioiSd2PWS8z1EgfUTyz1EgfkE0ujHy5bAGxT8HprYGGNYjEzsxYaPck8BgyRNFjS+sBxwIQax2RmZklDHy6LiBWSvgL8EegOXBkRs9dhlm0eUutA9RJLvcQB9RNLvcRRiXqJuV7igPqJpV7igBxiUcRapzDMzMyqotEPl5mZWR1zkjEzs9x0uSQjqa+keyU9m56LtvEtab6kWZJmSJpWaf1qxCFpG0kPSHpa0mxJXy8Yd66kF1N8MyR9vB0xtNokjzKXpPEzJe1Rbt0qx3FCev+Zkv4iafeCcUV/pxxjOUDS6wXf+9nl1q22CpblonG1tgxJGpOmnyPpYx0Qy4WSnkm/8e2SNknlgyS9VRDjLyuZb8H4ipfl9q7r7Y2l2uv7On4n1fv/i4gu9QB+BJyZhs8ELigx3XygX3vrVyMOYAtgjzS8MfA3YKf0+lyy/kfa+z10B/4OvB9YH/hr87wLpvk4MJHsfqS9gSnl1q1yHMOBTdPwYc1xtPY75RjLAcDv21O3Fstya3GVWobImmj6K9ATGJzqd885lo8CPdLwBc31gUHAk7VYlsv5TFWOpWrr+7rE0dp61Z7vpMvtyZA1O3N1Gr4aOLKD65c9n4hYFBGPp+GlwNNkrRxUQzlN8owEronMZGATZT01VrM5nzbnFRF/iYjmrgsnk90PlYd1+Vy1aOKonGWxPXGNBG6MiOURMQ+Ym+aTWywRcU9ErEjTVfob57Ust2ddb3csVV7f1+U7aU3F30lXTDKbR8QiyP7EgQElpgvgHknTlTVLU2n9asUBZIcNgA8CUwqKv5J2c68sd1e+QLEmeVou0KWmKaduNeModDLZ1lezUr9TnrHsI+mvkiZK2rnCutVUzjLUVlzFlqH2fJZqxNLs86z5Gw+W9ISkP0n6cDvn255luT3r+rrEsloV1vd1jaNq/38NfZ9MKZLuA/6jyKizKpjNvhGxUNIA4F5Jz0TEQzWIA0nvA24FTouIN1Lx5cAPyBaGHwA/Jls5y55tkbKW17OXmqas5nyqGEc2oXQgWZLZr6B4nX+nCmN5HNg2Ipal4+K/A4aUWbfygNZ9GWotrlLLUNE6OceSTSCdBawArktFi4CBEfEvScOA30nauWA9KGu+rUxT7d9tXWLJRlZnfV/XOKq2XnXKJBMRh5QaJ+ml5l3TtGu4uMQ8FqbnxZJuJ9v9fAgoq3614pC0HtkCd11E3FYw75cKpvk18PtS71VCOU3ylJpm/TLqVjMOJO0GjAMOi6znSKDV3ymXWAr/3CLiLkmXSepX7ueoVBWWoZJxtbIMFa2TZyxpHqOATwIHRzroHxHLgeVpeLqkvwPbA4UXeeS1LJe9rlcplmqu7+sURzX+/1Zr66RNZ3sAF7LmiasfFZmmF7BxwfBfgBHl1q9iHAKuAX5aZNwWBcPfIDuGXsn79wCeIzux23xicOcW03yCNU8MTi23bpXjGEh2XmB4ub9TjrH8B+/dxLwn8EL6fqr2nVR5GSoZV6llCNiZNU/8P0fbJ/7XNZYRwFNA/xZ1+je/N9lJ7BeBvh2xLJfzmaq8XlVtfV/HOKr6/5fbClCvD2AzYBLwbHrum8q3BO4qWJj/mh6zgbPaqp9THPuR7b7OBGakx8fTuN8As9K4CYULYQUxfJzsCpa/N39G4EvAlwoW+l+k8bOAptbqrsNv0lYc44BXC76DaW39TjnG8pX0Xn8lO0E9vLW6tV6WW4urtWWI7BDY34E5ZHuPeccyl+z8QPNv/MtU/qmC7/tx4PCOWpZLfaa81iuqvL6vQxxV/f9zszJmZpabrnh1mZmZdRAnGTMzy42TjJmZ5cZJxszMcuMkY2ZmualZkkmtip6Rhr8vqbUbvY6UtFPHRbfGe/eUdF9qjfTYDn7vv3Tw+x2dWoB9oEX5IEmfaaXelpJuySGez0n6ebXnW8b7Di2nldsi9b4k6bNFygdJerKC+axMy9uWFdT5sKSnKnkfs45QF3syEXF2RNzXyiRHkrUMWwsfBNaLiKERcVPhCEnd83jD5vlGxPBqzatMJwP/LyIObFE+CCiaZCT1iIiFEfHpdoZYj4aS3WOwFkklW8mIiF9GxDVVeP+30vJWdosBEfFnSsTcKBpow7O52f3vV1jvOkmvSOpM60qbOjTJSDpLWf8G9wH/WVA+vvmLl3R+2iKbKekiScOBI4AL09bddpK+KOkxZY0U3ippo4L5XKKsz5HnCn9MSd9S1j/CXyWdn8q2k3S3skbg/ixphxbxDgCuBYYWvPd8SWdLehg4WtLxab5PSrqgoO4ySReked8naU9JD6a4jijy3RygrC+J68lujELSsvR8k9bs62O8pE9J6q6sH47H0vd1Sql5tXivtWJW1i/KfsAvJV3Yosr5wIfTd/CNtIfxW0l3kjWit3pLPQ3/WdLj6TG8IKYHJd2irN+Q6yQpjft4Kns4/X5rNZkhqX/6rR9Lj32LTNM9LTOz0vfx1VQ+TFnjitMl/VGppdkUzwWSpkr6m7K9gfWB7wPHps97bPpTGSvpHuAaSdtKmpTeY5KkgWl+hX+Sw9Ky9ihwakGMO6f3m5HqD2n5OYp8roqWpc6gzjc8AS6OiLPbnuw9EXEC2Y2UXUvedyUX3Ck6jOwPbyOgN9kdvmekceOBTwN9ye4wbr5JdJPC8YV3nRYM/xD4asF0vyVLnjuRNXUNWR8kfwE2Sq+b70aeBAxJw3sB9xeJ+wAK+g8h62fhWwV3M79A1vRFD+B+4Mg0Lkh3SgO3A/cA6wG7AzNKvM+bwOCCsmXp+b+Aq9Pw+mR3Rm8IjAa+k8p7krXnNLjYvArm2VrMD1JwJ3Qr38HnyNo9av4eB5H6/Ei/7wZpeAjv3Z1/APA6WftI3YBHyZLaBunzDE7T3dD8Xul9fp6Grwf2S8MDgaeLxPllsnafmvsl6Zu+87+QmisBjgWuLPi8Py64O/q+lu+bXp8LTAc2TK/vBEal4c8DvyuYrnmZngnsn4YvLPh+LgVOKPgtNyzyOZa1eF3WskQZfa/U24OsZYE5wH3pt1/jPyENn0/W5MxM4CKy/oVeAeaR3RW/HfBF4DGyu9Rv5b11fTxwSVoGnmPN/5Fvkf0n/RU4P5VtB9ydfu8/AzsUiXn171zw+ur0u8wHjiLrd2VWmtd6BdOOL4yhKzw6soHMDwO3R8S/ASQVy+hvAG8D4yT9gdKNwO0i6YfAJsD7gD8WjPtdRKwCnpK0eSo7BLiq+b0j4hVlLZ0OB36bNqgh+6MuR/Nhsw8BD0bEkvSZrgM+QtYy7ztkCxhkC9vyiHhX0iyyP4NipkbWf0dLE4FLJPUka+PpoYh4S9JHgd303h5bH7I/9ndamVdrMVfi3oh4pUj5esDPJQ0FVpI1Zlj4+Rak951B9j0sA54riPUGsuTZ0iHATgW/VW9JG0fW70bhNL+M1C9J+p13AXYha0kWss6cFhXUaW6EcDqlfxeACRHxVhreh+yPBLLmPn5UOKGkPmQbSH8qmOawNPwocJakrYHbIuLZVt6zWXuWpbqnrFXl48gOSfcgazZmeotp+pJtZO0QESFpk4h4Lf1//D4ibknTvRYRv07DPyQ79Htpms0WZBs0O5DtSdwi6TCyvaG9IuLf6X0AxpI1u/KspL2Ay4CDyvg42wEHkm3cPgp8KiK+paxxyU9Q+frVaXR0K8yttmETESsk7QkcTLbwfYXiP/B4sq3vv0r6HNlWcrPlBcMqeG753t2A1yJiaJmxF3qzxfyLeTfSpguwivdakl2l0sf13yxWGBFvS3oQ+BjZlvgNBe//1YgoTLJIOqDUvNqIuRKl5v8N4CWyrexuZBsNzQp/m5Vky1+58XQD9in4oy+m2O8sYHZE7FOiTnNMzfGUUurzUuI9iy7rEXG9pClkfzx/lPSFiLi/lXlD+5alRtCZNjwnFiT+7qy5UTCozHl0Sh15TuYh4L8kbShpY+DwlhOkH7lPRNwFnEZ2AhZgKVl3pM02BhYpaxb7hDLe+x7g83rv3E3fyJpsnyfp6FQmFfQdX6YpwP6S+ik7wX488Kc26rTXjcBJZCtm8wr0R+DL6XtA0vaSeuUQc8vvvzV9gEVppf5vshWuNc8A71fWSRNkSbSYe8g2OoDsCrAS03yp+Y83bZ3OAfpL2ieVraf3Ohorpa3P+xeyjSDIlr+HC0dGxGvA65L2K5imOe73k+25XUK2Vb1bG7F0dm1ueJK1dn0r2Z7H3SUmHQ98JSJ2Bb5Hdhi2WcUbngWPHcv5EBQkftbeKGjkDYF11mFJJrJuRW8iO4Z6K9nxzpY2Bn4vaSbZH983UvmNwDeV9Y63HfBdsj/Le8n+pNp677vJVuhp6TDNGWnUCcDJkppbGx1Z4WdaBIwBHiC1EhsRd1QyjwrcQ3ZY677IulOFrHXip4DHlZ14/xVtLNDtjHkmsCKdyP5GG9NeBoySNJnsUFlrewCkPZP/B9yt7GKKl8jO3bT0NaApnSx/iqw12ZbGkZ1vmpl+08+k7+rTwAWpbAbZ1mprHiA7NFfqsvWvASel5fS/ga8XmeYk4BfpxH/h3texwJNpOdyBrGn3rqozbnhaC26F2WpO0vsi62myuenxZyPi4lrHVSuSlkXE+9pRbxDZeYpdqh9VPpT1hPlZ4Hmyi0meioiLJI0nOzT2CHAH2Z6JgIsi4mplVxf+mmwP4tPAR8lO5D9Pdohq44j4XPN8Cs7drP5uJZ2Z3vsdsu4I/lfSYLJeKLcgO794Y0SscamypHPJLs64qMTrwvdoOW6NeLoCJxmrubR3NIrsaqsngC82HyvviiQtJOtx8ONR5r0ykj5Mthf5r4g4IMfwuryWiaPCuuNxkjEzs1KU3Qs1mmwvp+x7ZdKVnMPJLtaptLv0huUkY2ZmuamLZmXMzKxzcpIxM7PcOMmYmVlunGTMzCw3/x/bBN6MIsdUeQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAreklEQVR4nO3de7xVdZ3/8ddbDiKSgAiUN4QIK0UlxRteELXEZhKnVDSbyByxflZjjVM6jpeaeKTlZNqkSWhoecnxktiIaag5moigCKIykKCijJAXBCdR4PP7Y303bA77nLP3OXudvc857+fjsR977e9a37U+e++192ddv19FBGZmZnnYqtYBmJlZ5+UkY2ZmuXGSMTOz3DjJmJlZbpxkzMwsNw21DqC99e/fPwYPHlzrMKyTmjNnzl8iYkAtlu112/LU2nW7yyWZwYMHM3v27FqHYZ2UpBdrtWyv25an1q7bPlxmZma5cZIxM7PcOMmYmVlunGTMzCw3TjJm1mU8dNsjm73esGHDFmVWXU4yZjmTtKukByU9J2mBpH9M5f0k3S9pUXrevqjOeZIWS1oo6ZjaRd95fHKrE5l00hWcMeJbQJZgjmkYz6STruAHX/pJbYPrxJxkzPK3DviniPg4cBBwlqQ9gHOBGRExDJiRXpPGnQzsCYwFrpLUrSaRd0JL573MGSO+xTEN4zeWPXDDozWMqHNzkjHLWUQsj4gn0/Bq4DlgZ2AccH2a7Hrg+DQ8DrglItZGxBJgMXBAuwbdyS2d93KtQ+gynGTM2pGkwcAngMeBD0bEcsgSETAwTbYzUPwvuCyVlZrfREmzJc1euXJlbnGbtVaXu+PfKjP43P9qVb2ll/xNlSPp+CR9ALgdODsi3pbU5KQlykr2LhgRk4HJACNHjnQPhFZ3vCdj1g4kdSdLMDdGxB2p+DVJO6bxOwIrUvkyYNei6rsAr7ZXrGbV5CRjljNluyzXAs9FxI+LRk0DJqThCcBdReUnS+ohaQgwDJjVXvGaVZMPl5nl7xDg74H5kuamsn8BLgFulXQ68BJwIkBELJB0K/As2ZVpZ0XE+naP2qwKnGTMchYRj1D6PAvAUU3UmQRMyi0os3biw2VmZpYbJxkzM8uNk4yZmeXGScbMzHLjJGNmZrlxkjEzs9w4yZiZWW5ySzLV7END0n6S5qdxV6Y7qEl3RP8mlT+eGh80M7M6keeeTDX70LgamEjWvMawNB7gdODNiPgIcDlwaY7vx8zMKpRbkqlWHxqp4cDeEfFYRARwQ6M6hXndBhxV2MsxM7Paa5dzMm3sQ2PnNNy4fLM6EbEOWAXskMubMDOziuWeZBr3odHcpCXKopny5uo0jsEdO5mZ1UCuSaZKfWgsS8ONyzerI6kB6AO80TiOiJgcESMjYuSAAQOq8dbMzKwMeV5dVpU+NNIhtdWSDkrz/GKjOoV5nQA8kM7bmJlZHcizqf9q9qHxVWAq0BOYnh6QJbFfSVpMtgdzco7vx8zMKpRbkqlmHxoRMRsYXqL8XVKSMjOz+uM7/s3MLDdOMmZmlhsnGTMzy42TjJmZ5cZJxqwdSLpO0gpJzxSVjZA0U9LcdLPwAUXjSjYWa9bROMmYtY+pbGrYteCHwHcjYgRwYXrdUmOxZh2Kk4xZO4iIh9myNYoAeqfhPmxqyaJkY7HtEqhZleV5M6aZNe9s4PeSLiPb4BuVyncGZhZNV9wo7GYkTSTrBoNBgwblFqhZa3lPxqx2vgp8MyJ2Bb5J1oIFlNnwK7hdPqt/TjJmtTMBKDQc+59sOiTWVGOxZh2Ok4xZ7bwKjE7DRwKL0nDJxmJrEJ9Zm/mcjFk7kHQzcATQX9Iy4CLgDOCK1E3Fu6RzKy00FmvWoTjJmLWDiDiliVH7NTF9ycZizToaHy4zM7PcOMmYmVlunGTMzCw3TjJmZpYbJxkzM8uNk4yZmeXGScbMzHLjJGNmZrlxkjEzs9w4yZiZWW6cZMzMLDdOMmZmlhsnGTMzy42TjJmZ5cZJxszMcuMkY2ZmuXGSMTOz3LhnTLMyHHfccS1O069fv3aIxKxjcZIxK8Nzzz3HlClTmhwfEZx11lntGJFZx+AkY1aGSZMmMXr06Ganueiiixg/fnw7RWTWMficjFkZTjrppDZNI+k6SSskPdOo/OuSFkpaIOmHReXnSVqcxh3TltjNaslJxqwM69ev55prruGCCy7g0Ucf3Wzc97///XJmMRUYW1wgaQwwDtg7IvYELkvlewAnA3umOldJ6tbW92BWC04yZmU488wz+eMf/8gOO+zAN77xDb71rW9tHHfHHXe0WD8iHgbeaFT8VeCSiFibplmRyscBt0TE2ohYAiwGDqjC2zBrd04yZmWYNWsWN910E2effTaPP/44a9as4bOf/Sxr164lIlo7292BwyQ9LumPkvZP5TsDLxdNtyyVbUHSREmzJc1euXJla+Mwy42TjFkZ3nvvvY3DDQ0NTJ48mREjRnDkkUeyZs2a1s62AdgeOAj4Z+BWSQJUYtqSmSwiJkfEyIgYOWDAgNbGYZYbJxmzMowcOZJ77713s7ILL7yQ0047jaVLl7Z2tsuAOyIzC9gA9E/luxZNtwvwamsXYlZLuSWZUlfTSLpY0iuS5qbHp4vGlbyaRtJ+kuancVemLT0k9ZD0m1T+uKTBeb0Xs1//+teMHTt2i/J/+Id/4P3332/tbH8LHAkgaXdga+AvwDTg5LSODwGGAbNauxCzWspzT2Yqja6mSS6PiBHpcQ+0eDXN1cBEsh/asKJ5ng68GREfAS4HLs3rjZgVrF+/vlX1JN0MPAZ8VNIySacD1wEfThtitwAT0l7NAuBW4FngXuCsiGjdgs1qLLck08TVNE0peTWNpB2B3hHxWGRnV28Aji+qc30avg04qrCXY5aH1atXM27cuFbVjYhTImLHiOgeEbtExLUR8V5EfCEihkfEvhHxQNH0kyJiaER8NCKmV+1NmLWzWpyT+Zqkeelw2vaprKmraXZOw43LN6sTEeuAVcAOpRboK3CsrZYvX87RRx/NxIkTax2KWYfS3knmamAoMAJYDvx7Km/qaprmrrLxFTjWbg477DDOPffcshrKNLNN2jXJRMRrEbE+IjYAv2DTDWZNXU2zLA03Lt+sjqQGoA/lH54zq8j222/PK6+8UuswzDqcdk0y6RxLwd8BhSvPSl5NExHLgdWSDkrnW74I3FVUZ0IaPgF4INpwV5xZcx566CGmT5/Oz372s1qHYtah5NYKc7qa5gigv6RlwEXAEZJGkB3WWgqcCRARCyQVrqZZx+ZX03yV7Eq1nsD09AC4FviVpMVkezAn5/VezHr16sW0adM488wzax2KWYeSW5KJiFNKFF/bzPSTgEklymcDw0uUvwuc2JYYzSrRrVu3ZvuUMbMtuT8Zs1Z4++23Wbdu3cbX7hXTrDQnGbMKXHPNNVx44YX07NmTwm1ZknjhhRdqHJlZfXKSMavAZZddxoIFC+jfv3+tQzHrENxAplkFhg4dyrbbblvrMMw6DO/JmFXgBz/4AaNGjeLAAw+kR48eG8uvvPLKGkZlVr+cZMwqcOaZZ3LkkUey1157sdVWPhBg1hInGbMKNDQ08OMf/7jWYZh1GN4UM6vAmDFjmDx5MsuXL+eNN97Y+DCz0rwnY1aBm266CcjOzRT4EmazpjnJmFVgyZIltQ7BrENp9nCZpLdbeKyW9D/tFaxZrTz55JNVmcasq2lpT+bPEfGJ5iaQ9FQV4zGrS6eddhoPPfQQzTX0ffrpp7djRGYdQ0tJ5nNlzKOcacw6tFWrVrHffvs1m2TcIZ7ZlppNMhGxxdlMSX8bEb9rbhqzzmbp0qVlTVdoz8zMMq25hPl7VY/CrJOTdJ2kFZKeKTHuHEkhqX9R2XmSFktaKOmY9o3WrHpak2S8qWZWuanA2MaFknYFPgm8VFS2B1knfHumOldJ6tY+YZpVV2uSjLsGNKtQRDxM1oNrY5cD3ybrLbZgHHBLRKyNiCXAYuCA/KM0q75mz8lI2jciNrsuMyJmtTSNWWf25ptvsmjRIt59992NZYcffnjF85F0HPBKRDzd6FzOzsDMotfLUlmpeUwEJgIMGjSo4hjM8tbS1WW/lHQEzR8iuxZo9jJns85iypQpXHHFFSxbtowRI0Ywc+ZMDj74YB544IGK5iNpW+B84FOlRpcoK3lZW0RMBiYDjBw5sulL38xqpKXDZX2AOS083s8zQLN6csUVV/DEE0+w22678eCDD/LUU0+19tLlocAQ4GlJS4FdgCclfYhsz2XXoml3AV5tY+hmNdHSJcyD2ykOsw5hm222YZtttgFg7dq1fOxjH2PhwoUVzyci5gMDC69TohkZEX+RNA24SdKPgZ2AYcCskjMyq3Nuu8ysArvssgtvvfUWxx9/PJ/85CfZfvvt2WmnnVqsJ+lm4Aigv6RlwEURcW2paSNigaRbgWeBdcBZEbG+eu/CrP04yZhV4M477wTg4osvZsyYMaxatYqxY7e4MnkLEXFKC+MHN3o9CZjU+kjN6oOTjFmFHnnkERYtWsRpp53GypUreeWVVxgyZEitwzKrS2XdJyNpRjllZp3dd7/7XS699NKN/cm8//77fOELX6hxVGb1q6X7ZLYBtiU7jrw9my6t7E12QtKsS7nzzjt56qmn2HfffQHYaaedWL16dY2jMqtfLR0uOxM4myyhzGFTknkb+Fl+YZnVp6233hpJGxvCfOedd2ockVl9a/ZwWURcERFDgHMi4sMRMSQ99omI/2inGM3qxkknncSZZ57JW2+9xS9+8QuOPvpozjjjjFqHZVa3yjrxHxE/lTQKGFxcJyJuyCkus7oTEYwfP57nn3+e3r17s3DhQr73ve/xyU9+stahmdWtspKMpF+R3aE8Fyhcrx+Ak4x1GZI4/vjjmTNnjhOLWZnKvYR5JLBHNNctoFkXcNBBB/HEE0+w//771zoUsw6h3CTzDPAhYHmOsZjVvQcffJBrrrmG3XbbjV69ehERSGLevHm1Ds2sLpWbZPoDz0qaBawtFEbEcblEZVanpk+fXusQzDqUcpPMxXkGYdZR7LbbbgCsWLFis/5kzKy0cq8u+2PegZh1BNOmTeOf/umfePXVVxk4cCAvvvgiH//4x1mwYEGtQzOrS+U2K7Na0tvp8a6k9ZLezjs4s3pzwQUXMHPmTHbffXeWLFnCjBkzOOSQQ2odllndKivJRMR2EdE7PbYBPgf4Zkzrcrp3784OO+zAhg0b2LBhA2PGjGHu3Lm1DsusbrWqFeaI+K2kc6sdjFm969u3L2vWrOHwww/n1FNPZeDAgTQ0uDFzs6aUezPmZ4tebkV234zvmbEu56677qJnz55cfvnl3HjjjaxatYoLL7yw1mGZ1a1yN8E+UzS8DlgKjGuugqTrgL8FVkTE8FTWD/gNWfM0S4GTIuLNNO484HSyFgW+ERG/T+X7AVOBnsA9wD9GREjqQdbiwH7A68D4iFha5vsxa5VevXoBsNVWWzFhwoQaR2NW/8o9J3Na0eOMiJgUEStaqDYVaNxl4LnAjIgYBsxIr5G0B3AysGeqc5WkbqnO1cBEsn7OhxXN83TgzYj4CHA5cGk578XMzNpPuVeX7SLpTkkrJL0m6XZJuzRXJyIeBt5oVDwOuD4NXw8cX1R+S0SsjYglwGLgAEk7Ar0j4rHUpM0NjeoU5nUbcJQK7a+bmVldKCvJAL8EppH1K7MzcHcqq9QHI2I5QHoemMp3Bl4umm5ZKts5DTcu36xORKwDVgE7lFqopImSZkuavXLlylaEbbbJX//6VxYuXFjrMMw6hHKTzICI+GVErEuPqcCAKsZRag8kmilvrs6WhRGTI2JkRIwcMKCaYVtXc/fddzNixAjGjs2O2s6dO5fjjmu5dSVJ16UjAc8Ulf1I0vOS5qUjBX2Lxp0nabGkhZKOyeGtmLWLcpPMXyR9QVK39PgC2cn2Sr2WDoGRngvndZYBuxZNtwvwairfpUT5ZnUkNQB92PLwnFlVXXzxxcyaNYu+ffsCMGLECJYuXVpO1alseY7yfmB4ROwN/A9wHrR4jtKsQyk3yXwZOAn4X7KWmE9IZZWaBhQuyZkA3FVUfrKkHpKGkJ3gn5UOqa2WdFA63/LFRnUK8zoBeMBdEVjeGhoa6NOnT8X1Sp2jjIj70qFegJls2qAqeY6y9VGb1U65bZe9BFTU4rKkm4EjgP6SlgEXAZcAt0o6HXgJODHNf4GkW4FnyS6RPisiCp2jfZVNlzBPTw+Aa4FfSVpM9uM9uZL4zFpj+PDh3HTTTaxfv55FixZx5ZVXMmrUqGrM+stkl/dDdr5xZtG44nORm5E0kezqSwYNGlSNOMyqqtyry65vdLx4+3QfTJMi4pSI2DEiukfELhFxbUS8HhFHRcSw9PxG0fSTImJoRHw0IqYXlc+OiOFp3NcKeysR8W5EnBgRH4mIAyLihYrfvVmFfvrTn7JgwQJ69OjBKaecQu/evfnJT37SpnlKOp9s4+rGQlGJyXy+0Tqkcm/G3Dsi3iq8iIg3JX0in5DM6te2227LpEmTmDRpUlXmJ2kC2U3LRxUd7m3qHKVZh1NuktlK0vZFd+f3q6CuWYf3mc98huZuw5o2bVrF85Q0FvgOMDoi/q94dsBNkn5MdtvAMGBWxQswqwPlJop/B/4k6Tay3faTgOpsypl1AOecc06b6jdxjvI8oAdwf0pgMyPiKy2cozTrUMo98X+DpNnAkWTHiz8bEc/mGplZHRk9enSb6kfEKSWKr21m+kl4Q846gbIPeaWk4sRiXdpee+21xWGzPn36MHLkSP71X/+1RlGZ1S+fVzGrwLHHHku3bt34/Oc/D8Att9xCRNCnTx++9KUv1TY4szrkJGNWgUcffZRHH3104+u99tqLQw45hEcffZRf//rXNYzMrD6Ve8e/mQFr1qzh8ccf3/h61qxZrFmzBsA9ZJqV4F+FWQWmTJnCl7/8ZdasWUNE0Lt3b6ZMmcI777zDeeedx/jx42sdolldcZIxq8D+++/P/PnzWbVqFRGxsaFMgJNOOslJxqwRJxmzCqxdu5bbb7+dpUuXsm7duo3lF154YQ2jMqtfTjJmFRg3bhx9+vRhv/32o0ePHrUOx6zuOcmYVWDZsmXce++9tQ7DrMPw1WVmFRg1ahTz58+vdRhmHYb3ZMwq8MgjjzB16lSGDBlCjx49iAgkMW/evFqHZlaXnGTMKjB9+vSWJzKzjZxkzCqw2267AbBixQrefffdGkdjVv98TsasAtOmTWPYsGEMGTKE0aNHM3jwYI499thah2VWt5xkzCpwwQUXMHPmTHbffXeWLFnCjBkzOOSQQ2odllndcpIxq0D37t3ZYYcd2LBhAxs2bGDMmDHMnTu31mGZ1S2fkzGrQN++fVmzZg2HH344p556KgMHDnTDmGbN8J6MWQXuuusuevbsyeWXX87YsWMZOnQod999d63DMqtb3gQzq0CvXr02Dk+YMKGGkZh1DN6TMSvDoYceCsB2221H7969Nz4Kr82sNCcZszI88sgjAKxevZq3335746PwuiWSrpO0QtIzRWX9JN0vaVF63r5o3HmSFktaKOmYPN6TWXtwkjEr04YNGxg+fHhrq08FxjYqOxeYERHDgBnpNZL2AE4G9kx1rpLUrbULNqslJxmzMm211Vbss88+vPTSSxXXjYiHgTcaFY8Drk/D1wPHF5XfEhFrI2IJsBg4oFVBm9WYT/ybVWD58uXsueeeHHDAAZtdBDBt2rTWzO6DEbEcICKWSxqYyncGZhZNtyyVbUHSRGAiwKBBg1oTg1munGTMKnDRRRe1x2JUoixKTRgRk4HJACNHjiw5jVktOcmYVeCee+7h0ksv3azsO9/5DqNHj27N7F6TtGPai9kRWJHKlwG7Fk23C/BqaxZgVms+J2NWgfvvv3+LsjY0/z8NKNxsMwG4q6j8ZEk9JA0BhgGzWrsQs1rynoxZGa6++mquuuoqXnjhBfbee++N5atXry6rgUxJNwNHAP0lLQMuAi4BbpV0OvAScCJARCyQdCvwLLAOOCsi1lf5LZm1CycZszJ8/vOf59hjj+W8887jkksu2Vi+3Xbb0a9fvxbrR8QpTYw6qonpJwGTWhOrWT1xkjErQ58+fejTpw8333xzrUMx61B8TsbMzHLjJGNmZrlxkjEzs9w4yZiZWW6cZMzMLDc1STKSlkqaL2mupNmprOJmzyXtl+azWNKVkko1x2FmZjVSyz2ZMRExIiJGptetafb8arLGAYelR+Om1M3MrIbq6XBZRc2ep7aeekfEYxERwA1FdczMrA7UKskEcJ+kOampcmjU7DlQ3Oz5y0V1C82e75yGG5dvQdJESbMlzV65cmUV34aZmTWnVnf8HxIRr6b+M+6X9Hwz0zbV7LmbQzczq3M12ZOJiFfT8wrgTrJe/15Lh8Aos9nzZWm4cbmZmdWJdk8yknpJ2q4wDHwKeIYKmz1Ph9RWSzooXVX2xaI6ZmZWB2pxuOyDwJ3pauMG4KaIuFfSE1Te7PlXgalAT2B6epiZWZ1o9yQTES8A+5Qof50Kmz2PiNnA8GrHaGZm1VFPlzCbmVkn4yRjZma5cZIxM7PcOMmYmVlunGTMzCw3TjJmNSbpm5IWSHpG0s2StmmuVXKzjsRJxqyGJO0MfAMYGRHDgW5krY6XbJXcrKNxkjGrvQagp6QGYFuy5pGaapXcrENxkjGroYh4BbiMrJWL5cCqiLiPplsl34xbGLd65yRjVkPpXMs4YAiwE9BL0hfKrR8RkyNiZESMHDBgQF5hmrWak4xZbR0NLImIlRHxPnAHMIqmWyU361CcZMxq6yXgIEnbptbEjwKeo+lWyc06lFp1WmZmQEQ8Luk24EmyVsafIutg7wOUaJXcrKNxkjGrsYi4CLioUfFammiV3Kwj8eEyMzPLjZOMmZnlxknGzMxy4yRjZma5cZIxsy5vuw/2qnUInZaTjJl1eUOHD651CJ2Wk4yZdXnLFr9S6xA6LScZM+vy3n59da1D6LScZMysy+vevXutQ+i0nGTMrMvb98gRtQ6h03KSMbMuYdeP7tTkuPHfOb79AulinGTMrEt4dclrTY57dubCdoyka3GSMbMuQWp6XN8P9m23OLoaJxkz6xLWv7dh4/Dokw5mm149Nr5eNOfPtQipS3CSMbMuYff9P7xx+K9r3mXb3ttufH3kyYfWIqQuwUnGzLqETxy5FwAf3mc3Zt3zFG8sf5Odh+1It4ZubO/DZblxkjGzLmHCd8cz8ph9eOHpFzeWLf/z//LdO/+ZHXbcvoaRdW5OMmbWJax8+XWWLniZbg3dNpZt2BDMmv4UEVHDyDo3Jxkz6xIe/68neXfNWj40ZODGshFHDueRO2fxxv++VbvAOjknGTPrEo76wmEMHNSfFS+u5Lt3fptDP3sgcx94huPOOsaHy3LkJGNWY5L6SrpN0vOSnpN0sKR+ku6XtCg9+1+wjab97Pe8/PwrXHTHPzNq3P6cf/PZHPrZA7nlB3fy+vI3ax1ep9VQ6wDMjCuAeyPiBElbA9sC/wLMiIhLJJ0LnAt8p5ZBdnQnn3c8B/7NvnzkE0MAaOjewPk3n82Lzy7znkyOvCdjVkOSegOHA9cCRMR7EfEWMA64Pk12PXB8LeLrTLp167YxwRQ0dG9g6D6DaxNQF+EkY1ZbHwZWAr+U9JSkKZJ6AR+MiOUA6XlgqcqSJkqaLWn2ypUr2y9qszI5yZjVVgOwL3B1RHwCeIfs0FhZImJyRIyMiJEDBgzIK0azVuvwSUbSWEkLJS1Ox67NOpJlwLKIeDy9vo0s6bwmaUeA9LyiRvGZtUmHTjKSugE/A44F9gBOkbRHbaMyK19E/C/wsqSPpqKjgGeBacCEVDYBuKsG4Zm1WUe/uuwAYHFEvAAg6RayE6bP1jQqs8p8HbgxXVn2AnAa2QbgrZJOB14CTqxhfGat1tGTzM7Ay0WvlwEHNp5I0kRgYnq5RlJTPRT1B/5S1Qhbr15iaVUcujSHSDrGZ7JbpTOLiLnAyBKjjqpkPnPmzPmLpBebGN0RPrv2Vi+x1EscUOV1Gzp+kinVDdEWjRBFxGRgcoszk2ZHRKkfe7url1jqJQ6on1jqJY7GIqLJM//1EnO9xAH1E0u9xAH5xNKhz8mQ7bnsWvR6F+DVGsViZmaNdPQk8wQwTNKQdDz7ZLITpmZmVgc69OGyiFgn6WvA74FuwHURsaANs2zxkFo7qpdY6iUOqJ9Y6iWOStRLzPUSB9RPLPUSB+QQi9yPgpmZ5aWjHy4zM7M65iRjZma56XJJptx+OiQtlTRf0lxJsyutX404JO0q6cHUx8gCSf9YNO5iSa+k+OZK+nQrYmi2SR5lrkzj50nat9y6VY7j1LT8eZL+JGmfonElv6ccYzlC0qqiz/3CcutWWwXrcsm4mluHJJ2Xpl8o6Zh2iOVHyvrTmSfpTkl9U/lgSX8tivHnlcy3aHzF63Jrf+utjaXav/c2fibV+/+LiC71AH4InJuGzwUubWK6pUD/1tavRhzAjsC+aXg74H+APdLri4Fz2vA5dAP+TNYK8NbA04V5F03zaWA62f1IBwGPl1u3ynGMArZPw8cW4mjue8oxliOA37Wmbi3W5ebiamodImui6WmgBzAk1e+WcyyfAhrS8KWF+sBg4JlarMvlvKcqx1K133tb4mjud9Waz6TL7cnQ9n46qtXPR4vziYjlEfFkGl4NPEfWykE1bGySJyLeAwpN8jSO8YbIzAT6KmussZy6VYsjIv4UEYWuC2eS3Q+Vh7a8r2p+JuUqZ11sTVzjgFsiYm1ELAEWp/nkFktE3BcR69J0lX7Hea3LrfmttzqWKv/e2/KZNKfiz6QrJpmy+ukgazngPklzlDVLU2n9asUBZIcNgE8AjxcVfy3t5l5X7q58kVJN8jReoZuappy61Yyj2OlkW18FTX1PecZysKSnJU2XtGeFdaupnHWopbhKrUOteS/ViKXgy2z+HQ9R1tfOHyUd1sr5tmZdbs1vvS2xbFSF33tb46ja/1+Hvk+mKZL+AHyoxKjzK5jNIRHxqqSBwP2Sno+Ih2sQB5I+ANwOnB0Rb6fiq4F/I1sZ/g34d7IfZ9mzLVHW+Hr2pqYpqzmfKsaRTSiNIUsyhxYVt/l7qjCWJ4HdImJNOi7+W2BYmXUrD6jt61BzcTW1DpWsk3Ms2QTS+cA64MZUtBwYFBGvS9oP+K2kPYt+B2XNt5lpqv29tSWWbGR1fu9tjaNqv6tOmWQi4uimxkl6rbBrqmb66YiIV9PzCkl3ku1+Pkzq56Ol+tWKQ1J3shXuxoi4o2jerxVN8wvgd00tqwnlNMnT1DRbl1G3mnEgaW9gCnBsRLxeKG/me8olluI/t4i4R9JVkvqX+z4qVYV1qMm4mlmHStbJM5Y0jwnA3wJHRTroHxFrgbVpeI6kPwO7A8UXeeS1Lpf9W69SLNX8vbcpjmr8/23U0kmbzvYAfsTmJ65+WGKaXsB2RcN/AsaWW7+KcQi4AfhJiXE7Fg1/k+wYeiXLbyBrVn4Im04M7tlomr9h8xODs8qtW+U4BpGdFxhV7veUYywfYtNNzAeQNcOvan4mVV6HmoyrqXUI2JPNT/y/QMsn/tsay1iyLjoGNKozoLBsspPYrwD92mNdLuc9Vfl3VbXfexvjqOr/X24/gHp9ADsAM4BF6blfKt8JuKdoZX46PRYA57dUP6c4DiXbfZ0HzE2PT6dxvwLmp3HTilfCCmL4NNkVLH8uvEfgK8BXilb6n6Xx84GRzdVtw3fSUhxTgDeLPoPZLX1POcbytbSsp8lOUI9qrm6t1+Xm4mpuHSI7BPZnYCHZ3mPesSwmOz9Q+I5/nso/V/R5Pwl8pr3W5abeU16/K6r8e29DHFX9/3OzMmZmlpuueHWZmZm1EycZMzPLjZOMmZnlxknGzMxy4yRjZma5qVmSSa2KnpOGvyepuRu9jpe0R/tFt9mye0j6Q2qNdHw7L/tP7by8E1MLsA82Kh8s6fPN1NtJ0m05xPMlSf9R7fmWsdwR5bRyW6LeVyR9sUT5YEnPVDCf9Wl926mCOodJeraS5Zi1h7rYk4mICyPiD81McjxZy7C18Amge0SMiIjfFI+Q1C2PBRbmGxGjqjWvMp0O/L+IGNOofDBQMslIaoiIVyPihFaGWI9GkN1jsAVJTbaSERE/j4gbqrD8v6b1rewWAyLiv2ki5o6iA214Fprd/16F9W6U9IakzvRbaVG7JhlJ5yvr3+APwEeLyqcWPnhJl6QtsnmSLpM0CjgO+FHauhsq6QxJTyhrpPB2SdsWzedKZX2OvFD8ZUr6trL+EZ6WdEkqGyrpXmWNwP23pI81incg8GtgRNGyl0q6UNIjwImSTknzfUbSpUV110i6NM37D5IOkPRQiuu4Ep/NEcr6kriJ7MYoJK1Jz7/R5n19TJX0OUndlPXD8UT6vM5sal6NlrVFzMr6RTkU+LmkHzWqcglwWPoMvpn2MP5T0t1kjeht3FJPw/8t6cn0GFUU00OSblPWb8iNkpTGfTqVPZK+vy2azJA0IH3XT6THISWm6ZbWmfnp8/h6Kt9PWeOKcyT9Xqml2RTPpZJmSfofZXsDWwPfA8an9zs+/alMlnQfcIOk3STNSMuYIWlQml/xn+R+aV17DDirKMY90/LmpvrDGr+PEu+ronWpM6jzDU+AyyPiwpYn2yQiTiW7kbJryfuu5KI7Rfcj+8PbFuhNdofvOWncVOAEoB/ZHcaFm0T7Fo8vvuu0aPj7wNeLpvtPsuS5B1lT15D1QfInYNv0unA38gxgWBo+EHigRNxHUNR/CFk/C98uupv5JbKmLxqAB4Dj07gg3SkN3AncB3QH9gHmNrGcd4AhRWVr0vPfAden4a3J7ozuCUwE/jWV9yBrz2lIqXkVzbO5mB+i6E7oZj6DL5G1e1T4HAeT+vxI3+82aXgYm+7OPwJYRdY+0lbAY2RJbZv0foak6W4uLCst5z/S8E3AoWl4EPBciTi/StbuU6Ffkn7pM/8TqbkSYDxwXdH7/feiu6P/0Hi56fXFwBygZ3p9NzAhDX8Z+G3RdIV1eh4wOg3/qOjz+SlwatF32bPE+1jT6HVZ6xJl9L1Sbw+ylgUWAn9I3/1m/wlp+BKyJmfmAZeR9S/0BrCE7K74ocAZwBNkd6nfzqbf+lTgyrQOvMDm/yPfJvtPehq4JJUNBe5N3/d/Ax8rEfPG77no9fXpe1kKfJas35X5aV7di6adWhxDV3i0ZwOZhwF3RsT/AUgqldHfBt4Fpkj6L5puBG64pO8DfYEPAL8vGvfbiNgAPCvpg6nsaOCXhWVHxBvKWjodBfxn2qCG7I+6HIXDZvsDD0XEyvSebgQOJ2uZ9z2yFQyylW1tRLwvaT7Zn0EpsyLrv6Ox6cCVknqQtfH0cET8VdKngL21aY+tD9kf+3vNzKu5mCtxf0S8UaK8O/AfkkYA68kaMyx+f8vScueSfQ5rgBeKYr2ZLHk2djSwR9F31VvSdpH1u1E8zc8j9UuSvufhwHCylmQh68xpeVGdQiOEc2j6ewGYFhF/TcMHk/2RQNbcxw+LJ5TUh2wD6Y9F0xybhh8Dzpe0C3BHRCxqZpkFrVmX6p6yVpVPJjsk3UDWbMycRtP0I9vI+lhEhKS+EfFW+v/4XUTclqZ7KyJ+kYa/T3bo96dpNjuSbdB8jGxP4jZJx5LtDR0YEf+XlgMwmazZlUWSDgSuAo4s4+0MBcaQbdw+BnwuIr6trHHJv6Hy31en0d6tMDfbhk1ErJN0AHAU2cr3NUp/wVPJtr6flvQlsq3kgrVFwyp6brzsrYC3ImJEmbEXe6fR/Et5P9KmC7CBTS3JblDTx/XfKVUYEe9Kegg4hmxL/Oai5X89IoqTLJKOaGpeLcRciabm/03gNbKt7K3INhoKir+b9WTrX7nxbAUcXPRHX0qp71nAgog4uIk6hZgK8TSlqfdLE8ssua5HxE2SHif74/m9pH+IiAeamTe0bl3qCDrThuf0osTfjc03CgaXOY9OqT3PyTwM/J2knpK2Az7TeIL0JfeJiHuAs8lOwAKsJuuOtGA7YLmyZrFPLWPZ9wFf1qZzN/0ia7J9iaQTU5lU1Hd8mR4HRkvqr+wE+ynAH1uo01q3AKeR/TALP6DfA19NnwOSdpfUK4eYG3/+zekDLE8/6r8n+8E153ngw8o6aYIsiZZyH9lGB5BdAdbENF8p/PGmrdOFwABJB6ey7trU0VhTWnq/fyLbCIJs/XukeGREvAWsknRo0TSFuD9Mtud2JdlW9d4txNLZtbjhSdba9e1kex73NjHpVOBrEbEX8F2yw7AFFW94Fj0+Xs6boCjxs+VGQUfeEGizdksykXUr+huyY6i3kx3vbGw74HeS5pH98X0zld8C/LOy3vGGAheQ/VneT/Yn1dKy7yX7Qc9Oh2nOSaNOBU6XVGhtdFyF72k5cB7wIKmV2Ii4q5J5VOA+ssNaf4isO1XIWid+FnhS2Yn3a2hhhW5lzPOAdelE9jdbmPYqYIKkmWSHyprbAyDtmfw/4F5lF1O8RnbuprFvACPTyfJnyVqTbWwK2fmmeek7/Xz6rE4ALk1lc8m2VpvzINmhuaYuW/8GcFpaT/8e+McS05wG/Cyd+C/e+xoPPJPWw4+RNe3eVXXGDU9rxK0wW81J+kBkPU0Wmh5fFBGX1zquWpG0JiI+0Ip6g8nOUwyvflT5UNYT5heBF8kuJnk2Ii6TNJXs0NijwF1keyYCLouI65VdXfgLsj2IE4BPkZ3If5HsENV2EfGlwnyKzt1s/GwlnZuW/R5ZdwT/ImkIWS+UO5KdX7wlIja7VFnSxWQXZ1zWxOviZTQet1k8XYGTjNVc2juaQHa11VPAGYVj5V2RpFfJehz8dJR5r4ykw8j2Il+PiCNyDK/La5w4Kqw7FScZMzNrirJ7oSaS7eWUfa9MupJzFNnFOpV2l95hOcmYmVlu6qJZGTMz65ycZMzMLDdOMmZmlhsnGTMzy83/B6mLAlXKiJLQAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxBklEQVR4nO3deZxU1Zn/8c+XRUTCKmBQVFAxiUtExSXgviRoEjFx10SiRjQxY8wkMRLjEif+RkaN0bhEXILGfVwiOmI0uI0LIiiCqAwoqAgR4gpGUeD5/XFPQdFUd1d1d3VVd3/fr1e96ta599z7VNWteu56jiICMzOzcmhX6QDMzKz1cpIxM7OycZIxM7OycZIxM7OycZIxM7Oy6VDpAJpb7969Y8CAAZUOw1qpqVOn/jMi+lRi2V63rZwaum63uSQzYMAApkyZUukwrJWS9Eallu1128qpoeu2D5eZmVnZOMmYmVnZOMmYmVnZlDXJSJonaYakaZKmpLJekh6WNDs998ybfrSkOZJmSfpGXvmOaT5zJF0mSam8k6TbU/mzkgaU8/2YmVlpmmNPZu+IGBwRQ9LrM4CJETEImJheI2kr4Ehga2A4cKWk9qnOVcAoYFB6DE/lJwDvR8QWwCXAmGZ4P2bWQp112Jp/EStWrOCsw/23UU6VOFw2ArghDd8AHJxXfltELIuIucAcYGdJ/YBuEfFMZK153lijTm5edwL75vZyzKqFpI0lPSrpFUkzJf00lZe8V28Nt3+7w5h01xT2b3cYkCWY4R2PZNKdU/j6uodVOLrWq9xJJoCHJE2VNCqVbRARCwHSc99UvhHwVl7d+alsozRcs3yNOhGxHPgQWL9mEJJGSZoiacrixYub5I2ZlWA58POI+AqwK3BK2nNvyF69NYH92x3G8I5Hrnodn1UwmFau3ElmWETsABxA9sPao45pC+2BRB3lddVZsyBibEQMiYghffpU5D45a8MiYmFEPJ+GlwCvkG0glbRX36xBmzWRsiaZiFiQnhcB95D9UN5Jh8BIz4vS5POBjfOq9wcWpPL+BcrXqCOpA9AdeK8c78WsKaSLU7YHnqX0vfpC8/NeulW1st3xL6kL0C4ilqThrwPnAeOBkcAF6fneVGU8cIuk3wMbkp3gnxwRKyQtkbQr2Q/zWOCPeXVGAs8AhwKPhHtha1IDzvifBtWbd8E3mziSlk/SF4C7gNMi4qM6Th8WtYcO2V46MBZgyJAhXvet6pSzWZkNgHvSD6kDcEtEPCjpOeAOSScAbwKHAUTETEl3AC+THcM+JSJWpHn9CBgHdAYmpAfAdcBfJM0h24NZfZDVrIpI6kiWYG6OiLtT8TuS+kXEwiL36s1anLIlmYh4HdiuQPm7wL611DkfOL9A+RRgmwLln5KSlFm1Slc8Xge8EhG/zxtV0l5980Vs1nTaXAOZZhUwDPg+MEPStFT2a7LkUupevVmL4iRjVmYR8SSFz7NAiXv1Zi2N2y4zM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxawaSrpe0SNJLeWW3S5qWHvMkTUvlAyR9kjfuTxUL3KyROlQ6ALM2YhxwOXBjriAijsgNS7oY+DBv+tciYnBzBWdWLk4yZs0gIp6QNKDQOEkCDgf2adagzJqBD5eZVd7uwDsRMTuvbKCkFyQ9Lmn32ipKGiVpiqQpixcvLn+kZiVykjGrvKOAW/NeLwQ2iYjtgX8HbpHUrVDFiBgbEUMiYkifPn2aIVSz0jjJmFWQpA7Ad4Hbc2URsSwi3k3DU4HXgC0rE6FZ4zjJmFXWfsCrETE/VyCpj6T2aXgzYBDweoXiM2sUJxmzZiDpVuAZ4EuS5ks6IY06kjUPlQHsAUyX9CJwJ3ByRLzXfNGaNR1fXWbWDCLiqFrKf1Cg7C7grnLHZNYcvCdjZmZl4yRjZmZlU/YkI6l9ut7//vS6l6SHJc1Ozz3zph0taY6kWZK+kVe+o6QZadxl6eY1JHVKTXPMkfRsbTe7mZlZZTTHnsxPgVfyXp8BTIyIQcDE9BpJW5GdBN0aGA5cmbvCBrgKGEV2lc2gNB7gBOD9iNgCuAQYU963YmZmpShrkpHUH/gmcG1e8QjghjR8A3BwXvlt6R6BucAcYGdJ/YBuEfFMRARZ208HF5jXncC+ub0cMzOrvHLvyfwBOB1YmVe2QUQsBEjPfVP5RsBbedPNT2UbpeGa5WvUiYjlZA0Mrl8zCDe9YWZWGWVLMpK+BSxKdywXVaVAWdRRXledNQvc9IaZWUWU8z6ZYcBBkg4E1gW6SboJeEdSv4hYmA6FLUrTzwc2zqvfH1iQyvsXKM+vMz81z9Ed8E1rZmZVomx7MhExOiL6R8QAshP6j0TE94DxwMg02Ujg3jQ8HjgyXTE2kOwE/+R0SG2JpF3T+ZZja9TJzevQtIy19mTMzKwyKnHH/wXAHalZjTeBwwAiYqakO4CXgeXAKRGxItX5EVmnT52BCekBcB3wF0lzyPZgjmyuN2FmZvVrliQTEY8Bj6Xhd4F9a5nufOD8AuVTgG0KlH9KSlJmZlZ9fMe/mZmVjZOMmZmVjZOMmZmVjZOMmZmVjZOMmZmVjZOMmZmVjXvGNCvCQQcdVO80vXr1aoZIzFoWJxmzIrzyyitce+21tY6PCE455ZRmjMisZXCSMSvC+eefz5577lnnNOeccw5HHHFEwXGSrgdyjcZuk8rOBU4Eck2D/zoiHkjjRpP1l7QCODUi/tYEb8Os2fmcjFkRDj/88MZOM47Vne3luyQiBqdHLsHU1YGfWYviJGNWhBUrVnD11Vdz1lln8dRTT60x7ne/+1299SPiCYpvIbxgB34lhmxWFZxkzIpw0kkn8fjjj7P++utz6qmn8u///u+rxt19992NmfVPJE2XdL2knqmstg781uIO+azaOcmYFWHy5MnccsstnHbaaTz77LMsXbqU7373uyxbtoxG9C5xFbA5MBhYCFycyovqjA/cIZ9VPycZsyJ89tlnq4Y7dOjA2LFjGTx4MPvssw9Lly5t0Dwj4p2IWBERK4FrWH1IrLYO/MxaHCcZsyIMGTKEBx98cI2ys88+m+OOO4558+Y1aJ6pZ9ic7wAvpeGCHfg1aCFmFeZLmM2KcNNNNxUs/+EPf8gPf/jDeutLuhXYC+gtaT5wDrCXpMFkh8LmASdBvR34mbUoTjJmJVixYgXt25d+NXFEHFWg+Lo6pi/YgZ9ZS+PDZWZFWrJkCSNGjKh0GGYtipOMWREWLlzIfvvtx6hRoyodilmL4sNlZkXYfffdufDCC4tqKNPMVvOejFkRevbsydtvv13pMMxaHCcZsyI89thjTJgwgSuuuKLSoZi1KE4yZkXo0qUL48eP54UXXqh0KGYtipOMWZHat29fZ58yZrY2n/g3a4CPPvqI5cuXr3rtXjHNCnOSMSvB1Vdfzdlnn03nzp2RsnYsJfH6669XODKz6uQkY1aCiy66iJkzZ9K7d+9Kh2LWIvicjFkJNt98c9Zbb71Kh2HWYnhPxqwE//mf/8nQoUPZZZdd6NSp06ryyy67rIJRmVUvJxmzEpx00knss88+bLvttrRr5wMBZvVxkjErQYcOHfj9739f6TDMWgxvipmVYO+992bs2LEsXLiQ9957b9XDzArznoxZCW655RYgOzeT40uYzWpXtiQjaV3gCaBTWs6dEXGOpF7A7cAAst4AD4+I91Od0cAJwArg1Ij4WyrfERgHdAYeAH4aESGpE3AjsCPwLnBERMwr13symzt3bqVDMGtR6jxcJumjeh5LJP1fLdWXAftExHbAYGC4pF2BM4CJETEImJheI2kr4Ehga2A4cKWkXBeEVwGjyPo6H5TGQ5aQ3o+ILYBLgDEN+RDM6vP88883yTRmbU19ezKvRcT2dU0gqWCLgRERwNL0smN6BDCCrK9zgBuAx4BfpfLbImIZMFfSHGBnSfOAbhHxTFrejcDBwIRU59w0rzuByyUpLdusyRx33HE89thj1LVqnXDCCc0YkVnLUF+SOaSIedQ6TdoTmQpsAVwREc9K2iAiFgJExEJJfdPkGwGT8qrPT2Wfp+Ga5bk6b6V5LZf0IbA+8M8acYwi2xNik002KeItma3pww8/ZMcdd6wzyfTp06fWcZKuB74FLIqIbVLZhcC3gc+A14DjIuIDSQOAV4BZqfqkiDi5Kd6HWXOrM8lExFpnMyV9KyLur2uavHErgMGSegD3SNqmjsWp0CzqKK+rTs04xgJjAYYMGeK9HCvZvHnzipou155ZAeOAy8nOIeY8DIxOG0hjgNFke/WQHUUY3IBQzapKQy5hPq/UChHxAdlhseHAO5L6AaTnRWmy+cDGedX6AwtSef8C5WvUkdQB6A74elKrOhHxBDXWzYh4KCJyTTlPYs313KxVaEiSqXVTbY2JpD5pDwZJnYH9gFeB8cDINNlI4N40PB44UlInSQPJTvBPTofWlkjaVdlm4rE16uTmdSjwiM/HWAt1PNl5xpyBkl6Q9Lik3SsVlFljNeQS5pOKnK4fcEM6L9MOuCMi7pf0DHCHpBOAN4HDACJipqQ7gJeB5cAp6XAbwI9YfQnzBFb/GK8D/pIuEniP7Oo0sxZF0plk6/zNqWghsElEvJsu3/+rpK0j4qMCdX2+0apanUlG0g4RscZ1mRExub5p0nTTgbWuTIuId4F9Cy0vIs4Hzi9QPgVY63xORHxKSlJmzeX9999n9uzZfPrpp6vK9thjjwbNS9JIsgsC9s3thacrLJel4amSXgO2BKbUrO/zjVbt6tuT+bOkvaj7ENl1FEgmZq3Rtddey6WXXsr8+fMZPHgwkyZN4mtf+xqPPPJIyfOSNJzsRP+eEfGvvPI+wHsRsULSZmSHjt2kgLVI9Z2T6U52CXJdj8/LGaBZNbn00kt57rnn2HTTTXn00Ud54YUX6rx0OUfSrcAzwJckzU+Hiy8HugIPS5om6U9p8j2A6ZJeJLv/6+SI8AUt1iLVdwnzgGaKw6xFWHfddVl33XUBWLZsGV/+8peZNWtWPbUgIo4qUHxdLdPeBdzVmDjNqoUbyDQrQf/+/fnggw84+OCD2X///enZsycbbrhhpcMyq1pOMmYluOeeewA499xz2Xvvvfnwww8ZPnx4PbXM2i4nGbMSPfnkk8yePZvjjjuOxYsX8/bbbzNw4MBKh2VWlYq6GVPSxGLKzFq73/72t4wZM2ZVfzKff/453/ve9yoclVn1qu8+mXWB9YDeknqy+lLmboAPRFubc8899/DCCy+www47ALDhhhuyZMmSCkdlVr3qO1x2EnAaWUKZyuok8xFwRfnCMqtO66yzDpJWNYT58ccfVzgis+pW5+GyiLg0IgYCv4iIzSJiYHpsFxGXN1OMZlXj8MMP56STTuKDDz7gmmuuYb/99uPEE0+sdFhmVauoE/8R8UdJQ8m6TO6QV35jrZXMWpmI4IgjjuDVV1+lW7duzJo1i/POO4/999+/0qGZVa2ikoykvwCbA9OAXKOVwZp9Y5i1apI4+OCDmTp1qhOLWZGKvYR5CLCVm9G3tm7XXXflueeeY6eddqp0KGYtQrFJ5iXgi2RNkJu1WY8++ihXX301m266KV26dCEikMT06dMrHZpZVSo2yfQGXpY0mdQEOUBEHFSWqMyq1IQJE+qfyMxWKTbJnFvOIMxaik033RSARYsWrdGfjJkVVuzVZY+XOxCzlmD8+PH8/Oc/Z8GCBfTt25c33niDr3zlK8ycObPSoZlVpWKblVki6aP0+FTSCklrdQVr1tqdddZZTJo0iS233JK5c+cyceJEhg0bVumwzKpWUUkmIrpGRLf0WBc4hKzDJbM2pWPHjqy//vqsXLmSlStXsvfeezNt2rRKh2VWtRrUCnNE/FXSGU0djFm169GjB0uXLmWPPfbgmGOOoW/fvnTo4MbMzWpT7M2Y38172Y7svhnfM2Ntzr333kvnzp255JJLuPnmm/nwww85++yzKx2WWdUqdhPs23nDy4F5wIgmj8asynXp0gWAdu3aMXLkyApHY1b9ir267LhyB2JmZq1PsVeX9Zd0j6RFkt6RdJek/uUOzqy1kHR9+v28lFfWS9LDkman555540ZLmiNplqRvVCZqs8YrKskAfwbGk/UrsxFwXyoza3M++eQTZs2aVWq1ccDwGmVnABMjYhAwMb1G0lbAkcDWqc6Vkto3JmazSik2yfSJiD9HxPL0GAf0KWNcZlXpvvvuY/DgwQwfnuWLadOmcdBB9beuFBFPAO/VKB4B3JCGbwAOziu/LSKWRcRcYA6wc+OjN2t+xSaZf0r6nqT26fE94N1yBmZWjc4991wmT55Mjx49ABg8eDDz5s1r6Ow2iIiFAOm5byrfCHgrb7r5qWwtkkZJmiJpyuLFixsah1nZFJtkjgcOB/5B1hLzoanMrE3p0KED3bt3L/diVKCs4C0DETE2IoZExJA+fXxwwapPsVeXvQm4xWVr87bZZhtuueUWVqxYwezZs7nssssYOnRoQ2f3jqR+EbFQUj9gUSqfD2ycN11/YEEjwjarmGKvLrtBUo+81z0lXV+2qMyq1B//+EdmzpxJp06dOOqoo+jWrRt/+MMfGjq78UDuZpuRwL155UdK6iRpIDAImNyYuM0qpdibMb8aER/kXkTE+5K2L09IZtVrvfXW4/zzz+f8888vqZ6kW4G9gN6S5gPnABcAd0g6AXgTOAwgImZKugN4mezm51MiYkXBGZtVuWKTTDtJPSPifciu7y+hrlmL9+1vfxup0KmSzPjx4+usHxFH1TJq31qmPx8oLZOZVaFiE8XFwNOS7iQ7AXk4/gFYG/KLX/yi0iGYtUjFnvi/UdIUYB+yK1++GxEv11VH0sbAjcAXgZXA2Ii4NO0F3Q4MIGsD7fC8PaTRwAnACuDUiPhbKt+R7Ga2zsADwE8jIiR1SsvYkeyS6iMiYl6xb96sWHvuuWelQzBrkYo+5JWSSp2JpYblwM8j4nlJXYGpkh4GfkB2l/MFqbuAM4Bf1bjLeUPg75K2TMeirwJGAZPIksxwYAJZQno/IraQdCQwBjiihBjNSrLtttuuddise/fuDBkyhN/85jcVisqsepXtvEq6uSx3o9kSSa+Q3VA2guwEKGR3OT8G/Iq8u5yBuZLmADtLmgd0i4hnACTdSHZn9IRU59w0rzuByyUpItwNgZXFAQccQPv27Tn66KMBuO2224gIunfvzg9+8IPKBmdWhZrl5L2kAcD2wLPUuMtZUv5dzpPyquXucv48Ddcsz9V5K81ruaQPgfWBf9ZY/iiyPSE22WSTJntf1vY89dRTPPXUU6teb7vttgwbNoynnnqKm266qYKRmVWnYu/4bzBJXwDuAk6LiI/qmrRAWdRRXledNQt8V7Q1kaVLl/Lss8+uej158mSWLl0K4B4yzQoo669CUkeyBHNzRNydiku9y3l+Gq5Znl9nvqQOQHfWboTQrMlce+21HH/88SxdupSIoFu3blx77bV8/PHHjB49miOO8ClBs3xl25NRdnb0OuCViPh93qiS7nJOh9aWSNo1zfPYGnVy8zoUeMTnY6ycdtppJ2bMmMG0adOYNm0a06dPZ+edd6ZLly4cfvjhlQ7PrOqUc09mGPB9YIakaans1zTsLucfsfoS5gnpAVkS+0u6SOA9sqvTzMpm2bJl3HXXXcybN4/ly5evKj/77LMrGJVZ9Srn1WVPUvicCZR4l3NETAG2KVD+KSlJmTWHESNG0L17d3bccUc6depU6XDMqp7PVJqVYP78+Tz44IOVDsOsxSj71WVmrcnQoUOZMWNGpcMwazG8J2NWgieffJJx48YxcOBAOnXqREQgienTp1c6NLOq5CRjVoIJEybUP5GZreIkY1aCTTfdFIBFixbx6aefVjgas+rnczJmJRg/fjyDBg1i4MCB7LnnngwYMIADDjig0mGZVS0nGbMSnHXWWUyaNIktt9ySuXPnMnHiRIYNG1bpsMyqlpOMWQk6duzI+uuvz8qVK1m5ciV7770306ZNq3RYZlXL52TMStCjRw+WLl3KHnvswTHHHEPfvn3dMKZZHbwnY1aCe++9l86dO3PJJZcwfPhwNt98c+67774Gz0/SlyRNy3t8JOk0SedKejuv/MAmfBtmzcabYGYl6NKly6rhkSNH1jFlcSJiFjAYQFJ74G3gHuA44JKIuKjRCzGrIO/JmBVht912A6Br165069Zt1SP3uonsC7wWEW801QzNKs17MmZFePLJJwFYsmRJORdzJHBr3uufSDoWmAL8PCLeL+fCzcrBezJmRVq5ciXbbLNWY+BNQtI6wEHAf6eiq4DNyQ6lLQQurqXeKElTJE1ZvHhxWWIzawwnGbMitWvXju22244333yzHLM/AHg+It4BiIh3ImJFRKwErgF2LlTJXYtbtfPhMrMSLFy4kK233npVb5g548ePb+ysjyLvUFmui/L08jvAS41dgFklOMmYleCcc85p8nlKWg/YHzgpr/i/JA0GAphXY5xZi+EkY1aCBx54gDFjxqxR9qtf/Yo999yzwfOMiH8B69co+36DZ2hWRXxOxqwEDz/88Fplbv6/5Wu/rv8Ky8V7MmZFuOqqq7jyyit5/fXX+epXv7qqfMmSJW4gsxXo2adHpUNotZxkzIpw9NFHc8ABBzB69GguuOCCVeVdu3alV69eFYzMmoRWVjqCVstJxqwI3bt3p3v37tx66631T2wtzvZ7Da50CK2WD0SaWZun9pWOoPVykjGzNkHtVOu4zbbbtBkjaVucZMysTejeu2ut4/oN6NuMkbQtTjJm1iZEpQNoo5xkzKxN2GDj3rWO67Ox230rFycZM2sTPlu2vNZxny/7vBkjaVucZMysTehWxzmZ9h19N0e5OMmYWZtw0Mlfp3PXzmuUSWKjLfvRb6APl5WLk4yZtQnb7vEVen2xO8q7kjkiGDZiZ7r1qn0vxxrHScbM2oQ//uQ63p79DyLvMrN2Hdpxx4X38tr0NyoXWCvnJGNmbcKmW/VfNXz2nT9n8+0GsHL5Sjp0bE/vjXpULrBWrmxJRtL1khZJeimvrJekhyXNTs8988aNljRH0ixJ38gr31HSjDTuMinb2ZXUSdLtqfxZSQPK9V7MrOV77sFpAKz7hU6cd+jFvPbiPDqt14nln69g/qyFdVe2Bivnnsw4YHiNsjOAiRExCJiYXiNpK+BIYOtU50ppVWtCVwGjgEHpkZvnCcD7EbEFcAmwZk9SZmZ5dvnmDgAs+/izVWXL/rWMdTp3ZAPf8V82ZUsyEfEE8F6N4hHADWn4BuDgvPLbImJZRMwF5gA7S+oHdIuIZyIigBtr1MnN605g39xejplZTceeczhbD/0SEWve+3/2nb+g94burqFcmvuczAYRsRAgPec2HzYC3sqbbn4q2ygN1yxfo05ELAc+pEYXtjmSRkmaImnK4sWLm+itmFlL8tfLJzDz6Vms03mdVWXrdevMJSf+iXcXvl/ByFq3ajnxX2gPJOoor6vO2oURYyNiSEQM6dPH18ObtUVDvrEd/b+0IZ99kn+47DMG77MNvb7Yo3KBtXLNnWTeSYfASM+LUvl8YOO86foDC1J5/wLla9SR1AHoztqH58yqnqR56eKWaZKmpLJaL5KxhrnvqoeYP2sB63bpxLUzL+GQn32LFctX8PjtT7P47XcrHV6r1dxJZjwwMg2PBO7NKz8yXTE2kOwE/+R0SG2JpF3T+ZZja9TJzetQ4JGoebDVrOXYOyIGR8SQ9LrgRTLWcOv368V63Tpz+eQL2PQr/Tn54pEc8rNv0blrZzq6WZmyKdsnK+lWYC+gt6T5wDnABcAdkk4A3gQOA4iImZLuAF4GlgOnRMSKNKsfkV2p1hmYkB4A1wF/kTSHbA/myHK9F7MKGEH2+4HsApfHgF9VKpjW4PBfHsSBJ+7LF3p0WVV28sUj+d5Zh65RZk2rbEkmIo6qZdS+tUx/PnB+gfIpwDYFyj8lJSmzFi6AhyQFcHVEjKXGRTKSCl5jK2kU2SX+bLLJJs0Vb4tVKJk4wZSX9xHNKm9YRCxIieRhSa8WWzElpLEAQ4YM8eFiqzrVcnWZWZsVEQvS8yLgHmBnar9IxqxFcZIxqyBJXSR1zQ0DXwdeovaLZMxaFCcZs8raAHhS0ovAZOB/IuJBsotk9pc0G9g/vbZGWvTm2jdjL57vy5fLyUnGrIIi4vWI2C49tk4XwBAR70bEvhExKD37HrBGGnPsH/neZqcw+cHnV5Wdvt95fH+zHzP3pTcrGFnr5iRjZm3CbofsCgG/+dYFTH7weU7f7zxeeGQGfTbpzUZb9qt0eK2Wk4yZtQnDRuzEOXf/EgLOPPA/eeGRGXxxs75c9/IfWGedjpUOr9VykjGzNmPoQUPos8nqdnR//Ifjfbd/mTnJmFmbMP2Jlzmkz/EseuOfdFpvHSRx9ogLOHXor1n2ybJKh9dqOcmYWZtwzek3seS9pXTs1JGb5l3J0WceAgGvPjuHV5+bU+nwWi3vJ5pZm/Clnbdg1pQ5rFyxgsP6/hCArj278PGST9h0q/711LaG8p6MmbUJ63TqQKwMyOtAd8n7H9OxYwc+WfJpBSNr3ZxkzKxNOOyXIxi47Sas+HzFqjJJfOenB9Jv4AYVjKx1c5IxszbhmtNvYu6MN2nXfvXfXkRwx4Xjeev/FtRR0xrDScbM2oQtd9qMdu3bsXLFyjXKO63Xyd0vl5GTjJm1CX+97IG1EgzAJ0s+4ZVnZ1cgorbBScbM2oR9v7cHaqe1yjuttw4Dtt64AhG1DU4yZtYmDD9uH/ps3Atq5JmDfvwN1u/XszJBtQFOMmbWJjx221N8sHgJ7fIuYe62/hd48PpHeO8fH1QusFbOScbM2oQv7bIFy5ctZ2UEZ9x0KltsP5CP3l1Kzw160HOD7pUOr9VykjGzNuHuS/6HlStXcsZfTmXfo3fniucuYIvtB/LWrAW8Pv2NSofXarlZGTNrE869+5fMmTaXLQYPBKBdu3Zc8dwFzHvpTTb76oDKBteKeU/GzNqET5Z+wtuz/7FG2ccf/ouFry+qUERtg5OMmbUJd158P7874vfcc9kDACx5fym/+vp/8P+O/gPvLny/wtG1Xj5cZlZBkjYGbgS+CKwExkbEpZLOBU4EFqdJfx0RD1QmytbhqF9/h9dnvMGVp/2Zpe9/zDP3T2HejDc55+5f+hLmMnKSMaus5cDPI+J5SV2BqZIeTuMuiYiLKhhbq9KhYwfOvPU0Rh9wPjf+9g4Afnf/aHY5cIcKR9a6OcmYVVBELAQWpuElkl4BNqpsVK3XJ0s/5aN/Lln1esGcf9QxtTUFn5MxqxKSBgDbA8+mop9Imi7pekkFj+dIGiVpiqQpixcvLjSJJblzMG+9+ja/ved0dvvuLlx52p9XnaOx8nCSMasCkr4A3AWcFhEfAVcBmwODyfZ0Li5ULyLGRsSQiBjSp0+f5gq3RRp/xd9WnYMZOmInzrz1NHb77i5cf+YtPvFfRj5cZlZhkjqSJZibI+JugIh4J2/8NcD9FQqv1Thy9MHs8s0d2GL77D6Z3DmaN16e7xP/ZeQ9GbMKkiTgOuCViPh9Xnm/vMm+A7zU3LG1Nu3bt1+VYHI6dOzA5tsNqExAbYT3ZMwqaxjwfWCGpGmp7NfAUZIGAwHMA06qRHBmjeUkY1ZBEfEkazU+D4DPRlur0OIPl0kaLmmWpDmSzqh0PGZmtlqLTjKS2gNXAAcAW5EdYtiqslGZmVlOi04ywM7AnIh4PSI+A24DRlQ4JjMzS1r6OZmNgLfyXs8Hdqk5kaRRwKj0cqmkWbXMrzfwzyaNsOGqJZYGxaExZYikZXwmmzZnIPmmTp36T0m1dYzSEj675lYtsVRLHFCGdbulJ5lCJ0xjrYKIscDYemcmTYmIIU0RWGNVSyzVEgdUTyzVEkdNEVHr3ZjVEnO1xAHVE0u1xAHliaWlHy6bD2yc97o/sKBCsZiZWQ0tPck8BwySNFDSOsCRwPgKx2RmZkmLPlwWEcsl/QT4G9AeuD4iZjZilvUeUmtG1RJLtcQB1RNLtcRRimqJuVrigOqJpVrigDLEooi1TmGYmZk1iZZ+uMzMzKqYk4yZmZVNm0syknpJeljS7PRcW2dQ8yTNkDRN0pRS6zdFHJI2lvSopFckzZT007xx50p6O8U3TdKBDYihziZ5lLksjZ8uaYdi6zZxHMek5U+X9LSk7fLGFfyeyhjLXpI+zPvczy62blMrYV0uGFdd65Ck0Wn6WZK+0QyxXCjp1fQd3yOpRyofIOmTvBj/VMp888aXvC439Lfe0Fia+vfeyM+k6f7/IqJNPYD/As5Iw2cAY2qZbh7Qu6H1myIOoB+wQxruCvwfsFV6fS7wi0Z8Du2B14DNgHWAF3PzzpvmQGAC2f1IuwLPFlu3ieMYCvRMwwfk4qjreypjLHsB9zekbiXW5briqm0dImui6UWgEzAw1W9f5li+DnRIw2Ny9YEBwEuVWJeLeU9NHEuT/d4bE0ddv6uGfCZtbk+GrNmZG9LwDcDBzVy/6PlExMKIeD4NLwGasv/3YprkGQHcGJlJQA9l/Zw0ZXM+9c4rIp6OiFzXhZPI7ocqh8a8r0o0cVTMutiQuEYAt0XEsoiYC8xJ8ylbLBHxUEQsT9OV+h2Xa11uyG+9wbE08e+9MZ9JXUr+TNpiktkgIhZC9icO9K1lugAekjRVWbM0pdZvqjiAgv2/QxF9wNehUJM8NVfo2qYppm5TxpHvBLKtr5zavqdyxvI1SS9KmiBp6xLrNqVi1qH64iq0DjXkvTRFLDnHs+Z3PFDSC5Iel7R7A+fbkHW5Ib/1xsSyShP83hsbR5P9/7Xo+2RqI+nvwBcLjDqzhNkMi4gFkvoCD0t6NSKeqEAchfp/h6wP+P8gWxn+g6wP+ONLmW2BsprXs9c2TVHN+TRhHNmE0t5kSWa3vOJGf08lxvI8sGlELE3Hxf8KDCqybukBNX4dqiuu2tahgnXKHEs2gXQmsBy4ORUtBDaJiHcl7Qj8VdLWeb+DouZbxzRN/b01JpZsZNP83hsbR5P9rlplkomI/WobJ+md3K5p2jVcVMs8FqTnRZLuIdv9fAIoqn5TxaEC/b+neTe2D/himuSpbZp1iqjblHEg6avAtcABEfFurryO76ksseT/uUXEA5KulNS72PdRqiZYh2qNq451qGCdcsaS5jES+Bawb6SD/hGxDFiWhqdKeg3YEsi/yKNc63LRv/UmiqUpf++NiqMp/v9Wqe+kTWt7ABey5omr/yowTRega97w08DwYus3YRwCbgT+UGBcv7zhn5EdQy9l+R2A18lO7OZODG5dY5pvsuaJwcnF1m3iODYhOy8wtNjvqYyxfJHVNzHvDLyZPp8m+0yaeB2qNa7a1iFga9Y88f869Z/4b2wsw4GXgT416vTJLZvsJPbbQK/mWJeLeU9N/Ltqst97I+No0v+/sv0AqvUBrA9MBGan516pfEPggbyV+cX0mAmcWV/9MsWxG9nu63RgWnocmMb9BZiRxo3PXwlLiOFAsitYXsu9R+Bk4OS8lf6KNH4GMKSuuo34TuqL41rg/bzPYEp931MZY/lJWtaLZCeoh9ZVt9Lrcl1x1bUOkR0Cew2YRbb3WO5Y5pCdH8h9x39K5Yfkfd7PA99urnW5tvdUrt8VTfx7b0QcTfr/52ZlzMysbNri1WVmZtZMnGTMzKxsnGTMzKxsnGTMzKxsnGTMzKxsKpZkUquiv0jD50mq60avgyVt1XzRrbHsTpL+nlojPaKZl/10My/vsNQC7KM1ygdIOrqOehtKurMM8fxA0uVNPd8ilju4mFZuC9Q7WdKxBcoHSHqphPmsSOvbhiXU2V3Sy6Usx6w5VMWeTEScHRF/r2OSg8lahq2E7YGOETE4Im7PHyGpfTkWmJtvRAxtqnkV6QTgxxGxd43yAUDBJCOpQ0QsiIhDGxhiNRpMdo/BWiTV2kpGRPwpIm5sguV/kta3olsMiIj/pZaYW4oWtOGZa3b/vBLr3SzpPUmt6bdSr2ZNMpLOVNa/wd+BL+WVj8t98JIuSFtk0yVdJGkocBBwYdq621zSiZKeU9ZI4V2S1subz2XK+hx5Pf/LlHS6sv4RXpR0QSrbXNKDyhqB+19JX64Rb1/gJmBw3rLnSTpb0pPAYZKOSvN9SdKYvLpLJY1J8/67pJ0lPZbiOqjAZ7OXsr4kbiG7MQpJS9Pz7Vqzr49xkg6R1F5ZPxzPpc/rpNrmVWNZa8WsrF+U3YA/SbqwRpULgN3TZ/CztIfx35LuI2tEb9WWehr+X0nPp8fQvJgek3Snsn5DbpakNO7AVPZk+v7WajJDUp/0XT+XHsMKTNM+rTMz0ufxb6l8R2WNK06V9DellmZTPGMkTZb0f8r2BtYBzgOOSO/3iPSnMlbSQ8CNkjaVNDEtY6KkTdL88v8kd0zr2jPAKXkxbp2WNy3VH1TzfRR4XyWtS61BlW94AlwSEWfXP9lqEXEM2Y2UbUu570rOu1N0R7I/vPWAbmR3+P4ijRsHHAr0IrvDOHeTaI/88fl3neYN/w74t7zp/psseW5F1tQ1ZH2QPA2sl17n7kaeCAxKw7sAjxSIey/y+g8h62fh9Ly7md8ka/qiA/AIcHAaF6Q7pYF7gIeAjsB2wLRalvMxMDCvbGl6/g5wQxpeh+zO6M7AKOA3qbwTWXtOAwvNK2+edcX8GHl3QtfxGfyArN2j3Oc4gNTnR/p+103Dg1h9d/5ewIdk7SO1A54hS2rrpvczME13a25ZaTmXp+FbgN3S8CbAKwXi/BFZu0+5fkl6pc/8aVJzJcARwPV57/fivLuj/15zuen1ucBUoHN6fR8wMg0fD/w1b7rcOj0d2DMNX5j3+fwROCbvu+xc4H0srfG6qHWJIvpeqbYHWcsCs4C/p+9+jf+ENHwBWZMz04GLyPoXeg+YS3ZX/ObAicBzZHep38Xq3/o44LK0DrzOmv8jp5P9J70IXJDKNgceTN/3/wJfLhDzqu857/UN6XuZB3yXrN+VGWleHfOmHZcfQ1t4NGcDmbsD90TEvwAkFcroHwGfAtdK+h9qbwRuG0m/A3oAXwD+ljfurxGxEnhZ0gapbD/gz7llR8R7ylo6HQr8d9qghuyPuhi5w2Y7AY9FxOL0nm4G9iBrmfczshUMspVtWUR8LmkG2Z9BIZMj67+jpgnAZZI6kbXx9EREfCLp68BXtXqPrTvZH/tndcyrrphL8XBEvFegvCNwuaTBwAqyxgzz39/8tNxpZJ/DUuD1vFhvJUueNe0HbJX3XXWT1DWyfjfyp/lTpH5J0ve8DbANWUuykHXmtDCvTq4RwqnU/r0AjI+IT9Lw18j+SCBr7uO/8ieU1J1sA+nxvGkOSMPPAGdK6g/cHRGz61hmTkPWpaqnrFXlI8kOSXcgazZmao1pepFtZH05IkJSj4j4IP1/3B8Rd6bpPoiIa9Lw78gO/f4xzaYf2QbNl8n2JO6UdADZ3tAuEfGvtByAsWTNrsyWtAtwJbBPEW9nc2Bvso3bZ4BDIuJ0ZY1LfpPSf1+tRnO3wlxnGzYRsVzSzsC+ZCvfTyj8BY8j2/p+UdIPyLaSc5blDSvvueay2wEfRMTgImPP93GN+RfyeaRNF2Alq1uSXanaj+t/XKgwIj6V9BjwDbIt8Vvzlv9vEZGfZJG0V23zqifmUtQ2/58B75BtZbcj22jIyf9uVpCtf8XG0w74Wt4ffSGFvmcBMyPia7XUycWUi6c2tb1fallmwXU9Im6R9CzZH8/fJP0wIh6pY97QsHWpJWhNG54T8hJ/e9bcKBhQ5DxapeY8J/ME8B1JnSV1Bb5dc4L0JXePiAeA08hOwAIsIeuONKcrsFBZs9jHFLHsh4DjtfrcTa/ImmyfK+mwVCbl9R1fpGeBPSX1VnaC/Sjg8XrqNNRtwHFkP8zcD+hvwI/S54CkLSV1KUPMNT//unQHFqYf9ffJfnB1eRXYTFknTZAl0UIeItvoALIrwGqZ5uTcH2/aOp0F9JH0tVTWUas7GqtNfe/3abKNIMjWvyfzR0bEB8CHknbLmyYX92Zke26XkW1Vf7WeWFq7ejc8yVq7votsz+PBWiYdB/wkIrYFfkt2GDan5A3PvMdXinkT5CV+1t4oaMkbAo3WbEkmsm5Fbyc7hnoX2fHOmroC90uaTvbH97NUfhvwS2W9420OnEX2Z/kw2Z9Ufct+kOwHPSUdpvlFGnUMcIKkXGujI0p8TwuB0cCjpFZiI+LeUuZRgofIDmv9PbLuVCFrnfhl4HllJ96vpp4VuoExTweWpxPZP6tn2iuBkZImkR0qq2sPgLRn8mPgQWUXU7xDdu6mplOBIelk+ctkrcnWdC3Z+abp6Ts9On1WhwJjUtk0sq3VujxKdmiutsvWTwWOS+vp94GfFpjmOOCKdOI/f+/rCOCltB5+maxp97aqNW54Wg1uhdkqTtIXIutpMtf0+OyIuKTScVWKpKUR8YUG1BtAdp5im6aPqjyU9YR5LPAG2cUkL0fERZLGkR0aewq4l2zPRMBFEXGDsqsLryHbgzgU+DrZifw3yA5RdY2IH+Tmk3fuZtVnK+mMtOzPyLoj+LWkgWS9UPYjO794W0SscamypHPJLs64qJbX+cuoOW6NeNoCJxmruLR3NJLsaqsXgBNzx8rbIkkLyHocPDCKvFdG0u5ke5HvRsReZQyvzauZOEqsOw4nGTMzq42ye6FGke3lFH2vTLqScyjZxTqldpfeYjnJmJlZ2VRFszJmZtY6OcmYmVnZOMmYmVnZOMmYmVnZ/H/2i7c/dqonZwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAtCUlEQVR4nO3deZwU5Z3H8c+XQwTlPow3SDBZT4x4gfeRoEmEGA/UJHhETNZsYhI3SrIeceNrMZoYjRuVYBaN96pENGpUvFY8EBRRVIIHGpSXEE8wSoT57R/1NDZDz0z30DU9w3zfr1e/pvqpeqp+3V09v66nqp5HEYGZmVkeOtQ6ADMzW3c5yZiZWW6cZMzMLDdOMmZmlhsnGTMzy02nWgfQ0vr16xcDBw6sdRi2jpo1a9bfI6J/Lbbtfdvy1Nx9u90lmYEDBzJz5sxah2HrKEmv1Wrb3rctT83dt91cZmZmuXGSMTOz3DjJmJlZbpxkzMwsN04yZtZuXPrjK1d7vnLlyjXKrLqcZMxyJmlzSQ9IekHSXEk/SOV9JN0raX7627uoznhJL0maJ+lLtYt+3XFQhyO47aK7OajDEUCWYEZ2HsNtF93NqL7fqnF06652dwmzWQ2sAH4cEU9J6g7MknQvcBwwLSImSDoDOAM4XdI2wBhgW2AT4D5JW0fEyhrFv84pJJqCf7z7UY0iWff5SMYsZxGxKCKeStNLgReATYFRwFVpsauA0Wl6FHBDRCyPiFeBl4BdWzRosypxkjFrQZIGAjsBTwAbRcQiyBIRMCAttinwt6JqC1NZqfWNkzRT0swlS5bkFrdZc7m5zBo18Iw/N6vegglfrnIkbZ+kDYFbgFMj4gNJDS5aoqzk6IIRMRGYCDBs2DCPQGitjo9kzFqApM5kCebaiLg1Fb8laeM0f2NgcSpfCGxeVH0z4M2WitWsmpxkzHKm7JDlSuCFiPh10aypwNg0PRa4rah8jKQukgYBQ4AZLRWvWTW5ucwsfyOAbwLPSpqdyn4KTABuknQi8DpwBEBEzJV0E/A82ZVpp/jKMmurnGTMchYRj1D6PAvAAQ3UOQ84L7egzFqIm8vMzCw3TjJmZpYbJxkzM8uNk4yZmeXGScbMzHKTe5KR1FHS05LuSM8r7nlW0s6Snk3zLkn3HZDuI7gxlT+RuuwwM7NWoiWOZH5A1iFgwRlkPc8OAaal59TreXYk8DtJHVOdy4BxZDelDUnzAU4E3o2IzwIXAefn+1LMzKwSuSYZSZsBXwYmFRVX1PNs6m6jR0Q8FhEBXF2vTmFdNwMHFI5yzMys9vI+kvkN8BOgrqis0p5nN03T9ctXqxMRK4D3gb5VfQVmZtZsuSUZSV8BFkfErHKrlCiLRsobq1M/FneHbmZWA3keyYwADpW0ALgB2F/SNVTe8+zCNF2/fLU6kjoBPYF36gcSERMjYlhEDOvfv391Xp2ZmTUptyQTEeMjYrOIGEh2Qv/+iPgGFfY8m5rUlkraPZ1v+Va9OoV1HZ624TE1zMxaiVp0kNmcnme/C0wGugJ3pQdk3af/UdJLZEcwY1rqRZiZWdNaJMlExIPAg2n6bSrseTYiZgLblSj/mJSkzMys9fEd/2ZmlhsnGTMzy42TjJmZ5cZJxszMcuMkY2ZmuXGSMTOz3DjJmJlZbpxkzFqApD9IWizpuaKyGyXNTo8Fkman8oGSPiqad3nNAjdbS7W449+sPZoMXEo2VAUAEXFUYVrSr8h6ES94OSKGtlRwZnlxkjFrARHxcEMjt6Y++Y4E9m/RoMxagJvLzGpvL+CtiJhfVDYoDVv+kKS9GqroYSystXOSMau9o4Hri54vAraIiJ2AHwHXSepRqqKHsbDWzknGrIbSOEiHATcWytIQ5G+n6VnAy8DWtYnQbO04yZjV1oHAixGxaohxSf0ldUzTW5GNrfRKjeIzWytOMmYtQNL1wGPA5yQtTOMpQTYG0vX1Ft8bmCPpGeBm4DsRscaIr2Ztga8uM2sBEXF0A+XHlSi7Bbgl75jMWoKPZMzMLDdOMmZmlhsnGTMzy42TjJmZ5cZJxszMcuMkY2ZmuXGSMTOz3DjJmJlZbpxkzMwsN04yZmaWGycZMzPLjZOMmZnlxknGzMxy4yRjZma5cZIxM7PcOMmYmVluPGiZWRkOPfTQJpfp06dPC0Ri1rY4yZiV4YUXXmDSpEkNzo8ITjnllBaMyKxtcJIxK8N5553HPvvs0+gyZ599NkcddVQLRWTWNvicjFkZjjzyyKosY9beOMmYlWHlypVcccUVnHnmmUyfPn21eb/4xS9qFJVZ6+ckY1aGk08+mYceeoi+ffvy/e9/nx/96Eer5t16661N1pf0B0mLJT1XVHaOpDckzU6PQ4rmjZf0kqR5kr5U7ddj1lKcZMzKMGPGDK677jpOPfVUnnjiCZYtW8Zhhx3G8uXLiYhyVjEZGFmi/KKIGJoedwJI2gYYA2yb6vxOUscqvRSzFuUkY1aGf/7zn6umO3XqxMSJExk6dCj7778/y5Yta7J+RDwMvFPm5kYBN0TE8oh4FXgJ2LUZYZvVXG5JRtL6kmZIekbSXEk/T+V9JN0raX7627uoTskmAkk7S3o2zbtEklJ5F0k3pvInJA3M6/VY+zZs2DDuvvvu1crOOussjj/+eBYsWLA2q/6epDmpOa3wXdgU+FvRMgtT2RokjZM0U9LMJUuWrE0cZrnI80hmObB/ROwIDAVGStodOAOYFhFDgGnpeVNNBJcB44Ah6VFodjgReDciPgtcBJyf4+uxduyaa65h5Mg1W7u+/e1v88knnzR3tZcBg8m+H4uAX6VylVi2ZJtcREyMiGERMax///7NjcMsN7klmcgU2hE6p0eQNQVclcqvAkan6ZJNBJI2BnpExGORNX5fXa9OYV03AwcUjnLM8rBy5cqqrSsi3oqIlRFRB/yeT5vEFgKbFy26GfBm1TZs1oJyPScjqaOk2cBi4N6IeALYKCIWAaS/A9LiDTURbJqm65evViciVgDvA31LxOEmBVtrS5cuZdSoUVVbX/oBVfA1oHDl2VRgTGoOHkR29D6jahs2a0G5Jpn0K20o2S+xXSVt18jiDTURNNZ0UFazgpsUbG0tWrSIAw88kHHjxjWrvqTrgceAz0laKOlE4JfpXOMcYD/ghwARMRe4CXgeuBs4JSKqdwhl1oJapFuZiHhP0oNk51LekrRxRCxKv+QWp8UaaiJYmKbrlxfXWSipE9CT8q/gMSvbXnvtxQUXXFBWR5mlRMTRJYqvbGT584DzmrUxs1Ykz6vL+kvqlaa7AgcCL5I1BYxNi40FbkvTJZsIUpPaUkm7p/Mt36pXp7Cuw4H7o8ybFswq0bt3b954441ah2HW5uR5JLMxcFW6QqwDcFNE3CHpMeCm1FzwOnAEZE0EkgpNBCtYvYngu2Q3s3UF7koPyH4J/lHSS2RHMGNyfD3Wjj344IMceeSRSHJvy2YVyC3JRMQcYKcS5W8DBzRQp2QTQUTMBNY4nxMRH5OSlFmeNthgA6ZOncrJJ59c61DM2hTf8W9Wpo4dOzY6poyZrcnjyZg1wwcffMCKFStWPfeomGalOcmYVeCKK67grLPOomvXrhTu+5XEK6+8UuPIzFonJxmzClx44YXMnTuXfv361ToUszbB52TMKjB48GC6detW6zDM2gwfyZhV4L/+678YPnw4u+22G126dFlVfskll9QwKrPWy0nGrAInn3wy+++/P9tvvz0dOrghwKwpTjJmFejUqRO//vWvax2GWZvhn2JmFdhvv/2YOHEiixYt4p133ln1MLPSfCRjVoHrrrsOyM7NFPgSZrOGOcmYVeDVV1+tdQhmbUqjzWWSPmjisVTSX1sqWLNaeeqpp6qyjFl709SRzMsRsUYnl8UkPV3FeMxapeOPP54HH3yQxkaSOPHEE1swIrO2oakk8/Uy1lHOMmZt2vvvv8/OO+/caJLxqKtma2o0yUTEGmczJX0lIu5obBmzdc2CBQvKWq7Qn5mZZZpzCfO5VY/CzMzWSc1JMv6pZmZmZWlOkvHQgGYVkvQHSYslPVdUdoGkFyXNkTRFUq9UPlDSR5Jmp8flNQvcbC01ek5G0hciYrXrMiNiRlPLmK3L3n33XebPn8/HH3+8qmzvvfduqtpk4FLg6qKye4HxEbFC0vnAeOD0NO/liBharZjNaqWpq8v+R9K+NN5EdiXQ6GXOZuuKSZMmcfHFF7Nw4UKGDh3K448/zh577MH999/faL2IeFjSwHpl9xQ9fRw4vPoRm9VWU81lPYFZTTw+yTNAs9bk4osv5sknn2TLLbfkgQce4Omnn67WpcsnAHcVPR8k6WlJD0naq6FKksZJmilp5pIlS6oRh1lVNXUJ88AWisOsTVh//fVZf/31AVi+fDmf//znmTdv3lqtU9LPgBXAtaloEbBFRLwtaWfgT5K2jYgP6teNiInARIBhw4Y1fBOPWY247zKzCmy22Wa89957jB49moMOOojevXuzySabNHt9ksYCXwEOiHSnZ0QsB5an6VmSXga2Bmau/Sswa1lOMmYVmDJlCgDnnHMO++23H++//z4jR45s1rokjSQ70b9PRPyjqLw/8E5ErJS0FTAE8E3P1iY5yZhV6JFHHmH+/Pkcf/zxLFmyhDfeeINBgwY1WkfS9cC+QD9JC4Gzya4m6wLcm3oKeDwivgPsDZwraQWwEvhORHjQGmuTykoykqZFxAFNlZmt637+858zc+ZM5s2bx/HHH88nn3zCN77xDaZPn95ovYg4ukTxlQ0sewtwSxXCNau5pu6TWR/oRvbrqzefXsrcA2h+Q7RZGzVlyhSefvppvvCFLwCwySabsHTp0hpHZdZ6NXUkczJwKllCmcWnSeYD4L/zC8usdVpvvfWQtKojzA8//LDGEZm1bo3eJxMRF0fEIOC0iNgqIgalx44RcWkLxWjWahx55JGcfPLJvPfee/z+97/nwAMP5KSTTqp1WGatVlnnZCLit5KGAwOL60TE1Q1WMlvHRARHHXUUL774Ij169GDevHmce+65HHTQQbUOzazVKvfE/x+BwcBssqtdAILV+2EyW6dJYvTo0cyaNcuJxaxM5V7CPAzYpnCzmFl7tfvuu/Pkk0+yyy671DoUszah3CTzHPAZsu4uzNqtBx54gCuuuIItt9ySDTbYgIhAEnPmzKl1aGatUrlJph/wvKQZpO4uACLi0FyiMmul7rrrrqYXMrNVyk0y5+QZhFlbseWWWwKwePHi1caTMbPSyr267KG8AzFrC6ZOncqPf/xj3nzzTQYMGMBrr73Gv/zLvzB37txah2bWKpU1/LKkpZI+SI+PJa2UtEa342brujPPPJPHH3+crbfemldffZVp06YxYsSIWodl1mqVlWQiontE9EiP9YGvkw0la9audO7cmb59+1JXV0ddXR377bcfs2fPrnVYZq1Ws3phjog/STqj2sGYtXa9evVi2bJl7L333hx77LEMGDCATp3cmblZQ8ptLjus6HG4pAlkN2M2VmdzSQ9IekHSXEk/SOV9JN0raX7627uoznhJL0maJ+lLReU7S3o2zbtEqeMoSV0k3ZjKn6g/hrpZtd12221069aNiy66iJEjRzJ48GBuv/32Wodl1mqV+xPsq0XTK4AFwKgm6qwAfhwRT0nqDsySdC9wHDAtIiako6EzgNMlbQOMAbYl65DzPklbR8RK4DJgHPA4cCcwkmw89BOBdyPis5LGAOcDR5X5mswqtsEGGwDQoUMHxo4dW+NozFq/cq8uO77SFUfEItLNmxGxVNILwKZkyWnftNhVwINkowOOAm5IQ8++KuklYFdJC4AeEfEYgKSrgdFkSWYUn15efTNwqSS5ZwIzs9ah3OayzSRNkbRY0luSbpG0WbkbSc1YOwFPABulBFRIRAPSYpsCfyuqtjCVbZqm65evViciVgDvA31LbH+cpJmSZi5ZsqTcsM3MbC2VlWSA/wGmkjVjbQrcnsqaJGlDslH+To2Ixi57VomyaKS8sTqrF0RMjIhhETGsf//+TYVs1qiPPvqIefPm1ToMszah3CTTPyL+JyJWpMdkoMn/1pI6kyWYayPi1lT8lqSN0/yNgcWpfCGweVH1zYA3U/lmJcpXqyOpE9AT8Fjolpvbb7+doUOHMnLkSABmz57NoYe6dyWzhpSbZP4u6RuSOqbHN4C3G6uQrgC7EnghIn5dNGsqUDhjOha4rah8TLpibBAwBJiRmtSWSto9rfNb9eoU1nU4cL/Px1iezjnnHGbMmEGvXr0AGDp0KAsWLKhpTGatWblXl51AdvPlRWTNUY+mssaMAL4JPCtpdir7KTABuEnSicDrwBEAETFX0k3A82RXpp2SriwD+C4wGehKdsK/0EvhlcAf00UC75BdnWaWm06dOtGzZ89ah2HWZpR7ddnrQEVtAhHxCKXPmQAc0ECd84DzSpTPBLYrUf4xKUmZtYTtttuO6667jpUrVzJ//nwuueQShg8f3mQ9SX8AvgIsjojtUlkf4EayEWcXAEdGxLtp3niyS/RXAt+PiL/k8XrM8lbu1WVXSepV9Lx3+tKYtSu//e1vmTt3Ll26dOHoo4+mR48e/OY3vymn6mSy+7uKnUF2z9gQYFp6Tr17xkYCv5PUsUovwaxFldtctkNEvFd4EhHvStopn5DMWq9u3bpx3nnncd55axxwNyoiHi7RI0VF94wBjzU/crPaKDfJdJDUu+hQvk8Fdc3avK9+9auk3oxKmjp1anNWu9o9Y5KK7xl7vGi54nvDViNpHFlvGGyxxRbNicEsV+Umil8Bj0q6mezE/5GUOHditq467bTTWnJzZd3/Bdk9YMBEgGHDhvnKSmt1yj3xf7WkmcD+ZF+AwyLi+VwjM2tF9tlnnzxW+5akjdNRTDn3jJm1OWU3eaWk4sRi7dr222+/RrNZz549GTZsGP/xH/9R6eoK93lNYM17xq6T9GuyXjaGADPWJm6zWvF5FbMKHHzwwXTs2JFjjjkGgBtuuIGIoGfPnhx33HEN1pN0PdlJ/n6SFgJn07x7xszaFCcZswpMnz6d6dOnr3q+/fbbM2LECKZPn84111zTYL2IOLqBWRXdM2bW1pTbrYyZAcuWLeOJJ55Y9XzGjBksW7YMwCNkmpXgb4VZBSZNmsQJJ5zAsmXLiAh69OjBpEmT+PDDDxk/fjxHHeUx88yKOcmYVWCXXXbh2Wef5f333yciVnWUCXDkkUc6yZjV4yRjVoHly5dzyy23sGDBAlasWLGq/KyzzqphVGatl5OMWQVGjRpFz5492XnnnenSpUutwzFr9ZxkzCqwcOFC7r777lqHYdZm+OoyswoMHz6cZ599ttZhmLUZPpIxq8AjjzzC5MmTGTRoEF26dCEikMScOXNqHZpZq+QkY1aBu+66q+mFzGwVJxmzCmy55ZYALF68mI8//rjG0Zi1fj4nY1aBqVOnMmTIEAYNGsQ+++zDwIEDOfjgg2sdllmr5SRjVoEzzzyTxx9/nK233ppXX32VadOmMWLEiFqHZdZqOcmYVaBz58707duXuro66urq2G+//Zg9e3atwzJrtXxOxqwCvXr1YtmyZey9994ce+yxDBgwwB1jmjXCRzJmFbjtttvo2rUrF110ESNHjmTw4MHcfvvttQ7LrNXyTzCzCmywwQarpseOHVvDSMzaBh/JmJVhzz33BKB79+706NFj1aPw3MxK85GMWRkeeeQRAJYuXVrjSMzaFh/JmJWprq6O7bbbrtZhmLUpTjJmZerQoQM77rgjr7/+eq1DMWsz3FxmVoFFixax7bbbsuuuu652EcDUqVNrGJVZ6+UkY1aBs88+u6rrk/Q54Maioq2As4BewEnAklT+04i4s6obN2sBTjJmFbjzzjs5//zzVys7/fTT2WeffZq1voiYBwwFkNQReAOYAhwPXBQRF65NvGa15nMyZhW499571yirYvf/BwAvR8Rr1VqhWa05yZiV4bLLLmP77bdn3rx57LDDDqsegwYNYocddqjWZsYA1xc9/56kOZL+IKl3qQqSxkmaKWnmkiVLSi1iVlNuLjMrwzHHHMPBBx/M+PHjmTBhwqry7t2706dPn7Vev6T1gEOB8anoMuA/gUh/fwWcUL9eREwEJgIMGzYs1joQsypzkjErQ8+ePenZsyfXX3990ws3z8HAUxHxFkDhL4Ck3wN35LVhszy5ucysdTiaoqYySRsXzfsa8FyLR2RWBT6SMasxSd2Ag4CTi4p/KWkoWXPZgnrzzNoMJxmzGouIfwB965V9s0bhmFWVm8vMrN3r3n/DWoewzsotyaTLLhdLeq6orI+keyXNT397F80bL+klSfMkfamofGdJz6Z5l0hSKu8i6cZU/oSkgXm9FjNbt/Xs6+Ea8pLnkcxkYGS9sjOAaRExBJiWniNpG7J7BLZNdX6X7n6G7FLOccCQ9Cis80Tg3Yj4LHARsPpt2GZmZereZ4OmF7JmyS3JRMTDwDv1ikcBV6Xpq4DRReU3RMTyiHgVeAnYNV1h0yMiHouIAK6uV6ewrpuBAwpHOWZmlejavWutQ1hntfQ5mY0iYhFA+jsglW8K/K1ouYWpbNM0Xb98tToRsQJ4n3onTwt8V7SZdezUscF5e3xlWAtG0r60lhP/pY5AopHyxuqsWRgxMSKGRcSw/v37NzNEM2vLumy4XoPzunVfvwUjaV9aOsm8VbjJLP1dnMoXApsXLbcZ8GYq36xE+Wp1JHUCerJm85yZGQA9endvcF7/zfq1YCTtS0snmanA2DQ9FritqHxMumJsENkJ/hmpSW2ppN3T+ZZv1atTWNfhwP3pvI2Z2RrGjB9Nx84dUYfVG0F69O3O53b9bI2iWvfleQnz9cBjwOckLZR0IjABOEjSfLI7nCcARMRc4CbgeeBu4JSIWJlW9V1gEtnFAC8DhX7VrwT6SnoJ+BHpSjUzs1K+/O2D+Nq/HULUffpbtFPnTlz29C/ptqFP/Ocltzv+I+LoBmYd0MDy5wHnlSifCWxXovxj4Ii1idHM2o9rz7uFm399O+qgVYlmxScrOGnbH3HlC7+h3yZr35u2ram1nPg3M8tVRB0dO3ck6oJ9x4xg4602onOXTtTV1ZW8isiqw0nGzNqFTp06sfKTlRx52qH89NofcOED59Bv077Zpc2+xS437iDTzNqFL52wP527dOawU7+MJAZs3o8LHziHx6bOpO/GJQcetSpwkjGzdqH3gJ58/YdfWa1swOb9GHVK/d6vrJrcXGZm7cbbi95d7XlErFFm1eUkY2btwq2/+TMnbfdD5j/1CpAlmMt/dBXf/cK/O9HkyEnGzNqF4aN3oVuPbpx+0Ln8ddbLXP6jq7j14j+z71Ej6POZXrUOb53lJGNm7cJnBg7gwgfOoVuPbpyyyxncevGf+dr3D+G7Fx2HO3DPj5OMmbUbG23Zn8/uNHDV8wO/ubcTTM6cZMysXSicg5n+pycZPmoXNtqyP2d88T9XnaOxfDjJmNWYpAVpiPHZkmamsgaHKrfmufGXt61qIjvn1n9f1XR2+kHn+sR/jnyfjFnrsF9E/L3oeWGo8gmSzkjPT69NaOuGg761DwBH/WQUklado5k+ZYZvxsyRj2TMWqeGhiq3Zuq7cW/GnD56tXMwnxk4YI0bNK26nGTMai+AeyTNkjQulTU0VLlZm+LmMrPaGxERb0oaANwr6cVyK6akNA5giy22yCs+s2bzkYxZjUXEm+nvYmAKsCsND1Vev+7EiBgWEcP69+/fUiGblc1JxqyGJG0gqXthGvgi8BwND1Vu1qa4ucystjYCpqST0Z2A6yLibklPAjelYctfx6PAWhvlJGNWQxHxCrBjifK3aWCocrO2xM1lZmaWGycZMzPLjZOMmZnlxknGzMxy4yRjZma5cZIxM7PcOMmYmVlunGTMzCw3TjJm1i7U1dXx13qjYJYqs+pykjGzduHnX7+QU3Y5nfuueQjIEsy/Djud7+1yBi/NfrXG0a273K2MmbULo075Eo/fPpPzx15KXR3c+ps7eHn2Aj4zaABb7bBlrcNbZznJmFm7MHf6X6mrC9RBXHDcpQB06boeb7/5Du++9b6HYM6Jm8vMrF04+qdfY8ToXYi6WFW24p8rOPuWf3eCyZGTjJm1Cx06dmDRK6uP/bZyZR1L31lao4jaBycZM2sXfvaV/+KVOa+x3vqdV5Wpgzh/7KU+8Z8jJxkzaxeOGf81uvXoSt3KOn4+5SfsedhuRF0waLst+OzQQbUOb53lJGNm7cKch17gk48/4ZwpP2H4qF342fWnsudhu7Holbd4e9G7tQ5vneWry8ysXRgzfjS7ffkLfHan7KilU+dO/Oz6U3nt+YU+8Z8jH8mYWbvQsWPHVQmmoFPnTgzecWBtAmonnGTMzCw3TjJmZpabNp9kJI2UNE/SS5LOqHU8Zmb2qTadZCR1BP4bOBjYBjha0ja1jcrMzAradJIBdgVeiohXIuKfwA3AqBrHZGZmSVu/hHlT4G9FzxcCu9VfSNI4YFx6ukzSvAbW1w/4e1UjbL7WEkuz4tD5OUTSNt6TmnXnO2vWrL9Leq2B2W3hvWtprSWW1hIH5LBvt/UkoxJlsUZBxERgYpMrk2ZGxLBqBLa2WkssrSUOaD2xtJY46ouI/g3Nay0xt5Y4oPXE0lrigHxiaevNZQuBzYuebwa8WaNYzMysnraeZJ4EhkgaJGk9YAwwtcYxmZlZ0qabyyJihaTvAX8BOgJ/iIi5a7HKJpvUWlBriaW1xAGtJ5bWEkclWkvMrSUOaD2xtJY4IIdYFLHGKQwzM7OqaOvNZWZm1oo5yZiZWW7aXZKR1EfSvZLmp78l+/iWtEDSs5JmS5pZaf1qxCFpc0kPSHpB0lxJPyiad46kN1J8syUd0owYGu2SR5lL0vw5kr5Qbt0qx3Fs2v4cSY9K2rFoXsnPKcdY9pX0ftH7fla5dautgn25ZFyN7UOSxqfl50n6UgvEcoGkF9NnPEVSr1Q+UNJHRTFeXsl6i+ZXvC8397ve3Fiq/X1fy/ekev//IqJdPYBfAmek6TOA8xtYbgHQr7n1qxEHsDHwhTTdHfgrsE16fg5w2lq8Dx2Bl4GtgPWAZwrrLlrmEOAusvuRdgeeKLduleMYDvRO0wcX4mjsc8oxln2BO5pTtxb7cmNxNbQPkXXR9AzQBRiU6nfMOZYvAp3S9PmF+sBA4Lla7MvlvKYqx1K17/vaxNHY96o570m7O5Ih63bmqjR9FTC6heuXvZ6IWBQRT6XppcALZL0cVEM5XfKMAq6OzONAL0kbl1m3anFExKMRURi68HGy+6HysDavqxZdHJWzLzYnrlHADRGxPCJeBV5K68ktloi4JyJWpOUq/Yzz2peb811vdixV/r6vzXvSmIrfk/aYZDaKiEWQ/RMHBjSwXAD3SJqlrFuaSutXKw4gazYAdgKeKCr+XjrM/UO5h/JFSnXJU3+HbmiZcupWM45iJ5L9+ipo6HPKM5Y9JD0j6S5J21ZYt5rK2YeaiqvUPtSc11KNWApOYPXPeJCkpyU9JGmvZq63Oftyc77raxPLKlX4vq9tHFX7/9em75NpiKT7gM+UmPWzClYzIiLelDQAuFfSixHxcA3iQNKGwC3AqRHxQSq+DPhPsp3hP4FfkX05y15tibL617M3tExZ3flUMY5sQWk/siSzZ1HxWn9OFcbyFLBlRCxL7eJ/AoaUWbfygNZ+H2osrob2oZJ1co4lW0D6GbACuDYVLQK2iIi3Je0M/EnStkXfg7LW28gy1f7c1iaWbGZ1vu9rG0fVvlfrZJKJiAMbmifprcKhaTo0XNzAOt5MfxdLmkJ2+PkwUFb9asUhqTPZDndtRNxatO63ipb5PXBHQ9tqQDld8jS0zHpl1K1mHEjaAZgEHBwRbxfKG/mccoml+J9bRNwp6XeS+pX7OipVhX2owbga2YdK1skzlrSOscBXgAMiNfpHxHJgeZqeJellYGug+CKPvPblsr/rVYqlmt/3tYqjGv//VmnqpM269gAuYPUTV78sscwGQPei6UeBkeXWr2IcAq4GflNi3sZF0z8ka0OvZPudgFfITuwWTgxuW2+ZL7P6icEZ5datchxbkJ0XGF7u55RjLJ/h05uYdwVeT+9P1d6TKu9DDcbV0D4EbMvqJ/5foekT/2sby0jgeaB/vTr9C9smO4n9BtCnJfblcl5Tlb9XVfu+r2UcVf3/l9sXoLU+gL7ANGB++tsnlW8C3Fm0Mz+THnOBnzVVP6c49iQ7fJ0DzE6PQ9K8PwLPpnlTi3fCCmI4hOwKlpcLrxH4DvCdop3+v9P8Z4FhjdVdi8+kqTgmAe8WvQczm/qccozle2lbz5CdoB7eWN1a78uNxdXYPkTWBPYyMI/s6DHvWF4iOz9Q+IwvT+VfL3q/nwK+2lL7ckOvKa/vFVX+vq9FHFX9/+duZczMLDft8eoyMzNrIU4yZmaWGycZMzPLjZOMmZnlxknGzMxyU7Mkk3oVPS1NnyupsRu9RkvapuWiW23bXSTdl3ojPaqFt/1oC2/viNQD7AP1ygdKOqaReptIujmHeI6TdGm111vGdoeW08ttiXrfkfStEuUDJT1XwXpWpv1tkwrq7CXp+Uq2Y9YSWsWRTEScFRH3NbLIaLKeYWthJ6BzRAyNiBuLZ0jqmMcGC+uNiOHVWleZTgT+NSL2q1c+ECiZZCR1iog3I+LwZobYGg0lu8dgDZIa7CUjIi6PiKursP2P0v5Wdo8BEfF/NBBzW9GGfngWut0/t8J610p6R9K69F1pUosmGUk/Uza+wX3A54rKJxfeeEkT0i+yOZIulDQcOBS4IP26GyzpJElPKuuk8BZJ3YrWc4myMUdeKf4wJf1E2fgIz0iakMoGS7pbWSdw/yfp8/XiHQBcAwwt2vYCSWdJegQ4QtLRab3PSTq/qO4ySeendd8naVdJD6a4Di3x3uyrbCyJ68hujELSsvT3Rq0+1sdkSV+X1FHZOBxPpvfr5IbWVW9ba8SsbFyUPYHLJV1Qr8oEYK/0HvwwHWH8r6TbyTrRW/VLPU3/n6Sn0mN4UUwPSrpZ2bgh10pSmndIKnskfX5rdJkhqX/6rJ9MjxEllumY9pln0/vxb6l8Z2WdK86S9BelnmZTPOdLmiHpr8qOBtYDzgWOSq/3qPRPZaKke4CrJW0paVraxjRJW6T1Ff+T3Dnta48BpxTFuG3a3uxUf0j911HidVW0L60LWvkPT4CLIuKsphf7VEQcS3YjZfuS913JRXeK7kz2D68b0IPsDt/T0rzJwOFAH7I7jAs3ifYqnl9812nR9C+Afyta7n/Jkuc2ZF1dQzYGyaNAt/S8cDfyNGBImt4NuL9E3PtSNH4I2TgLPym6m/l1sq4vOgH3A6PTvCDdKQ1MAe4BOgM7ArMb2M6HwKCismXp79eAq9L0emR3RncFxgH/kcq7kPXnNKjUuorW2VjMD1J0J3Qj78FxZP0eFd7HgaQxP9Lnu36aHsKnd+fvC7xP1j9SB+AxsqS2fno9g9Jy1xe2lbZzaZq+DtgzTW8BvFAizu+S9ftUGJekT3rPHyV1VwIcBfyh6PX+quju6Pvqbzc9PweYBXRNz28HxqbpE4A/FS1X2KfnAPuk6QuK3p/fAscWfZZdS7yOZfWel7UvUcbYK63tQdazwDzgvvTZr/Y/IU1PIOtyZg5wIdn4Qu8Ar5LdFT8YOAl4kuwu9Vv49Ls+Gbgk7QOvsPr/kZ+Q/U96BpiQygYDd6fP+/+Az5eIedXnXPT8qvS5LAAOIxt35dm0rs5Fy04ujqE9PFqyg8y9gCkR8Q8ASaUy+gfAx8AkSX+m4U7gtpP0C6AXsCHwl6J5f4qIOuB5SRulsgOB/ylsOyLeUdbT6XDgf9MPasj+UZej0Gy2C/BgRCxJr+laYG+ynnn/SbaDQbazLY+ITyQ9S/bPoJQZkY3fUd9dwCWSupD18fRwRHwk6YvADvr0iK0n2T/2fzayrsZirsS9EfFOifLOwKWShgIryTozLH59C9N2Z5O9D8uAV4pivZ4sedZ3ILBN0WfVQ1L3yMbdKF7m8kjjkqTPeTtgO7KeZCEbzGlRUZ1CJ4SzaPhzAZgaER+l6T3I/pFA1t3HL4sXlNST7AfSQ0XLHJymHwN+Jmkz4NaImN/INguasy+1esp6VR5D1iTdiazbmFn1lulD9iPr8xERknpFxHvp/8cdEXFzWu69iPh9mv4FWdPvb9NqNib7QfN5siOJmyUdTHY0tFtE/CNtB2AiWbcr8yXtBvwO2L+MlzMY2I/sx+1jwNcj4ifKOpf8MpV/v9YZLd0Lc6N92ETECkm7AgeQ7Xzfo/QHPJns1/czko4j+5VcsLxoWkV/62+7A/BeRAwtM/ZiH9ZbfymfRPrpAtTxaU+ydWq4Xf/DUoUR8bGkB4Evkf0Sv75o+/8WEcVJFkn7NrSuJmKuREPr/yHwFtmv7A5kPxoKij+blWT7X7nxdAD2KPpHX0qpz1nA3IjYo4E6hZgK8TSkoddLA9ssua9HxHWSniD7x/MXSd+OiPsbWTc0b19qC9alH553FSX+jqz+o2BgmetYJ7XkOZmHga9J6iqpO/DV+gukD7lnRNwJnEp2AhZgKdlwpAXdgUXKusU+toxt3wOcoE/P3fSJrMv2VyUdkcqkorHjy/QEsI+kfspOsB8NPNREnea6ATie7ItZ+AL9Bfhueh+QtLWkDXKIuf7735iewKL0pf4m2ReuMS8CWykbpAmyJFrKPWQ/OoDsCrAGlvlO4R9v+nU6D+gvaY9U1lmfDjTWkKZe76NkP4Ig2/8eKZ4ZEe8B70vas2iZQtxbkR25XUL2q3qHJmJZ1zX5w5Ost+tbyI487m5g0cnA9yJie+DnZM2wBRX/8Cx6/Es5L4KixM+aPwra8g+BtdZiSSayYUVvJGtDvYWsvbO+7sAdkuaQ/eP7YSq/Afh3ZaPjDQbOJPtneS/ZP6mmtn032Rd6ZmqmOS3NOhY4UVKht9FRFb6mRcB44AFSL7ERcVsl66jAPWTNWvdFNpwqZL0TPw88pezE+xU0sUM3M+Y5wIp0IvuHTSz7O2CspMfJmsoaOwIgHZn8K3C3sosp3iI7d1Pf94Fh6WT582S9ydY3iex805z0mR6T3qvDgfNT2WyyX6uNeYCsaa6hy9a/Dxyf9tNvAj8osczxwH+nE//FR19HAc+l/fDzZF27t1fr4g9Pq8e9MFvNSdowspEmC12Pz4+Ii2odV61IWhYRGzaj3kCy8xTbVT+qfCgbCfNbwGtkF5M8HxEXSppM1jQ2HbiN7MhEwIURcZWyqwt/T3YEcTjwRbIT+a+RNVF1j4jjCuspOnez6r2VdEba9j/JhiP4qaRBZKNQbkx2fvGGiFjtUmVJ55BdnHFhA8+Lt1F/3mrxtAdOMlZz6ehoLNnVVk8DJxXaytsjSW+SjTh4SJR5r4ykvciOIt+OiH1zDK/dq584Kqw7GScZMzNriLJ7ocaRHeWUfa9MupJzONnFOpUOl95mOcmYmVluWkW3MmZmtm5ykjEzs9w4yZiZWW6cZMzMLDf/Dw1R4ufu3v5rAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", + "# for subcatch_id in subcatch_all_ids:\n", + "# index = subcatch_id - 1\n", + "# subcatch_smooth = hillslope_pars[index]['subcatchment_smooth']\n", + "# m2, lc = meshing.createSubcatchmentMesh2D(filenames, subcatch_smooth, subcatch_crs,\n", + "# mesh_pars[index], plot=False)\n", + "# m3 = meshing.createSubcatchmentMesh3D(m2, lc, layer_info, \n", + "# os.path.join(mesh_dir, f'sag_subcatchment{subcatch_id}.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "bd6e1541", + "metadata": {}, + "source": [ + "# DayMet" + ] + }, + { + "cell_type": "markdown", + "id": "42957ce2", + "metadata": {}, "source": [ "## For a given subcatchment" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "id": "f40ce9ae", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-20 23:22:55,812 - root - INFO: Querying: https://daymet.ornl.gov/single-pixel/api/data?lat=68.2176&lon=-149.1589&vars=dayl,prcp,srad,swe,tmax,tmin,vp&start=1980-01-01&end=2020-12-31\n", - "2021-09-20 23:23:01,948 - root - INFO: returned code: 200\n", - "2021-09-20 23:23:01,949 - root - INFO: writing to disk: ../huc/190604020404/data_raw-daymet/daymet_raw_68p2176_-149p1589.dat\n", - "2021-09-20 23:23:02,036 - root - INFO: Converting to ATS\n", - "2021-09-20 23:23:02,038 - root - INFO: Writing ATS file: ../huc/190604020404/daymet/huc_190604020404_subcatchment8_1980_2020.h5\n" - ] - } - ], + "outputs": [], "source": [ "start, end = datetime.date(1980,1,1), datetime.date(2020,12,31)\n", "hillslopes.downloadDaymet(hillslope_demo_pars, daymet_raw_dir, \n", @@ -4310,44 +7600,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "b2e67606", "metadata": {}, "outputs": [], "source": [ - "start, end = datetime.date(1980,1,1), datetime.date(2020,12,31)\n", - "subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", - "for subcatch_id in subcatch_all_ids:\n", - " index = subcatch_id - 1\n", - " hillslopes.downloadDaymet(hillslope_pars[index], daymet_raw_dir, \n", - " os.path.join(daymet_dir, f'huc_{huc}_subcatchment{subcatch_id}_'\n", - " +str(start.year)+'_'+str(end.year)+'.h5'),\n", - " start, end)" + "# start, end = datetime.date(1980,1,1), datetime.date(2020,12,31)\n", + "# subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", + "# for subcatch_id in subcatch_all_ids:\n", + "# index = subcatch_id - 1\n", + "# hillslopes.downloadDaymet(hillslope_pars[index], daymet_raw_dir, \n", + "# os.path.join(daymet_dir, f'huc_{huc}_subcatchment{subcatch_id}_'\n", + "# +str(start.year)+'_'+str(end.year)+'.h5'),\n", + "# start, end)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ab520b03", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "df4cbfbb", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c78c4030", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/new_scripts/landcover.py b/new_scripts/landcover.py index ef7c2fd..059a232 100644 --- a/new_scripts/landcover.py +++ b/new_scripts/landcover.py @@ -36,7 +36,7 @@ def classifyVegetation(lc): lc_remap[lc == veg_id] = ats_id missing_id = set(lc[[lc_remap == 0]]) for mid in missing_id: - raise RuntimeError(f'Missing vegetation id {mid} type {id_to_name[mid]}') + print(f'Missing vegetation id {mid} type: ', id_to_name[mid]) return len(missing_id), lc_remap diff --git a/new_scripts/meshing.py b/new_scripts/meshing.py index 7c1f118..b59b358 100644 --- a/new_scripts/meshing.py +++ b/new_scripts/meshing.py @@ -4,6 +4,7 @@ import landcover import workflow import os +import matplotlib.pyplot as plt # Given a hillslope's parameters, generate the mesh parameters def parameterizeMesh(hillslope, dx, @@ -119,7 +120,7 @@ def createHillslopeMesh2D(mesh_pars): # The extrusion process is then given four lists, each of length num_layers. def layeringStructure(organic_cells=30, organic_cell_dz=0.02, increase2depth=9.4, increase_cells=20, largest_dz=2.0, - bottom_depth=45): + bottom_depth=46): layer_types = [] # a list of strings that tell the extruding code how to do the layers. # See meshing_ats documentation for more, but here we will use only "constant", # which means that dz within the layer is constant. @@ -180,8 +181,76 @@ def createColumnMesh(layer_info, filename): m3.write_exodus(filename) +# Take mesh parameters and create a 2D subcatchment surface mesh +def createSubcatchmentMesh2D(filenames, subcatch_smooth, subcatch_crs, mesh_pars, plot=False): + # 1. triangulate the subcatchment + verts, tris, areas, dist = workflow.triangulate([subcatch_smooth,], list(), refine_max_area = 200) + centroids = np.array([verts[t].mean(0) for t in tris]) - + # 2. elevate the triangulation + dem_profile, dem = workflow.get_raster_on_shape(filenames['dem'], subcatch_smooth,subcatch_crs, + mask=False) + dem_crs = workflow.crs.from_rasterio(dem_profile['crs']) + verts3 = workflow.elevate(verts, subcatch_crs, dem, dem_profile) + + # 3. get a land cover raster + lc_profile, lc_raster = workflow.get_raster_on_shape(filenames['land_cover'], + subcatch_smooth, subcatch_crs, + mask=False) + lc = workflow.values_from_raster(centroids, subcatch_crs, lc_raster, lc_profile) + lc = lc.astype(int) + # 4. renumber from NSSI ids to ATS IDs + _, lc = landcover.classifyVegetation(lc) - \ No newline at end of file + # 5. riparian vs hillslope + # 5.1 load raster of flowpath length + fpl_profile, fpl_raster = workflow.get_raster_on_shape(filenames['flowpath_length'], + subcatch_smooth, subcatch_crs, + mask=False) + + fpl = workflow.values_from_raster(centroids, subcatch_crs, fpl_raster, fpl_profile) + riparian = np.where(fpl > mesh_pars['riparian_width'], 1, 0) + + # 5.2 riparians are incremented by 10 for unique indices + lc = np.where(riparian, 10+lc, lc) + + # 6. label land cover + labeled_sets = list() + for i,vtype in zip(range(100, 104), landcover.vegClasses()): + labeled_sets.append(workflow.mesh.LabeledSet(f'hillslope {vtype}', i, 'CELL', + [int(c) for c in np.where(lc == i)[0]])) + + for i,vtype in zip(range(110, 114), landcover.vegClasses()): + labeled_sets.append(workflow.mesh.LabeledSet(f'riparian {vtype}', i, 'CELL', + [int(c) for c in np.where(lc == i)[0]])) + + # 7. create surface mesh + m2 = workflow.mesh.Mesh2D(verts3, tris, labeled_sets=labeled_sets) + if plot: + fig = plt.figure(figsize=(6,6)) + ax = workflow.plot.get_ax('3d', fig) + cax = fig.add_axes([1.1,0.3,0.03,0.5]) + mp = ax.plot_trisurf(verts3[:,0], verts3[:,1], verts3[:,2], + triangles=tris, cmap='viridis', + edgecolor=(0,0,0,.2), linewidth=0.5) + + cb = fig.colorbar(mp, orientation="vertical", cax=cax) + t = cax.set_title('elevation [m]') + + return m2, lc + + + +# Extrude 2D subcatchment suface mesh to create 3D subcatchment mesh +def createSubcatchmentMesh3D(m2, lc, layer_info, mesh_fname): + if os.path.isfile(mesh_fname): + os.remove(mesh_fname) + + layer_types, layer_data, layer_ncells = layer_info + assert(len(lc) == m2.num_cells()) + layer_mat = np.array([landcover.soilStructure(layer_data, lc[c]) for c in range(m2.num_cells())]).transpose() + layer_mat_ids = list(layer_mat) + m3 = workflow.mesh.Mesh3D.extruded_Mesh2D(m2, layer_types, layer_data, layer_ncells, layer_mat_ids) + m3.write_exodus(mesh_fname) + From 0097744e16094b8ffa7d2819c84515d47c6414e2 Mon Sep 17 00:00:00 2001 From: Bo Gao <83304414+gaobhub@users.noreply.github.com> Date: Thu, 30 Sep 2021 13:32:44 -0500 Subject: [PATCH 3/4] updated meshing to eliminate hillslope depression --- new_scripts/meshing.py | 42 ++++++++++++++++++++++++------------------ 1 file changed, 24 insertions(+), 18 deletions(-) diff --git a/new_scripts/meshing.py b/new_scripts/meshing.py index b59b358..1d8bd2f 100644 --- a/new_scripts/meshing.py +++ b/new_scripts/meshing.py @@ -8,8 +8,8 @@ # Given a hillslope's parameters, generate the mesh parameters def parameterizeMesh(hillslope, dx, - riparian_slope_min=0.01, - hillslope_slope_min=0.1, + toeslope_min_slope=0.0, + hillslope_min_slope=0.1, min_area_ratio=0.1): mesh = dict() @@ -26,30 +26,30 @@ def parameterizeMesh(hillslope, dx, x_bin = np.concatenate([np.array([0.,]), (np.arange(0,hillslope['num_bins']) + 0.5)*hillslope['bin_dx']]) z_bin = np.concatenate([np.array([0.,]), hillslope['elevation']]) z_native = np.interp(mesh['x'], x_bin, z_bin) - z = scipy.signal.savgol_filter(z_native, window_length=11, polyorder=3) - z = z - z[0] + mesh['z_native'] = z_native + z = scipy.signal.savgol_filter(mesh['z_native'], window_length=11, polyorder=3) # 2.2 Determine riparian area and hillslope area according to slope - slope = (z[1:] - z[0:-1]) / (mesh['x'][1:] - mesh['x'][0:-1]) + for i in range(1,int(np.round(len(z)/2))): + if z[i] < toeslope_min_slope * (mesh['x'][i] - mesh['x'][i-1]) + z[i-1]: + z[i] = toeslope_min_slope * (mesh['x'][i] - mesh['x'][i-1]) + z[i-1] + for i in range(int(np.round(len(z)/2)),len(z)): + if z[i] < hillslope_min_slope * (mesh['x'][i] - mesh['x'][i-1]) + z[i-1]: + z[i] = hillslope_min_slope * (mesh['x'][i] - mesh['x'][i-1]) + z[i-1] + mesh['z'] = scipy.signal.savgol_filter(z, 5, 3) + + slope = (mesh['z'][1:] - mesh['z'][0:-1]) / (mesh['x'][1:] - mesh['x'][0:-1]) riparian = np.zeros(slope.shape, 'i') i = 0 - while i < len(slope) and slope[i] < 0.1: # in the riparian zone + while slope[i] < 0.1: riparian[i] = 1 - if slope[i] < riparian_slope_min: - z[i+1] = riparian_slope_min * (mesh['x'][i+1] - mesh['x'][i]) + z[i] i += 1 - + mesh['riparian'] = riparian if i == 1: mesh['riparian_width'] = 0 else: mesh['riparian_width'] = (mesh['x'][i-1] + mesh['x'][i])/2. - - while i < len(slope): # hillslope starts from here - if slope[i] < hillslope_slope_min: - z[i+1] = hillslope_slope_min * (mesh['x'][i+1] - mesh['x'][i]) + z[i] - i += 1 - mesh['riparian'] = riparian # smooth z once more to deal with discontinuities z = scipy.signal.savgol_filter(z, window_length=5, polyorder=3) @@ -73,7 +73,7 @@ def parameterizeMesh(hillslope, dx, mesh['y'] = y # 4. Resample land cover onto mesh - land_cover_mesh = np.zeros(slope.shape, 'i') + land_cover_mesh = np.zeros(len(mesh['x'])-1, 'i') def lc_index(lc_type, is_riparian): if is_riparian: return lc_type + 10 @@ -182,14 +182,20 @@ def createColumnMesh(layer_info, filename): # Take mesh parameters and create a 2D subcatchment surface mesh -def createSubcatchmentMesh2D(filenames, subcatch_smooth, subcatch_crs, mesh_pars, plot=False): +def createSubcatchmentMesh2D(filenames, subcatch_smooth, subcatch_crs, mesh_pars, + refine_max_area = 200, plot=False): # 1. triangulate the subcatchment - verts, tris, areas, dist = workflow.triangulate([subcatch_smooth,], list(), refine_max_area = 200) + verts, tris, areas, dist = workflow.triangulate([subcatch_smooth,], list(), refine_max_area = refine_max_area) centroids = np.array([verts[t].mean(0) for t in tris]) # 2. elevate the triangulation dem_profile, dem = workflow.get_raster_on_shape(filenames['dem'], subcatch_smooth,subcatch_crs, mask=False) + index = (dem!=-9999).argmax(axis=1) + for i in range(dem.shape[0]): + for j in range(dem.shape[1]): + if dem[i][j] == -9999: + dem[i][j] = dem[i][index[i]] dem_crs = workflow.crs.from_rasterio(dem_profile['crs']) verts3 = workflow.elevate(verts, subcatch_crs, dem, dem_profile) From 67022975be3bff0c31a1bb42f0644c662d3f94b9 Mon Sep 17 00:00:00 2001 From: Bo Gao <83304414+gaobhub@users.noreply.github.com> Date: Fri, 1 Oct 2021 11:03:14 -0500 Subject: [PATCH 4/4] eliminate 2D depression, smoothed 3D no DEM area --- new_scripts/hillslopes.py | 7 +- new_scripts/huc_process.ipynb | 7405 ++------------------------------- new_scripts/meshing.py | 59 +- 3 files changed, 451 insertions(+), 7020 deletions(-) diff --git a/new_scripts/hillslopes.py b/new_scripts/hillslopes.py index c845a84..81d680b 100644 --- a/new_scripts/hillslopes.py +++ b/new_scripts/hillslopes.py @@ -170,7 +170,8 @@ def loadSubcatchmentRaster(filename, subcatch, subcatch_crs, nanit=True): def parameterizeSubcatchment(filenames, huc, subcatch_id, target_crs=workflow.crs.default_alaska_crs(), hillslope_keep_fraction=0.95, - hillslope_bin_dx=100): + hillslope_bin_dx=100, + plot_smoothed=False): # Find the given subcatchment shape subcatch_crs, subcatch = loadSubcatchmentShape(filenames['subcatchments'], subcatch_id) @@ -267,7 +268,7 @@ def parameterizeSubcatchment(filenames, huc, subcatch_id, # 8. Smooth subcatchment for easier 3D simulation - def smoothSubcatchmentShape(subcatch, subcatch_crs, smoothing_factor=100, plot=False): + def smoothSubcatchmentShape(subcatch, subcatch_crs, smoothing_factor=100, plot=plot_smoothed): if type(subcatch) is shapely.geometry.MultiPolygon: subcatch_simp = shapely.ops.cascaded_union(subcatch.buffer(100)) if type(subcatch_simp) is shapely.geometry.MultiPolygon: @@ -302,7 +303,7 @@ def optimize_func(radius): subcatch_new = smoothSubcatchmentShape(hillslope['subcatchment'], hillslope['subcatchment_target_crs'], - smoothing_factor=100, plot=False) + smoothing_factor=100, plot=plot_smoothed) hillslope['subcatchment_smooth'] = subcatch_new diff --git a/new_scripts/huc_process.ipynb b/new_scripts/huc_process.ipynb index a370c2d..db1e5ab 100644 --- a/new_scripts/huc_process.ipynb +++ b/new_scripts/huc_process.ipynb @@ -88,12 +88,15 @@ "# number of horizontal grid cells in the hillslope\n", "hillslope_bin_dx = 100\n", "mesh_dx = 20\n", - "riparian_slope_min = 0.01\n", - "hillslope_slope_min = 0.1\n", + "toeslope_min_slope = 0.0\n", + "hillslope_min_slope = 0.1\n", "\n", "#Don't let individual areas get too small in width -- 10% mean as a min value?\n", "min_area_ratio = 0.1\n", "\n", + "# Refine mesh area no larger than refine_max_area\n", + "refine_max_area = 1000\n", + "\n", "# what fraction of the total flowpath lengths do we want to include?\n", "#\n", "# Effectively, some small number of pixels are often a long way away from the stream\n", @@ -102,7 +105,7 @@ "hillslope_keep_fraction = 0.95\n", "\n", "# demo subcatchment\n", - "subcatch_demo_id = 8\n", + "subcatch_demo_id = 35\n", "\n", "# The top level directory where these packages will go, one subdirectory for each HUC/data package\n", "package_directory = '../huc'" @@ -229,31 +232,31 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-23 13:19:22,496 - root - INFO: \n", - "2021-09-23 13:19:22,497 - root - INFO: Loading HUC 190604020404\n", - "2021-09-23 13:19:22,497 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:22,498 - root - INFO: \n", - "2021-09-23 13:19:22,499 - root - INFO: Loading level 12 HUCs in 190604020404\n", - "2021-09-23 13:19:22,500 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:22,501 - root - INFO: Using HUC file \"../huc/190604020404/data_raw-hillslope/hydrography/WBD_19_GDB/WBD_19.gdb\"\n", - "2021-09-23 13:19:24,538 - root - INFO: ... found 1 HUCs\n", - "2021-09-23 13:19:24,539 - root - INFO: -- 190604020404\n", - "2021-09-23 13:19:24,549 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:24,550 - root - INFO: ... found 1\n", - "2021-09-23 13:19:24,551 - root - INFO: \n", - "2021-09-23 13:19:24,551 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:24,552 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:24,553 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:24,583 - root - INFO: Collecting DEMs to tile bounds: [-149.3337383807433, 68.15835009523077, -148.79217986384458, 68.33619896061079]\n", - "2021-09-23 13:19:24,585 - root - INFO: Need:\n", - "2021-09-23 13:19:24,585 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w150.tif\n", - "2021-09-23 13:19:24,585 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w149.tif\n", - "2021-09-23 13:19:24,586 - root - INFO: source files already exist!\n", - "2021-09-23 13:19:24,679 - root - INFO: ... got raster of shape: (641, 1950)\n", - "2021-09-23 13:19:24,688 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:24,719 - root - INFO: shape bounds: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n", - "2021-09-23 13:19:24,723 - root - INFO: casting mask of dtype: float32 to: nan\n", - "2021-09-23 13:19:24,725 - root - INFO: ... got raster bounds: (-149.3337383807433, 68.33619896061079, -148.79207171405866, 68.15814340504932)\n" + "2021-10-01 10:56:12,437 - root - INFO: \n", + "2021-10-01 10:56:12,438 - root - INFO: Loading HUC 190604020404\n", + "2021-10-01 10:56:12,439 - root - INFO: ------------------------------\n", + "2021-10-01 10:56:12,440 - root - INFO: \n", + "2021-10-01 10:56:12,441 - root - INFO: Loading level 12 HUCs in 190604020404\n", + "2021-10-01 10:56:12,441 - root - INFO: ------------------------------\n", + "2021-10-01 10:56:12,443 - root - INFO: Using HUC file \"../huc/190604020404/data_raw-hillslope/hydrography/WBD_19_GDB/WBD_19.gdb\"\n", + "2021-10-01 10:56:14,729 - root - INFO: ... found 1 HUCs\n", + "2021-10-01 10:56:14,730 - root - INFO: -- 190604020404\n", + "2021-10-01 10:56:14,740 - root - INFO: Converting to shapely\n", + "2021-10-01 10:56:14,741 - root - INFO: ... found 1\n", + "2021-10-01 10:56:14,742 - root - INFO: \n", + "2021-10-01 10:56:14,742 - root - INFO: Loading Raster\n", + "2021-10-01 10:56:14,743 - root - INFO: ------------------------------\n", + "2021-10-01 10:56:14,743 - root - INFO: Collecting raster\n", + "2021-10-01 10:56:14,777 - root - INFO: Collecting DEMs to tile bounds: [-149.3337383807433, 68.15835009523077, -148.79217986384458, 68.33619896061079]\n", + "2021-10-01 10:56:14,778 - root - INFO: Need:\n", + "2021-10-01 10:56:14,778 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w150.tif\n", + "2021-10-01 10:56:14,779 - root - INFO: ../huc/190604020404/data_raw-hillslope/dem/USGS_NED_1as_n69_w149.tif\n", + "2021-10-01 10:56:14,779 - root - INFO: source files already exist!\n", + "2021-10-01 10:56:14,871 - root - INFO: ... got raster of shape: (641, 1950)\n", + "2021-10-01 10:56:14,880 - root - INFO: Masking to shape\n", + "2021-10-01 10:56:14,912 - root - INFO: shape bounds: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n", + "2021-10-01 10:56:14,917 - root - INFO: casting mask of dtype: float32 to: nan\n", + "2021-10-01 10:56:14,919 - root - INFO: ... got raster bounds: (-149.3337383807433, 68.33619896061079, -148.79207171405866, 68.15814340504932)\n" ] } ], @@ -285,29 +288,7 @@ "execution_count": 7, "id": "98defa77", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-23 13:19:24,915 - root - INFO: BOUNDS: (-149.3337383807433, 68.15814340504932, -148.79207171405866, 68.33619896061079)\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu4AAAEBCAYAAAAn5yAAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAxOAAAMTgF/d4wjAAEAAElEQVR4nOy9ebxdRZk1vKr2PvfeDBAIIEMCCIQZbAYBUQYVERGBpgXn1qbb1+HDt0VUHHp8Hfp91dZuW+luh1ZUZBJFobGRQYUEhCAyg4wRIRIwjElu7j1nVz3fH1VP1VO197k3QQQCtX6/yzlnj7Vrn3BWrb1qPYqIUFBQUFBQUFBQUFDw7IZ+phtQUFBQUFBQUFBQUDA9CnEvKCgoKCgoKCgoWAdQiHtBQUFBQUFBQUHBOoBC3AsKCgoKCgoKCgrWARTiXlBQUFBQUFBQULAOoBD3goKCgoKCgoKCgnUA9XQb7LPPPvTAAw88HW0pKCgoKCgoKCgoeF5j6dKlvySifbrWTUvcH3jgAdx///1PfasKCgoKCgoKCgoKChIopTYftq5YZQoKCgoKCgoKCgrWARTiXlBQUFBQUFBQULAOoBD3goKCgoKCgoKCgnUAhbgXFBQUFBQUFBQUrAMoxL2goKCgoKCgoKBgHUAh7gUFBQUFBQUFBQXrAApxLygoKCgoKCgoKFgHUIh7QUFBQUFBQUFBwTqAQtwLCgoKCgoKCgoK1gEU4l5QUFBQUFBQUFCwDqAQ94KCgoKCgoKCgoJ1APUz3YCCgoKCgoKCNiYmJvCTn/wEixYtwq677op9990XO+20E7QumltBwfMVioim3GD+/Pl0//33P03NKSgoKCgoeP5i9erVuPDCC3HOOefg/PPPxyabbIJXvOIVuP3223Httdeirmvss88+2HfffbHvvvtihx12gNYaWmsopTr/JiYmcPfdd+OOO+7AkiVL8Ja3vAX777//M32pBQUFQ6CUWkpE8zvXFeJeUFBQUFDwzKHf7+O8887DOeecg//+7//G5ptvjmOPPRZnzH0EMxZshqoiVIqgqEH/vodwYm8/LF68GIsXL8Y999wDIur8s9aCiDAyMoLtttsO22+/PTbeeGOcccYZ+NM//VN84hOfwLbbbvtMX35BQUGGQtwLCgoKCgqehbj22mtx/PHHY3x8HG9+85vxjVmPYWTrTVFpQGmCUgSt+c9CAdDKvdcKqLR12yiC8sfU/jOAsI6XA0D/oSew9fkTOPvss7HXXnvhDW94A4444ghsv/32z1objrX2Wdu2goKnGoW4FxQUFBQUPIswMTGBT3ziE/jXf/1XfOxjH8PX5ymoXgUoR7ahPHEHoLSF8su1IPNKOSVea4tKEyptoXnZFMSdMXh8NZYvvBNb3AAsWrQIvV4Pe+65J/bcc0/stdde2GuvvbDjjjtiZGTk6e4eAMD4+DjOO+88nHbaabjkkkuw884744ADDsABBxyAI444ArNnz35G2lVQ8MdGIe4FBQUFBQXPAhARLr/8crz3ve/FrFmzcP/rDsDIlpu5lYr/CIpfdZvERwXekfW6Mqg0oVeZqMgrCqRdEvbGpqp1WN80WHXvI3hP/Spcd911+NWvfoXrrrsOq1atwgte8ALMmzcPO+20E4455hjsscce2GSTTTBnzhwopfBUwhiDn/3sZzjttNPw/e9/H/Pnz8fb3vY2fGv2b/DpLV6NRYsW4dJLL8UDDzyA973vfTjssMOw2267Yf31139K21FQ8EyiEPeCgoKCgoJnCESE6667DmeffTbOPvtsLF++HB//+Mfx73MAVVVuIybXgrxDI5B39wdnkakcea8qi1pb1JVtWWZyld2SgiUF/sWXBL/SNmxDFIm4MUD/0VXoL1+B/u9X4PVmN/zgBz/A3XffjX6/j/XWWw+HHHIIXvrSl2LrrbfGlltuiS233BJbbLHFlLaWhx9+GHfeeSfuuOMO3HHHHbj33nuxfPlyLF++HL/5zW9Q1zXe/OY340dbrsDIC7cAkQaRAtMVIsLqm5dgr+seweLFi/Hggw9i6623xu67747dd98d++yzD171qldhvfXWe0ruX0HB041C3AsKCgoKCp5GEBFuvPHGQNaXLVuGo48+GhfN6mHGzjtA9XqBpNMw0q4J0F591wRdeRW9so601yZYZbRKbTGAI+KuLakqrgRh5zWESNwttVV0PoYlwBiFZnyAyQcewcrr7saB43Nx33334b777sOyZcuSybALFizANttsg7vvvhtXX301fv3rX+ORRx7Bpptuih122AE77LADzp+4G9X6s1CtPxPVButhbME8kKphrQJZP+CwCuiiKwqwK1ahf98y9O9bhmN6m2PRokVYsmQJDjnkEHzxi1/E9ttv/wfcyYKCpx+FuBcUFBQUFPyRQUS4+eabA1lfunQpXve61+GNb3wjTrzzdujRnttQAYEbez87NEDeFhOWS/Keqe7KK+5VZVve9dCe7DOr7Mr/pW2PJD8QfrGOFe/8vVsvDmQaDB56DM2DD+PDL3gx7rrrLtxzzz144QtfiJe85CX4x98vRL3ZxtAzxrJjAmS1O2f4rAArSDtBdFzWT/xkonKvzQO/x2tvn8AFF1yAyy+/HNtss83UN6+g4FmEQtwLCgoKCgr+CLDW4he/+AV++MMf4oc//CGWLl2KI488Ej+fMYYZO+0EzRM7Pd+MhD2+BsKuvfqeK++ejMJPSFWeqGpFwQ+vxCvgXnOlnUi1CPtUYEJtrfJkWiXEepgCHvz54Im2hKrylh2hokPaXyRJt76j+NWfS+XXI0h7Msjh/lIWR131e/zgBz/AZz7zGbzxjW9ExdakgoJnMQpxLygoKCgoeAqwatUq3HjjjfjVr36Fa665BhdeeCEGgwGOPPJI/I9WmLHDDtC90eEHkLYYAKQRFfgu9d2T0UDeZepMB0GW5D34wjPvOiA4t1ye+eKDum69uh6OJfbrkvWHTK7VipztxTiCTn5A0CLqFlDGnU/Z7DzSpM+Dnsq/6nSgoyoLKMLKn/8SM3/yK8yaNQsf/vCHsd1222HOnDmYM2cONthgA6y33nqF0Bc8q1CIe0FBQUHB8wL9fh/WWoyNjT0lx1uxYgUuuOAC/PjHP8Yvf/lL3H777dh4442x9957Y88998TXVz+MsRduA6VqKAMoTz7VFIo0IIi6X9Yi8EzePRFFbQMZ5n2GEnggqONsM8mJe0LCZfP8YCEcx+i2VWWYbSUcJFPClVfB+SmAdeQdVgHGE3Wbv8bjh770YxmSfaYJVAFUEahKlXce+KiKADvAxyc2w1e/+lUsX74cjz/+OJ544glY6ybmbrHFFth///0xa9YsTE5OJn+DwQD77LMPjjzySGy77bbYdNNNMTo6xeCsoOAPRCHuBQUFBQXPCRARHnroIdxzzz245557sGTJkuT9fffdByLCjBkzsOGGG2LrrbfG0UcfjWOPPRbbbbcdAJehft999+Hee+/FsmXL8PDDD2P58uVYuXIljDGw1sJai/vuuw8XX3wxFixYgD/90z/F1/v3ot5yPvR660NZ7UmncuqwV4mVhVtmEYhmaLu8ELbDIFXbSUtCKoh7ZqFRYh8m8PJEgSAzwbZdnSlIOCMj3PAWlkQNT8h7xzUl9h+hhCuKbeHjEqAa14fK+L4z/tIs/PmQDBL42FT5SwjE3fVVODf3ke9Hp/5H9m8bAk0MYFdNoHnwEfTvuQ/UNFB1D6hrqLqCqmsACkdXs3DRRRfhgQcegLUWG264ITbbbDO8/vWvxwc+8AHMnTt32Fe2oGCtUYh7QUFBQcE6BWMM7rrrLtx0003h74477sCSJUswPj6OzTffHNtssw3umPEYRjbbAL0XbIjephtiZNMNoHoVzMoJ0Kpx9O9fjl3u0Lj44oux9dZbY8WKFSH5ZKuttsLmm2+OG5sHUa03E2psFKS0k521hp41A7P23gn15pvAWu0sHkanajGhRdzD5y5im71n9ZjJriPtCKQ9ktCMjDIphlfJISaJMrGWhFu0JfeKS/tJyzfOTxAMHyuq4kB8ACC9+xRU78zCwudiwm5FvxnZf/7PMpnPzsNkXUfCLt+HJxdM8OX5c0j/fD4Y4ScncnNrYVathHliBZpHHsGf/GYprrrqKhx11FE48sgj8ZrXvAYbbLDBkJMVFKwZCnEvKCgoKHhWYMWKFbj11ltxyy234NZbb8XSpUuxatUqjI+PY3x8HKtWrcKqVauwdOlSEBF22WUXvOhFL8Luu++Or6z6BXqbzkW98QbQY73gweaMcmsVrC8wxNVFtbaoFMGuWo3Vv/4t6jkzMLLJBlDrz4ZFlexnrYI1IjNcKte2gwyz+swqu7fKKOMJH1s+JKTKzp890UysH4lqLAg1kJJ4Ru4B5xN0+cX98haSNkRlWvGTBb4e8UShdV28f9fgw7dPiT5M+iyQdrncvwpCzU8lImEHqKagwEviTnk/5QiDmbTvVN6f+XWKAdTE0vvxl2OzcN555+HWW2/FnnvuiQMOOADz58/HzJkzMWPGDMycORMzZ87ERhtthG233RYveMELnvLiVQXPHRTiXlBQUFDwtGLlypW48MILce655+LWW2/Fo48+ikcffRRPPPEENt54Y+y6667YddddcTldC4yOQo32QCMj0GMjoJERjMydjRnzNoSqNBqrYUih31QYmArGaKeAM5HzOd9yMqUTzilM2tQ6TtyUaSlkdZyA2TVhksk6kBJ1JqCs2DIRZZLpSW5O3BMiqXKiKVR3uVwQ9YQEA20VPVf5c8Kdr5dQXrVm0s2LO54ksI2F90uvwV+HJ9ZSLleyv2xHfxkF3TjCDgK0Eet4MJUTd36fDXhCP4p+akES93y7rn3ya4V/9QOFweOPYWLJPZhc8hu8ZrN5WL16dRiUjo+P46GHHsKyZcswe/ZsbLvttthuu+0wd+5c9Pv9xFff7/dhjEFVVdBao6oq7Lbbbjj44INxwAEHYMMNNxxyQQXPBRTiXlBQUFDwR8Ott96Ka6+9Fvfeey/uvfde3HPPPbjiiiuwzTbb4JhjjsG+++6L8x77LNTsmdBz10M1ZzZWmx4mTY2+rdC3NSYb935gKkfUrYaxMQ2FVXVjtCPuRvuYQqR+bibTnmApLZhZTuIoU9K7SDoTXZup6HICKh86IfFMcIU3OxB2oQR7gpl8FmS9ZUHJvCkJ4cxJaFiuUtV6KuKuxXmkSm7iAEDaWtLroEiimdiKQUYg7bLfuE8T64wj7KltJg6C4tMJwFbxlZcl/d31VCK/7GHqetY38pjcR8l1MpHnJxXymOK6aWISg0cexb8d+jLcfffdeOyxxzA6OorR0VGMjIxgdHQU//jfP4fi75gl/P2fvhzXXnstFi5ciNtvvx277747Dj74YBx++OF49atfXVJxnmMoxL2goKCg4I+CBx98ELvssgt22mknbLvttthqq63w0IzT8MK952LDbeZg3I5iwvYwSbV7tTUaW2HS1pi0FSZMD31TY8LUmDQ1BqZC31RojMbAVLBWeYXdsViuosl+8zDR0RPUhJhKX3PLrJwq1EOV9EAyVUIyOwlol8Wiy2rBJFeSPknQu7aXyntmh0ltHh3OEDGYkG3N+yYfTKTEncmzCmQ68cYnynccdLT6CKKf8n4UbdUGUE1O3mPPkFZR3a8AW7vXzj5fA0xljUkGT5ni3uo3f59IxUFb57Xm1y22S55AdHznBitXYPx3d+PI7dfHD37wAyil8I53vANvetObsOuuu0Lr+MUfHx/Hgw8+iOXLl2OzzTbDvHnzkvXPNRARfve73+GRRx5p9cW6hELcCwoKCgr+KHjjG98IIsL/+syNWGVHHVGnHlbZUUzaHiZsD+N2BJO2xmozEgh739ZorIYlhb71hF0o7v3GvTZNFRV2zv+WhF3GCEpl3COPXXQL48qESE2npGfbASkRC5/lOTqQkOKEGFKbxGef0/a3SW/SBtEJnQS6q22ChCbHDIMa98oWlnSiaJvw52Q1tG+q9/74krAHxT0bLNhKxfNOxdE6rj1c63RKu7hHIbZTi/XieKEdWb/J68ufkgwfCEbi7o5F0abE2xqDFffdgT+Z8yguvPBCzJgxAwcccAAeffRRXH/99Xj88cdRVRXmzp2Lhx9+GL1eD9tttx0WLFiABQsW4MUvfjGOOuoozJo1a4pOePZgMBhg2bJlWLp0KZYuXYr7778/vN5555349a9/jVWrVmFsbAyzZs3Ce9/7XnziE594ppu91ijEvaCgoKDgKcfNN9+MvfbaC9dffz1+O3YsxmkUq+yoJ/AjGDejmKQa42YEq82Is8dYp673bY2+qWDIedilRaYxztOe2mI8cedEl2GTRFn5zolejjxrfQhJzxXqaYn6MPI8vBl+B6REXaryvMkwpT1XbcPBs/Y8CSVaEttglRG2FRu85VMcYjpiOoSsakNJJKS8n7nP3fWdSgc5yQCHwntuUzIoyvsmWGNU+96gPaBi0k7CsSK/G8n3seO7kw4gaeiARlqe3HsK78kYfPH9B+Lyyy/HxhtvjC+edTNGZ2yAXj0DmhSo32ByxSOYWLkc73rHnrjrrrtw6aWX4re//S2OPfZYvP3tb8fBBx/8jKnUTzzxRCDiw/4efPBBAMCmm26K+fPnY968eeFv++23xxfe8DXMwGwoKPzNpSfgTW96E4466ih87WtfW6cmAxfiXlBQUFDwlMAYgwsuuABf/OIXceWVV+L444/Hwe+/CrpSMFAYeEvMuCfvrLivNj2vuFeBtE+YHgZeZR8weTeOyFurPXF3E0gtTxzNE14CqfE/ykOK+Uj7CyBIun+dyuKSWDzskO3z9xiyDbq36bJjtOwmEpl6PGUbupTmKdqSDwZ4Xa66p6S54zh5W/2fNvF9IJ7y3ojzJERV8BVSSvjxswFQ17nXEp1PPsTxo2VGEPuMuOffDTmpV5Lz/HuSfMcy8p6r7m45dfeT3M6QGwg15I7RWGc9GhisXPE7vOTVM3D66adjbGwMb3vb23D00Udj5513xvrrr49+v4/bbrsN119/Pa6//nrccMMNeOKJJ9wpMg45MjKCGTNmtP5GR0ehlILWOhDohx9+OCHlK1euxIwZMzBv3ryElP/wcxdhFDMwhhkYxQyMYAxaZYOLIVx2Na3C1fXFuPPOO/HCF76wc5tnI6Yi7vXT3ZiCgoKCgnUPRIRvfvOb+PSnP42JiQmccMIJOO6fHsHIhjfgIbsBBoMK1suuPWVgoKCVRU8ZjOkBbGA+I8lxdQerIlIgRT4VxjHX8DutCNDCCE5ZkSHjCB2s/FOAoUDwlX8bCGruKxenUhYupYYjEIGEXE9FgkmqxBkRSy84JZeq9WYN0aHk5stIdR+2U/3t+BysGxoAe927DpgPfDJ1OH8ikpNYZQmdpDZcRxyBrWnk47TIVXYMub+ssFeuQdJGQ5Xo4BZxj9cUCXx27eE6qfN+JgTeZp+N2E+Sev/kQhvriLuxUIaAxkJZiw2qTfDrnxjsscHb8fCKe3D33XfjiCOOwMMPP4wXvOAFePTRRzE2NoY99tgDe+yxBx66xqKnNvJtIvcPxL8fJ4sVNIClcVgyMDCw1MCSARGBQIFk99DDqJqJmbQpdsMLMapnop7sQS1RwBLgQerjQSzBVmr7Nbh33V+AGWo2dt99d1xzzTXrFHGfCkVxLygoKCiYEr/73e/wzne+EzfeeCM+97nPYflu/wFbj8BAwZJOJp82NiphTMotKQyoSiam9m2Fvk+VmUp1tyHmESJfPf5IywjIxP9uHLviDPNERabUBx8Pho5McaTJMCKuMbwCCVlTQJxQyKSfxLIOJVW+H6rUr4Vy3DruMHSownJ5m8RTGOxM16bcKiKtHmEQJI+Z7zOEtEt1tfXEYmhjsg1y7uPXt558+Pf5OUinin9Yz8vChtlpAtHO+4SSPgEkqafkWuP+JJR3ikq+oYzQe5XdWKe0Nxaw/rUx7r1xy2A9sSZCv1mF8cFj6KkxzFDrQQWfErntAEfa5aRh7ldrxbbWLbdZZ5AF5cu6wAODqZAr8ALb/tUcjI+P4zvf+c70x3mWoFhlCgoKCgqeFL73ve/h3e9+N4444ghs9Z6HMDpnBIY0BlRhQBV6ysCSwrgdcbGOpsakrV18o2c0GgQLhdozk4a0S44hlyDDaTLO6+4Ju0+QAZARd14mllvtuLCNiTPBB58R0xbDYxuNL/qjm0jakyJFQmEP1U2zzHU+R16kqG0z6U6fSSe/dpP6TlUd2bLsuBJDSXzXcaX6K7ex2fV2XIs8Vn49XX7zqa4rXd7h/06ORWmfMH/UjmyvESRBz56sBMJepcfrIvmd9wNISbUk8jlJF6S+bSOiVFUnAEGF9+u6CHtjoYwBjIXypD0QcU/YYS2IibclR5wDIReEXXwmv5//4NcJwi77PjvGkybvnqyrae7rf/7609h///3xkY98BCeddNL053oWoBD3goKCgoK1wvj4ON7//vfj+9//Pr72ta/hmgWn+0SYXiDkA1uhEfLiwFaJkm6shkUk4FoRtGcgDbmJqIOQ2e5y240n7URc0TQl72CFHQhsiauc5qCcpPP+PLGVK4IaR9xd4R/vi5eHlIdRiMWFZGVQHc8RjuGjE2Xho5ZdpkXIZMGkIeQ9ez+1Op2ea422S9ZT65xDr2ENCPh069IN221iZToq1lGpTtV6ygZB1Nnm1rmEb10mx8hlpNW0VqkpL6vzvlGrfyMBj4o6789KeuwTAjxRjwp89LOzLWYqhT0Qdkms/xDC3gUeCGRYY/IuyfoUKnuOx+3DuHXsCnz961/HG9/4xjXe75lC8bgXFBQUFKwxrrjiCrzrXe/C3LlzccMNN+BfH/4gJs2ot7jUoXCSJYWGqqCOW1IhJcb4aqeSiDOUZyvGqkRdt/zZCiXd22AY5LPayQppk+BVb1cdFdr74321VGc4Z+JPgFIg6BBnyPtS5b315OswDSNnigCu0smknSt2Wq/EkgKMU2bdxUS7jDwMk3UK1hoK16v8QCNabhCIHfOiYBUJ/8mOHzou7ivJtfThy/YlExw7BkbSDhLaIAgp5eeX+/Jy6U/vsKakO3H74sDGpc6ojOzCk2AViTtkXyPmwTMB9v0eoBVspaC0J+yI31neMUmyEW1Ovisq2SXpq3SZbI+83my5J/dBSRdkPRB56/3rxOss4Em6MqyuC8JuDEAUlfE1IOsAui0x4jNPQKVhx8qgtJqevOekvUtpH3KMOXojnHXWWTjuuOOw2Wab4eCDD576XM9iFMW9oKCgoABEhJ/+9Kf41Kc+hWuvvRYf/vCH8ZtDb0ejRzDwJN1CuYx1nwoz8Kp640k6eQJOpIJ6TgCs1cHaophce7Cq3iqwxFVRpeVF+qpD/CMTp0igVeUYnPJkWp6PxDHJK+0ynUZJ/7yihNgn8AMEaLjzaHe+5NjSqpOn2nD7uaBRl4WGWF1F6pUX24TPQ9Tf1va2vT6ZKCmqlLJ620pPGaIySztPZ1qM6MKgWLOCPUU+emi7n3OgDcX5B13Hp1SZTwh98NhTS83Olex4YaLNDK0S5T2Po2xdB7dRPgEQ15ar73w9UlWX9hewBcb9A/P3zw4n60RumVDXOwn7VMo6w4ovUReH9Oup63hSJdcqWb9GqjumIe6izV1447+/Eh/60IewaNEi7Lrrrmt0vmcCxSpTUFBQUNAJIsIFF1yAT3/607j99ttx4okn4tcv/TX0ejPQsPUly1wnUoGss8XF+s9M0uOrQpe9BYpSHp7HPTIpl+Q8aThC3KMrAkSp+u2JNJP3fF8ify45CJDtY/D+Sqj3DAWv7KfX4/qVjy2ujZ8O5Bn0kuD79kS7jErSQ9p9gEiupd9eksHkfUcxJibqBKhGFD/yx+aqpMHbP9UAgeKxWvnr3P6EtMe/UAlVtY/t5h/4djVCNR/SDkfw0z7QgpBLhT6Q+DC5E2l8orSiMM/UClR78l4xgRdEvgvJuYUvXbYhKNR+m9z60kXUpYruCXmLsAOBsAc7zDB1fSplPa5IP0uyLo8nofnpRYcavzZ+d0xB3tdg/5d+bHt89atfxT/8wz/gz//8zzFz5sw1OufTiULcCwoKCgpauOCCC/C3f/u3eOCBB/DBD34Qi/a4DTQ2M9hgACTWl4HVaHzqi/VEPKS6eLLOeetBZU9IqYoWF0Sl2q3z61mpNmx1YJLLOyFsz2kvwWvulfaEvEuyPQ2hSpeJjcX+Knkv1mWHl9aKOKFWpN8wkWcCH4ivIPPilZuRNItVeh688GRZzf3jN+zw2Ccqfq62y6qlkrhXyCbnur+ctEcSnB436WcN2Cq+5sfki40qu2gTX5dq36bY9kiy8+hF+ZBGkvfYXo5PJDeQaZxPXDcEPfAqNjx51wqoFGyl/TWo9PhAJNyIfRCfSBBiGoywuQgCryguS9az3cX6THY50dR94cL6lrrO63371sgOI/dhTEfYtUoLH8niTnnazJMl78MgPPHJYiL8+ddfgy984Qu4//778e53vxsnnHACtthiizU679OBQtwLCgoKCgImJibwoQ99CKeddho++clP4sc73wrqjTjbC2lMNrWLYwz2FwQvOgGxommupgNgL3nLMtKlnDPRzr3AxBYWJIkvXf7gUPRGUyDw4Zgqew+kRHsIkZ/mZ7G9f6bCx/VD1PjwJusr7ie2B/HGeXu8oq68jz63CxE/JeBtAplWkcAalRFdlRJcSbiVJ++yWqmfnMtkXvm2RvKvWqQ9eWqgImFPjifiFUO7hH1HWkoSdZvaTwrS5Y4oS196iGAU7dZBbfevDaAHjjDrQUremUQ79V2DKu2fSMTjAxBPc8R3j/xnT96DP71h8p0S9mQSaVDih6wHhlthgD/cDiPWTcUhlVIpUc/RRfqFB35NCTyAaZNlukBEeMQ+iHlHrIeLLroIxx13HE488UTsvffea32spxplcmpBQUFBAQDgjjvuwBvf+EaMjIxgp1OOxfc2/S0auz7MRJxAaqxGY1ymujHRn578RrMf3bjs9GA5yX9rBRnltBUAjnAZFUkmkDFzZOQ7EvkQ8cdskT8QPHFXwp+eyZ/Sh5yfsyuFJn+fe+A596/LzcPXxsq/nzQbro2bpz0b5cJSSVqOUONlnzBHs9mJ5WAFYhvrSb6BGxSB3KvmY1PsG2FlCVYXobTLKExSnnRrcvdYe5KtvYJdxc6WSTmk/HEqwPIAQJB3dwwFVUVyzYOP0B7uQz9AsApAFfuHByZcQEsmwSgxkGGSroy7Rq3dBk4pdmzf1fTiyl4aSgEarqCR7hvQwAIVP4bpRpcFKNwkoabHyaXC7sJkPY9v5P1tJOad3vJ8WZeyDrQtMTlysp0hqOuSsA/rE7+N8sd1hdPifoqr0K4BmV8bki8xV22K1T8G9qZDMGfOHBx88MHYa6+98IEPfABHHXUUqqqa/iBPM4riXlBQUPA8wOTkJM444wz89V//Nd71rnfhylcSTNUL1pfG21wkrNUwRsGaCjYUMsqIKivGPNGzi7wL5ZcVVBCEPYJJtt9eHDu88iROo4KyCiAhj5DFkeRgQJBRALHqZgYl2961STZwyXbuPk9S8TXfbkg7eFItE35EjpZPtJVt4sm/bkOAvfxhEm6jxT1QzituVKJmJ154T4jD2IjJtSYQK/CViMZEPJ6050gSnQy6xGCAj2VruCcxQGhr3N9/h7hJKh5X2onytkdfeuwXaQsKSr23xegG/o+8r56CbSYo74agBtZ/NmJSqO+HjFuRUmFQ6QaWSqTGUOpVzyeWAimJB9pEHegm67x8KnWdj5c0eJr14hgtsj4NUW8hK9aUH//JWmmeDBo1wGv/6SX40pe+hDlz5uC73/0uXvSiF/3RzjcMRXEvKCgoeB7ikUcewfe//32cf/75+OlPf4oNN9wQZ5xxBv5BX+EsMA3QGJcMY4yGaXRIdUkIoidi1Hjl1omQHQQ7kvOEuDFU/Kx8bjoB0Rfc5UXPlG6ZiuLIlnLkkRw5Urx/IO/pQMPZOrqJRe5Dzts89DOQpK4k5xHKvxugqGS/VgO43X6yLSmeZOvWu0MNUR3l0wBxyOgcse4pR9jMtY/4Xvkdw6RJg2BB4Kz6oJQD7YmlFYFqjmKk1KtvlFNQ/XeHdLzX8RgU5yr4wQt/99xxKBk8SusPd3pIiQkDkPQ+wQ8AlPakXXkNneDiH/2frdw9JU1Qxg1+tCboAWCVBhqnyCvrYkQ5L50nsQbveeOIuGJCqhRQ6Uh2p/KqZ5NKOxV1oFtVl8vXlKyH/dZAgdc6/QoP87GH1cOfRKCqYtvEdorbotgLrwGyaxYd+SRRUw8Xfexa7KD2x8uO3wn7778/PvnJT+LEE0+Ensr28zSiKO4FBQUFzyGMj4/j/PPPx+mnn44LL7wQe+yxB36782yst9d2GNl6U0cgSfmsdDGxlCuWNs76kmScMwFiywUTMglJennCJHlVM69g6iGTR5JDDbUUxFe2OigT1dtAeuXE0JYK3t1vQ7hwO5dbDmiy5cOOnRDyvC3y6UVQof0ykROv2E6jPHFXaKfcdFxgkmxjdJg7EMmwuBCSfvKoboMEYffFp5K+zjPt+fvSlZqD7BrDdVN7UjEQJzeLSbrJdTIfzibzKtkG7ibh3dfsnefrzdJ0nJIek2xCBKV1/nf2vcckmixb3RA0Fz4aGKhBAxgTJra2blLuU5cedaCtpoebO2TdMCtMWD+Nwt6FnHxnRLZFzqXvfC2KJcU2OUsPEbm8eWtBxj4tyjsPWB+jh/HwVnfjhS98Ib71rW9h/vxOEfypP39R3AsKCgqe21iyZAm+8IUv4NRTT8W8efPwlre8BTe9ems8ttnGWB/ud7k/QCDqobgREzuOR2TbiwUS2wshWkk8kWIyBKRESVokgEj+kjg8ADkRd+9VCJrJbStDCbwUGdmOwOgi07kKK5dLYq6y7TxZZbVYZUS+017jN0wGF0BUr5MBh/8T9hF4v3VQ9DU5wdmr8aEBHdfJBB8K0DWBKpNMhCUj7i8r2to/cQk2DtEv3E45EVj6+Fkp998DnmxLSWciknQlMv2zuQZEiNYr+V0M34WuCxaHsmLw6K8jqUYL37/8vuf7vfJk3d8zqrz3vYn2GzJOkY+JPOSSZwycjcZfdJi0y/cxTDjOiDovAxLbyBpZYEKfdZP2FtaEsHf51JER83wyaE7Mef0wpV1EOXap8XJSrTLW/RsyxukI5L6rSq959vuTxQZqI8y+bwNsffBsvOhFL8J//ud/4g1veMMf9ZzToSjuBQUFBeswrr/+enz2s5/F97//ffzZn/0ZFu4+B6PbzgOgA2EK/5tngg4gZJiHwkCCGOVKaQch71Q0eR2y7fizeJVEfcptcsIvfrJa9o54yHS9xDDSLvbrJO+I61o++qwtrf0F6ZV+/nAciG3YIiLtI7kSD7lcdoh4VZR65XW02cgnLSC4ycWyGFXeX4TUqw8E0q4qgqpssPLIC08GhZQuVwrtybf5e3/+5MmAfJoj76/4jubpOHzedhQmwvZJ+k1HoadW2oxhpZ336UidGRhnnxkYoDFQjYke9ikIu3sRFzcswjFcu20vax1jmkmngqS7NJgnQczz4kp8LN5O67h95d/zX2x0/DMWMAbUGMAaYNCAfKVXGSVJxkx9bWuBoek0SuPdp/8Z3vWud+GII47Al7/8Zay//vpP2XlbpyuKe0FBQcFzD1/+8pdx8skn4y//8i9x22234VWLz0DPKlgjyFIgUFMQpECy5fKMuGMNVHVgyPbyc0b0wedOP4dtxOeuZZ0q/HTbrgFaFhm5TA1Z1rGf4mWen7ByLkm5Eoo7p5+oQNSFWu/V9/AeGZmXdpPAlyJpB+LATesY72I5kpGz5cO2cESeBwJeWefjJnYdThhaw+9dHEBm3zvI14xsi+9kshzpfjKOUi5LvkfCNpNWjCW0J65yrrsn6E1U2BObTOOz2BvrJ66a4aR9SNxiZx76WpL2NfKyDyPqsqjRVGo5kGa05x53JuQ6EnbSvEwH4k5Vdg4LhMqvxvWbqgzQNG4OS6PEEwhyFhquwPokLTRrGiX5lbf8ADfecyOOP/54bLPNNvjLv/xLvPe978W22267Vuf7Q1EU94KCgoJ1DDfffDNOO+00fPnLX8Yll1yCt99/kS985O0vFkgqg0qfsCBQqaLuD54rml1ku4usQ+yTLYv7TkHau46T/TxNS9qnWNdSZ7ve5+fJMMw6k3rW0+VDBwDCKkNCzW4dw08Elek7Uo1PsuulR3xIxdgwsdNPeFVKRlQyKXckXubzs1qvRKQlkfJzIzxpDzarju9ZOH9sR5pmo2QTku0VkPjWk8JTHd+fZH5FTvxFG6Q6rz05l0o9K+5RZRfJMr6qqjYuEhKhgFJU2uHJumpMJOysGKOLYHcQcrdhe5u18bN3ICbBqISIO8ItyHu+vfvgtxcEXe6vfaa9n4gLrd2AtVIgrf33VLuKs76IlbsvPAASfTho3PyAxpP3wSBO2uV+sNJW5FV6YbXJifyTyXyXTxNIAY/ah7DN0RvgvPPOw6GHHooTTjgBhx122FM2gbUUYCooKChYx3HnnXfirLPOwplnnol77rkHRx55JK7ZcwZm7Lx1KIbE5J2rlwbPOpMVSajERL6hNhhGkGuREiybrg7IyNcwMh8Oz0RuqjaI/YaS8PyY8vzyuF3tmmowIJbnRFwS904ir9Ei/NS1vUq3DykuSXILxfcVhW3QRdIl8msSRJ+r1+qKoLWFrqznYrEDlFfbJcm3VqNpNKwvxkWNdqlDnCjkc+O7JosqeS9sdk/Yzy67mQm+JOL5/ZTXSnGfhLBbJN79QNx5e6G6a2+BCeS9oajG+yqqqrFxEqr1BZkap7R3quze0jGlqh4+d2yTbzeVNUb2nyTWyYpuwq6CWp7FO+YEnaMt+TNvU1e+IFUVsu0lSU8/u+OFpxYiYjMh742zyqBpQJ6cQ5DzJDknJ+858r5eG2R2oAkaxys+sju++tWvYtasWXjve9+L448/HnPnzn3y50Ah7gUFBQXrJIwxOOuss/CFL3wBN910E17zmtfgTW96Ez47ei1oZAzGVzPNibtTQjuIO1sS2G6Qe4elItqhGCcEWBJ+j6Geb8kr/bFb44IOYi1fpWKfY0oLTD4QENvKwUFQZ70lIiGb+fWERvtFKv2cLMvV92GKfEbcoQFbtck7hWXk0lyU6FwCpsyil/c1Sa4B4L3qnFoT1HhtoXWbuCsFWKvQNBqmqSJx56z4Romqp2lV1kiaVdL/UhnP71GLhHcRd8r3oZTkdynxcrtA9im8Z8KOYKOhkOGuG5uqw3kGe26NmapAklsR33etl8unwrA0F2mB6SLp0t7C24V9NaiuEm96kk3v4z8BOGXdV5KNrwq2ioTdfYeVSygC0ox8nicwMI7Iy1QefnoxjMD7PiLxZCPtP5uo8WuNrv4EQLB456lH45RTTsEvf/lLvOUtb8FJJ52EXXbZZe3PgULcCwoKCtYpEBHOPfdc/P3f/z1WrFiBj370o/jaxndAzZoJY5XLXffZ69Y6u0KwyHifMgk1PbwCLfIKeLJnEScmijSSsE/YVw0lyl0kP7dCcCpKen55jiz/PSf9nSfmA8X3w/z1bQU2PYaMBOxS/7sGAOHcQ8j7mpD4aJcRBF6Q9aT40RRP41tPKro6W8Vjs/Ie1HvEZajYckOB0IfJrkCY6GqtSoi7Ml5tN8oTeAhFO4thzAZPCbHOFXZWzHOCnpN36lgn3gflfBh5p+hfDzaaoLgLHzu/MmlvTCTsQ3LYh1Y1ZUylwnfe8CGTRoFIvKcj6WxvkUp63i6to5LOZLzS2aDRV30FHEGv3DFtzxP32hF39wpH5DWCLckRdtfXVd+m6jtHa8qnGf6JBjVNJPDGpOo7kE78lcR9Kgzr+yHE3XW3+7zCPortjtsQl19+Oe69996pzzMEZXJqQUFBwToAay3OO+88fOpTn8LSpUvxt3/7t/j21vfgv6r7YM0sp24aQditDrF+bI2RBDhAIWU3kkhLosee6S7SzschcouIP2fr+bDWETcu7uOqiApyKMh2OATB/7hmSTMZAZPX16XsR3VXRYLWQdKnIuSk0i5Q1N5Gkshw/aF5sRgUv8ZJp4Ib+WQZRZ5M522h0PGhYapB6ylF59OODMQN0eKwojBUHDBQUPPjAEO8l9GPEmzhAaDg02O0aBzfX9FRgdBzOkuH6t1JxlvknYYS9UTB5+NmZF0eg9V6RfBEPbPFNL6gUqiWOkRlH6a0T5XFHpazD61jlNbl0ZYkXWyjlAKqCsFvzmo5v9c6TCBNFHTfNuWLSZHWQK1BvQq29v70noatVJgcGu4bufjSQNK1V9prBNXdVggEXjf+O+H7XgMw0NBaQTcWViuomtN5FJTWvj2Vm7yqdSTw/KUgC2UFec8nBHMfDiPwTyJ3ns+1nt4Qp5xyCubMmYMHH3wQm2666VofayoU4l5QUFDwDKPf7+P000/HZz7zGTzxxBP44Ac/iO/v8FucNvJbGDOKQVOhsZG0kyftwQ7DJIZLxXsmF2MgBXHiV/6zvjokVFpEJ2d/Xb9jgnzL84LgKnRquB99HjjI44q0koQhszc/O08ykdaqQMBIkPO8eFDe/jDgyPtAXoon+WCyz8dRcayS7CC7ShJK0X+R/DKZEoTdIKk+qoQnXlm/zsLFNfp1Qwc1QEtgTyAHVgoimlKlTwK0/y74UUcyidZ764Nar8SxGZrCAMSlzFAcCSnPiXz/ysQdqX5LQh+iF+XTEoj3REMJO5PIQOxDSown5Nm24dX649o4YdIVVsomnuaVTrvIOtAd6cjoIo8ZAV/jhJfcm+4JO9VVUM1DmoufIOpIOxyZ91WM3b8n79u31u1Ta0faaw1beyW9EnaX8MTED4C0I+dBaQ9PjeJ7971y/6+wNaAbFVJ7aOCq0mpt3ZMb5d6TtlCVgmqsu7fOt+UIvNbOQtM0AIz/N+SIPfyrUireF06kWVt0DJ7kBN7jNjsB22+/PX71q1/h8MMPX/vjT4FC3AsKCgqeQVx22WV4+9vfjrGxMZx88sn49rwb8YNqGQZmBgYDjcZUwRZjjEiOIUcOSfsf2SQCEJDMsjPHnRzpZU9yINc1OXUrU1NlAgll7DBJGeEnAEq7H0RWaLOkE7IqeKnDQENYfUK7vY1HPlFwhB2AUVAghKqaTPCBZFLoVD/LQb1lUZuECsyfeWDgzxvehxhDJnzZMfkc3P1hA0GGlQIXciLhb2f7TFgnSPfaopPM+3O3LDz+flBQcOMgg7wvGYG4i++NvFBxPqfeMxN057OKoHmjhgl+HPe57SjpF5C71yHtxUaCmMQ+5oWjeBkJBZ2jG0UBJCbyUSlnAm/bEYWsrDNpB1IrDLBmCTHDICd7Am0Sn6FlgeEkF/+aTxZ195CVcGdjCaq47/9oCxL9UilY6VevFWyPVXXfljDgcffOVsIWUyGS9woxCpLnEhjlq9IC1UD5ASKBtCfvXt1XlQIG/nxwg6PYMzVU04A0jyYIivzAQxQQUP6+EdHQfl0TdBWPYuy999649tprC3EvKCgoeC6AiPCZz3wGn/zkJ/HZz34W5+38a5yuboFpRjGwGgPjSLsVJL2qANIGafVTdzylyCeCEHRuYYAg1Va5Y/qqlFSzCujVYE3QtUsYYfLOqSLaT1TUmRpPcCkjPLiwWjvLjT+eApJJjrHN7pjw+1ubVXX1hJ3gJVoCAitkpZ0rWjJ/qikhm62GMlTH8kDaFVSFoODz4CixcrC1ww+GmHwmNgth8wDcw4ygpgeSS6nazQpkhcT3nlzGWpB4tudM2QdChQ+Enjf3TwISf71ScZCh/AHkMcLxKWknVb4DyBN66wYt4SlC6F+Kcw38PcjJerBVNFwEyavnnjDnFhq3jLy9hdV36/exUVHPJpQGcs9EPbPAtAolhYvt8EgPI+2ttBf/WELaXYYRROlXz5R1qpnAq+BJdx51T94Br4RHKwvf+zAPgAc6PB5hq0vPE/FawXoLDA9+FTniDyCq6ZKwZ99v3SB43cl//22V/XuHhob1g2Vvl6ngBlV1FZ+GEQFV5Zpilfe++4GgMfHr36W+J7dgLcl8HgNpLfbee29ceeWVa3ecNUAh7gUFBQXPAO688078wz/8A6688kp8bMV3YKiHxqfEsKJdaYsKAFg88mp3nJxKsF65ripHjGttU5sGeaIOBKsNjHa+0cokLhUy6Y+V1nxci8qr7ZUm1y5tg0g9MBUao9FojarSsNbCeuWb26WV20/lpJ+vR7kfS2N0FLGtAhntIgaNSykBT3bkxBLAKXs1ImEXinA8EYQ6m15n4in3CjJZOPIuVH62tWhfqFGxI0L8KQIIbnQSLAeewBPiAIO7IXjpmbh7j3lwVQjlG3I71bqMTnTyj4ynyLaEc7HCrhBJVuKD57/8YO2Tt+bH8v3LrC+SvMP3t26oVbU08aSzwiuIfVgOBLKswpcKaXxjrqgzYZeq+jC/OmOqyMawbBqlvcOjnhB2WXVUxjKysl5VnrgLZV0kugSizpNFPelOrCpseyH4JCAKiUDBmlah5VO3NdKBJhx5539PcZK1Eu/9ecQAWA7clPhehAnclZ/LU2n3MM9/F4PvfdCkXz/4r7olAIZHBcl9dN05xaDoSeIn49/BySefjImJiSd9jGEoxL2goKDgGcBNN92EXXfdFX+z8tsgahN2Jri5um090W2MhtE6rGcbS6+K+wbSTgpGlLJXCqhgE+uLtcqR+Y7fsEoR6sqirox774l7rSwsFAbaoqkc4eZBBXMZrdz11NpCK0fgG6thSKExFRpOyWG13mrYRrtBhFHtlBJWsRWBej4IRxJZzj/nfmHWaOE29r57SV794dx7Jir+tx5wj/DzCZKAUIojR3GvGomNhvwDA7YPSCVeSxdFrrz7QUQ66TWucykgfFPFDZuGIw5br/I3knRJu0wVORDkwKJLzec2y1WEMH9AN+7PPT2ByE33pL2JiSMcGRgUYH71JJ5TYIL6HpaRIO6UEvaQ+239OhuJXU7a/xBMpeB2TSjlfTJFnZd3knXvQYdW0f6io8ecn6awTcXW3muuI3mXlhcl5pLwe6i4D08udYOASMwDMuINr7zzqyJni3FdraBBfrzl/mGRUu7/b0pBg8di2j3Fq3xikdXR98591GiXOqMUVOO8WKEpSseM9z/knk2DJUuW4Mtf/jIWLVr0pI8xDIW4FxQUFDwDuO6667DbbrthuSLv+XUsTnlya4PP273yZwVAVwa9yoTPQErw+b31xN2QgpPtnUqOyra2NeRIM58fEAK0V8srRehVBqNVg5HKoFYGWhH6tnZk3Go0HVmFfLzGagxMFUm70XHSbaPDhNtO0u4ns1r5qxUmvEJMtGT5Fr7/KMjaSnkxtEuqZguMUNd1o4Ly25qAKkhJi8jnyNXDxA/M6ynl3oqJliDNQp13liNKVXJuXweS9nduIM8d9wkDBOG7Z7K2pqr/MISnEdzfvjJpQtr9REW2xKjGQhtqK+4hYpGXd5B14V8HvMrOk0rziaaStE+FYRNLu1T3KaIbh5J1HT8Hz3qSx+7XVypMHI0e9Kisx8mhYiIyTx6VNhY5kTcQ9vje2Zzi9yAQ9vBefL/l4DgZcPr34t+Ndv+jSci7e69CW1VPgQY+S78hKK2gjYWF4Nja9WWYtKqVi48Ef/UNoOtom5FRkTlRzxT3NbHPEBF+8vg3cNxxx+FNb3oT9tprr2n3WVsU4l5QUFDwNGPp0qX40pe+hDPPPBNfq85Doyo0XnUHEFTyoIZDBRJeZcfSqu05BxB+9CwpDEyFSqpOcD9illRC8o3V0dLit+V9EtKuDcbqAUZ0gx6r7ja9BgDe+qPRtxUGtnLKvyft/SaddGtJpaRdqNxQANVReQ5Fh6QinafhsOLNx2Fyr9Em4WyHYfuNV/clmWfyrfJOFGjdhmybxJIjyT4AgvKqMe9K8TI47xpxHyi49vF5puMUGXHvGmC0/Pfc5b6Pg53CAmTW4JxrgJgeQyJBhv/SdJmkYmm4HqGqBz86xCTVjLjzMknMSezbaqBqLV8jtTbsn1lf5HElurLVJVnnCae1j0Jkcuxz02FcsSz3b0FDafcNIhUrlDqVHWEyaZwsGj870i3JOkJ/yrkk0lrjYh7j/mFehLxEMcDkJ0nK+OSrSo6n/P/3KsBwO4xIm6mAagA/YZVADaCVgg4kXQEqEvXQBKWgvNeNTND1p564Lu/RGk5gVVBYuHAhLrzwQtxxxx1rtM/aohD3goKCgqcZZ599Nvbbbz+cvdHZGLM1Gm2Dv72hKiG/AJLPuRKvOoi7JPOWFHradJJ7IxR2YzXr8aiUs7bw/kzwR7SBVhYjlcGIbjCjGmBUN97+UmHS1mhIY9LU6NsKDVXoG0faB6bCwOqgtFu253C11xD3mMm4CjFbHkiJun/NOVDiOxfH4V/qkO5C8F7c5Cc+O5g4jlTN+XBScffNI7Fv4pEX2eTkiXdC5K1y1yO83woAWQpqKF9KS+0epn7ny3LiLq5pKDUJAx93DWTE4AGxXWsKmfyi8vvk1/Mgyb0nP2E15qmzqh73gSPgDSvm4lw5YRcqa0LYgyIvpeJ0+ym97clF6DXzqQMJUYfi1JcOss756Tp61qNliAcjcIk5iqCUhfYMPzbbfWGZvPPk63C5nnRbJQas/ilVPichzH+QpD0vFCa/l9nXRPlHOhr+fNoNAvhcYY6DiqSe+05VBKoB1VSgxsdGcmQkb+OVd1TROhOeqJA7oaqmuY/h6YZuL5OwhPOXnYLTTjsNb33rW/HRj34Um2+++fDj/gEoxL2goKDgaYS1Fueeey6OOeYY3F1fg9oa9G2NgVfda7JBqWYizaRbe4ajQ7h4RG6V0d5+Y8WvZS32s17J1/C+c6+WW1KeoFNru1ob9JTFaNUEmwwANLbCgHQg7ROmdtdkKvStJ+/CGsMJMsZoUfVV/MJz/AqTdmmD8ap6EldJKkZHAoIM848uifdxfagYS1k1WKGuJ8u5iYKoR/KakuF0sh1AFtDGZ2SrGJcHVjT5+N7fKwktW0qCHWgKdBJq0UaJKe0zXU8U/HWk5+AGykZM3UbeJn+a4Zaxyk7B9+76iMR98QQdQKKwS3U9abiKE02t8LLz/vI1J/LDJqQCSDLAc9tLTtYzJT1pG4BQtdQT9oSos49ds/2FJwmrYAmKSTmuPYrcZF4L6/NYVPj/hyPGbuKp85qT6xood0gm5Ep8r6cY8OUWKn6yRRq46yMnYenSpTj99NPx0EMPYcWKFVixYgUmJiYwY8YMzJw5E7NmzcIuu+yCl770pdh5552htcZuH/4XdzvgrlVrCrYfN+8BoMap7q4N2ltuXD+r2kLVGmqgXd6771flbTNuojV/oeW9F/9vlXMP8sGpX3fhg/+OVatW4Zvf/CYWLFiAsbExfOITn8Bb3/pW/LFQiHtBQUHB04iTTz4ZDzzwAO7d6xKM6lnpSgs00Ki1hc1IglTRmWwzga+GLJfrACRk25F0HbblgYIhhYo996FZKhy/1gajukEFiwFVWG1GsNr0MGkjYR+msg9MFQg7WeVjLVVqB+bZnhW5PyCQdhUUdpai4Z88+AJSiITfradI4ImiJcaq4JtXBoD08bKf3hPq4CuH4KP++C2FmwmOb5tUM5mja8DbFzxJ5Vl3Iqkm2oCQKJyq4TfZiSldHol16oGPPmNWa+XgB2sEZeTxmHSu2b7hGPkgSTyJkLGPquF1FAg7gEiWWXkHhk42defwZLZjWXK8FomfgrTDE/RKyQXuNS+A1KWoSwIvvOyOqItUmCxrnf3qciJoHpMpJ+9Cu+++snDJTH7gCM5q1zzo9eNb+V7Bqe9T3V/x70ASdgLh2we8BG9+85vxgx/8AIcccggWLFiAjTbaCFtvvTXGxsYwMTGB8fFxPPHEEzj99NNx4oknotfrYb/99sOhu+yCwWCAiYkJTE5OYsaMGdhggw2wwQYbYNNNN8W2226LTTfdFLNnz8br//pU1CMjqOsK1hB0o6EHFmpgoWtH3NXAkfjgfR9E60y4vxwd2b7R4CcoRBafv+QEXH311Vi8eDH23HNP3HTTTdhtt93wuc99Dq9//etRVbmh8amFms6rNX/+fLr//vv/qI0oKCgoeK7DWotPfepT+NKXvoRf/OIXOH3iA5iwPQzIWUz6tnYTRFn59nTR+B8SJuC1stDKoucJt1YuraVCTG3h94xK2UDEe8qgUo50SxjSGHibjlaEnmdojszr5FgDb4uZtL1A2vu2woTptUh7v6lgLSvtXmVnewwQLDIhhQVIlfJANBBIh+IoFv+EAJ78dx3DZTn7PwvvYxeRkqx4exuA5u0yctkJqUp7os7NTiakis9hTCXU+KAuJ4MHQcAoOyalinw4p+i6rsmmnELTaV2g7Jo7rn2oL36Ioj8dcpVdh35wKroWBYA4TQaWYpyjzF7v8K2H83Qtz+0w8lVOWEQk7ckEUok8NjAn5F5JT1R1tsPAD4AqT+pF5rqzJ4nl2uenZ9VI+XxKPpUICnwc8DDxDz73LM4xSYnx3vUwmVQmC6mUpLN17PaT/hq/+93vcNFFF+GUU07BkiVLcPzxx+OEE07AggULpv0+NE2DG2+8EVdeeSXuvPNOjI2NYWxsDKOjo5iYmMCjjz6KRx99FMuWLcPdd9+N3//+91i1alXYv9frYfbs2dhhhx2wxx57YI899sCee+6JefPmYdasWZg5cyZGRkZw+M4fgxo0rvqtvPfGOP87KwleVf/hvV/AqaeeijPPPBO//OUvAQAvfvGLse+++2LffffFfvvth/nz56/R5NU1hVJqKRHN71xXiHtBQUHBHx+f+tSn8Hd/93e47rrrcNWM92PcjnjS7sj7wFYwiHYVg7bMVcF5z5l852RcK4sKFF4Z7jMTfcKIagIZr5QNpN2dX4PT3fm9FcTdkMa4ZZW916m2Txpnk2l8ISlJ3FuFlhDJO8AKukMg7FkRp7QAlYocTQ4AeLmY7KoaT9o5C56JdCCQqu25HvZbLAk778PCd34MXib2lZP/mKhDklcm74Gwp973RFml9jnVkN/2dlqNZPjUJuf5ACQ7dlJh9ckQd7jr0ANJ2qP9I1Q5NT53vbGBqMdYxzZZz68rTmLNrREdpH3YJFXpUc/XMfLEl9yzrpS3bag4yZSVdmltCvvFewa490zcuWppIN9aJMLkA0P//ZCZ6jwxVabKyAmnyQRWQd6porD9Fe94Kz7zmc/grLPOwrJlywAAL3rRi/De974Xb33rWzFrVvZU8SmGtRarV6/GypUrsWrVKjz++OP49a9/jeuvvx7XXXcdrr/+evz+978P21dVFew5/Lr11ltjt912C3877rgjxsbGsHLlSnzlK1/B5z//eWy00UY44YQT8LKXvQy77LLLH19Vn4K4F6tMQUFBwR8BRIQbbrgB5557Ls4991zcdNNNOPnkk/GrmSegIo0xNUAFl9RiSWOgK5hgV0kVbsDZVJicj6kGPdUEVb2CRaU8ofcEvRc8DWgdC3AEnEm5URoVeQKPynli5cw1Zd12vn2Viop+/srvtYoFm4i8zUcDbBixVrn4S1LuUTzFCrGA50JsD/LLyGo0hkl7h7ouPxOcNcbCW2H4LyXR0goTDqU7YhaRfW6R2fwg2W65Ms+kSnxm326IRjRxey5ok6ipHRMGmXxzNdewLT9REL4kl+lN7WuU/Nemy2Ql0nRFPObaIBBN48m7KKDUqbDLhJipYhtzm0yeGjOMtCeNE9dSVVFBz9dlSnxiheEJppUSE005LSYl5zL9xXmwgdZTETkhN2tuSHpR/nsinuJw0bAwoVTktoc/eS62bIlBIQFx0KeAt6x8DNtuuy1e9apX4Tvf+Q623357bL755qjrp49aaq0xa9asZICw55574s1vfnO8FGsxPj6O8fFxrFq1KvyNj49j5cqVWLJkCW6++WaccsopuOWWW7Bq1SosWLAAy5cvx7bbbov/+I//wJFHHgn9BxRkeipRiHtBQUHBU4RHHnkEl156KX7yk5/goosuwiOPPILXvva1+NjHPoZ7t/sKZqx3LR4zMxMlm8kw4Mg0E/AxPUBPGfRUA0Co6rAY0wOMKAON9Je7yn/JPdw5dErW4YogxeU6KP02KPCxjQOqwqCCk21qbWChwsTWEe3aSuSKOQGRxBtLMFbBKA2ryavu7k97oimt2sp72q1VsMFeowDbMRGVX+WykFID72mPnwNU+jlUAWUSkxGnqFJTa185wTWk1iiXrKFEO1hhd8Q0xk/qBiEaDwCsUnECbqbkp0k1TOwpnsOvI3Ie5oTwGxWsKAouK11eX3LNcrCRDQwSq4nO2GUXsuSOdMJjJO9Rcc8KJVlhi2GvuiDsqsv6It9Pp7InjZMKuphcWsX3lCvr/F541fPX4FevBEmvdWo30sqr3VkxI/C9pjDPgCufyntGyqnlViN815RV7hIJkXgLhV1WwuX0oOSzXObP9d1XvAwHHnggFi5ciP3226/jhj97oLXG7NmzMXv27Gm3JSLcf//9uPnmmzE2NoaXv/zlT6kF5qlAIe4FBQUFTxJEhGuvvRbnnXceLrroIlxzzTXYZZddcNhhh+G//uu/8MuNPwOMrMSddDoGtAGeGMRfYia/TJgZ7C8fUOWIu26cMq+M97YbwAJW6YTYAwhKPZNxd/xodZFkvU91QtQjoVcY2Npls1OVeN/j9qK9INTKwngSb8kANVBZGyImG29p4YqprrpqrBQr7TGWXP60y3fXkbQbBTI6pMCkpJlfI3FnchtSY9jHzlCOtyntd5cDAEFu8sQUR7YoVaoDAXXnTNJfFIS3Hm7CpfKTYuGyrHk+biBq4fIywiA89G1vfE7mKbH+hH0SQkcg4aUP1hvRldKqE/o2EF6EPPFcaU+2CZ0n1GJ+ywo7kBD1cAyiOAmVKBRL6oxyzM8zbNJp0qfdg91WdCPbXKqMyPN670NvkfWKFXYVqpXGz0gKIoXvnlDDra94Gu1SKlqKgGB1sT6jnYR/HYB4ukNhwmmY6xCsL+KPv4cZcYci3PG3J2FiYgKnnHIKXvnKV+KTn/zks560ry2UUthyyy2x5ZZbPtNNGYpC3AsKCp5XWLZsGe677z4sWLAAG2644ZM6xj333IPvfve7OO200/DAAw/giCOOwHve8x687rMVxjaejQn7a1xOd2Fg52AwqDCgKkQmSr94ntfOiTC9MAHVBCLf08YTdYOeGsOoV+THVB8jfjmjS1XvUx389Lnan6v+lhxpZ8LeUJVMnM3bDAA9ZVFVrihTY6tQ/ImjLRvyVVJF7GRO2A0p9Jsa/caxDvIkPlHTJbqWU/bH8AREAY50SzG7ZUdQnrhTJO86rofmP3LJN14ZD/56BShNjic2nv1wQo10WGSEPbmUISJ2IOAN4uRaSLIeVdaEyJMYJJDy6S3Kk3//quBVbcQUF361iGq7sMu0/O55XwoS3fbPO+ItrS9JoSS5nZXbCMVdbsPICXv+XmKqiaVAe3KpzFcXk0rDabh6KRN2X8XU9nRK1nVK0NNJvqmNhZ8AcXwpD9Skbz0n7TzhFPDkXT4RapHyOFCNhZgoKvEKuOwtb8Df/M3f4Gtf+xo22WQTXHzxxXjpS1/a3acFf1SUyakFBQXPedx33334wQ9+gO9///u48sorMWfOHDzyyCOYO3cuFixYEEj8yMjI0L9er4cVK1bgnHPOwS9/+Uscfvjh2OwVt2OHl28KGhlLEmL4ddLWMeNcVBblKEYJTofhP5keE/LT9SBMTmU7zageYEwNgrWmy/4yoBoTnrhzOxurxWTYNOeZYyFl22X1VpkTH9tPrevhJBwm/en1x/NyEs1k4ye3Dmo0ieKuXWoM22U8gWkp70Ak86y627hseCoKtYkys+ia2vnpnnBzZKWqLFRFYRItR1zaRjvizhNieVKsySwzmcrdsqsExVyo9n6/JIDH227yxBqdnQfkPM+udLwvcmNk/CIC0WVbTDpJ1qvgxk8aDccdwifYsy7tLbmqPkUqDBAV5pZ6Ph1hz7EmtoeuCaaigqnMWGfbDFU6SW/hCEfLsY4htaWDtHd8Ti0rIvqR70O4T/57wP72kBATiXi8D7If2gMD/p7f8bEP4JprrsGPfvQj3HLLLbj99ttx99134/DDD8f//t//G4cccsizzj7yXEOZnFpQUPC8w9133x3I+rXXXouDDjoIb3rTm3DWWWfh1Ef+ChMrBnj8/pV4qf0A7rrrLjz++OPo9/tYsWIFBoMB+v1+8jc5OYmqqvDnf/7nePMX+qg2eBzjdmustj1XdMj2AlF3pN2p7H3/yopzojKLfHQAoYppJO9Oca+1Ra0senrEv7rKpTN1H6O6h0k9wLg1GNUDd9zMo87quYxx5CqnAzGgAFICLqu58nveRubK8zXIwUetFKANKkUY1QZaDQKR53NyhVVW3422jqey0s5QBKt0JLQWIDFzjieyBpC31ghvu5JhIQrOh96lcEsWzVYQSdzFMdzyuE4B0JUFWfcUQ4nzOOXevQaCXXnFXNgRwnuh8Duy7lVyDahKxcmD/CSBVXhPiDUn0xgFy6k1TLyN28+RL/Lk07tD+Dis5hKcT957z111V0SLv9KO2LNSLgk5kJLwYWSdt5Ov3M3DvOvDMGwbGc3In6faVuatdxH2zArjqo2qSN65amdeZVN8vdiWEpJcQoKL6vadi0Ea27+S+Qdoq+n8XRpK4DVgve3r/D97Lb797W9ju+22w8MPP4yjjjoKL3/5y/Hud78bf/Inf4Ittthiut4veBpQFPeCgoLnBPr9Pq644gpccMEFuOCCC3D33XfjkEMOwbHHHourtrkAoxuMJcWH2ILCuec9baBBrTSWSkXbypgaQCuCJYVxO+rIOtUYNyNBYe/bOhBSqbIb6xRnY9t2EwYnsfB7VrUrbYMKP1I1GNEGM6oBRnXj1Xj3N6qbJH+dybq0vVjSgbTLdvZtBeMrrSjBBIhUaHdjtesvbTvb6AYYJgw0+EkBv3I/Gmj0bY3VxsVJTjQ99G2MkeSiTf3Gtcn53VUa/+hV7ziRNVZTJYKLnWw0yCifLqOCeh07HJF457eEgFD3vStMggcMms/tB16Vi6wMmfXcBn460Li2qCbaauLERIptAhw5MwpoXLVIZXhDcR2sxAr7jNsWifLOy4I3PouiDOXljVxPMQc8fJbrxGRSY4PnPE19kV0mSHyXD30qLzo6SHwyKGir9C27Cy+Tk0uzY7cmnQ5LhWE7DBdDYq863z5f/Ch4yjVCdCN5P3rwpQeFXLXV8szOIgeQSd0AxM8UFHQI/zqlqn2WrnTzye/DNttsg3333Rd/8Rd/gcMOOwxjY2Od96Hgj4+iuBcUFDzn8MQTT+AXv/gFFi5ciIULF2Lx4sWYM2cOXvva12LTd2yOF+37YqgZM/ATLAawCeyEShRiVq6BWBGUyaUEE+JR3WBc5KUPbJ2Q9tVmBJO2ClnmDVXomyp4upmwG/F+GJjAa+V0ZSbLI9o45V43aEhjteqhp024ltoTeFd5VQWveuMJPCvsXOApWFbg2tT3hZNy2uQmk+pQiLHS1v0pF2cpnxAMI+21NrFIFAysUqhV5ZJoakAbYRUyMSO5Mb4vfNXCmEYT2+dE0fjUAgCICLay3Yk0DGccbiv2cj2ydX6gAMHveD0PILS2qGtyA47KVYm1pByJ1wpotPPZA1HNJwTSrjTFpwZetbW1V4gzC41T5L0NB4CqCFTDx0uqYMexNYJlhpfLDHtnlVGeuCtH4n1peR4UhHxxEmk0ROmYx6bvVU7Gp4tklBNYbdc9yYi+zb4IjLxMvUh/aVUuhVCkeVmYjDo1YU8qmfLXlkTfAlEx9xNNJbGWqTCJdYbV94qf1lCa+sP3PpB2MTAN56PWcYH4NIXbd/fJJ+GUU07BzJkz8f3vf/9ZE3tY0I1C3AsKCtYZ9Pt9XHDBBfjWt76FCy64AFtuuSUOPPBAvO1tb8OM92yGGVtuiIeoh5m0Gx61GjQRK5BKolwrG1Rs/jxSNcitH7VXttmzLiuT9rSJKS4UveKN1WjI+bUb0hgYntgZ01SsJ+45LeEWMnGP6rsjywNdoWcNJnWNqnEK94huMFI568yoNrC6waQnT+xV79s6EPe+cYOLLtsOW1QGpsKgqUIbebtaW+jKhrZWnqTzKz8V6FLaW5VdKybpvdgG0miUhdUKldUgr+wrRTAqOuqJVCjmxOvlUwLHvQh17ZZxQg3ZeI1J9ru8EZKFkiv2JCu3um0o2dStJ1SVI+1V5QtlVcZ9H5oKTaOhWFXt8XUha3dkYtY6pZ5qJ7WSJGbS4y8tMxWr587PbzUBFYI3Ht5SYxVCugyTTKsVUAHUEPQAIQveglwKjoIn606FDxNtvd2GJ606dd6mnvbQ0eFGp8umIu1rkhrDkIRcWmG6CHuXdYYP7yedSmsMe9ZJD/etW//KE4jDZF7EMSDpVJnn7x8/ASG+L9Y3yaceMZF3thcx2AOTdoqfeZXYVuoE5M99zwc+iEceeQQf+9jHcMopp+Dss88upH0dQCHuBQUFz2pYa3Httdfi29/+Ns444wysv/76ePvb3w7ztlGMbrEhHjU1vmdugaF5WD3plGGpaktyylAq2k8qFW0ejErZQIYbW2G192pLZZ4tKkG9Rswzb7wthkm7ERVEg8qdEU9+1dpZcZSihMg7R4KPSrQavco/LVAValFUxwrmKb3kE6YOTwEG3hYz6OgjS8pNDCVv9fBtrCobBj/8NCBH1zI36dVFUealxHvKwGpOq9EYqZowgLCVcW4VUt6xYIOVJ5Lk9HzcZ3LgoxWAHmCsT7gJFVyZuItc+MwnL9Gq6OrbobX8c9+jShPqyn1nGqsxqAyaumr1tSTt/CSBBxidKTrs2ffkHJwsEmwvKrXAcOqMzHs3wv/u12lvf+EiUHnhHle9FH6iK09KJajGesuMi2gMlU27bCyxI6d83+lpnyodJiPjqQWmQ3GX0Y5KpTYoWdVUFEpK7DBaJYQ9rT7qXv1Xw+f2p+3NK9cG1R2ICrroujA/wwKq8o4vb30B7ystScL7HrrAH/+e/30Srr76avzsZz/Dtddei23+bRv85je/wR577IGrr74aO++8Mwqe/SjEvaCgYK2xatUq3Hbbbbjllltw880345ZbbsFDDz2EzTffHFtssQXmzZuHvfbaCwcddBDWX3/9tT7+73//e1x88cW48MILcdFFF2H16tU49thj8ZJ/2htzdp+HW/EAVLMJnujXIY3EkEJjqpAPLiMHc1uFe/WVPb21QXv1s+cJ18AaTKo68ZfX2gSVm8k7AJe+YmN0Ysg8J4WBqdAYHUgj+6+JAGui6s1qqyw+pLWFUoBVBE3OKgIAqAy01ahVtMQ0tnLXQjHNRUKrqMgBCE8AeEBhBKmkQNpd37FnWylH6iUa5VTWhjS01dAVOSKuyCfnWAAVNBEaVOhCsCx5m5IGobKOBA+0xSBYday/t20izfdP2owq8ZkHdDb7nvB1M5Hne8OdFe4PxBMQTWGQxTYmrhLbqwx6Oj6F4AHcwJrkiQs/8eBBhLPziMx6JunCH88pOTETXuTTB9U2FnXKPezpthSLP4XtSRB24WXPSbvwtzN5dxVqrVDcqU2yp/jcUtines9g/3lui8khvepM1uV7oc5TpUG9yifC6FgkidNdfHEknkTKRYy6klySGEZ5KRy7GP5n5P6ChSZX5Bmswlt+esD1BISszxOI/bnvOeEDuOqqq/C9730PW2+9NVasWIFXvepV2GefffCe97wHe+21F+bOnTu87wqedSjEvaCgYEosX74cV155Ja6++upA0u+55x5ssMEG2G233bDrrrviiCOOwAr9j1jPHo+lS5fizjvvxGmnnYZ77rkH++67L4466igceuih2GKLLbDRRhthZGQkHJ+IcO+992LRokVYuHAhFi1ahNtuuw177rknDjvsMJx11lk4c+w/0NcG65utMGkrTJieiw60XkH2RKzx/mxWioO3WSKo21HhlkR50FSBhLGXuxde2cPdC6Rdxhqy2s6KtrE6kHZuE1FUeblyKFnXIPZLOwcCwWoV2kia2tYa5Yhw8JiTCmRZRjmGibJMFv0fg9V1Juvw67kdyM7MxDnPY3fKuQ0WHUBDk0KD+CTAhDam9iVGrSzquo8xHxPZ1OlcgfR86bwFmcpTKRv89lrZVpa8LArFiTm5jalLHWeLUOW/N/L7wQM8nrzL3wGebCu/C8G+40k6e/DDpFjOYffkfWihJU6caZAuD6o7IgFvkfe4LsRDmritjB10BN3NReBM97C+EYq7JO1TEO+Wf31NCHuYbOq+PyFXXa7LoVmJ15Gwy1QYkT2vLPk0GCbpHQp7rYL3nK0x6SRQN+G0NYlU8OvgXQ++eiC3s4R8f52+xghHjil1yvu9f3UyrLX4zW9+g1tvvRW33norbrnlFmy11VYYHx/HMcccg69+9at45Stfmfz/t2DdQ0mVKSh4nmJ8fBy/+tWv8Jvf/AbLly/Hww8/jImJCe9nVXj44YdxxRVX4Pbbb8eOO+6I/fffH7vvvjsmN/oCXrjDKOZs0gOpqKAauLzwPsVljz4wid7t78ePfvQjLFq0CI899hgAYM6cOdh4442x8cYbY+nSpVi2bBn23ntvHHDAAVi97Y+x6R6bQK+/HsbtiEse4VfTQ9844s5KO5Oi3AoxzNMckNs9Ann3hMz7lLW26FWOjCk4n7dSlJBHBhM+qepKosakWLaJ88ldG1h5B5RXcxEGFwj+6V5l0KucnWdGPUCvMhirBhirmqBeT5o6EFX2tPOAIq9g6tqq0TQiN50QVX/t+qOqPDmtTEtd7mmDkcqECaqcNpNMgs0GOdxnfB94nzzTXvZvPuhwy3VU65WLz8xtTQBCHj2n6XC/yMSfxupwD3NUop05UR/RBrV21qm+dek4k8Z9P7moFPexaaq0Giwr60zMM4IOqzIirhISnqyTy1k1N4g574maDufDFgSeU2SCAs/KOme3E+9D0RpjTDdpf7JkvQt5RKNY1opcFOuDX712iruttUt7YVLOxJ2QFpwCYCsN2/OEvSeIew3xyiRcRDr65SKxNN7L3CaTxTcm42QFkKZ4Dl8QjCpy8xG82n75q9+Ij3zkIzjvvPPQNA122GEH7LLLLthll12w//7745WvfCV6vR4K1h2UVJmCgucx+v0+brnlFlx22WVYtGgRlixZgmXLlmHZsmXYZJNNsP3222OTTTbBw/UVGBtD+MGdPVvh9R+YgR323Bmz547A0A0wuBGWNocFsJytB77YD+B8zDF6UKO3sUGzyek44kCDY9QusP0G448NsPqxCUw81sfKRx7AenNHsOBPdkZvxgATtAgTdiOssCNYabzdxFf/NELVZQR1VTtFtVIEaAsi7TzZihVtFUMUhKfZZBmASpPLvNYuvcRWClprDIyzXeQxia49mRcaUUnPbRCJbYfEcXwbHbtSPmIwttcSRx1qb1vRsN4L35CGsoS+qkNUpQUryTHmsS987dKywVYREu0hgosw1AQLDQ3Xl4AGKut9784Ck/eB86ynnnsmx5LEU0bA2dLCpLsrXnKkasJcA64yK1EJ4g8gJOz0fBpQyLGveiFr35L2TyRihdeu+8ptrMMAwYYBCqf6DGyFCVOH65bH0YpgEJ/0BElWELVA2hsV7TCBvKcpMZ1xjmEdiQQZQcpzQp8o8WnMY7TTUCTqHP1ISBT2zmqnAlMS9q7PYUeVvB86uZQnn8rtp5tc6v8cYVaRtGeTStmuogz8xFEK3nVlRQ6/jGD0RDypXkpIJxL7p2uxUilSoo94PGgKlU1RE37z3g/hwQcfxP/8z//gggsuwC4n/h8cd9xxWLx4MXbcccdC0p/jKMS9oOBZBiLC/fffj/HxcRARHnroITzwwAN44IEH8Pjjj0Nrnfz1+308/PDDeOSRR/Dwww+H948//jieeOIJTExMYL311sMBBxyAgw46CKMH3IN9N9kKszfdCetvOgZXhKWPnt4TlSc9oTKn6sMCeKgZwaSvuAkgEN6Bjf8LiVaISN45faWnfEa6bjC2UYP1Nm4w15MpAJgAMCE4mItgHCT9whMYa20iAcyUNqMc+ZEe76CCizxwaypYX5hHTkokq1z1S6pAlmCNDko8q+z8Ggl4Rtylmu5JGVE8V4ujhHUAoEAVV990n0N5TPbgivOxMiwHEVZ1k/aBqaK6HDz3wsvulebgrw7tp8QDrpRCA40a8BYUZ6lxnn7togeVCp8DaZd+ctFmd0wK8ZJECr3KQLG6Dh4kOLCSzpn1o7oJmfyV8qRfkGsA4Xvtcu1djOeE7bmnED4uE0CoFjsV5IAhLyg1LOIzTCwW/FYxeRMTbKl2pN1dsh/EsVrLxI8tLh2vEuT5bBjnkhLnUikJ9UkmuvEDCpv62R1ZT/PZ84JL8cTTKOdd69ljLl/lOiAl7X5yaTLBNPvsiLpOCXuwvkSverxl0YueknjRFCIQxL9Xvw3peI9aV6ecYs7pMP5UkbwDjphXTl1P90WSDPOb//Uh/PSnP8Vhhx2GSy+9FHvvvTeOOOII/MM//AN22223qfu94DmDQtwLCp4mNE2D3/3ud7jzzjuxevVqWGthrQURoWka3H777bjqqqtw9dVX45FHHsHo6CiICC94wQuw+eabY/PNN8eGG24IIgr7WmtR1zU22mgj3LHeDRibN4I5c0ax2QbzMLreNhiZVWNkVg8zNhhFrwYexHV4AbYHAExC48FBVAM5ro/J0JgeYKZ2ys2AKozbkVAddCDsMKlVRAd/c2MrdzyRLz6qm4TIS4LF5KoCoacajKkGlSYY0jDQsJUK22rjMsPZ6tATnuWg6CJ6jI1VGHjSzWTYcQRPTq2OzMcqX+2yg4RlZL2VCU7Zttw3XVxGye3gyEdF8bSs9Ok4sBgGWbSJJ6qGhBtKk3ZynzV55Z0tOyHRRFHSRJWdL42rTNsnrScDq8MchHwSLNtuet4WxBGKrjKss57wa1chp64Um5y0MyxpVCBUeoAxDDC7moAl97TIfWd1KFJlEEk4Z+G7CrTaK/Tup5P9+mxJYtLPHnuOtRypDbRyyxtNMJrQNAQoDct1c3mQxxVWNaL1RTtSqSr2nqtEaZeqfJigauUySpcHywwr9VFhDtYZr7KDBGnPE2MsMGUV1BxTkfqOWMawWwdp5/QXaYeBz10nzl+v/ATTWqjs2eTSVuEt14g4WGL1PefUgrTzkwqIfuf7ByhnGWPyXpNvA4VUGPI+dffloTDAIiLc9qb/jVWrVuGnP/0p9t57b/z2t7/FCSecgFNPPRWbb7758P4seM6iEPeCgrWEtRarVq3CxMQEmqbBvffei1tvvRXLly8H4P5n+8ADD+COO+7AkiVL8Nhjj+GJJ57A+Pg4tNbYZpttMHv2bGitoZQKr9tttx1+s+3j2OF1L8fs7TZBNVontoKVAFb6NrClgJNOVqlxbKVewhQAQHw0P6ksGiIgFbBDCgpv68iQxWjV+EzwBuN6BBoUcszz6qDW/yjJiqRMGNm7PKINRqsGM6oBJm0v8SLn2d5M6vlPK4v1qgn0lMFM3cdkNenb0AsTL117KvS9b1l635moGmFbyRECJQw/bgccuecb7l8lCe/iH0PU1qHbe9XNdYZnCfwntxHt1N5zr0UBpGjXYB+3jvYUcS94ABNjHlUoDBRIO/uts5zozqZLXzr/gYLKLqMw88EC4OIltS9CxOk+7prYghIjOhtbwSrts/RtLOiUeeKZzMvvEBC/+jmp12LiKoDwpGhAVTK510IFVZ3nDEi/PYnvveyTWlnUvb6L5FTkJhP7wkVu8GKBGn5CpHZfIcNKPLxyjKiyB787BQU+vLZ88C53XTWAboQVhIl6SJMhX2yJoPyrNhaq8dVQpR1mqnz2fEJqV7zj2kLaY7QGKp1OMpUJMVXcNqjqWgULS4BsjrC4sGWmTeTjgJz7UK4Kr1JB54GUeKiXHI6V9JqAisK/t5tf///hG9/4Bi644AJcddVVWLFiBWa/82MAgG233RYnnXQSjj/+eMycOfPJ9mjBcwCFuBcUdGAwGODaa6/FZZddhssvvxy33XYbVq5ciZUrV2L16tXJtptuuil22mknbLbZZt524pa97nWvw1dXXoItZs/A/JmjqGaOoJ49A3rE/bPLJzjeB2ADbAkAWEHK+UcwlDuFiZKVmAiYrJeESsUMco4s5CQN+OOwh3jS1qEap1Y2kKOBVxrlxL6+iQojX4cRBKanDcYqV+XTiF8vJkpMwliZH/H2h54yCYkf8yrpmK686u/aOal64bzWW2jcBQGV1RgoQqVd5KEjm0DTeHWZeXh47C0egUupWSIj72o6Rb2lwLvlXNHQdYL/4c7rniiECaraTwzlCbOViCGsBMHtm1j0SSre/aaeWmn36SY8eEmvWTSJOZSiUBSKvf+1cpN2wYMEUug3VZj4yjYlshpKWyjlffpWw1g/+DNV+A5p1Bhv4r8RRq8yYcAqC2jFpzvWV7odhCc8/G9jQJWz05AOJJ6V9jgw7R4U5ok0XGFW+vU5YlKmEnEsZf4VSXzuEN/DJPIxfYpDvrIq/NMijgaManm8X8nEVelvZz9843zwekCBvKuctDfWTUg1xg8ObKqsh4Z3vKKDtCvxj04WSMrXh+v1hN0r7S3SLlX2oKxr7wv3NhjFyS8qPM1IzqEQCb7wmneNw5X4fwQ/0AmTUXsqeNpt7QcENeKEUlbbK3hrTByoEwhfnLMjdtllF8yfPx9vfvOb8bnPfQ5z587FrFmzMHv27JIEUxBQiHtBAYCJiQlcffXVuPzyy3H55ZfjyiuvxNjYGA466CAceuihePTVPdCMGaDRUaixEajRUaDXcxP3ehUmASwRP+B3kMJCLEUFV9CiISe0TRKAyfTcXQWCuiY+5raApGiPShVQOYmyq8hQ8Dt7VbznLQoTpsZIZQLJ5/353Kw2chEfl0+t3TmBxJ5SVwajlSM6TH7k5EQAwQbBAwcmWdIaMaobzNR9jOmBH0hElb7WBjMA1NoEhbRva0w0PUwYN1kTTe3JlfNja02w2pcFYq7BncWKvFTmKX0NP968TEhqySN15mXReeIWVwRFCsTP4ll5V24CqtIE5auKKl/Yp/KpNrVIkwmWEn+/ZHIM35cmyZCPSnuoyilVdibt7LMN17lmiqmFgiYkKnSwLoVJum7AoLxvXflCTHagWjGcPLCV/wZk9GJeMEsOPke0wYyqDgRebsuDQQtngWH7V2MrrDb+vRh8yicYsnAV5/Ozf58LKMlcfi7KxLUCLD+J4LkWVsM2YtDkibpLjRFZ7flTG34wwx533jZX2pmY8/smKu2stiekfWADYQ9qe8se06G25+8xjdI+xBaTFE+S1hiOcJQFkrSKRZLCBFRniYF2qS9BRQfCv8NA4j1RD5GOIqKR1+cEPnjgeYIvue1dVGRK/EN8o692GooliXsIUvj5K47DX//1X+NdV30e//zP/4y3v/3tQQAqKOhCIe4Fz1vccsstOOecc/Czn/0MV111FTbccEMcfPDBOOaYY/Av//Iv+NjD/4HVqHGBvRc9uwADrwY23nIQiMlEzHyW+dwAkKeQKDX8xywn8LEYTlw27P/n0m8sCwzxKxMHVmrZvmBJodIWfR2Jfa8yCVnXiMdmSwATQ2mDABAmKQJAzzrldcRqDHSFcbAi78iYJGDdxGsQJj+yB1kri1E9gAZhTA8StXS1GQFMD40n/iNCfZd9SqRQVY71WCFzJ+TdK8f5yhZp54tGe3s3sU1FNT1sz8fnnSmo68pXA1XaJhU5K20xUhvvB4/FfcKAyt8TmRzTlRtuhUWGfOVNcAVO4739bBPS8Z4rTzKIyHO3WATJkkLl762Fu+esREtwko+LQFRArVw7fZGpSHTddzX/95STYFlwiQn9qK+8GmwslcKANCrLyrxBozQmlU9+IYVJ2wuEve9rBPDAlLfpmjsR/n0CcVDk/02RjZn8LsLTDb60GECEJCFZaMmooLQnBZaMs7uwbSsQeUo/x4jHpOvjBFYbCXyn0p6TdjuEtHcRdz7XWlhjOok6vweiyj4kIcaKiaccyRhIdPCxy8Zx16tokwkEHv6YcMTfv7KNxl0bknkEYeBfISX+gcCTGNzHZvzmhA/ht7/9Lf7pn/4JO//1znjb296GX//619hoo43WuO8Knr8oxL3geYdHH30Uf//3f4+vf/3rOProo/GWt7wFvXdvjpF5G+ExqnCuvRNnPXgPiGYGVZpJkPNK66CucWXJOFlRrZE+OUxPGbpvpyrvjyVXiQmFYZFQbpkcAQgqqFIIiq77qwMhCq+Iin+Xkst9wtCC9HGlTRLEp1KEvh9IcBb4aNVA1/zUwCaTCydsDwNUgBmF8WS7sTq8j5Yfp8AzmHQZbQVvJjQ+kccYglWebEkFmh8fZIo6hZznDkVefObxmSI4EpfYBxCrYlYkkmc0yLpH6LpScFWZvPIMJERZk0LfVqhlHjr8tVLqZ49xlCIaMyPtYEKiPHlnf67lFB10IrdjcTGjPLkm5tf7LrIKZtIn9mgdBy5+YNmZva/SpxCaBzeKMFIboG7AP2m2UmEgUVsxAVrFOEf5vUnmSXD+un8qNfDVbXlAEv/di/8H8FwBWUzJP2axlYatLYxRqOvYnyFpqAsdCntUemPso+iaVIVnkt7E6qjKUHy1ovopk/aBFZGPQEiM6SLt0yXHrAFaeex5UgyT9Uoo65VQ1usY6Rirl0ayTl5J52JHSUEkHmcHFV4lCjnVEMfJ9uVJwVkXBDWfCby3xZBCYpe5+g1vw/ve9z7813/9F44++mhcd9112Hnnnf/g/ix4/qAQ94LnDay1+OY3v4mPfvSj2GuvvXDQN47Gyvmb4BxzKyxtjhX9aB8JkxpZPbS6Y0KfioVzggrboTLmaD17Ha6ky22SJJMuA6bclj/yZlwd1KtAzEuZXBijfLykrCSaZpfza/64X+aTx4xqG73UYoDDBY6oNqgBVNqEiY7yaYQl7Yot2RqrEDO7LU+29JMF+T2AJNtb2nz6qkalXYb3QFs0lQ6EjEvPJ4qppRAVGatZ+l96r6JPS+DFPXI8UWWjNYrb+AmHZMkTeXI56LUW5FD7fo8ed2dFMkCF4OHme2a1hbFc+bT7qyIHJqzyUiXaZdxGrE5aFaVL9rmzN70i5Z6WsO+8qd2vSxO3N16BtqqCNQAZAEaBBn5g559MmLwvfaY9V4pURCBLMMqp8HVt0W985GLNczg0BqpC35qkqBM/1QEQPOv8fWM7jHzyFSaeWo3GF02SqjrZ/HuC+Oq+gCB+slMDTeO//ySe0jHJJ+Vz3FW4ByoQxTQNJuSzi8+sdCcknhC82N5O7Y7TsIovPO2WoAYm+tqln30tyHqiovP3RajwrfXaFUSC9vGN01hhEnW9F9NhpO0lFixCJPOcpy6fSPD/vtkWw/nrTNp7gGVfOmRf84Aj/r/Z2WaoVViJfNTjXe87Ef/xH/+BHXfcEa94xStwzTXXlAjHgieFQtwLnhdYvHgx3ve+9+Ghhx7CV7/6VXxjo0tgUGGyqULGdT/zrAaiTpGsJzncQo0NZDpTaBPlbAqyTQCSlJEg2SIulMdJ2tBxXLa28DEVJe+TTTWBtHIZ6KJaJ5Pw+BqJO/tzufJjUP8rgq4Ay5MfBcHh6psytzpcAjkiziQJiAq/TEyRVTellxpAsN2wR55V4LF6gNo6D3wg7R0+cFNZf8+HDNAkQfMqNbHCSW4oFCwS3M1MnuC3VfyZvytuQEDwvnd/PPITNpUmWOt9+Vah4qIxMKi066tK22RQEJ8QxUmhXA3Vsk0lVOqM1gwmncrfFJdNrQC4pxVu/KEAo4MdXtpIqHL563zPlCLUlSfJfP3QUMr4iamehDXeY9/IoGvfV5y4odOnRioMLuGf9MSnOqayGFiNnrbuqYSwYlmyQNXAknLVd4W9SFa9ZYXdeLsXEAk3FAHeqx/aHmoCxMEcBZuEe5JiLSvC8amY8tdGoohPGOjl4H9jlH63HDmnSOR9akxrH56k6uMdwQkpFs4ak5N2w7Mv/3CFvYvMJ5NOfVVTqkX2uqxumhN2b4cJ1Uur1GPOirsN6re3vkzZRiTWGDmZ1PoJpQDcvxGiTH/xfakQMtdJAUtO/CAA4Oqrr8Y+++yDlStX4uyzz8arX/3qP6g/C57fKMS94DmN++67Dx/72Mdw7rnn4kMf+hCuP/h3+K/eT9E3vfA4XFphktSNQMpVosIFBZMJsWVLBLyCquLkxuzHvPVo3BNzSoi6fzOdUopM8eXV0qecNzpfx3zD/9goTbB+wqQKrxD7+nN4uwU1OiqEntgYwxnpCIMM5RMUWJm31hUKMlYBcMq5tnmsCkJyjlTju0gWK83s0ZcTWPNJvTJ9pEcapjKimqgja41XuF1bdbA2yAGcbVSY2EkGoa8CLVOUpIIocd/IAkq7PnKxcZ68I7VaETy5C7exnZ8uveR8DZY5YxBLeXCJ+P0UA0BSUcFlgqQ0nALfuIa6JwF+mT82aqAxsS3SWtZvqjAAzv31EIMhqVBz5VAoR5riwNQT98qGybrsd+f+kJ537hftBxW+BECYM9H4SqlhboCpMGiqYIWT910Wp3K+dESV3CuwnALD/+6VH5yRJqceW/J/ypHicCx/DDmIapSLbzSIUY5MyBtJziHsL4jFmJik82RUQe5DhVT2totqqGyLCbYurRCKQIUb/hRATDqlqopWmKxgkg3LEQsnBWVc2GB8Fnsg7ENIO7/nIket/3WKYwRoobiHJChq/X+cLOHaNx2Pu+66C3fffTfuuusu3HXXXdh///1x1113YeXKlfibv/kbfPjDH8bo6OhT048Fz1somuYf4/z58+n+++9/mppTUPDUYOXKlfjc5z6Hf/7nf8YxxxyDFccZVBtv4OIMmzqpJDkw0frBanJSnt4TH4acqJn6nxF/zI34YccQ4j7s/TDINkyxffsHiaKarzyx7xoUqK7ts/dASsplGgkhPa6iWFSostC19yX7WEOp5Mvd5KXJiYgM60kVk3duel2ZxDMvYzJZpZeQ69xxVVLhk0mwPKdpEVGvYgvlVRkFeLLFEwoT+wKQZkdreBuIJ8UVvxJQW+jaQvnJjfzXqwzqigcp6eCEE08GTRUGok2j0wQTbq+IHXQE0PdFHlvn7yN8W3TtiHNdW9S1TwWqXH/zv6emqeIgmJ/MCKU/WA6YvIvvTChOU1v//Ynn5Ime3Ad1fr/9fZUknqNNrU84MoK081OXfuOXNxrG22Jag4xk4OPvaSDdsf/il8wX3qnIDUS0+LcnEmTYLhXjGv33ZwDogQqpMI7IM3lvq+ytCMiQJCP+fA67ss7fDkvQjUUrqz23ygBTk/c1La7kfFZt0t6rkgmn7GFnVT3611VC0iEJu4x19H/B9lL773Ww0VCS9sRPmZynPQopVBFueNP/wqJFi/DLX/4Sjz32GFasWIEnnngCK1aswO9//3vcfffdePzxx7HZZpthwYIF2G677bBgwYLwt/3222POnDnD+6egIINSaikRze9aVxT3gucMrLW45pprcN555+HUU0/F1ltvjZ/+9Kf4Zv1loJmJ8QbBE80eUxOU1TjRDMF/ipS086NQQdhJqIWtx/yEkCYSHptnv+stj3T+2xeOnZH2jAjK/aRo78ihiiqSohg1lrPlwIJZnhQkXzazg/gnedP+xy6Qdn50bAHrK1I2TSXsApHEA0IdBjLPvVSPVZzg57czVkNri8ZoDCobCDyAJIKSIclurlxXilBVBqhM2D88mVGu+qX11hqjKpdHPnAsgr38gApl52U3B4+xQiiuw6qyu1cESRLdZNksAYcUjHU+do5P5KxwfmoQ+7JrlOb7Pjwh8mTR59v7aQruGQAP9ozyTwYAUgoWGsagNfBiP3iLtDcKeXJKmGDpBy3JIIEtMhVBe3uJ7EtOtuH7N6JdROaIbjqftjiF3Q3I3ETUKhngpPMcVGh3HtOYk+zw3vdZ/FK5/tfwFhv/ZIX/XSlSgEEyaOJjRPKdfnkisadA4HVC4sknx0R1HeFz/ANlaruciAokk6nXGNNFGEqlnRNi6lxlj6Td9gRxDzYY+T4uS0i6zGIX7y1PEFUIvnOqCdYr6fe+68NYvnw5brvtNixduhRLly7FkiVLcOWVV2KjEz6K7bbbDi95yUuw8cYbY8stt8R6662H9ddfH3Pnzg1kffbs2WvfbwUFa4lC3AvWaRARFi5ciO985zs4//zzMTk5ide+9rX493//d1z1wlNxpv0CjHGPJrvKo+dwCR7+cbdirs3e1riNI+TkHicT4iRVQJAw2dDu94lfXq5X6bJEFfKETvF7PlVO8gnR7hKezqsWEW+1SwwwXMqIaIAnpK392SbkGxssHxYhRzkcJzB2vy2nisgnGT6S0SWNxHW8Ptg+uDnaTbCtKu0ItSe1/Wm4xHTIzwsAWls/4IoDwGCdCNfl/7T/PkkbOm/mSZit/aUo7jXfX/4/boCiQd7nbo2GrmxITqm19R5gZyky0rdvhHrctBVvSRLh7RXQ8E9R/IDLE1aqyO3nCak09RAQ7EXunN1PIxKFv/HH9U8bXH+5PkNFULWrrKpUapGRefY8YOlVJkRkysx2OReCUWmLGv7pirYw2ltquN/Dvx+V/BsMF8rquhjshP4LgzAAypNDo5IBNFUExY+QhLoeE2Pc53BvxEA97CPSZWI2e6awB9VdpMg0/IXy5JzJu5iMysQ+qO3xHwCeNERqTKef3ZP2QNYz0h487cHugpAaI0m8TIIJqnqF5OkWDw5JE5a894P4xS9+gW9/+9vYcccdceedd2LevHmYP38+5s2bhy233BIf+chHcOCBB2KLLbZ48tdfUPAUohD3gnUSk5OTOPPMM/HFL34RS5Yswdvf/na85bObYv4eG2FQP4xfmW+gsSMhLpAhH6MruB9x4yPv5OQzRd53nivi/gcgTOIE0kmrUqGX+wHhWEkqTHgEjfa55CE41YSJulewQ5pBosBTWB7OySpqIM1t1bxF/IU1Rm4cmjmMFHsl0ZmOqb0t/4iyLcKfKxyX2x1sGhQysVtPOYAwcZF8hKK1Co3S6KtYoTbPz48Z+bFhMj0nn5DbtR8XE0omJWeJFcQDEqWCEh/uBTnSp+HJBXgA4O+1RfBHw3irBRFsbeEmeRK0VkF5Vuy9p7S9cgAg26madl54IJ/+npNve3IfeUAl+izYh2yctGzlpFNB2BOyCj+w88qwMjzgc4OEMNFPcEkS90EBYU4DE/YJ04v1FkQhJXdYFf3vijPgCVyci4hAletfW1t333ycKYzyqTaI1h7+vlpHuKUtClDJhMeg8hqV2DHCQy0/QOIBlbTBBGIfJpjy9qnCHrLZfcwjT0aFJ+/O2mN9Gykl6kZOWhWk/ckSdmGLkZVOmbjb3hR+dmGRsbWC6cFbXWJ10sQmo8TnSvR1mKxKgchDA4uOelMg67///e/x5je/GV/4whew//77Y+7cuU/uegsKniYU4l6wzsFaix133BFjY2M48cQTMeul/wkzthjjdkOM254vWV4lShvnN4/oximVXnGTHus48Y/JTsZMmbBnBXIkZNEkSQrzCEdZvAVAK1aSCWGSVhNWIj565yzuQMjce2Up7MJRckBU3hMmLS9TXo601FDH5kJk7go1dmRE5YvFoIGVSHEsSRC1AhmKJJ8PkLQR3j/sJG0DHSII8wbnT/I7n3Z4riEzw4eR987rzo6nxP1TQGqDIL4fvoMJ/klOvJ9hwqqCf3oBwCjnyGhcCo+tXFZ+YiOxIrud7TaeRCvjBlYJcRdqL3HKCeA92xTOz+0jT6pd6lLlctmFLSafcAlpBxETKakSRJeJOrl9HbfUbmJzyLXnwY97slBpJtx+QjG5Ql2yQFiYrEtpAbQgevt1SSa7nHydXIe4BqG2M+HOM77D+FzD+7qdZQN+EjDfehn1mBRRYoJOfH9YVY/bx+04MQa+qmdU29kaExT2lrIOMWmWUl97+DJ3jNQ7i0lk23Mu+1TWGM5g72VpMbWC7bEFRiTH1EgIPJPzZIIpE3YN3PP+k3Dffffh8ssvx3e+8x1se+LH8apXvQqf+tSncNRRR2FsbKzd/oKCZykKcS9Y50BE2HXXXTEYDLDdYf+KCephlR04zy1cJc2B8lVOqUJjXRVEl9tcBTKfK26wzo5APpPPhkI80RbgoujSqpacblFXskx7JANBlexITSEgSS2RxWqCUig837xTiCg07gePFUAicvYD/4OurPLL/MlYiWfrBqvEwzBMVZfrVMeGgn+3Sb8npiq+jeSdf+z5R1glA4SEELEirwA0vngRn4/EOcTxutqYDAbEwMJoCkWBAqHPD8GkMyHzWTd54hWJXbe9QmlP6uRxuJqp6GNyXhUY7fLmG1WlbZODCVLJdyXYYzxp5wmPTEYBABxJKMg6V091NaHIe+8VrA+4TmImM4Xd2T5UUJD5mnnehVRDmXw5qwwB2vnbtbaoahusMlpHmwwAN+G06SWTinlC8cBU8d+V7CaFUMQppPT4f//aJ+igosxB5tJ/4mBL+f7yayUJJ6QDUw2QAZRIR4n3KSXtSYqM97TnpF6RUNv9vAmZ596y3w0h7S1rzNoo7LLaaV4F1b86wi0movoY0IS0e0+79LMHdZ1TYpioy5SYSkw4ZdVdEX75F8fjmmuuweLFi7F48WJs/v8+h+XLl+NFL3oR3vCGN+Ab3/gG5s2bt+bXWVDwLEIh7gXrHKqqwj/+4z/iNa95DSZoCwyohiV+LB7JcSy8Mv0PUWqT8FYJ9jLL/RUNJe0jdRPSLQAkGeNM6CVkdB7nRfM+UrGnjLhzPB3nQscVrK4KxdYr8+ERvCAIJCfVCXUvYKpu82S6i7PL/aU3v2s5BYVbHI9PIAYGKbn3/ckDFs6s1vH4nc3Jno4oSdjzfYJaR4EMsGe9EzIClNsqrjdRToPCjPgEhLdhW4pGokAr8oTRk2/Oxe6aPJxYnJg98uCAIwfZz54RxdB4tnIo/p7ErHF4zzbxvzW2LmUKu+YBgTg+p644kp6Od0K/iUGW4gqpVSTtI7UJmf2AGxAPq+Yr4xxDSgzisbmPFOL/A+LkZ/HvLoyh3ROQ8CQr/HtSkVALm4vbB0jIu7xf8vqTSakZYRdqPCiS9fC98aRch8mn8vsXlfg1ssYk96PjH3eeyS4TYyAG39otC572Sg31s9uegump1MsuK6BWCDYYm1tgvN3urg99AD//+c9xyimnYNOPfBRbb7019tlnH7zyla/ERz/6Uey5556YOXNm+3oKCtYxFOJesE5i9erVaJoGL55xES5ZeQwGVMFAw8A9Kmdoz4zcaxViAbk0uxU/0gy2yzgbDInlcT2TdlnFsuczxEerBiO6ccWAVJpW4pItfKKFj6XraVcwJhSy8Yq9fJRvva2Hj8EVSQFHNEJBJE+ieIInl7YnWbmQmFyRJ3KIk10lkZdjlrQrwD772DnZDRLbJxP2gHQcJHfpGgB477sSZMcRHwVqeJlK18mTJMdUbffTMOKuPGHQ5OIZWQnO1OwEVgwGJCEX69m7zkRMm0jkyJN6avW1cmppNlKK/vP8glQY4AQSnNUVCFYmnichyCKR5+JebeenBVxcijTcHAa+rx3edZ7AGXza7KEHwuTCpMR8SJShJFEGQHgSZbzXfLIBaq1gtA4DYs7e74rq5CdUSYwjRP9wl+bfP7ai2fb1pQMSFUm3GAQ7PzmgZXGerkQnhUC+W8q7VNitVN19iowl72sHVGOD7x3kPxsf9ZgTdfk+R07WtWovy7bNyTqvC2S98sTdV0B1/nZElb2OTyHCRNNadVtihNJ+59+chLvuugunn346dtppJyxfvhx/9Vd/hdtvvx3bbrttd5sLCtZxFOJesE7iwAMPxFFHHYV3vOMd+MlPfoF/+fWrg7d9wvYwaevwxxYZJuuGdJi0x4/UAafQE+BJu2MZ0uoiiTsX/JGkvfIVGrVyhYBGtMGMaoCeNtAg354KfVtjRMdJc0zk+VxErmQ7t6kReeIAgh0Avv2N0aFwDBMcWfUzEHlPtMi4R9U88dGp8fzKSp8j8iyyIiclgPDLDwE/bZBEVJL2jDO0SLwn6EosC/aDrgNk+yWFVLITkPzcxUlYEff2hjDRVhw0v35pRwrN8/0Z1OcmEvbQp5XgT8Ttd+914wddqmPQIUhg0ifiukIeerjoNqRSrKy7RGUADWezsgRndbGOdIPia9JXjS8elEyo9NfM6vOw6pX8VCEMbghkKKiq0Bq2IhivvhufMiMniPPk2JCiMyzOMR8Yyf6STzBa8zY6/kS3J8eTf8n9FgNole3P96BF0gFQRtobCraYMBk1pMOQI+0i5jFmsos2hNnS/lWjW3W3lBJypO+J9/W2mUDik8JKHfnsPRW861ZaYxIbTPrKhP26978L3/rWt7Dffvvhuuuuw+GHH45PfOITOOqoozBjxoz2NRQUPIdQiHvBOgmlFL785S9j9913x2mnnQa8GG5SGlUJae/bGpPGFVxqsgmrCvC2Fh2qeytSqLTt5Dj8U8Xl3JVy+dmp0m4wVg8wohuMaoNR3WBG1UdPGee9Z8+9J4CNde1tau0qeWrj7DM2ezogGI98UsDFZHgiXmN0sNywKh8mKfr3CKTdEXVW5WHg1NOgDjrSZDUThkh6FKIynKvywbOdE/2cvA8hkqGvMxU04dmSeQu1XWUbSlVVWhaU/Cz3Ec3Svj9iM5XcLBCtxH9v5XXGPmglg5hIkkOfBdLsyFS8FqGg553UGowIMq8pToBUcSPpr8/vgbJA1fdEyQBUO2XZ1uT5uSBslfv3IjPgw3F5mSgYBD9nldhDb5gfK3cuDe//JjeR0w86uBiVJQvU7t8N+9WHTjiWnRLuAT8dQLDsxAv33xGeU+EnxDKRJ0VQlbcr+ax9ZZQPTSGXXqr8UwbfBc5uB2ilYBWr4uJ7wEp8PH34LoT0mEDOkeSwa2+HyTPZWxNOqeMzd1SuuHeR9rxzc8IO+AhPHQk80E6N6enoZQ92mKywUiDoKiPq7rtx09+9D1dffTV++MMfYv78+ViwYAHe9a534dhjjy1JMAXPKxTiXrDOYs6cOXjb296GhQsXYqcXAz3dwFqFmVUfAGBJwyqLQaacuR9aCu9DLCEBlQ5G384kCrcPWqS9pw1GtMGIt8nMqAaetA8wU/cxpgeBvBvSsFDh6UBjdYit7ClR8Ac6kHwm8gNb+eIxbjAyAqDvtyc/mJD2HCJE9d2IhBFhAwhKpCCdIaHBFykhPpj08gZSJAiq5wLBE41I5AmYmsx7wjIUiSTfsU4Nex8Hai0LCW8mj5cx5C670LSDErGNVFPl04pA3slzpsq7Qwa+oZKUdwwykmaqbLmKpL21HZ+/UUk6iSTemgDbg0s/Ub6d1ndlwxNZ4wnTSZVcNRbJBEsrzs0KuPZqLmnvm69cP1DN6U7pjbaNgqV6WocH1zpIqtnKp0nSM84doxCjBSvlJj+LgybkWv578d/v3Meules/q9yARHlLEPeJbhRC4SRB1IMtxshlIptd5LCHpJiulJjpSHsOraYm73lKTK6yM4GXXvZap7YYobQzgY/566qltFMFfPkVL8K//Mu/YO7cv8fY2Bhe/epX47//+7/xspe9LD51Kih4HqEQ94J1GptvvjkWL16M+WYGJrxVZtLWQcme9GkyMkmGiIKdxZICtEX+BF9OLJVgYsxFX3raeFuM87TXyqKnfFEYZdBTLmO6pwxG9QBz1DgAePW99t58FSbVamVRgYI6P2F7WG16mFTuNYesAhv98bHtSTGZcBGEyODce1KuKAwRnA2CY/kCGfFEV1lhu/EERhB6Jm6k4P7vouC3pWgnTibVqYTYJuSe3zOmEgTFJbkdh7yC+UcmVXcMGvJz55afzvV5m6ZYpwjBK14Jrzu3NyfcXQS8Re7DtsNJe3hlG49XgoMy7sdz0jYD5SuAGt4/7T8lySz798UxWWXXxqvRlomZguVHOHJAxd85304YDWI5l88lu9PPhWh9D4iJepc3PX4OHnQZLcjpL/44QDpga6UDdXnTk88UjkPakVXlLV3Os64COQfchOBw60iQeybdTNSB6dXy0B/TbJdPPA0NmIK0V8or7ohe9qCwt73stgZMT5L0jMB7P/uP3/mneM973oPXf/n/4KSTTsKnP/1p7L777tC6nc5VUPB8QiHuBessBoMB/v3f/x3vec978DguAYBghRmQTr3tVAWLCeATZyrjCrHYdpGWSrXZFvtpK+9f5/LqY1UTJqT2lMWoHqDWjqyP6QFGvdouSfwYBs6X7smIoai6W1KYoB402da5XYSl89FrY/0gwqJHGgNt0VQ6eOIbo9FU0S7DVTfZ+x49wADg1E0lSToQ+4BUmDioKhsUzRgzSEDjGBcnhgQSliuUMs3GULTcsJovPNeUNcO1pWMZYpMlge2iIdLakgwi5Ks4z9BzhsYNb1OqyneQpo4BQ0rGVWuZ/CyvNfnMyxIVPt0muV5PZnVDPuEwKsgWgBrAWaq6jiGvgyJpT4oH6ThfV8MRNI6a5HYQH5gHggM+tk5tSF7hln0dSD5PhMgGNMn3LmTYI37m71sg7yoUTgrdmZD2uCyZIyCVfGl34faLa2D1PO4XJ5y6uRDeFsOFlHzV09jnFJT3HEPVdt5vbTCEtJPWLpudFXbtJ6P6AY+LfvRKevI4JA4K+ekC+QrUioCb/+lEnHrqqfiTP/kTvPWtb8UZZ5xRrDAFBQKFuBesszj11FMBAOYVP0JPjcEojYGqOuMfZSykhbcCwFVPRChh7zBs/lzIfVcWI5XBWDXAWDXAqDaYUfUxqhtH0LUj6RpuW8Ap7LDAQLWPbsml4fB7ttPw0wNW323G3rg9/BSBYygBBA9+TTZETTY+lYOaqi1eV+QsCsr6H2Zy5IjTPaxT41XlcrUBxHL27ozOUlOT8LkymUKMpeTUkQbOP86qvHVDh1ShjPYGTlxJFNWEFGfvET+HPuniKzlRH3KMKZV/8TnaEaZuS9xhyHnC9kNGJ1gD0g6khKlzFBPbrX0OeJgsa+GUeE+wkyhD+XRADnokeQ2+fmc5UdbtQwoxJcibwZ3Ny4+BrAKa2PZAjpkQh/N1X1vrmsWTB0UpuU7aav21KnGtiPtJm1P+vYvEPCPqObG3lPYVk3Um6IG4U7TCmBjlmAwCvcoe1wmS3mWHeTKEXabGVFFhd1aY6GEnHSedxnkCzsdOgehHS0zrqYgFiCy+dOReOProo3HNNdfgrLPOwuGHH752bS4oeB6gEPeCdRYPPvgg9tlnH6w3ugRVR3EjIBL2RlufKhMnfbLKHv3g3Y+JQ3EWT5LZFsOknQk74Ai6sRoDT/+Z6Gv/iyvfW6jgd5el2Q20eHLgJtVOmhoDn1OfWH8EsYtl3odlw2f2HwWoygIVYpEhX8qej6r5yYNvD1cTdRyggoX1tgyhDHM+NjxX8BUnObmCiIDaE33eLaiUKiqgbBvgZBwgUXalFaWTxGekOCivCdFOt2GEbadDF2nvwjBVPj//GrQtrO/4uiZ2G6CbrGWEH0AkxfyExJBLlWFlVNhI4AkYL+P5IZLYBss3RV92/M56v7sS2ykFRZROMJYDAz+Qk9nz3RfVXhzaL+9/OCbS2EqOuewYBMUnM5QOVsTxkuOK7eK5sgmnTPQbK5ZTVNalqm7Fsvz+dhH23Ncerke1l+XrutR1VtPzaEcm7FU68TTajuR7xEGgBn744T/DwoULsXDhQvzoRz/Cm84CjjvuOHzjG9/Axhtv3H1PCwqe5yjEvWCdxcjICB566CG8c4fL8a07XwrtbSjOjtJDTxlM2hqj1GDS1LCVm9xpSSXk3f3ptqINYUtRhFpZ1NqgF5Y5L7uFwmo7AuOJCVdz5P3D8bzvXUbYccqMI+9RdWeSI8l631Qtyw8QBxycG2+sRqVcjOTAEBpTeZuCm2irKwul099vrQlVZUM6HE/K5aqSHDUZPys0CtBcAZGtAxpB7Q8TYpXzv/JER2iA2NcMhImyZJSLuSMfC+j9rszaIzFSYhKsX83v4XlXFznueC+VfGn9534JpF8es4tci/uQbJOQrOHHUsOOS93nTdAlPHcMElIPfDaIEao0yOfLW4q2ESbannApJmEZMU4aoZxSq+CsH5oo/Bvj5BXtu0iDt21fU6pop3+SOMvtwxOHrI1hvSDUSREqr4C3jiHbIYl/MgiglKQzOSdB0sMrf6fbRJ0nnIb7l5Fxtzwj715t71w3DF0jv3yiqVfaSatY9TS8+qqnFeet82d+jzR/3X+PbvjSB3DJJZfg//2//4cddnCFkQ444ACceeaZOOigg1BVw555FhQUAICiaR6fzZ8/n+6///6nqTkFBWuOO+64AwcffDDe+MY34rOf/Sx+8NuXYsL2MEEjGFCFcTuCSdsLk1Yb6+wnzo6iA0Fm0iwniAKOgGsQam1cdVTvU6+9es9qOMc38jEZkrRXnvgz2QeQ7DfsSQAPKIJvnXSIf1wTsNrOefWsuhvv41ee6APOu19llUErP4E3LwqVF7whiqSeiX4oCsVpNlYwRp7gmlTbRLDHMAIxMiolTYnKmVatnMqmMpQQD/nfYKcFJzvmlPaa1jLq3ke2ybb3TwYXeRty0txxfj4vZWRNEUVFVDxlYOVeWmPyZcESkZN4Jq8G0AOCHviBgHZpIWEyoiyu0yWYy0c/yEh7Vkm068lHmKCbk3bZ79JnnivmFh1PMOR3L9piAlHn1yb/nMY1yomqiZoORLKdk/EhSru85tb6NcEQO0xIiNGCuHco7Gmko3/lQkn5/6aMxaHrP4ivfe1r+OAHP4j3vve9RVkvKOiAUmopEc3vXFeIe8G6jDvuuAPHHXccer0evvvd7+K3I0djlR3FuB3FKjsaKqqyT3wgPeOkgi1FQitCBRuUcbbBAM7ewgWekuQakV7TWLbJRAbKiTO1iJvkfXjyrHwCADiSzWTehOJR7r3xJd1l23Nvf8yap5A9z1GRWlHOZaB8O2X8JW/ParL1pN9Y3RoM8DnDOp4Q60vO87mYxBMXxuFYyrABICuQKi6eQwBXeO2yxkTy1U3yu9TZocSc0UH+O7fNyXIHyV5jIp8PKrL9g1Lc0a60jZLoDW+/I+3DrSZASmDbBB4tZZ7PqRtP3BuEuEdbc8oIYhXV/PRD+i71pFP3PeP9O9oejmeze5VPHGWLSmbJSe9B2/YiiyIlKTAmU9SBoR51t0yQd/maDGrXgJwP20aS9TyHPU+IkYQ9JMOoJH+ddCTs7vjZK4CL/+kdeOtb34p7770XP/rRj7DDDjtM3/6CgucppiLuxSpTsE5jhx12wOLFi/Hxj38ce+yxB44//ngcc8wxeOV++2H99dfH+ffsDkMaE9SL8Yt+4ifAfnINrWxQyzmeMc9clxNGc9Le9xVRWRmPlgA3abQmm1hvWE3nAkqsqku7BZN4AmJRJU/YZaVULkbDcJZzClYXrXwbKgstqryyBUhCeua7CDyQDihkBCW3mfuAPfYEOOWdEMvRs4pXeYLOx+aiUCJjnmpX1ZUCwVEdpMvZawI5ygh6JH8qmTiY2G2STpziSzcF8Se5TU7m5Xvi86vkWJTt65ZTi7jDZp8zsp8PCMK5s2sI+041AgBSEpx8lqo7dZNkJtlwA1+l4Tz0SoVCRfKYeRuTwUpCmIHOZvMyxdeWXcqw42aedHmuZH9W6TvIeqhg6pd1etQB5Kp6pxe9g6y79q8BYQ8bt7/IQ+Mcu9R1zmCv+T5nGewyMtP3DRRw7ddOwuTkJK666ipceumluPTSS7HZZh/B4Ycfjquuugpz5sxZ82soKChIUBT3gucMbrrpJnz+85/Hz3/+c9x333045JBD8G//9m94bMZrQm56nyoMwCTcEfm+yFQfUI0JqjGwNSapTgokSTtMQxqTpvbec/c6MFV4ZVW70tZ5z0HJJFcmvLy9ESQYcKRZqtzkSTvbXGymaFsbYzCUIihtg2+dyXtdmVA8ihV4bg+QEhxJ6KVaz5Nt2U/PRJ8HPn1bYeAjOMPEWMD1jXFPDZjE86tT7P3nYKlBtNZ4Fd2NAATR9UV1QsxfsE2kUYEAUoIbfM3pfsEaIa0fCoASk2gD8RIDACZWGWGdSuFPyHcOSao7jhX3zYhmvi3a7wFBPHOfeDj/GhDDoNgCifoeXsV98uTXWWXSzO5guQHa/Rfa30WoMWX/xs/tAUyyrThfYoEhHhASxAM3QcI7lPVA2qmbqE/nU5cYQtpb17WGmGqiKbxfnUm75fcid514sqkYZHHRLP68+Osn4oYbbsDFF1+MSy+9FAsXLsT666+PQw45JPxtvfXWa9XugoLnK4pVpuB5AyLCjTfeiH/7t3/DN77xDfzFX/wF3v9/LsGANCaoxgT13J8d8a/O/z5BPUz6985SE6MYWWFnL7q0xLDVZeCV84F1RJxIRdKeEWQG204GPgEmt5y464mqe0yGyUgv22bYUlL5SaWevEsFXr5n8G+vzpZzOyTZr7QNxadqZUOW/UhlkrQcTvCRAxq2+xAQ7DTsleeBCIDEXsPXC3+tgdCzzcYTe2VZue/6Uoj8bhExmfjhrYgrZOW4IwKRFBNfhIST0IkqEhtp23ELKLbDt6XV1i7iikjKk4FHTv4liQ3EP5LWRPXv8HJrI4l8+sSiZdvJ2puSdkHmsm2tVGhVu29byAcsyWRQSvskH6iI37V8cJQMwih9n1hkmMSHQZEn9EzQ/fvQX10VTIHh9pekUR3LhpB2iS4CHwZNkqh7C4ytPVGXmetM1NnyUnuSLpJhZEqMtEL95DNvx8UXX4wLL7wQP/nJTzA+Po5XvOIVgajvsssupbppQcGTQCHuBc953H777fjmN7+Jc845B8uWLcPrXvc6vP71r8dGu34QM2fpQM5z0s6EfdyOBO86J71MWq+kSy+6t8VIe4tJvOcuL50nf2ox4VMSd6mis52ECyXlqnusggr/ymTWE3kAtnGTQGGVi2OsPFHnTHZ4fqQkU/FvmcgMWcaTTmttw/VU2gbLTa1tqCBbKxP8/DI9R5J5VuX5yQT3nbQCycEKP1FoTXY1OqrwkrRL5hiIniP67JEOTyck8eNUGo6sY7VdfoYk7dGy47ahVrEf2Y5I2lUyaEgnf4pjULqdVPiD+ixJvTyXJNs5ORXWkGSiJ2eZcwynIMFdlpIWWGkXyntoEquzw9T5YdxOkukWgaf0OrkZkoRn/Z8f221P6SAB4tgydz2xvfhtbFyWEPbpVPWpfnfXgLB3IlPUQ+a6J+qssockmEoQ9kq1CDovu/pr78fll1+OSy+9FIsXL8add96JlStXYuXKlZiYmMAee+yBww8/HK95zWuw//77o9drV3guKChYOxSPe8FzEsYY/OxnP8NXvvIVnH/++Xj961+Pz3/+81i53T9ixozb0VOfwATWR9+4X8IBKqyyoyF5ZtL2MEF1SJ5xnvU68bD3s8qrUxF2mZtujIZRhKpSaEy77UxKmYRHcs5qc8pkpBc6/OQLNZotIvAElUzmN+4g5WGZOJVSFD5zprv2dhurFbTWQXnvKwokvvLEvvKknQk9E/kRbTBSNwAw9KmFzLK3/kmEi7R0qr3WGsYQrPJKfB2rrrIaH/oE3B9wUZMWvvKrd3MTReKd2V2C2q78PoFguvcuQlK5yYXc74p8AStK1sXscU9ONUBV6pvumuwZSKO/4fKJAQ2zuGRfkLYKHd8raTGSMYgWIMNPBliFd/1IisKgJxDWZGDhvnOuqFZKxpWheI3Zd871a6bUC1U3vZaOQYTYDmi3Ca1+EP8W+G1O0CHe27hP2D+sY/Lu9xnmVw8XOwVhZ+RJLMOI/Jr41DkxiAsjsV1JLI8pMJG0//xf/hcWLVqEH/3oR9hiiy0AAK95zWtwzDHHYOedd8b666+P2bNnY6ONNsJGG200/TUVFBQ8ZSjEvWCdAhHh+uuvx2mnnYYzzjgDxhi87W1vw8f/Zy9suPkD+C2+iApzsKIhjKgGY2oQst0Bn5Huk2QMVEiZYcK+2oxgUkw0lQo7k00m7J1Ri0BQzTkq0bU7J+L8pi018nFCnjnvn+3DqntK3PlV+gEAyZQCdeggSkxOoV2hJVdsqYJVBKVVYr1hJT5YaDSn2LTV+BFtMFI1qJXFaNVgBmLCDU/klXMG+tZXwG3c/6K0AhpFsJWIp7Rx4BP6zfdDyJAPyjzFPgsKPZNgQfYFsSQd+wJeDQ/9BHkcBHIPRcnEWli4LHqiYOdh0hz73pNajkXUkfSHarMWUOE4EBaZeJ95/KCyhB55mi7F3hUf8n1hyL8izgEIhYIEoedKqKCUKFuC6qMVBZg/fUi+c1osnM5VIZXzIcQ9V87jtcdiUHIfJUh3a5+MpCd9OV0STBemKn40DJLI89wCYX8JlUzZ/sJRjeE9MgKPqK77uQY///w7sWjRIlx22WX4+c9/jg03PBlbbbUVDj/8cJx11lk48MADS756QcGzBIW4F6wTuOuuu3D22Wfju9/9Lu69914cc8wx+OY3v4kbt/gsbHULJu1GWD5wv3A9ZdDz1Uz5r4JFTzWw0OhTjYFX2tnPzpnsDWn0bR2KHfW9Xz0n7VJl5wmjudUFcCReWlpyok4ZucqVxnCsQDSZEEoiL44bVMMOaVMct6V48jIliKBPCokkXiHEx3vCDk/g458j66aygcA3WmOgK0yY2qnvpgkqfE+bUN1WVwMMSLvYTFuh1o7ky8musUhVTLPhPsqz5a12Pnn0bDIQChNgk0mwWb8Iwq5kHzCB5+Pl/IuQZNaHgYL195IVbFB630VfcxoKWeUVdkqfDshM+5zwCkVZidWM1sRcA1hfOdSReGEnYtsMk3jDNpr43o3i3DYEFew3IP+0IB8cyu9s1uU5Wk8TBKHOx7vKULpPMmCZRkEXx07IvB22TUr014iwPxnkVUyDau5fVepRD0o6F0QKBB5JBdNffvMkPPbYY7jiiisCUZ8792S88IUvxMEHH4z3ve99OPjgg7HVVls9tddTUFDwlKB43Auetbj99tvxve99D+eccw5uu+02HHrooXjLW96CO7c/FdWMkTiRVBRX4gJJrLJrUELkGRz3OG5HMG5GWmp731SYML1EaQcQyOIwi4y0vsSJpIK8S3sLhJLeqbzzm0xBzVV2sU7l2wJDjx/QYZkJijN75DPbSEJmNRNvmxB49vj3BImvvAKv2TOPGJEJICTXyImuMt++oQoaFJazxWZgqjAxWE70Dfta9wQkTHr1/UpW3IPAkzxh89eu/DLlr00m4fAE2nC/Ou5r68lI5z3wr35wkDwZEIMMzrQfehxSbfKaEWZpf1HWZayrxP/Py/wfuVfdCE+8J+5uO2ezCXnmRpD3nGSHi/Mf+W1OkpNrGtJlmYe9tYyRKenpMcRyoayny6Oq3nnuVnv/AAIvK5cKGwyxHYbfs4Je66ikV4Ksh0qmAFXARf/0dixcuBCXXXYZLr/8ctxwww3YbrvtcPDBB+PlL385Dj74YMyf32mnLSgoeAZQJqcWrDO4/fbbceaZZ+Kcc87BnXfeide85jXAfvdhmwPnoV5vFAACGeMqqDyJ1JDCqFdxAZdJPqoHgcgDCGS+Um7ZgKpI3O0IJk0dvO1s2TDWxRySJ4ryX4y0y3Dc4VDfeiByguAnynnmz86JOsRniYzItci73ydPHUmQ83r2Iysm70itI57UK02O3Go3EVYJAl95wl5XJpB3hUjO8zhKJuwyepKrzcr4SbfOdubnN96fwU9HBmJwxfn3JIh8bmEaNkFXDsJC2o1U76cYTHX2NfejvKc50ZbHCupu970FutXmACa2gcRmBJ8iQVdGQTfinMFOI0h740l7w+Tfk3dP4vXAxyPy33Rctot4rwkZD9sOP0E6cXfI8fNiSLytOM9aRTCuybayCBKQWl9YUe+IaQSr51WmqntLzDWnnoSHHnoIP//5z3HZZZfhsssuw6233oqdd94ZBx10EA4++GAcdNBBwbteUFDw7EMh7gXPeixfvhx/+7d/i29961t47Wtfi2OPPRY3bHMaMGPM+897IUOdfdGGVOJF18pipBKkvWowohun/ILJoSPso7pBTxuMKjdhcpLqQOAdca8x6Ym7JIZM4GVxJEneWe2FXw5EHiXzy3kCaq7Ct6wxUnkFUtI+naIuiKNi/7uNSSVJXKHbyL9mp/JEkxX4oMRLAl9ZR94rr7ZXnCHvlPdwClazlYuZlMu1WFcJ73ytLSp/b2uVq/Xx2PxkxPrvRd9UYcJrXnm28aRdTobNffOt9J4uq41XriVxV+J9J7g/+Xr53kjintzDjJi37u0U2wHJ90Rl+yZqvNw3IfNKqOyerLO9hrwSb5xKH9+T+JwReFa2p/jpSUhy4o+nbLvh61o2oeSYgqjLfYedd9hxhqFrGxGLyNaXruQXWwkVPZ9QysWPhE/9l988CU888QQuu+yyUOzo1ltvxe677x5I+kEHHYRNNtlk+nYXFBQ8K1CIe8GzFkSEU045BX/3d3+HAw44ALv+f49h9pZzQvEjSaJZWWeiLtNdGu+N5tjCWlnUPqKQrRWSzI+KvzE9CMRenne16aFv61YcZJ6CwsSQiTwQiaBUcENuuakc4WcCLxR5kor+VBaM1vpMlU86WZD2xpHNEAEoBwVAm7QDYL97IO0VQBVF4l75+Em2zYj8+GH8RebK8zZyuYzS7Ilqr9Jm00XitZeU5X3q2zopjtWlwjsbzTQDqkDYEUk74CeKsq0F0z/dSLt22m067S9IPyd+dkno3e5pwkw+YBvWthBficQik8ZHUqLGhzx4Ju+GvCofCxUlk0SZxE8VgTgVWe9Yn/ZBts52HGstSHu67/QEPthegNT6kkU0sjfdVh2KuphUar0N5opT/j9ceeWVuPTSS/HTn/4U11xzDbbddtuQn/7yl78cG2+88fQXUVBQ8KxEIe4Fz1pcf/312G+//fCjH/0It2/9z85z7jPVV5velOp3XnVUe8JXsa1CWC9GuFCQNoG89zy5H80nsiobvPNy8MAE3lAaY9hQlRJ4RBU3z26Xym9jKlhW4Fm996o8ENV36aGmjKyTGCwk8ZC8HzmFGI32OeYK8HYIlSvwfBh5g4I6DJdTXk1B3tnzXkVfuKuGKp4kAO1JnvJU3mpT+b9a5MZz7CTbbFiJzwdquerOmfFM2Bujw/wEWX2WB02yems6wTRV11X4jBZZVzmBD/coXmsXSK4TqndyY7oGQ1Mp89kJOgcBeYMoJeipVYbEZFbehrL3FIh9UmU0U9wT0v4H2F2G79exQVc6TNf5nyR5T6uUqnQy6TTWl+Bd12lM41X/9X5ce+21QVG/4oorMHfuXBxyyCF45StfiUMOOQRbbrnl9A0uKChYJ1By3Auetdhss82wySab4KKLLsJW76RgZZlALyW9YpKiJO0Dq9H4CYlAtGBU2qnvPe2qewIIueF9W6HWvUDe+1WD2ttnWIEf1QPMRB+zq4kwkXVAznrB8ZGSzPOrtF4AqX+bJ1OGwYewcYRro7bVBoC3dSBYcrpIfm7xIFGNlLQjSKQ94fRkXCkCaRUreVLG4diPDXjCSo6IeHJKFVxWoyVXcVTDZ3ZHuTdUOhUKsIxW5BhFJv3h1ApoABgLaKWjGq+jjSbETiqLXqUBg6RSK5P1gVfUm0DWo7pufRvZ/tJJ1IGUrIviS0kxJVJJhc+WDWUK8g1E23vrSQifv2u/IUp7az2GrO84HifYBMLeiIQZJvJWqOuCqLNdhienusJEGVkHuuMXp2wXf4Hy65le+Q7ossgM219jWvKeTCQFoqKuImGPCjvie45prCJRl/YXqwhnfPxIXHLJJbj44oux0UafgFIKr3jFK3DMMcfgy1/+MnbcccdSlbSg4HmIorgXPOO4++678ZKXvASf//znsXTvM4PKPW5H0PeWldWmh4mmh76tMGnqhLTzpFBrFZRCiCSUueKyQFBPm04FXtpneBIrgJABL6elOo99JPFcbTWuU37f6K8f+KjJga2CT58JO4AwqGCbDQ8EiFRITInXqjFVjrn0ZFuvtsOwTUbFKqJGEE1R2KeVMJMo7wgk3RF3ijaanJR7EpwQUfZ386CAJ8CyWl/Z4JWXufGcHR+871laTa2tL9gUCzcNs8JYUkhSZaQNxqhUVU+UdF7Oy9pEvfUeSNXwDvKeq+DJYAAd2zFysj7V/87XYNvwPRCDEt2QJ+65HYZipdXMDhPIuqW2FYammKw6he2l3VaxosMC0zV9o/Mca5sCk8Q0whF0QdSDgt5F2iuppqvwb4i0wo8/9+e49NJLcfHFF+OSSy7BsmXLcMABB+DQQw/Fq171Kuy5554lS72g4HmCorgXPKuxdOlSjI+PY88998RNzflorMZkqGTqYhk54UXaHvpN5dV2HVJCAEBrDesnRtbaOmJWGWhSyH/2mGRb8pYXo7HajIR1Mq6wQrTgsK1mpu5jvWrCqeeerfJ79tZLgs9EPky0hVO/mcRrpcM15pMpmbDHWMNIQAGEiZOtSa1M2IW1Q2V/KVnrYDyeZMuoQqUAMvBEBU55VxSJTehkp06Hya1M1OUrDwysApGGsu5JgPVJNcqTeCcDA1o8mQDiEw22InG11ZDp7lV2tsAk/STmAITYRVFAqWWDCYORlOB2WmSmUdy7SLRKBgbZfkA3eR+mtg9DlwrvfeeyKmtql6Gh6vpQst4V/bhGkzvbi9bIrz7s81TnzL+vySRSsZwJuvN0uXVZPGNQ2aX9RajqMlP98v98LxYtWoSLL74YF198MTbb7MPYfffdceihh+JrX/saDjjgAMycOXN4uwsKCp6XKMS94BnFI488gre+9a34zGc+g1P6n8WkmR1IrZxc2DdRae8L5TkQM6OFtcS6yo7KETn3OcYE2sqR6UZrjGiDRmv0tW0p6o3ViVdeK/JVQBvMqAZxYqsnBVbI1Bw5CdIwQJjYmsdN8jWSV+BloaF+UydPE1gxtiaNI0yIuukmnyG3m0lnTgr9puw9jwo5ExW3nCc6Kr+KtLMLqKC4q/a8RwXnh2d/PKfSeF+8LG4kPfpKkPZKKPC1V9trP2nVTV41MKJUp5wf4Cb/6rSSaj7BNCjd0xB2SvtyKsLeOfFUEuwOUt89EECq6reOReHzmthguiDPK88p1fVgjxmmrhMFT3uiqv+hnnQJ271+2uuegoznCOTc70eeqAclXXWT9FD9Nvep+0mmFgZfPeEVQVXfcMOP4wUveAEOPfRQnHzyyTjkkEPwghe8YJoLKSgoeL6jWGUKnjE88MADOOqoozBv3jzM+MjGIOik5D1P9JSZ3IMhpN0Yr6YC0LUNJI//OE+cU0rkJFZOo2EwieaBQK2cFWNEG4zVg4S4s9JrBWlkhb7nU08q2KC4c5GnCdPzTxLigCQWdWqnnRgTFePgxc4TTphUGoAtHJ3KruAqTGICoU8UVpVaHHRGejyRj3GR/pXf55NZxUTWrghJ7Q3e0v7jrE8paeeiTrUn7SPaoNIWxmo3MDIV+k0VFPemcU9SrFWOvBthHRJEPFhfusg3L7ddJLetsOfq+lQTRluDqA4CHc+ZKuKtQQVhCotIel75PYjnonC+SMyjup5PNFU2kvaEsK8FWXftXIONgKHEPYGWJD0q5O5zfN+9b9wnvFaRvA8l6UoSdvf+5//+blx11VVYtGgRFi1ahF/84heo6xovf/nLg/1lhx12KD71goKCFopVpuBZBSLCxRdfjHe+8514+ctfjsePH8OKZjSozaw8B7uIdaRYVihNFGhWU40GFMESFzEhUGXhGIUOKS+N0ckkx5y0AzHOkVXd0drlvaNB+FfDkZQ8MZVRK+ej51e221jSPq6wyooJuT9H3FUyiVI+TQiKMRN1VteBqKozMfekGUBQ05N7oAghwpCTZlrbBKE9klLeSAMEBQVH3oMHHkgP5EkvOLebz0nkrsMr+GQ1LGzgVMO87TL/nfz9akiHAUYs3iRF0ynIHqvrbH0ZRuD9trmFRXrgW7aXTHVX+XZDtk2Ied7WaYg9gPAEqGvQNlVXBKIuSbychDpVlGMXYV8L0BTkVZJ6qrRYASRPeGQhI96eVXFPwNMDp5/jceKrq1gqyHoYoEqSDiz+9gfx4IMP4oorrghEfc6ck7H55pvjwAMPxDHHHIPPf/7z2G233aC1RkFBQcGTRSHuBU8rfvGLX+DDH/4wbrvtNvzd3/0dfrHvLaiowsA4AjzZ1ElSDFcrjRMxVauCpTUiuQQKVFsgiKiO+CptAxHUOmaId5F2IvebXmnrBL4a0Ea44xug8T++MhaSSIVJkrUyrWqfAELOuAah1sYr+ya2oVIYuFOigYZ7ImYBoz2BAKxBIBGw5K5bK29VoYR4uNeMTHlPN1m4iap+EyWIXuJ/l4RSwZF2SeJZ6bVwlhnr+o+JvdskEmG3r2PsVBHfNkDFSEkouEx4v6yqLEgTjBXpMooS9V2mEDGB99HZfh9WTmXjRRcRUu9656RTlWzf8qIn/eyPLUn2MPI+FckO56J4X6z8oymPnSrj/n1HOwE4ou7JOBNx53UXRJ1fgbYtpiu8X3xP1hjJUyHVJuhSGddykmjsR1bB2eICeNLdca6osrdXn/WFN+L888/Hfffdh8nJSfT7/fDa7/cxsWoCO+zwFdx1113YbbfdcMABB+DEE0/EAQccgK222motLrqgoKBgehSrTMHTAmstPve5z+ETn/gEPvKRj+Cml90NmjEj2EWGTTqVEzFbRXHY352ngXC+uCd/kszKDPGWwgzPH7VFXVvUtQl+6jyZhklins0uE044Q563rbVNkmwGPkWmqw944CITZNjf3lLfg4oNZ0FhSwpfVD4Jk1itd8RdNVnCjHzvH1hIRZcHEElFVcRl0jIT1ovP8T3FgUB4T9H/XlvoijrvFfveK39v6sqgV7lB0cDo1vfHGu0GeGypYhuQ5etXviKosMSEPxUTdxDb3yLvvDon4uJYnco80E36E6KM9JXvk/Chp8emdBDAE085Wz0n+fkkUptlrov2Dotz7L6O4YOEuBO/Cj85EJRz6TmXBJu48mj4vqlUnQ/EPq5Pzoe2yk4KuPLMD+K2227DD3/4Q5x77rm47rrrcOCBB2KXXXbByMgIRkZGMDo6Gt6PjIxg++23x0tf+lJsuOGGHRdYUFBQsHYoVpmCZxQPP/ww3vGOd+CWW27BZZddhn8efBUDMwsTg15LZZf+dVkYxwqLSJKYwqRVovHsUAlC6IkiAaKSIRMSFdXeilCpmFBjtUZjHWlnew2AllLPNp5KxFCytYMnUFoyQX2vSbnCT95S09eOwNfKorIVBorQWA1lCA0QJtsq5YgkaSCJfZRk0RdAik8jIDzdKrHVRIKuOpRcJIQ1XLL/zOolp9C4ubhOrWVCDoVg55EcKXqGvaXH/4WnCHD33eQ7sopeKVhLMEahrlWwzShFyZMTthuRUWksJvlYTJ4jIL9LgRSrVj+Er4xUbgVJ70qD6bTAJOSeOo/V+ixJO49HgwUJQZHPBwcJ8ZbHENYXRk7Sk2VyvkOH4JMq/UMEITkCGzLxU26XKOlhe0QiztsxyUe+v0qPlbcBkawvXrwY5557LnbaaSf89re/xatf/WqccMIJeN3rXleqkBYUFDxrUIh7wR8VV199Nd7whjdgzz33xN5fORD/NPlf6NvRKVNiYkY5Imk3Ql3OE0GAhAgBcP5tC0cKAoFXrR9tv7Ejjd6L3VgFpQmmqaC1n0DpCSOQknYmikyeOUdepp9oRdA+oaYhjZonsyqnwEto5Sb+aUXQpnLEv7LBcy8rreZe/3h+cqTVaDhvv7+24F1WMcedVXeCqIwZlffEQw1PkCQR5f4M27BtAeE1B5N10gjWFPJ/aFQ8WULYESa3Uk3uwMp5cqxVaJoKTRb2mWfcQ/4xGeenDVZcs3UTc7k/osUkXid7m+VgJifq/L1sE3ihoiNu14VEYRfWmK7PCUkXxw3EXBJ9cfzpCiO12jMV1iB2MSHrXF2Un8JMQ9LDkx50K+hJU1S6rssGAwDnfOHNOOqoo7Bw4UIceeSR+L//9//isMMOw6xZs6a52IKCgoKnH4W4FzzluPPOO/HjH/8Y//M//4PLL78cn/zkJ/Grl92CSTuCvqkx2XAcYtWdEpP51ztVdgWgtrG64RRFc0AKKihxkrXAxRQqFX7VOWOcX63WLq5QKLkqO4Zb5pbrykJrR8C1jhYb9+oqfLrJkxa1dtVae355bStoQ97/bjFaNSHZRhZk4gQattNwJVXJSwhwZLYhABUsLAgaaACqmBAqQdJiX7HqLC0ZyeVmFSVblpFAtoBc7SQNKO2jLDVFkm88MeOzCLJOFRxZF/YcbjMPYhS6uS/biciI7wQQJ+bKDgvXEYl9bksJBFmL/fzrcOKeKuotK80wZE8/mKDLqqVBaTdok/b82vh8bKPxXvfEYjKEtE9L2MOGKTvOfel8vk5vemZ7Cckt06jmwwj5sDYxrjzjJHzjG9/ArrvuiqOPPvr/b+/N4+2oquzxdc6puve9R0IYAiSMKjMJQwwyT9KkBQVBRATtlkmEbuyvIt0tDeLQinZrqz9sRWVQEWjBCREQDUpQlCCCQIAgMqoEhAQ0EJL7btU5+/fHOfvUrrr1XsIQIHLW53M/d6qqW3WqXrLOqrXXxgMPPIC11lprBQ80ISEh4aVBIu4JLwgeeOABfOELX8BVV12FP/7xj9h7771xwAEH4Itf/CI++sSnMGo76Nl8hUh7jD1kMo7wf28uYhtV9f8xOXjvMpN8R5GUehJPgpQ20kKsCuQdgQw0CDyAaLFpkHtwBrkJD+2855o7eorIwlxbDJkSHVN6O4yi2PRJg0K0pENXW5RZSNEhFYtfZeY7dwi12oXmUX6/yhCDKL3dlQ0IAAVbCgHEf/nCH8/ef3lnQjWIJqhSofl7+V2EIFiV1716wAUC3yRigqw7gzpZ58lbP1hstKqy4IHqjoxkmc07NPGOgz/3TT9/fDQVcR4LvitBFemVs4amJz2Okdid2rg1l6kp8011ffB1TcF31PpbcfuBqA8Wr1KYNPk7TTVLzFjbasGYJB2ok3Em61qJa6OuqJMg8QPbbuxPa7HKeFDApZ86DG94wxswf/58/N///R/e+MY3LmelhISEhJcHEnFPeF4oyxInnXQSLrjgArz1rW/F5z73Ocxe++ugoSHcaW/HLU/cWXU+tb4Ys7BGNEuCsJp4pT2Sde0ZjArdNb0o55kNxwUCCMWHVLfURD88CcIGT1qFPYQzzyN5BwKZ0TGZolZEycsZ8jnkoUBSG1/QKgsluYjVkW/41AvkO1MOfWdC+oyDDkSe/e8dXcIEdlQ4P1aFKVCGYlaZZMMFrX1rwDWHXBvA3m45qamp6kyUjI+GjD55Hiv+ngkrK/FxjKrXQOO9IFw8H5IWGp/zLkh9eHaZ+DxsQFl/DlVUasl3rDQE2KDa83FJ8AmsqejSt67icVWKeotNyPLyYtNRfadqnFCtM5ai3kZ6pVI/lg2mIuf8G3KCUOWqywlErZGQnFg0weR9HItMbfEaaVZVwgsgzrsk7BjXAkOmeh0neHJZuZ2BwWvbwZbFCHAgnPvBWbjoooswffp0HHnkkfjOd76DSZMmjXu8CQkJCS8nJOKe8Lzw0EMP4ZxzzsEHL3sd1tziCdxkz0fHdrCMizuDvaMkDUuh4ydQs51k2sWIPzJORD/CE/mwnIoNlSoPuVIUmhaxaj9GoyIblHinvE1CkvTgha+poUzMNHx6haYqbpE7fYrJA+AJM0L/1dIamLB/RlO0zOTGJ9UY5UREZNWdNdM2kHdvo/F2GodhAKMuQ5c0ltkcvTJHCeF1p3DcojCTEQl5sBSN6XFvFmAywWJiBSFoC7IZx1GMGxNMLXakaoZTJ+/OAMgAF8mviuqxX12orBrePuGAeuVqWI8EwQtv6vul6l1P42sxueN9j353Qd4FaZYFq/FOglTMBZGO11VDmY/fiX2qdyXlbZGYVFVWl3G32epRF581lfXlZbCLtJe2pJdwCmIDpOhlj68xQNBrlpnm64FnNXCMAHDjBSdj8eLFWLRoERYuXIhFixbVHvzZfffdh912+wgOPfRQ/OhHP8Kee+45/vEmJCQkvAyRiHvC88Kmm26KjTbaCPuOfALz8NnYLTTmlUdPN8Eoh1LpqJyTIJoAQudMggk1hr5VfcUuODVEh+6nmeG0lhDJ2NJR1bkQA6gUUHrvCxn/Pz+pyiqhrVDX/ZcAKjIUOU0kIFQ9A+G3mMibWMzaFlfIDaVcmMR4rhPGSPumTR1ja9GRw6bAsOlj1LX/yfJkyJGCC2NELhBtQX7AxaWKPMFi5Z1Q2RtCp1NOmqnZY5ighh+tkeKach3WiVGKBM2ENxJ3r7ayZT64eYL1SUyuEIixCVYf56Mba7OmJucUhF/FAZLku9FwCfI7DHjaK6JOkdBLZVyX4ZoKxLMi70IZF6j50+V+0RhkPSjrAOqknbe3HNLdmgwzsJAcT6q/b/rTX0iy3lDiSSzHv3nTN07G2WefjTvuuGOAlHc6H4S1Fp1OB+ussw4mT55ce7zqVa/CjjvuiPXXXx+zZs3ChAkTxh2rhISEhJczEnFPeF5QSuGAAw7Aj3/8Y2z2ntH4uQET98zbQBRBI/dRiNqhsL57aBEKLJUowoyEVhG0rvgbk1P2ubNibRTBGBsTWRhEXqFTgaySYbWO5eNATrTv4unJkyArit8zvUYskiXH9hqCheA4SsRKhkJV3iO+M+Bfq3isfCyZCQRfGxTOoq8NhkwZ7lYodLX1EyGQL2bVFhlpEFk/AQrdXSOJ1w4KOhTxhvQOnsRoBVhPkJThlaSaXqneVbqKqshzGJYqKlFmwDdIPKe2WHhLhwO0A2DJp+RAQTNhZwtNJIrhdIXUH3JUz4mH3GdUE6tIhlWdnDMBp8ZngjzXiLlUuaVthqrvYz46IXjvq7GsWWr4t1Af67Z89Wq/6mS9uQ3/ntrfNzEeaW+iRV1vjWoEVjgJRvrWa8WoQIPEV7+liKCIcPnll+OjH/0ojj/+eGyxxRaRlEuiPmHCBG+nSkhISPgbRiLuCc8b+++/P0477TTc/bm78Y3f74qlrouluosR08dS28GoyzBqcoxmGZbZfKDpEDcwAoKwKUg8wnsZhQggkndHKk4MOsbGz/m/b6sIymrY0O4zFmdqVL5uAArki/Oi8omKCHKhqwUoeqsVYkZ8WASG/EM576m1GiX8Plura7GRMj7SmNDsKewzq+++G6hnW6XztyGM0rWCVJ68KPGcG+sdLsF25JyGLTWs1iClQ3EogTI/gSGgXrjJarmFn9AAsc4gKt+sKsdOo1SLUoQgudFqEhJldEleMXeALjxhJc7xZtIuLDQ8d2IFX0VbBaFphamhRo7F9w1S3mZvkV7zZtRjLXpRkPNobYlV08Kv3pbVXqsXaKjrvD6/biHt0jayPMXdXyzi9fJIvIxqBCpSLQuKUR3rihSZtinrbWQ9bjoc08+/+s/YZptt8F//9V847rjjln+cCQkJCX/DSMQ94Xlj9913xz333IOHHnoIQ7qAgyfKtrVyrAIXYxbK1OIWfTGnCt3UG/+Zq6oRkmxulGsbCzmNJhC54PuGV8Ej0UO0iJAOPmp4sqFAdcWdCSGCmhp84cQqPRfmGaoSaBxA1sBy4ozWUGzNaWTPK+NgMudtKYjczNcEOA0gQxny3wGEYlYbi1oz7QCUQOaV7E5IpPHdV22VMsPiqXGgXGSby4x8q6s6gKCsc+oKH5vPXifveQ8KORN8WD8W7DFncg2gKlAVIBWau7IabsKAq1ADIYpXq0LVoIbzNpVqkG3U1HWgQcjbCHuzaZEk5pJ0t00CpBreINz+c6ptT35WHwyxr2H95SrstWNcAdLeBJN4hxqhr5FnVT2TaVfV4zoNsl63vEgPO39eLTOg4IdjpjAp+/SnP4111lkHxxxzzLM/zoSEhIS/MSTinvCcMW/ePJx33nm46KKLsNVWW2HixIlwT2poOOTKYkiVrQ14ZKIMe+C9khwyuUlBM3lVVFPhtfLpMjJm0RPYsG1TbdvbRwDPCi3YwEPCsE4IpJ491UoQJb+IJ1+lJ6PkmJSqSExUiSqfXAcSz8+KKkLCpF0RkHmS6pwOWeuBsFuDzNhY0CrBxa1dUyLTrjGOvmhXuap5E+fHy7FrrQXQGs5QFcHJxbxMnvNwPJJY8WwgqPRsI9Hc0EjaZMJDB6uMLqvvwyYGFFf+LvrexdDVfOcYJO5tynu0pDTvqPB6cf3BZdiyMkDw20i42PcBot22bAtZr20f7evVDk+O27Mg8aRULDyO71tIdIxubBLzpl8d9ffV9y2fCfJfU97luBBw2amHYtq0aZgzZw60bvnHJCEhIeEVhkTcE541rrrqKnzsYx/DXXfdhcMPPxz/+L+vwatnTMJFj78dwOq1ZYdU6Qm2sljqOshcaDzksqiQj7osNhcqnfZJNKjSUiRkAguTfp9aY6pElcb+au1ApD3rhvbNiFSQhUvtyTshSIFUEWxJ8ABv7aCKaChJeFhx1yJjnIkKKoJGhnyGugUIGo58EalzOqbllEb7SQITPwUY7dDJLCwp9MosqvCSlDNRz7TDUFb43yMFBz+u1mkUzSrJapQq90S8OxHsQOBJiyf0UcLn8WYSpgGXETTE+DXU2Uhgm8Tb+jswwZUfk3CUayd0bfaWJjmP6wgiXn/dUNLdGJ9L5RwQ+90g7vJSbR5f/LxB0HmcWjqePhdIb3jzM7mPy41rlMuPRdZFbKPfJlARdT+JltanmOPfli4krpF5//N+3H///bjhhhvwjne8A0ceeSR22mmn5zYgCQkJCX9jSMQ9YYXx17/+FSeffDIuu+wy/Od//icW7PhjmAmLAWyMPxeDBNuEQspcWRjlMMH0MMH04EijIIOCDHou93nkZMLnnukaRZHYA76Akd87KPStQUneCsJdRa3TGLUGpWjsVJbGR0RaUzVqYgIqEkY4/aTKOkejkJEJEcDeGaq4j2/o0yA5XAMbyUzo0qpKVEWuJYW4ScBpnw1fBJUfAJQGtLEwxh+fUhlc8Hn7CYn3zetA2DuZvwPRzUqvzIfUHQ2DPkK9gFDymzGcsWst/DGTIJfexhKSecJx12wTgdAz6Q9lBX4MA0mTRF4Sb9LeGWKi3x1x8oM2gtskxfJ8NQtLW6wu0toSi0LRsk7Dz95KxtvQLEaVthdJ/MeCavnsWZB5iikvDYIO1BNggIqsy0LURqqLVMrHs7nIOgUyCI20VHwtVXi5jQvfuhfmzJmDG264AVOn/jf+8pe/YObMmdh9993x7//+7yt+4AkJCQl/41C0nFurG264IT388MMv0u4kvByxZMkSfPe738WHPvQhbLvtttjo/QZD605E6QwK8go5gEiq2buulUMe0k+6uvT2GV0gVzY+LFSNyDNs+GzUZfHhC1sz9Epf4Dpqs+DnDjnuzltNZKZ7m48bVgnCDm/7CM+R8DW80ACiJaSGpsoaCYywyDBRiap8UN6jGknRJw9dkUhoAJmDznyjJ767QLFA0y+oFcUGULmxyDMbC1RZmbfkIzMLq1GGBlgkiLkL4+RCx1UqwwSnNpkR4yY7j/K4MGG2jYSZaKPxD1VS9ZrTVJQgiBgkdnF8gQECXv+sYXWBXLZBppvbqNlkxARhYJLQ2E4bGop6G56TN30ctEU0DpBzYEBFBxpKeiTWakBFH4hxRLXN1mUNQJkvNGbiLgn8efvuiA9/+MP47W9/i3322Qe77747dt99d8ycORNDQ0Mv6PgkJCQkrCpQSi0gog3bvkuKe8IAnnrqKcybNw+33norbrjhBvzwhz/EZpttho9//OO4cdufoaQMT/brHTwBRAIPVN71TDt0dIluIO9dXWDYFBjSBUZ0H11dINd9GPimRJY0epRjqetgifX/cZdk0HdZJO09m0XS3g/qemFNLb/dRwfCPzNZt4FdOEHaBXlXgqsNePODvYE4NYWJom0ZQIUq/URugpNZFKLK7n/LF4PWIto1gTICQg49NGDjRELFZZQhUOZnGc4plErDFgq9Iou7YrSDdd6KZAMx57QZYlIOP1YgVEW0YcxUqWpdRmuTHibljSSZVt85/06wEznDw6yqnPdycCwHrBstqvl45Dy+l8o5b66Z7CLWGcvqMvBZs4g0Lotx0UxRGYD4esAuhJbvxopl1NWEaCwVnaMZmbTHux0Qn0ny3dx3QeZrar3x3XBr6xvCd9+8H0455RQc+LmPxrt4a6yxxvjjkZCQkJCQiPsrHUSEO++8Ez/96U9xww034LbbbsN9992HqVOnYocddsDMmTNxww034MylZ+Mq+jXc6MToKWdPOvuopR89Uy52Re1og76xKI23whRkMKoz9HSOEd0PJH4UJrAoF1R8LlaVcFDRHuJVZBULLctSV11TbdU51ZNuwQA1vK9dheLUEHES+VpDmaxIekiVMTIqUNXjAlmx5fXD9jhtBVBVTnkkOgRo5TPfmQAZgEpVKfEKVQILAAQCRMG3b+FVc+ksUfBJMsZ4Sw3fgSBSvilVc0IDsbJ8TagXnnKaDFVNjOqZ7agr8ELFloktcax12Ns2S0uoK5CEmcdT7mNr8op8L++UyGXajlduL343jvVlLDTuFCx3ObSQcADNGSCJ/RkrOx0I15Ak6ANFpOJ6UyrYWoQizovyUIYJp8sQs/xb/fC6/nkk7ZmPY/3+gbOw995749hjj8Wll16KtdZaazkDlJCQkJDASMT9FQQiwlNPPYXHHnsMN9xwA6655hr87Gc/w5IlS7D33ntjr732wsLdn8GWm+0KPWl1lKTxa/c0bnzyG3BYrbat6D2nqpGQJNlWe+JuyYWC0xKOFApt4EzFCoxygAMsFArKkKsyPAyGdIGCDDKyyJTxFpwxWBB3KpXEtTrwQN6Z9bGlJTxX/nPEJBj/WjAWVuVjagrbQagi8ISQD49arjhbyuPoWEmYEApaxXtFkUhBqqW8v8Y3LvKHoEFEnoTXBgRQ7Fu3FVnn5lFxMhP23R9XfRJS22lelo/NNtJjmtaYOAaNzqCthaIthL2mptdtJ9GiXyPaYxD1MYj84Pryc2r/3Mk3yyHttQUxOJ78U3z+awR4jMjFxm/zZ5FEi2ul5kUXRLr2WSDUcl+8Iq6iSl471njHpFLPnUylEUWmpKvBkb72qw89CHvuuSdOOeUUnH766Ss0fAkJCQkJFRJxf5nj8ccfx0033QRr2zwZgyAiLFy4EA8//DD+9Kc/YcGCBXj88cexcOFCLFy4EP1+H51OBzNnzsR+++2HE088EZ9334QzOX7uFqDjtsAzzqDomdjBtBnFyMkuDCbtcllyGoaTTxqkwzcV6qAMvvZceRvNaPC/d3URM+ANXPwtb72xyAPxVzFJxWfBA95pQQgWEIbyinaMTWFyHCNiwrGE7HWYqvtpjEi0wfct8s2V9HlbVuG9RUexqh4IrLSN+H0XajNHTFY7XBUL6opAkQ6JNKSgye+bj/NT4rjCxEN7AkaZ8+tJ+4urSHrNehMIubbwDZL4FHMyjuiAGo8nqvGSxI8fu1i9blkO/LqhaFP9tf9u+ap623KthL2NrDeI+nNBJORGtX8nSTqq59Zs9LbvxTbitcIKeuP64fUHCk2lQt4g9V61bzkwuVxQ0uMEISr5FJe968R/xuzZs7HffvvhqKOOwmmnnfbsBzMhISEhIRH3lxuICHfddReuuOIKXHHFFbjpppuw5ZZbrnChFhFh8uTJ2GijjbDRRhth1113xbrrrovzn/gKumsMI1tjBHqkA4LBfPc4brOXoo8RFIVBYY23nYRCxrbmR0Y7WKmss/WCEC0s3CDJaAdDCrn25LvvTIwm7BuLTDnvezdlJP9dXZmcuWCVu4ZKsGWG7TKOOGmFfBMhQ56nBwcGCFWTn/qIVcdnHHRGMJmt2UucNXBlUDOtt68Qk99IWisFnr3ztVhCSRbZRoIG2awNdkOVDzYFsoHAc1KHVGtDQawKnnmf6KL997IzqiDgvN9yOJp57Pz7fDw6dEgdtMgIC9GAqs7Pg+p6pY4PFnS2FXi2EvbGaW3rVLrCnnVghUh7zbIDQXDH8Jo3j0NaW5oZ6by9WpGoWM/xuWfCzJPEsE68uRQUdLmvkuDH/eZlm9dcJPAiRam5HfbGh4Jrfj/vqOPxox/9CN/73vewzhkfwZQpU3DiiSfi1FNP9c2zEhISEhKeNRJxfxmg3+/j5z//eSTrjz32GGbNmoXjjjsOR/5PD2us0wmdRHUs3vSJKzl6Lseoy0KcovJEl3znzD/SH3E/PYzSGQytu3GIXVQoCxNzvUsKhZ2BrFfWl2r/uOs5kQqJJKj5zJ3T3p5MCjp0NLWOYLRC1qI0ak1w5HxuuSKRQuNzvDldRoNqRF4q/7yeIwWrNZwjWNSEUx9zqBAZ1phcQXuFXWtP2jsdnz3vnB+bsiTfpMhRzRtOWgFG+aZPTirxvtgyNhlim4kgQ5L0NhXn6gDCuLOyaQWRiwkdIp2GVVbDdxIQu8SCi2+p2qda4kvTJhOW06Uk1tVdg8rDTrXP2oj6wPpBUY93H2pqe4ulBSugprfh2SrszwEUrm/pR69UZyW84I2Lb2BiJnPRWb0WqjqquxQ1NV1ELkYCzXdI+DKQyvvApEAci6q2xw3EgIaSznepgp2Mt+GoxLUHHob58+dj/vz5uP7667HOv56GLbbYAoceeijOOOMMbLvttomwJyQkJDxPpDjIlwgPP/wwrr76alx99dX46U9/iokTJ+Kggw7CQQcdhHs3+C90hgwsqqhFto4UZFAEos4xifya4xlLoWxz8osLxJzzzsuQ1d0k67rx/6ok6WyH4fckv3P+vdYEY3wjodxYZMbBaIeusbHTaUdbdEyJTkiaybRF3pCeY0fVYJUpyGCZzbHM5uiFx2iZoe9MTJcpynDXoPTJMhyd2GqLZzIUbulr7eMUs8xiKC8xlJWwpNAvM/TLesRkLIAVNpqYwCJ98Fy4CowdlShV6VrCifhMKKlS5WR/sVRdyVBdhQ3xkjKyEZBEW42hnqPm1a/2kQYiMwe+p8YxMFFv2GSax1w7PS9EQ6I2wg6MrbKv6GZb1PQBv3lLagtQkWCZ3CIJPEnPOL8PxxLvdBDqxL2hvMu4xbi/qL6TthzHtR08Xhr1a0n4039/wr9g7ty5uPfee/GHP/whPh566CEsWLAAWmtsscUW2GabbTBz5ky85S1vwRZbbPHcBjkhISHhFYwUB/kywZ133okLL7wQV199NebPn49ddtkFBxxwANY/8jGst9UaUOph3IKvAFgjxuJZzkiHiq+9fURHdX3UZihI+8jE0JhIKupM1FlVt07VyDhQ5X07IBJ0AJGUs6rOnzFIbCt8EFT3OhEvnYYKKnkfQEkavfA+075pENtlpKLOpH7YFCEL3qGrLYZMgZ6pCHymM4xqB106GO2JdmwoxL57VnUVqmJW5ZV2rR2MIuSZRSdMMgwpz8sU+YZOWkNrjbIELGc5SgIX0mrIhKQa0bQnqvGlJ2A1v7hUrAMhJoTXyr/ndYCKWClWR21F1MioBoEPFhlpj2mq4o00mAFFvTm5EMp5mz2mRtJrhHlswj4uUX8OBHusVJjaR0IlHxPLSW8ZSG6R6nkjtSVushmt2CDx0pPucv+sLeC49gCIE7eqMJX3Rbxn/3mLxz3WVyCo6ArVBJGvZUP4/fH/D1deeSW+973vYd0z1sXIyAimTZuGTTbZBJtvvjn2228/vOpVr8Imm2yCDTbYAFmW/ktJSEhIWJlI/8q+CLj11lvx8Y9/HFdffTXe9ra34UMf+hBu3uDryCYO4690G7q0AZ4sVVDY60QaqCwi/rUOJF7VFPaSNPrWK9DW6fjMzYlKq6O67gTZJqp4iyTm3hcelgEEy6mDCFF5VpqA3GeFA4FEks8WN5pQOo2eyuKxmeCZz7SL7e4jcYe33HSMRUeXWGZz3wk0ML5cOZisj0yFnHiXYbTMMGoy0ZBJ1+4YMFT4faUIWvmccxOIO++PUQ5F8NZrRWIdf1cBcCCl4DTgtAJyVASTx08Ug6IMK4Oq5R1VJF4WvIqiVlJ+Nacqcq1LCj8jLTPh4Viprb4DKoVfR/uOUPtrhL0i1mP71RvLUGO9ZswiBFFHNU5j2WLGI+orrJIvr7lRsyHR2Au2EnVJsqmRCjTgPQ/LSS++ywDKVDx3zkAUddZVcgBwbFvK/Bi0NjQSXvOazYo96lKF1+QjRXW1rEy+uWafg3Huuediww03xMSJE/H2t78d11xzDXbcccdkd0lISEh4CZGI+0rE008/jXe+85346U9/ihNOOAH3338/znvyBNzmLoF1E9Gzpka+ZRdSwNtFTIOpcGGoJOvcBMnysyDsbd1Em4S8xnGYSzk18N1AQyEmpxyFmBGcCtt0CmWpUei6ss0EWAeSbMRnAGCdglZAZiy6xvpj0hqltujZLK7Lz1qRt95oiwnZKBwU+tY3bJL2IO466kgh0xWLNKreKIq/421kyqHvDDpGw1LprTjWj7P09vvxUJWVxiq4UvuxQSBIGUIqTPDDlz5xJ45PUGqZEJP2RJvV9yoWMjQssgSUTMxUjcQ1o/oG4hrH8ak3FXVZBDqm/aVB3tvI9wthf2kWhI4JFe54NDPQm2S9oYbL7yrSLTuIDjYqai32jIq4mECJcWUbjAvXRN1fDoDrM/j8WQUqUdUhQKzDqS5xsiBIuiDqlJFX2U04YRpQmYM2hAeOPA1Lly7FVVddha985SvY7v+dgUMOOQSXXHIJ9tlnH2gtZfuEhISEhJcKibivRJx88slYvHgxPn7NtsjWugMX/OXdKKiDUZdhme0Ej7oniKUbbDY0HtgOU7jKFlNZYTxht+xjFx1FHXfijIo6AgPAcpRHVOksDcLO3lhYgEjDloBVOvrHlVD1ok1Fs6UGNeKulPfIs52ndBqFNlgWluHUGq0ImfJK+ZAp0DEWw6ZAphx07sk3e/0ZlhQc6Tgh0iB0TRmKY6vYSUcKo6FTa+EM+s7EuxmjNhuwHjGR911Jjf9FDSjjmRoZ5dVzGcUIVLaLQLKsIeErDzYa5ckeK+7V4ahY+KkKACUJ8qd8V1ItiK5QyFeUrFfv+eQ3iXvYk6b9pQXPirSr8b9fUfJOWoxzeK6ltsjiTLaJ6CpasWZ5kcWiTRtMnCypgX1zJhDzBnnn34tdRTNU9iZReByTgBzBdapxiZM78ftsb3EZAEOiN0H1rAwBmqBNsIdlDr/Y4wQccMABuPbaa7Hxxhvj+OOPxyWXXIJ11lln+YOckJCQkPCiIhH3lYTLLrsM3/ve9zBv3jxc8cw/Yqkz6IUUmGW2Iwots0jcGdyJFEC0jgCI9hH+XqrrXlWvkl6kN92FQspI2l1DSdfyTQsjkgRfKpbBhM0Rg+QASGLEZFsof/5AKCa5gIm7Qkh28TGMTvtj42Pn4+aoSVbkuyhRaoOMHEZtBpgSOoxZpm0k6DqwSq0IubKtOfRA8K4jWHHCRIALah0p9J2/S9Kzma8tsMbfPXCEMtxV4ImSUn7swUWsCrH5Emny40aCnBGEbcbbeJwKFhoVCoc5zp+/4/Qa6xsTEXd2bSSGDNhdBgg7tSwj/O1hG/4Sodp2gfFJ++D19CyWHWsTDd927bsxyHk9+5yf+UtvWyIFuIy7g6pBH7lQ3muWFiMeYrJUt9R4gg5UY9y0ssTXgcj7yzHc9XAASMXsfJ4AVvUMFMl7JOyBqCtTkXXupmuMw892Pgn77rsvtttuO9x5553YbLPNkhUmISEh4WWMRNxXApxz+Kd/+ie8+c1vxuqrrw69tEESobw9JlhjpM2FbRfNTqRNoknwiTBFUNF53bpPXUXSToFN6PAfPHOWqKKjWs+/4A8EaUd92WolAFZBO0naUU0CamQ/EHodnpn8GIIyXp12TNhrSnyVWJMb6wtGFUEpA5S++DXTDkvLThiv4J2PxJ2Qa58drwXLlNYkPjcAYg0B++55YsU1Bt5SU/oJQhh/ozVU2cyc12jw3jAeyh9/IO0ET+RZlQWCym4CMS9VmOSEsSjFxoRlRVtU5D6eh2oHWr3qDRW9prpTte54iB7uFcFyFPW4TMv7gUZEYxDzqJjXSHpdOY+bdgRdKt+BNpJsFdVySeLRVNv58hG/4eS/qmL8+W9CFpEyqrsl/ntkQTHPXCwiRYjsJOIGWuHvRyjqMBT+lkITMf5bD3e4+G8o0w4/mH4s9t13X+ywww745je/CWMG+yUkJCQkJLy8kIj7SoDWGmeccQbOO+88rLvuujjggANwxhln4OruR5Ari0z5pJQyPLQiFMIaErejKKrpnKvejGZs+qx5Gf8c1Gwd3jgNUgSF6nuEdVnRjogv/fKR4HOxJRAbEMVIQUHyPDdVAwQlzhgURXWeNMVcdArkIwrLClDG+Vv8cFDKF7uiRLy70FfeniI7uhpdWV+McugYP+7S395mTeLPmKAzaee7HDV1PthlinC3o1lLwF53sjraZBBsSqr07yv7ihKEGjVVXDlVja0afCbtSScQ1F7hRddWKORRMRe/A/G6YYd5UbA8tTwsIwm7PG2SoMuEFlkUyp5zSeJlYa4uwwyWqt9oIvrWhe2lHr1YDZiM7CTenvhdAJWlJRje2fceLS7cwTcjqMz5SbaDn4SX2tuvCLVOv3FIg8JujI83NcZbw5Qi/OR1/4LZs2fjJz/5CaYfMR1HH300zjrrrETaExISElYRJOK+knDSSSfhpJNOwu9//3ucf/752HPPPfGOd7wDZ555Jv7nz++NxLAkjYwcrHOwqLLVAYRGRj4ZxZP3Kh1F+sL5vUxPqTLWAQped4jv/AtJ8sV2Vf37SNplJjp5xVzpoByr8J0gnXCqztmZtDCZZzLDhD0+hxV0IDHQnpg27ihYUhgtK9KuRPoLgNi9lYtcjTJxXWlFkpA+d37mNB7bGCv/3QoQdibtJCY5oTg15rqz7zkq3mogQ51zvLUsMrXCq26r9QcgJgTxXMjXGHzdhtaOpGio7bXtDW6QlIrKtV9IfC7V8TDJiwo6xOdAZVdpKOCsaJNWtbx7VvqjtYiocnwBoVi0SptR5Mly9JPzuWgq+JnIzucNiokEDN9Z4pjQsC4r6vxn5QKz10y+feGoDn0R4rVlqHa3TLEFRtebjGnt7TB3HPQx3HnnnTjzzDOxwSEbYMaMGXjDG96AX/3qV9hhhx3GP+EJCQkJCS8rJOK+krHFFlvgv//7v3HCCSfglFNOwfbbb4/LL78c3x36n9pybNNwpOACYbfWK71cZCqbHjHbaSPqtdQYoEbY2WoB+E0ojMPagkSodFDjXbV9v9NeAQR7tbn7pvNb9QWQguzLn+GJAhdQxmcllEcEfzgBme+2SmTGtNLIyEYTGj91Mq/d850MCmNdu7uAelfW5ufcnMpxsyoeHmFHisW/nCYjCLvi5kxyUkOoR0C6xvcy153JvG08Qpxk27JjWmF4EGrnQijt4vvB94OkfTzCTkrVCjoHikNbCPoAEZcFoXI7ksjrisQDFXmX1pZaqg5hIJ8eCrB5ZY+JhaTxOAna+vhP0oLUW3EMgLe4ZKj85jwRjWTexfdKIRaKKkVx+BQQrS3sRVfwkwqOWtWaag3Q+HrPjPXRq0t6OLXYCddccw02ee8mePzxx3HUUUfhwQcfxEYbbYSEhISEhFUTqXPqiwgiwhe+8AWcfvrpOO+883DEEUfgvb99B5bZDp4pO1hSdn0WufVZ5NKCwQRS/mc9kLsOCJJeo+SVsyIQ3ug8UFWyC782wk6iFfk0lpiaUnnm42tpA3G+cyissH6IorpqMITq21RZNVX2hmgdQCxqZUWyhjDBYItAnttol5E2IFnsy+/D7sRx4kmSHNuqO2x9rHmca51UA3FXpeiiGpN8xPkgQShlM6aGGl4j8jbkeYuiVNUk7k1SCknC6+M2JpmP52g5CnvbPx+CYPthCmNZyxGv21uYpLdZXHhd9qfLFBX+fVkYKpfnfY13KbgBVknQZagVoCqW0XF8o6mvzwkuNVVfxDm6THjXOZIxeNbBz9H+4oJKXqnpxrjaHSMFxLjUzPhiak6MAqq/Ub4jBwC5cbhhv4/jq1/9Kj784Q9jww03xBve8AbMmjULe+yxB4aHh1tOVkJCQkLCyw2pc+rLBEopvO9978Pmm2+OI488Evfccw/+98MX4323vQOAJ8k9nSG3uSfv2qF0GqVxtYjHJokHSBDNdhXav2+Q9PCbGat14dG04RS2ipxk5Vkm11irYUvjU2wKDco8eSVW30NKCqvxDAr7GMk93w2wYdIRfcSB0LGKqeoZ18gcVPALM1HnZJf4W5J0CrE9ToSCTaGyIIyddU/iGBAIOyd+gC1CBZN2FVVxoEHKeUIjyHezgLTmdRdKe635UVyHBqIdB9R0VL8//ufUTtSbEER5LEW9el0vFuXOrmxlqUivJ9DSlx63IbzlrmHLbhJuIBBzMZbVdpT3mYfPXA5QpmrxjTIHf0zPf7gToqFAzvvW+dqFmHxG0i6LRoOVJct87UUWCq/zQMqV8j0KTOgqLC1esmEZAFy4xcn41re+henvnw4iwoUXXog3vvGNY+x0QkJCQsKqikTcXwK88Y1vxK9+9Su86U1vQlmWmPz2JeiG7qA+KrKMMZF9a1A0uqBK+0azKyiDybkORF3GKupA2nPjbSSZdhjOCmgQOqZER1to5eBIxwxzGT8pu7L2S+PvDBjnrSS5J7LWari+AQX1HeGZIums23eAuoobCXRQomsdKIMXPjaUQbWshU/Zqar9mIiPf04iGZdETViP6l1vEItM5WcqEnhU3nVhbYnbYZsQIfjdG6o5E3Jh7YhKeiPOsemPb8PyVPXqMxr4DGgn7W1EnYeCxzGS9ZYs9Nj5MxZ6VuMvu4LWvPByuGNueVC3JakPw6wL/3uKr5swOawlvcT9ULHwNGarc6qM6EQ6OLj1Y5bbjmMpb+eIu0JjkXb/bGN/gky5SNBHnylw+hon4Z577qk9Xn3XF7Dvvvvi9NNPx9vf/nZ0Op0xdjghISEhYVVGssq8hLjrrruw22674dxzz8X9076Bp+0Qltkcoy7HqPMdUUdD4x/uBMoPSxxPWLEEjj6MDYq0ixnmnKYiu4d2dJUb2NUluqbEsO5jQjaKEd1HL+yHf+Rh37JaQ6LCeeLeKzMU1ifglFajLI0n76UGlRooFFSpgVIqzKpSooFKeRcWmpoSCwj7DFBr285ReOMRp5YJTk1yZlI+FpjEA9XdA2kDYoIdibaKxaS6ULF4VE4OmoWntUQZqbAPbFssJ3PYmfQ7QHY9bR5qPB4Iwi4+GxMtZJ2HbqCgNBZsNrq68iOrIhZZPed5TS0Xnc+xPH+qXhDqs9bD5DRM9lTpE2OiPYaLUkv/HYABBV92npXxjLIpEkmCTmJioRr7GGIao+KeBcU9c9Emw6kvubHIjU8/yo1F15QYMgWGjP+7zKiPu09+AHPnzsXaa6+NLbbYAltuuWV87LLLLpg6depyTl5CQkJCwqqAZJV5mWLatGm46KKLcOSRR+L9738/TnzPe/DdZ45DQQaFyzBKGZbaDgoy0ZtdOoPRQOIBT9b5O98oyDMS/j4PEYi5sjAt0infcrekMaQLTDA9rGWWoKMs+mTQow6Wug6W2i6W2C6Wug6eKbtYpn3zqJ7N47aM1ig0QStTs6M4gk+2CSkepOAV+KCs18iogLLhSwVPkJkgkZfjlVIgC9+ZSNhoBog7b0+SKkGguVHUWN/H9w1bST35JbwWyzZJ9sAxssVlQFlHFVUYUmPQ2G7dWjM2aR+LrPvjpfbv4ri0TXQa8x+2vYiEF2eEyh7jEoV/PKYGebLs8mpZaSUaaEjUOLekqfKhi7szsm6gWZQbty8If42s1yYNVJ9oMInPRGQjW7iaY8iyv1NVEyTVWLY+3DX4Cbbv9aCdweFPHIn3/OE9WLhwISZPntyyRkJCQkLCKwGJuL/EOOigg3D55ZfjC1/4AjbbbDPsv//+eO9734snX3MaCsp8YSg0+uTJeo9yONLIlYWF/8/dQsGA0NUFDHyspEGVY96J8mLVDqigzNtKKNhLSCNXJXJl4aDRI98UypFCriyGdAGjHHJnYeC7ieY697f5lUNPZUCZ+9xzVcVZauWVRqecJz+lCi1AGcpnwfNbSWyVT6WJZJ991zp8oP3ySlNUgZVqtJ1vkO2w2eojBSioun1CieWa6weVNRJFaW9pkHi5jVpGO+Q2KjW4RixJKOYtEwElvh/38+YYoIWwi2NrRjIOLCZJumJS2yDqIo5REvcBGwxvU6NW4BkrhIFKEZfFnlos4xBrCerWpHrtAL+GQy2hpnYnoKmsRztQY7ISz4kClC80VcaFbrX1i4scoDRix1JZY6K1//vgIlT/7P+2fPOw6m/4S1/6Eo4//vhE2hMSEhJe4UhWmZcR5s6diwMOOACTJk3Cl+dMRJ8MCspQkIGFRkH1ajwm4R3lPekG5Mm1KmFAsFAoKKttp0/e9lKQ8dttGIhZldfKoXB+HS6IK5xfh+0zfZdFK08vFNSOlllsGmWd98UXRQZbhlSaQgNFSF0JBZy6rEhXjfBCkGD2NatKBW1rcMMYi7SOaQVhctjwU0ci3lTbJZl2gObGSm1FpW2k3cntI9hkqLb8wO/USHq9QFV2Tx3z2DEGaYdQ1wUh59smtTSVMRR10qqKUeRl2eKkmttF8JKLfQnqO+UtjYlkPQMr1hyzWSpvfbHCHiNiNtmGJG1K0uoSCbyp9qlJ4GOsI1t2WDnnhKPQIMwYF+wvvsDbOZ/GpFTVrZQLwWWtCeDrTHJjY7OwIVPgy5t/HP/3f/+Hr3/967jvvvvw+9//Huuvv37r+UtISEhI+NtBssqsAjjnnHNw8skn4+CDD8YnP/lJXF8cEYk2k2xW1xkm+NdzZZEri44qMaQKWKVhlIMljR7leMZ1Mepy9CiLFhwm4WzDAbztRir1AILX3njlPyjwBWn0XeYTb5yJ6RYaFGPqOL5OWU9OSq2hSlP1IioVKHhfqgJQzxVr8ZFMZOGfSQcSzeq7UIbjyIxBztmCPGAfAQBbqc01CHKueD/RQsIlaYcg1ELx5fUkUR9QzAdSYcZYjpV1cbxjJcTUDkfaX+QdBjHxaXYejdaVUMDpH6qeviJUbJkaE0kv/75Q26tl/PHFZkYZeXuJCWlJimoRoBRsVhSuF1Jq4LTx9qPtXOzXYPxoNSmBWDbar5qRpGx9CQkx7FePBaeCoMsaFKN9B9NuVnpbm+GWa8Dle/wvHn30UV9setc9mD17Nja8akPssssueN/73ofDDjsMEydObD+pCQkJCQmvGCTi/jLAxRdfjFNOOQVXXXUV5k/5KC5f9m4UNMkr5s4nunjfu4n2FibZubboqhJDukCuLHoqH8gpLyjDUtdBz+VY6jo1tbyginz7QlY/GTCh0NVBoXAGfecjIbnjqyPlYyLJ581zZ1GOreTseVYdnVNwVtdjxBUA4z3wmoTCqiqSGhdlUqy99SCSyzbPcJwIMOOsyJPC4LYHrSQtJ0kS9YaiPWbhqCD8TNb9sdCgGl8rTG0pRo2/Se2/PzAIg8fFnzeJOie/uBDPWItCDIo1gBiV6DLVyDCHUKkbd0TEnZL4+2x5ie+Dei1IOjIHnbtaXj855QudG04reUxKI3bZVVRNEgaOXeyjY1Xd1Pc3jg8BihQIYbLowgSv5e4F22A4XrWblchUPWLVF4aX+OZ2/4VLLrkEF154ISbdPglLlizBxhtvjK222go777wzPvOZz2DTTTdtOYkJCQkJCa9UJOL+EuPKK6/Ee97zHvzgBz/Ab9c7E6N2JKa5sBrOantBOqrembbo6hK5s+hpT8i5AFU3GJuDqiXElGS8rcVltdhJIhVv4WtFyJSLsZAlaW97CVGQZejmap1GYX0EYxkIOpGPgyQXcqaD15ebFFVdRRFUcwKZoKIicDzFcjoi4VKBRJIDYIBYIArUSG5FdAXDG4ucj6FMN9GqZjeJ9VgEnom6mDDUvdd1Mh6XBWrksG2fW0l7/BLVXQkIUopq4sM5+bJjKBeR+sJZAjgLXarSEuK46p7xZjEnYtIKglqN4PNWMpkl/ITJbOgQqmBLDad8DCicqpovUSD+4XxTbae8Bas2RC2kPe5vJnz00hajqn1XrLaHh1Zjq+1ZaACWB+uLj1klnGSPxrnnnoup35mKrbfeGsceeyy+9KUvYfPNN09NkhISEhISxkUi7i8h5syZgyOOOAIXXHABbt/gf7DUDqEXYxerSMjCeQJfUqW2Z8phmbboap/5nClbU9qb8Osbv+3gS+fP+tYT+cJ6SwwAGEW1Zkw2NF3i7o3cDMqymu4qdV0Sdf+aSXr1rKzyRam2It4IJI2yQNBDcSpcnaAyeY8kkoSq3UKqgeUQ3PGwPGW+qcATole9aaNpFqbGItImqW+Q9vEsMGNaf/j7aHmpdyolrep55ZxlHl7HcbWBxJc0eJwOgI01wgAATQqOKEyseCMqTL6IF6pIuyFo7aLlhDuI+sZgXuovrIFSBtYSoHS4hLxPhp9j8SuUCB8Kxc18t6NWKwF5I6aajERFnipbTGicpE1oXKarbqdcYJoZC6Mp+NSFHUZbDGUFhk2B/1zvI3jf+96HN133Jhx11FG44YYbsP3224998hISEhISEhpIxP0lwo9+9CMcfvjh+OIXv4j7tzkPo8HKsszmWOY6GLUZltk8WFRMJNpEqupyqix6IdWlaY9hcFxk/A6+YLRncxTW1JopyYJSBcQiOgBe9QzNn1hVl2Q9qun8zJYCQdhrueec8sFe9moHa4R4wNbCxxVa1dcy0RvEEhiLEIv1ID4bC4GMt/5Oc7uN7wctLzSwb212mNp2l7N/1DyWaAlpND9qkveojKuqOFMQd25Y5BSglIo+/do+Efw5E/ugoUAU1Gv4RmFwAIzyvvWMQNYTYuf8csr4hbQGtPZEuJNZWKdB5Pw+km/gBUP+MiJV7QMr7/DXeDh8yJOteKyihYfq149TgK2WJ558EIHg/E0HA8BpkHKxa7FPhqHYQKlrSnSzEh1dYsiUGDYF/v6BAzBt32k4/PDDce+992KdddYZ+4QmJCQkJCSMgUTcXwJ8+9vfxjHHHINvfOMbuGfrCzAalHbpPY+NjkT3VPaSc4QcK+9MrpmkcydVXoZJfbOBU+m8P70MdhdP3EP6S7CgaO1VRt+hFZ60B5vMAFl3CB1FVUWEHKrYRH7NZA9oJdneQlIppTUiz8opLydVdoEa4Y/bp9ZlW9dlNCcPbWR9BdZrFpjWjrdB2Ae2BQxONORPMUkXfu+m0l7zdwfC7gRhHyDuCDae4EqJRcDE2xWf8aNlvzxRpmg5iYWqvI6mGJco7Sa5ccjD9esnjV7hroZIw8GFYlvNxhj/vREzMwXAEYiTf+J4if2Q+yuSZCSph1U8R4E2/lS1dSxmuMZ3F154IU4//XT8x3/8x5jrJCQkJCQkLA+JuL+IWLBgAU499VRcdtll+M53voP5rzoLznVQhMLPJmkvw+dM2lkVd1RFocdYOcH0WJU3qkp54c+ZuBNQs72Urup2SlFFBzjpxa+P5avq0Q5TEXcZqVjzf4uklqb/u5Ymw8vLZxbAlfgeYhtjNBcaWFb4vpvLxffjqfdj/MZYhH08S0xtU+MQ9QjVQsoDWR/8DI2mQ5Uthr3tpBCLTQFAaU/eSdcnSYqqbcvoRwrNlFyXYLsEN+yArvXJL2U4oFD4qaJPPGScs1VGEbJI3i1yIF7HhdUwuurMq5SGhQ7FqH4YlUa4RUB+fOJvAk5Vzazi/ofvoxe/kWoTPe2K4t+CL0BFLETlvz0/f/Lvs9CtONcWp65xOnaYswM++clPrsBJTUhISEhIGBuJuL8IuO+++3DBBRfg85//PA466CDMnz8fly89GtZ1YEnHjHbfbEnFQtCSdGVPCUq6I8A5jb7TA4pfJBDKEyCtXY3g8/IuqIWWC0xDcalzoajUemJOVkdfMIBAYgVRj2RUeb+6k59hUF2vpaiI74TdoZ6uglYyDAjCPoYyXYs9JPiyxQbZlxOI2iZWQF2vfY769wO2mrEIexNtnUrbctfZAiN92WACXZF2GXHo1fQxFPZAXDm60WWIxZ+xmVFbvjzE7/LEICM/H7KA6iuQ1kDXAgbQuYtZ53yoWvvX3Hyok1nfhMhYZMrVJp5+OEL0qCaQ875zRw5EIdQ/FN2yzUfaouIErXEdEZ+UYKOp3UXQBJ25cEegIuqyEJUtMibYZDraomO8VQajfbz73e/Gcccdh+22226ME5+QkJCQkLBiSMR9JWHBggW49NJL8a1vfQvz5s3D/vvvjx//+Mf443ofwLW9t8OgG/PXc2XhdMhJV96z7t/7Z006quo68GbZ4MWxAh6gdNWZUaqDDLa9sE+diKMaFZxVIA5bj6Hr4sCYqEvbSyTAapCoNlTyAXIvl0GduDcJ4oCfXZDhZuMkoEH2aXDbcblG8etYdpp2e4xkge3LNYn6QEFpG2Fv+W4gxhGok3aZFBOVda+uk27ENjKxzxC7hA6kwWjEZBnFKUCo1He+k0KaKsW9Q3BdbpjkyTBHOFKpvYUcQN4pvbIeijr5DhEr7V1TYsgU3g6mHfrawOjM110UfF0blAVARgNEfrJpSOT9k49xJIArVvmYIqFv2nzaJmOcjERVAW1uLHJTRT7m2mLIlBjKCnS097Xv/4eDcfLJJ2P99ddPantCQkJCwguCRNyfJcqyxOOPP45HH3104PHnP/85vn7kkUew11574cQTT0Sx/ZdhJj6JefQhwI6ELHbPJExooOSUgtNFzEiXaL4HAFjtCRNVkiLbWzjW0edaV90ZVYNBUlDxaxYYJuuN9BfZzabmV28j2rXXg2otMEiU2wh/fWerlzVC3hwauX2HGLXYqhY3Xg9A2E38eDVIH1Cf2ChP5AnyPWK4Cr8Hf/YsIJNQlFw/WGNcTUUfVNYr/7Yn67Xs8qC0cySijEKk0Bwp1i1Y3+1WlfDP4Whr2zcE5A66a30ai7g1ohQqL7uxGMpL5KJrKNdkDJkCQ6ZESRpZmNgSWX/XKC8R3ECewJcGVhOcIlChK/U91lrIsaqfa/a7xzsYtbtLvIDff2nn0WEyHKNTtUOm/V2CrrbAM0vxzne+E1/60pdwzDHHQOuWmWVCQkJCQsKzRCLuAo888ggefPDBMcn4o48+ioULF4KIsPbaa2Pq1Km1x1ZbbYUpU6bgtvI/MeXV22Hi5B769E0UtDqW2BwFGfRcDhfYgQ3xjtxUyUJDg5DpKr6DC0tjkWlZnTLpsS1L40mj8qTblWaQjAaS4tdF1bGU0O5Vj+Q3JIo4XSfYDd9z7Co6jsUlfl/tSjuZV9Xnrdti9bmpqAeyvtzJACv1TKYbJD0uxp/xMnIXWwh4HDf+nvctRERKzh/34zmQeGdkDjuiss6qei3qMUOlikfVXTZKoqrDaewMCijjfHdQBZADXKlBpQZlFXmPViqFqsNoSHchp6ANodMtq0Jp7WICS8f4uMTcWHR0GZKSmLy7WOMRm4WFOo9+maG0nHCkxXXMvjD4yYf3SFX9AlrOabT46DBhMdUYKENQmYM2Fnlu0c1LdDIbSHo12eiE/R8yJbraP3a45+9xyzYP4Ljjjnt2JzchISEhIWEcJOIecNVVV+Gwww6rEfIpU6Zgo402gnrVz7D1Oh2suc7amLju+piwVge6kwV/+igc/QEWf4IjjQVQWJs2RA8KvRJwpNFzeWymZKF9PrszKILqzk2VHHz3Ufmemy0Bnrwb5VA4g1FFKJ32zXEA4XfXnnsr5y0KjaQXBokXkqTLQtFKpW7xoyMQU1aCURFm7zFWdaLaRsqbhL2FWA9gPJLLiqryO0SBMNeU8vCk2sZiDEQ+2Ni/qKSL7+Rn8RiV/4JUY3/CMm0TgNrxiokFk/PK9lJX26NvPQNcbCgkiLoBwA2Roq+7elahyZDWFLzofked1VGBp1KDlPJNs3gfA+lXGUXCz0WngL92hzoFhrISXVPG7qH+2TcT4+u8dL7fQM9mPrbUGYyWWSzOLq1PQ7JWw9pgF7OqmsQFBV1BgZS30MTxFup7nKwZYe0RpF0bgjYWWeaCrceT9OGsiHGPHe1tPZnyhaif2eJszJ49GyecdgLOPvvs5VxZCQkJCQkJzw6JuAP44Q9/iCOPPBIXXXQRiu0/BUcKfVoIhydg6W6sR68GgGhxeQoKrtSwUChcFgi3hoPynUVR3RbnzqdM1Nkiw42V+kFV5M+ZrLM9Jhalov4ZR0JmRsVi1NLoQGY0lNJwmnyhqda+IpUJfDNTXarRreo31fOvFaK/WarvNQQZu0b45fZFakzEcsh669eC8AreFkmzakxYxsPA3YHmnYK2LPfwvu23pTUn8ncEjwenzaBB2sUdhZpNR1eE3WUqpr+4HPXiUBMIe8YEnuqdSw0BWVDStUhHCUWiXBdhTNUboLTiela+DgPG36rgZBi5DWMcsqBMm5DJzsWbw1nhu4gai2Hj/eBdXSIPDcSW2Q5KmPh7WhE0/LVu2QKG6m4TD5C3hql4nQIUx0/p6s5HHF+OfUQ1Jjp3cTxkN9TceLW9a3wzJfayDxv/OHXtj+PKK6/EFVdcgcnXTcamm26KU045BYcffnjrdZaQkJCQkPBc8Yom7kSEc845Bx/4wAdw8cUXY+HWn4W1qwWynXliTgaOdCTmNhBsVtClkl46E8l7Kaol+X3pqmVkpjoT81IkxcjYxipRRqGZJMMJMQAi4VKK4HQoXtUalBFc8K5zjKOMc2zltTVFXNVJT/hN5chbaErlRVvuhCrJf4PgthWINos3xwST2OVZS+R+8kuZyz3GdsecvFC14Jj72lDQ5R0L5ailFmBwnNjmExV4VfnVmbC7HJG0x/jFjILdA7G41OWolOTMDSjhRijiPAnkItEYMQqgbw20Mig1wWqCtQStPWnXgfj7DqK+uFQpitsZykrkxkKDYkoMF292tcWw6aOrS4yYPnJlUZAZGNZmN+Bo7bdVDGNZAo77t6qqt4APXQeoeYXz3YVgi9GGYDKLLLO18WBbzHBehLSYEiNZga9O+xyuu+46zJ49G7Nnz8b5D2yOvfbaCwcddBDOPvtsbLrppmNcJAkJCQkJCc8Pr1jivnjxYhx//PG4/vrrceWVV+LWKZ+EsyM1Fd1HNOqodLMXvSLsGgXVCbsTJJw/L0NeOhP2WsQj6sWnVYdSxOJRy8TdDTLPWuqhWIfYKqI8bdGh4DBaOiIZV3Wvu3zNJB8UFPq6gh5jAm1F2quOqGH/Wgit5FGtHnhpHRmDrNesLmMtK1Tr+KzFs1iH16tZgVx9exwxyHccauuL2Mx6ik59XPwz1TPRUY2L5mWJqjx2oagPePHDNhxbadgOo0KzI7bDSC9PSEhRyhPjTmbRycqa5xwACmuQ6Qyj2qFfGpTKwBh/4M3IUSN837IxGPu/O9oi07ZG2Lu6xJAu0NWFL9AmX+PBHnetCNrm8fw41P8efHdWvz/WAqTC31QzCQmoF2yrkB0fFPVOZr0NJqsKZXPtx2IoK/Ctnc7GzTffjGuuuQazZ8/GWnPXwmte8xrMmjULn/70p/H6178eq6++OhISEhISElY2XpHE/aabbsIRRxyBLbbYArfffju+8vhxsOVIzepSOi2IuhYFpf49W11Kqkh4k6hzDnsZ8tKBSj1ncu4CiW8KuTKqkTPYY3MkwWIV2CZAgZBxa/gxyDlQ+Tb4NT9LWwnbYJzyGe1MKK2qkVJwR0oREdimrA8o1cISIgtRVeOZwjJNH3iNrDdtJZK4SxuJrmIO43dMavmuRWOiEbcrjyckk8hayErd5UmNHytdALoMZDHWHCuAqFZ/y/vuFHzmuchOVxZBTyZo8B0Tr7zz3Q+QV9oJiHn/3hZFIBvSVoLyTuGv3gZbiHX+eiz41EOBr1ijHXJSQAYY7ZdtxjfGwlNQ9H5n2kUSnse0lRJd7e0lTNiHlP+so0pY0tDKIbcWBk4QeBc98X2TIQ+FqqPWeM+71rBZVajKfzOycRiAqKZnIsoxD551XxhrMZIV0MrhE+udEYn6Oj9bBwCw33774R//8R/xzW9+E6961auQkJCQkJDwYkNRW4MXgQ033JAefvjhF2l3Vj6+/e1v45hjjsHHPvYxLPy7G+C0icRb2l2sIOJtBaMrQtS5M6lUzwFUSrsgGjJbvUpK8b/D5JyY4JOqrC9MdJmkyI6mUkFvA7W/rlljOPKx9MRdW1RJMzEWsiLqA7GL419ey8cKkPU4HxHdQasuoRTjENnXHN8rLkocHIdYAyCJu1UV0Qeq9TiNR/k7E6qUEx1AhwQWHR78mm00tWMVar9fN+wWF5lyokwsQEWVIiNiHquuqMHjnpPoBuotM9wMibPJmdR2MouusVF5tk6j70y8UxStJEGdz5RDx5RRadchEpELTrlXgVYUX1fEvcCRG1yN66+/HptuuiluwFFY6rpY6rrouRyjlPlnlw10Fu7bDD3ri8T5b9CGSTFPLLj/QUdbdLMypjZxUamBhe718G/r/SduvPFGXHfddfj5z3+OP/3pT9htt90wa9Ys/P3f/z1mzpwJYwatPAkJCQkJCS80lFILiGjD1u9eScT90ksvxXHHHYfvfOc7uHrKN8ck5kBdWZd+9JLMmNYXJg1F6ERqScTVoU7eI0kPqjoBtSZKlQ+dZd265ExMzrlRUliHn2OTpAZxX66fvGltkfYYF4jnGJYYqbY/a8I+BkGX+eVy2aiES1VdVYo6E3WX1cm5T1NBiDwM1glORAmZ5RTubCi2mgD1LrJ6UM2VDas4+14XITaRSXghFPhSWGd4fBvNnCprTXXMVZMkVUuRcXlF7rk4tdZMyVAVdxiOXQUS79NTfEFpJ7PIMx/VyI2FstC9tHQ61niwb72jy2iHaSPrubboqsoSc8yGP8RvfvMb3HXXXZg/fz7mzZuHm266Ceuvvz4effRRzJgxA3vuuSe23357bL/99thyyy1x5j1vw6jLUJDBqMtqqUx9l6FvTe3vEvATXY6X7IRupt7+UuIL076Km266CRdffDG+/e1vY/Hixeh0Opg5cyb23ntv7LPPPthtt90wceLEZ3kRJyQkJCQkPH+MR9xfEVaZe+65B2effTbOP/98fPe738V31r4ErhiKKS/SeuIEg/SqukYZClCZuDTVPU/epQVGDXQ1ddQg4YC3sAhLS42oA4PKOUPaXEhFBTw+j6d4t1hC5HP8dd5GJOOqRiTH8rE/V8I+nppe+bYFQVfyfUVqEe0wnqxTFgaC1eYQTxhjD4U3h4st5V0MHUgrn0sAsQCYP7elT/KhUoNKBVIKCv5OiwYBZTi/oXup//2gvCt4KxL8+WcFngNT/DFhILXHL+f3R4dxI/LFyjr4v/1vBZ+RUlUzpTDR85ObqgGXtRp9IF7PpdOxM2jXeILuu3F5ZMpGS4yEgW8qJj3s//SqH+Lss8/Gqz71KoyMjGD69OmYNm0ajjvuOFxwwQXYdNNN8eSTT+Kyyy7DzTffjLPPPht33HEHRkdHsc0222C77bbD9ttvj+222w4Xuq9CTxgGmTwo6A6aCBoGLlp0ghVGlRj982IcuOwtmDt3LubOnYvVb18da6+9Ng4++GD8+Mc/xlZbbYVJkyZBjdfBNiEhISEh4WWAv1nFvSxL/PCHniz88pe/xGGHHYaTTz4Zn+l/dcDuAgBaZBOyp12SdUfKZ0cHct70qNtA7JxTcFbX7C81H3Igf82iUlZr26wtst18tZJfrq5yN1JPxjq1NA5Bl1YR/rxphZHxjmNsf7loI+zhecACI5XkQGSlpz1uR7Woy5mr53JrF2IQqWYRqdJUvK8b8ASW/duFNbCO75aE68JqlKWBsz5H3JXan8eQn+/tReHuRCk966qyzNigvksbEkdFygkYe+i1HB8VbTHRHpNVz2So3ogpqO8wFCc2cUKTuZhbbgwhy0JjpJCs0s1KDIdEmNgtNBSQSg97FlR3aYfpuAIXvusvICJ88pOfxP77779CJNk5hwcffBDz5s3D7bffjttvvx3z5s3DAw88EJfJ8xzdbnfg0el00O128Yc//AFPPvkkZsyYgV133RW77LILdt11V2yyySaJqCckJCQkvCzxirLKPPLIIzj33HNxzjnnIM9znHjiiTj22GNx4r0fGTOKkdVTrSh+xhYZVtAJiO/LQMxtKBi1lpV1PX5hKHuhpTItC0aj+Cs+E6kkvHxNSZeqdyXCjg9pq442Dfl9vTCyZtt4Lqp6GyRxl5YXYQcBUCW7sEWElXTxvhn1SIGQyi6YshMoNxeSOd3cXCcPySqckpKFtJO+M7ERUN8a9EsTmwCVpbdGkVM+N5/vnJQqxhL6TqOqSuJxgbgXgcTbBnkXXWDlHY7KFhSIu7AKDTRhyoVthv3+fBdC2mYyBx2Iu8msz2E3DsOdIlpmuqbEkCkwkvXjOOfKBVuMi/YYSdrZLjPp1/+Aj33sY/jd736Hbrf7vC+dpUuXYsmSJRgdHV3uY+rUqZg5cyaGh4ef9+8mJCQkJCS8GPibt8oQEa677jqcffbZuPzyy7Hffvvhq1/9Kr4+6Ye4AQ/jurvPhHVDkYyTIO4SbJsYKz+di0zb7DCRuAnVnFwLWZe/2bC21GwsUd1W9YQWoKbGrhC46LGxPNtfBgdUqLxt2xlrcvBslfYmYY/pLxXJHFTVxbE0f0/uF/kJT5w0GQIFz4kDoJSCUwpaczEjwZKCdt4u0kG4HhR80x0U6FuDXOcYtRk6xsROnnznJXbzZCKf+zssVGpQ7km9JPHaKFBOcKzIh2LUWsSmE1GSksTzHQYtJnJ8zlS4o2P9cXqrUJhMhmMiVU1qFD90VaiaGRsntBKlM7VOoVmj6NQoB6Nc9ML3XI4LvvAFvPe9731BSDsAjIyMYGRk5AXZVkJCQkJCwqqEVZK4L168GL/73e9w6623Ys6cOZgzZw6stTjuuONw99134/TH/xtfc1eh77roW6+UctqLbZBx9qYDGJPIy+8IVRpM5WHXgqgzQWsQckm6pQ+9zZNOqq6EM4mXWAGS3FTRBz6Xvyu3SfXV2G/NJLuV7APLVfslWQcatg+R/MLJKPVCU6rNeeQ+1LLQEUgrqVouO39PpAEiWBITM+Ovh8xqlIG0Wl1FgGpFGDIlhjsFJqGHURtSTUJhpFTii9KgzLyFxloFZw0cHKjk4lZVHRvJWZAn1E4Foq4ApatUmWqA6xnwAHnlXZL3xgSP5DVkwz4ogMJ7Ut6X76BhKwu7v3uUVR+wRUY7E333VinftRcGo8r5olxFMGLWd9RRR+Gzn/0sjjnmGKy11lrjXyQJCQkJCQkJY+JFscpcfPHFePLJJ1EUBfr9/piPtu9HR0fR6/XQ6/WwbNkyLF68GI899hjWXXddTJ8+Hfvssw9e//rX43/pa1BZVnUoDSkThavSJgouKg0KOae+sDcdwEBn0rEQ02DYGsNqu1U1v7rskOlXREXYowVi0P5S8zc3TmagKgAAKt1JREFU118BtJH2Af97G2lHZctobm88f/u4wzaef12q7DIFRb6OnUGpxnNr49vi8Wffe2xvr1D3dGeVXSYLXu4sWGe4GVE38xaRodDevhuY9DNlF8tsjqVlBz3rYwq9hSbzzYosk3ft7TMhqYavD06eUaXycZFSZS9VpbyzD15alriBE3jclLAOoR4dmQEupyo6kuMh2SZjKHZV1YaQ5bZmH8qMj4Zkr78Jvna2EUUyLwaeIyHjeSDC059cBK01LrvssuQtT0hISEhIGAcvuced/6N+29vehk6nU3vkeT7wWfP74eFhfPaBr0N3M5jhDlbbcA0MTerAhdvxzSQYwEfXEVVdTK3TXhG13t7Ayjn70wFEW0UtASZ+Lkh9mxVGWGJiBnjb0JJMZxFqO8TyrBw/GzvMGMuphj1nXLW9ZaKg3OAycjsDhL2NkzUJO9tixLOThJ192dGnDiA0D+LYRpJ3NlzL+PO+xt8Lg8z2kKzyu7OvmwlrHvzu0ts9ZEoMmwLDpg+tCH2XYZnNsczm6JU5lpV5yBb35J1TWbgGwpYGjgl8KQg822ZE1nsk7jEHHpVFJpwHZf0JIKMGxrUq5vUxkS4nQdrDuGaBuOeVv11pB8MFvMon6ihgoHC3mZEOVHenJLmPDxC+vs3HMHXqVMyfPx+bbbZZ+8WakJCQkJCQ8NJ63K21OOCAAzB9+nRscMxv0aMMoy7HUtvBqMvwjOvgSetJUN8ZlKEbaWFNzZOevXY6AM/FniKFp5ZWv9HkrFKUlZ1KmUxFiwsXjgoQqUohjYS1YXsRZF1x9npbqgsqYtvmW68R9gYhrh0M1d/XLCMklgMGiDS1jJD0RCtBdJVDtJRE1T0c+ljHJa0vY6GNtLPSXiPssmEQE/ZG8aTSDlnmGay12ie6yKLQWBwq9i2+bsrxFfEM7pEGOa3UZe7gKRsByeuVc8MBwIQi59Jp9EuDvsrCtWZAHONIKtwtUI27K2pwwibObRUTqaAsQbngc2+cexLjHGsF+BzI2gGr4MiALAFKo1QIqTvw3UcDiecUHs2JPEJlV4HAm9CZlIk9N2fKjUWv18PIyAgefvjhRNwTEhISEhKeI1YqcXfO4fjjj8cDDzyAr33tazhn0fGxCyI/ltkcPZvHLoiFMzF2sbCmVhQKIBKtqpGRf+aC0jbUohnFOvVlAGoS+oai22xqVCsKRLtCHn9J+tZrPywWpBYFW25EDX5PjeU4jaW+/iDrliq6IopWjBqBbDRUkgSzuR/82YD1RgkSaapjiYkwosOnyzCQBiNtHNwkKAsRjjarp/o4p30kY+MOStwXbrIkBs8FAs3XhqMqPchqjdIRemUOZxT6LoMjhX4g7XytFiISVNZNWHHdMblVbNshCp8j5L6LUxWU9VqajKrP4RQQClMHL7hYSwBhcVIASgVN/m4FtIo2oqpYlc+NuDvBzaaUHzulq2Ph7Hu+W+EcIQsZ93mw1ly1+3/jnHPOwYzDZuCtb30r9txzTyQkJCQkJCQ8N6xU4v6hD30I119/PX7+85/j/3vsJBQ0jIJMrXV5z2bo2RyFNRi1GQqno9XAOt/aRZJ2qaZDfLc8Yo6B5eufKwVAOxil4LTvmkrSysKk3dVJ7wBpb5Di+o8EkhqTPcRXbeujQZCb67XYVKKvu8nymrOFqOKSsPZUUYUyux3c+ZNTURqKPe8nqerz2u+F467y16mKfZSkPSNQ5oAspJxkPuVEpp1w4kknFE16Pzl7ysO+BNVdQdxRIfjCYVKxU2ocAwq2qfBe876XGZypD7KMheRUmdLqGA1a3c3xE0ECqvoHtvdwh1XO9G9cT5Fsi/GNdz54OV6FC03FHwYXoWqEhkxOxRoB0qo1ThIiVjNGbvKzqBPwjasclEGwyvi/HaOo5onPdIkTFu6KbbbZBt1uF+effz4OPPDA5G9PSEhISEh4HlhpHvd+v48pU6bgiiuuwPdXO6vWqtzbDUxQ2uvKJRMxK9TvuLNCbSehwkdlFeIzXkeuK2wRDLlu9ZmqGupwUx1W3GsLNl6L6L4BSToQIyZJkhBFos3bEV56JnfEDK5BiP2z+G4sXsTLmEpBrW3HibsMNlg4uIAyeLGrZkGq7rlujEVb6kytcFIHr7VukHbRMElndZXdmGC/yGzMW+e6hX7pC5BjMWiM50RseFXzLAU7CE8Ksqye5260Q66D31373xsyhVfbQ5LMqM28nYuvWfH73JCJQmEquCiVEJtpxTEMz3DBy25VVZAqioEH7n4IKxOPb5wYNhN5lPi+GbdZi+Kk+F0s6OUc/EYTK39ewhiFZk25duiaEqerg/Hv//7vWLBgAT72sY/h6KOPRpatkgFWCQkJCQkJLzpeEo/7T37yE6y++uq4csL/oHBDWGY70ccurQasXHJjI+lB9ztPlR1G2lhCESmr4gMNjwYGATWCLDOqpaIvtxO9H6wWg6INo0navV/Zex/IiAVYDQ0Kb7QhCCsCv5b7KPfFk0xEP4qz1f4CgArfKXEMcvdi4oeiSFKVIljrvRFaE1xoee+srkivrZoKwSq4QkEVKjYKUqFZUBzjMNEYcy6oBGlnQtmcaIRjJqfgFKBUNXnjxBcuGvWdTTNk2qFvDUrtYkGoVL5BqnaOEZRiVvC1It8hNJBPSdg7uozedUcKGhR979bp6O0GHJD5sbSaYLWC04DTPscdgPffa/LXijzuSMRVvGx4fFS4iyFtSLW6BlUfS+lt5+JUTtQZqDUQ9QWQKru8Nscg7J2sRCdMorpZiVxbfGatd+PUU0/Fwb88GKeeeire9773pbz1hISEhISEFxArjbj/4Ac/wNve9jaUeCgW8HFUY9MfLO0GTS97HZ7FENWV+NYupcJ6gvBSKtMkN8nbaTuQ6E1grwKzqMZyhDrxkaky0kfMpJ3VzKD+QlceaHDhn+JiQJ/wwYWBfPxau9j51YiED7YYKYi0D+3Qyay3NDDBJeXtDmE5eS6iglzqqGLLAlDLiShFUOZ5uBx5Ai/iCwFUOe3yrgB/rwCy4rswXip0ONU6xA8GYp2pqqvpkCnRDzn9nOrCDbJKq+NYSBhRVCkV9m5WwiifKJMpT0oBn1AUr2GnYUPxdPTCB1tXLVo0MG1tAFIWZETxLFt5SgVVAFp4dmKxM8awzIjrcoCIy1jN+J4qBV4SeFbjOWFGUdVhlq9HcVfCGKpSdzKLoayMhH3IFDj8j3tgp/13woknnogLLrgAkydPbvtrSkhISEhISHgeWGnEfcGCBdhll13wR30vRnUGHeLrHOnYDClGNo6lkMfXbJGhQFQBp5wn6Up53y4QiXtU4WtNkFCzoNR/rMWGwpDr6UDaQfVtspIut2HE78qC0YY9JnqGuegvEnRPttkiorWD0STytP1rAMhCAoofI4UyVKjqkG7Cr7njJUdk8ucAYub9qCIoZXxiiSJoraFK45V4HUinVoBWIKW971naQEoVmvyEaZZorNQ2WVLOE1zuAErCf187DYEkF2H/UALIgCFTYCTrw0F524zL4rG4xgRPjoULk5bc+G6fmXYYMkVNXe9bg5LCZICq67UMkwFJ2q0g7RTuXgxEVgY7VbRA8XyQlXU5LnzttF2SYtnaZIjHuVEIXE2UwrUbnuKzgzf2E8C3S1QsRq1IuxE59xzzqBXhc+v/K2YeNBOXXHIJDj744PadTkhISEhISHjeWCnEvSxL3HHHHTjllFPwmCrR1SVKU6AgjVJr5MZ3pWRLhydUDnDaOy8UjZkQA2AgJYbj6gDULB9yuYrEN1R5RpuCHomPJDvE8n0g8qgekUBRnTQFa4bclmJFU3lV2dtXBrOzmayzhSNTgUBpBw1CpkPjoNCCvgjKMOvMMuOel9Gg2uejIdGn77IQ3+dVa072YQWeLSjWVgkuVIZc8rKaFKlwXnmYeBxaa4ZlR9R4XkicK3++miRcItMWw6YAcqB0xl9nzsBBRYLugrUKqBN4Hjv+vCSNvs1qkaTjdd0dsOY47gMgjoc97sHTLmshYmFww7MuMVZSz4BVphH9GNflux8ExC6rqhpjv+nqx8M9GgAODhpKOSiloDVgnb8mAEApg89NPhZ77LEHjj322ETaExISEhISVjJWCnG/+uqrobXGvvvui9vv+R8UZFBqjWGj4UI2OwBoBHUXgNUK1tFA/KNEm31G5m7nQS0dtQa9fh7iJH1iCBezVsSKCbz4rebmZfGr34Mqw10ajoNHuFb0yZMJtnyoynrAthfOvJYEna0rQFDSRcdKJpkdU6KjvQ9bkvFMW+ShmyUAGDgU3nAfx9xCx1SfgnRUqLmZlVKEjrYoFUE7HW003PAnjDoUk10AFOR0vuvh4Dt7RhJZO4lyfNFOVlU1fpwdLpv98H6y4msUIVcOq2WjGNJFnJgUzsTjL8gEYu6jRpnYF8ICw2PBthuevLCizjGPPAmIEZROVRNF2UVXNocCYpdXLuxVVkVbUWzIxdYiVuH5tfhcjpEk7XFySYAq4W0vztdcOEPx7k+NwBPL/gBMOIeOr3lP3q28ZRT+xdCKYBXhkEMOwdFHH40zzzwTCQkJCQkJCSsXK4W4n3POOXj3u9+NC+7fC1qNwCgXW8UbRci19fntKodxzhPFoGw68vnXroW4x4Yv4TUrz+yzjR0tyxxdY+O2CmtgnYJWqMVMAsGCEdV5RH9yLPCUJJ04kxuovO6VH722XtjH6BNWFIloFiwHsgulPBbZcVILwq7D2GVhPLu6CM/em50rJu6e5RVkqmZXofGVT/cxMTuf6w2YsPLYS6Iaiav1ajvHHNaSWthqYQiEUKAriXZMx6l/Lm1Ivj6AZwDBxRHuoChF0E7BaBXvpLgG4+drZsSMYkT3AcAfv+vEhl+ONAoycdLC9hpW17mHQLwWxRj4/aksMc6GBmHBs05Wj99JVyrtTdIeU2YQyX2sbxZ3cyRxb5J2kq8bef6KUE1UpS0nWGUUFAi+cDbMdSrlXTmQUnDKT1QsgCJM5LjBWop5TEhISEhIWPlYKcR98eLFOOecc3B0/2gce+yxuKY8FktNB0vsELq2REd3MGwKjJosRkOWTqMMqihDvs60i0qnVoSOLkMRocOw8QSWO1v69BpPyhhsi+AGOmyjGLUZRssskrUi2B7491np5YY6gOc8rLgCnsg3lX2lRPfJ8JonBlb5DG+jEW0xTNo72qITvOi0bBn6i5Zg9OllOGrdk/CXv/wFvV4PRVFAa41utxsf1y38MNbZoIP1tloNPZfjaTeEpbaLpa6DZ8quGBcTrSAcaVg4HSc3TlpChKLMdyqaKT5RWWY0rUJAJIsqNJ+qq8aBnerqoYywEYX89kw75KayDHWzEiNZH6uZPoZNgWHTx4jpY0T7x5Aq0KMcFipMYDIscz7ZiLue9mwe/fA8Dpxu1OwhwIlGMW4yjEVrPrtVlfWFKoIeiTsTc+ez8Tmdh3Pzq0jR8HfQ5lfHIFHnAlSuKZDj3yxe9WNODRKvAEc+ySf8FoUJh1N+JSvPK4Asy9Dr9ZCQkJCQkJCw8rFSiPucOXPwk5/8BOeffz622WYb7LrrrviHf3g7Dth9d8zW/wyrsqgG91weiVXfeQLNqR9MlI2iaG8AvKe5q0vkKjwHi4gl7RVl49XlgpiAe2WUvc86K2JL+ky5GC1onY6EnhVXVu2t09ANYsuQefPsU/evhbcdlfVBQXjy+yU+tdZbMX/+fPzud7/D3Xffhzvvvx8LFizAkiVLMDw8jLXXXhsfWutDWHPNNTE0NIQ8z+Gcw+joqHjkuO++e3Haaadh5JBrUVAWx7UgjVFnIlkdLbPY7KrNwx5tRQSvrjdtRZKwRx+3uABkYa6EJIhAtBnFPHtDULmDCpGVJjzzHYqMSbspMWQKP2EzJYZNHxPMKCaaHkb0KABgqet6Zd1lsEJ+tuxjDyq7HAfrVK2HQLOPgBwPZwVhlw2sZPY9q+yykVV8tBB2kdsOQpWzzrvf4nHnJlYuRDvGIuAWAZxTZeK2nG9GFZePd5ZaHvCWr1goDuAT2A3/+OSXMW3atMEfS0hISEhISHjBsdIaMDEWLlyICy+8EN///vdxyy23oNPp4HWvex123nln7LTTTth9993xrUWHA0C0MfRcDgeFXPk4Pib3rIAb5Qsz+XsHhV60gWQoycTOrOxflsWKnKjS9NFz2kqbt1laJWSH1qqlvSTsYXAbnnylCLe98cO4/vrrMXv2bFx//fX4zW9+g0mTJmHbbbfF1ltvja222gqbbbYZNtpoI2ywwQaYNGnSCtsQbr31Vrz1rW/F0Ucfje5hN2CJHcKSsosltotnyi56NsPSshPvMvStQRGaB3kbjI7kFKg869Qg4RQKLmPBr2gwxCtKv3bsBsvKL5PE0IyJ4zHbSDs3RepkZWzwM5wVGMo8cV/N9LF6tgwTzChGjCftPCnka6l0esAmxBOYZWVea+LE4+DvMugW4j6osA/YYZzwrAtPOyvsaBB5QCwj1PG2gt7BRkuimRU3VWpeLnLsTdUpNzbKEmp8nEyFpkvIQgfbzIWUoyphZu/ZT6Lb7eKzn/3sCl2fCQkJCQkJCcvHeA2YVjpxlyiKAnfeeSduuukm/PrXv8ZNN92Ee++9FwcddBDe/e53Y9GrzkBfd2rreNKewULFAkqGhYqq/TKbYzQ+ZzVLCGdvy2QREq8dVek2/DnbRvi7WkJNQ3GXdhgJ/twowre3+AecddZZ+Pa3vw1jDA444ADstdde2HPPPbHZZpu9YB7h6667Docccgj+9drXYTRfDUttB8/YLpbZHM+UHSwtO1hW5uiVGfplhn5pav51bmw1WJiLmuLu3wdS7wSJBVqtIqhWqUi7CZ72QBJ17mAyiyzz3VJzY9HJLLpBZe9mXmkfMgW62mK1bBSTsmWYYHowoOBdN7W7ONypl61BfWeijYobgPXDXYfCmtD9lDuvVscaJyttnVADMZaEmD3sTZW9RtrjelXJxJhkXXadlZ1RuYlSxnnsaK8hkJ1/+ff5rgAvxrnvWXUHBEzaTZV+ZIzD7B3fg7/7u7/Dv/3bv+G44457LpdqQkJCQkJCQgteks6pbcjzHDNmzMCMGTNwwgknAADuv/9+nH/++TjmmGNgjMH06dOx/vrrY4MNNsDWW2+Ng9/wBlz7l7+PxL1PBj3qYKnroBAETdpC+rH4sp6/zcS9SdKjj7mhpLcVyFbRk6LwspF4AnhP/k93eT++//3v49JLL8X2v/oM3v72t+MHP/gBdt11VxhjsDKw9957Y8KECdj5iX/HL6d8sSpyDQksmeLoSAdnrDhmgEjDBYJHgUnGZJPm/C4q8cL/AzQsFkoQ0kAqZZOqQNhVIIaetLPCbtHJSt/oxzBhLyt7jO5jQuaLUB1pjArS3kbYZXJMYb1tqLChtiKQdqm0xw6ubXcXuClSUN3Ztx6PWXrVbTUOHMlYI+08/tISA0mkBTlnsi7Ie2ygFEg2x4zGhBmE69k2MuWjtak6f6QpdgmWpF2ZqrD67rd8GN/4xjcwbdo0HHLIITjssMOe24WakJCQkJCQ8Kzxoiru46EsS8yZMwcPPvggHnnkESxYsAC33HIL5s2bh1122QWf+9znsGjysXjKDeFpO4yn3RCW2CE8bYdaiy9lWkpFzJdP3Pm1JO5yhJif6gZRj+q6JszZ4z/w2c9+Fp/61Kcwc+ZMHH744TjiiCMwZcqUlTmEER/84Adx8803Y/bs2fjo/LdiSdmNhZnLbI5emXuLSOg02i+zhs+9SkwZiM0M5DQq7ZHMDlpGIrSwX7DCrgFlnFfZjVfYO5nvytkxXm0fzry63jG2VoQqIy8BhPoFT9w56pJJOzdRYguUzGUvQzEy+9r5roNzup4UE+8gCPU6qO66RLTHgC3krKKLiMeK2At7DFWbrNlj2gg7v86pGke2GAVybYyLnWYBVOk3nLnP9p444Qjnje0xuq60K0NeadfeunTtLsfhPe95D2677Tacc845eNOb3rQyLt+EhISEhIRXNF42ivt4yLIMs2bNGvh8wYIFOO+88zBr1ixcccUV+OvUf40kjX3vY4FVZgfEYtOBZcL3RD4u0gmablrIuV+neh9jKWHxqZFDcPHFF2P9w9fHNttsg7lz5+K1r33tsx+M54lTTz0Vu+yyC2bNmoWzzjoL3zIfGVhGKwdj85Bm41oLVSOJZ9tIIK/EpLyNtPOQhULIWHgqC1DZehEIYZ6XyI1F3ihA9Qk7Fh1dhkZTnrBbaIxaHc6/RkFVfwBJ2Hs2j4kxsoGSvxYQC41jck7LXYXYHMmpalJCEPGNFTGv0mAEkW/GOgJx9sdpMVXaC1UqO/vYs8q64r+vfOfKhIx742LkKICYCNRMAgJboEh520wg/pGw63AHxIRuvuEcZZnDHQedhhkzZmDbbbfFnXfeiTXXXPN5XqUJCQkJCQkJzxYvG+I+FjbYYAN85CMfwUYbbYQ3velNOPfcc9Gd8QX0VI6uKmF18K6jbm3RyqHUBoaVVkUNdb1S39n7S6RgwDGUTNLrlhitCFfO/HfMmzcP9957L+69917cd999+PWvf41D+t/AoYceijlz5mDHHXd8sYZoAGuuuSZuvvlmnHrqqdh5552x22674Z//+Z9x4IEH4v13HOubNakMmXb+7oT2xbxGEQqtYayB1Q7WcH47eSVa63pxZi0yJxDLUARZ3ZqgqLgzGWRlOMuq4tPM2Bj1mDNhNyU6uoxxnwYuZLGraIdpdkl1VDVXYnBBslTXZWoM8XNM0pH2GH6g6nzaJOQQPnarBotMA2oedkV1Owy/FgWmxMQ6q9cCKE2RtJvMRtIuozvj8XBDqFLXimmrCRXCHRC/TWivsitF4RxZGOPw+c9/HgDwzW9+E3mev9CXbEJCQkJCQsIK4GVjlVkR/OAHP8Dxxx+PPfbYAx/5yEcwbdo0fO7eg2KToaWu4z3MoRum7IrZJHfRKiM+AzDgbb9+v//GI488gptvvhnXXXcdrr32Wtxxxx3YeOONsfnmm8fHDjvsgD333BNZ9vKaCy1atAjnnHMOzjvvPDz11FN45zvfif333x8777wz1lprLbzjxuNr9iJpJ2EVvpk849gLbhsdQpueIiUIO5NNVS9y9N1haYC4D5kSneBt74b4TwCRqDcTg0pRfCzPq7TFcEY7H0tZapAb41hEA6XoZxcNlKJvPRL2KjGGj59TWmpNkXiTBj5H3Ui7DNWTdmJdQPXMHnZWw7WmWh1CbArFBL6RfhMbivHkSlekPTYLCyo7Fwh/qPdaHHXUUbjmmmuw6667rqxLNSEhISEhIQEvo1SZFwILFy7EKaecgssuuwxFUWC77bbDa1/7Wrz2ta/FzJkzcYU+A5TlsdU9R0SyQuugYiY8OcLSxX0se6KH0zY4AY899hgee+wx/PnPf8ajjz6KBQsW4I477sCiRYuw1VZbYa+99sLrX/967LPPPlh33XVf4pF4dnDO4frrr8eFF16In//857j//vuxxRZbYJdddsGuu+6KnXbaCWcu/l+4vOt94mVWK+AciEsMme8xz7zlMookUyMquNxQqU1p75oSmXbo6DIWog4Hb7sjhWW2E1ODetafz+ZkY7w6Bo715OZZsQuqnIiwp50tMEzYmxGPDc86K+01y0sg5RRsKDKqsbLFCCuRINOsfsvOu6g19QpjHJqDRdIuz0lzMhVPjP+95vlRujo/XCB8pt4Tb33rW3HppZfiwAMPfKEvy4SEhISEhIQG/qaIO8M5h/vuuw+33HILfvvb3+K3v/0tbrnlFvR6PcyYMQM77bQTdtxxRyilIiFvPh5//HFYazFhwgSst956tcfUqVMxdepUTJ8+Hdtttx1WW221l/qQX1AsWrQIN954I+bOnYsbb7wRN998M55++mlsvPHG2GGHHXDwwQdjl112wQkPfhkuH0LhvM2k6YFnH/VA3ruqEniYsPsccFeLeWSFnQl7R1sMmwJnbXUWfvnLX+LRRx/Fu971Lpxy57uq4lqb1wqQC2tioyxW2a2wi8hIT9ewxci8drbJRJW61J68l76QU3FjJaG0VyTeK9m19BcuKG2SdKDy/GuqK+mBxMs7E9IK09ZDgO0+tW6uzT/rcC7keWGiXj0cjKKYmz971w9h0003xWc+8xkcddRRK/uSTEhISEhISMDfKHFvA5P5m266CTfddBNuvvlmGGMGSDk/pkyZgvXWWw8jIyMv9a6/5CAiPProo7jnnnswd+5cXH755Zg3bx56vR422WQTbLPNNpg2bRqmTZuGTy++Dtn6k0HdkZp6zSQSqFRhtnPE7qcNhT23PZSLFuOkkX/A7373O/zud7/DbbfdhltvvRWvec1roJTC0NAQfvazn+FfH/xgTMXpWW+JYiuMLDxtKuuDGfwIE426D7wWcSmTV2yDvLPHXXSLjV1LVeVTj3GNMq2loaYr7Uk6K+vGuJhQxDYiAAOpP60dXYHqGAJUUNd1UOyNsNhwYTVblUz4za7xxcKv+9mauPbaa/GLX/ziBeszkJCQkJCQkDA+XjHEPeGFBRHhsccew91334277rorPubPn48nnngCU6ZMwZZbboktt9wSG220ESZMmIAJEyZg4sSJmDBhArIsw+joKPr9PpYuXYpHH30UDz/8MBYsWIA//elP+NOf/oTHHnsMnU4Hm2++ObbaaitstdVWmDZtGvbaay9ssMEG6Pf7OOKII1AUBSactp6vZwjdXwtrYodbALW0mDLYYJjoRqIeD66tEBX+Ef3sqsppt1U+e9PKj7BabGAUFHeYEN3IaS3chVTXbUOePPuJTR4INJNqrjVoNstyjmsyEI8t7ofYNyUmBVpOnoyLsZuZcuhmZbzjcf52n8eHP/xhnH322bj22muTrz0hISEhIeFFRCLuCS84nnjiCdxzzz34/e9/j3vuuQePPPIIlixZgiVLluDpp5/GkiVLUBQFut0uut0uhoeHMXXqVGywwQbYcMMNscEGG2DjjTfGxhtvjPXWWw9a6zF/6y9/+Qu23357zJo1C6eeeir+5ZEvRuJehKJTANEeI9V26ccnh8Eseo58jMkxItqSCXujiZJMhpGNjgC0k/YsFH9mLibqyOJcJuwdjsE0FpmyKMl3dh21GUatQWlNJO+1VBw+Dt4HUtETL60wfnJQj93saBs70rJN6ZnP9vDAAw/gggsuwNZbb/3CXjgJCQkJCQkJ42KVyHFPWLWw9tprY7fddsNuu+220n9rzTXXxI9//GOceeaZmD59Ovbdd1+cdNxx+N8J1wOmC60IhfXFyDZYRojqdhLPuhukvZkgI+IeI1EHwF2VCKqW9sLxjtVvyMLUSmmXPnaOwWyS6NpDec8/HFBqjRy2Nh6lJZRKQyklfO+DE3D2xsv0nk5WIg8KP9cWZKGhVa59vcHkyZOx7rrrJtKekJCQkJDwMsPYMmdCwssI22yzDS6++GI89NBD2G233fDBD34Qd7zjQmz/g2fwpclvx0heYCgv0c19Mo3WLjYkqhi4gMhmR43gI/rRKSNRYIoQ3+jfuwzV9xn5jqb8yLzKjpygcgfTcchyGwtNm9CKRNMpn6izWtbHSFZgJOuja8rwsOhkpbe76KrjbJ63P7gbbTc+ezV/KCswMR/F6p0eVs97mNTpYVK+DJPyZVgrfwb77LMP5syZ88KfxISEhISEhITnhUTcE1YpTJ06FWeccQbuu+8+/PCHP0S/38dee+2F3mk/x/EPb4lf7P0hdPMS3SzETWauKsg09cLQSNKDrQQZgTquejQIeSTrOYFyN0DWKXdA7oCuhepamK5F1rEwmUWWW3Q6fmIx3Ckw0u1jtU6B4bzASN4PRL2PCfkoJuY9TMw8qZ6Yj2JCPorV8lGM5H0MZSW6WRmPMTftj07mv/fLlRjOC6yW97Fa7n9j9c4yrNlZisndJZjcWYIp3acwtbMY/7rhebjzzjtx9913Y3R09KU+3QkJCQkJCQkCyeOesMrjqaeewsUXX4wvf/nL+OMf/4gjjzwS73rXu/Dev/wQNiTP2BhhKeIf29Jk5J9D0wMvmivFZ+5oKhpNQSEUhIZEnWCN6WQWmfExmF1TRm+5VuQLRHWJLPjMJ5hR5MpiqfPZ9c+UXSyzOfrOoGdz3wk2HJvMrufd4uLWLFhiOpo70fpmVr4bre9IO8GMQveewSPfmIavfe1rmDlzJj7wgQ/gLW95y4ty/hISEhISEhIqpOLUhFcEiAg33ngjLrjgAlx66aWYPHkyjj76aJx44on4u7mf9yk0VhR2NvLbYyMp0TG1RtwZbL0ROew6c62dYY3yBD7n9BhFXjEPXWG50VRXl5FId3WJkUDcR12Opa6DpbaDZbaDgjQc+YZToyHL3hN3DScM9xqETOTjd4N/vRO2P6QLjOg+MjuKLR78f/jABz6ATTbZBGeddRa23XbbF++kJSQkJCQkJNSQiHvCKw69Xg9XXXUVvvzlL2Pu3Lk45phjsP/++2PXXXfFPr86KyazVE2ZAFCjiZGMiXTcqrTqcKo0BZW9ajQl02LyLCTFZKUoBHXItK1U9kDcO0H5HtF9jITn1fQoLCksdV30yHcDdqQjkR91vrZcK4IjFd/n4TcMnPfPK6+yG+XQ1QWGVIn93Fn4+te/josuugidTgennHIK/uVf/mXcdJ+EhISEhISElY9E3BNe0bjlllvwla98Bddffz1+//vfY8stt8SsWbNw+OGH432Lr4KDFs2bNMpSV02lAnFnSw0Td+5CqnXVgbQZ8cg56V5dLzGS9b26bkoM674n98piSBfIlQ0Eu8CQKrCaHsWIHsWQKuCg0SeDgjL0KMczrotRl6NHGXLlE2dGXQ6tqo5QQ6qEVg6ONHJVQvV62HzRJ/CLX/wCP/rRjzB//nwceuihOProo7Hvvvsmwp6QkJCQkPAyQSLuCQkBixYtwty5c3HllVfie9/7HqZOnYpPfOIT+PTwL1GSz0rnLqVtDZwAxIx0FYi77A6rQ+xiLjrE5trWbDHDpsBq2Sgmml5UwEf0aCDwJYZUgY6yGFJFeJSwUOgF4l5Qhj4ZuFBbbknDQsGAvCrvCDvr/8Ntt92G3/zmN/jFL36BW265Beuvvz723ntvvP71r8ehhx6KSZMmvZSnIiEhISEhIaEFibgnJLRgdHQU5557Lj7xiU9g7bXXxrvf/W68613vwoG3fNp3LA2Nmyx3XRXEnaMmFRA6n5LPZQ8Z6R1ddSXlotBhU7T6zEd0H11dYHW9DCN6FKvrHibqHoaURa4chhRhSPnf7oW/1x4pWFLYbL0HMH/+fNx666249dZbcdttt+H222/H6Ogopk+fjte+9rXYa6+9sNdee2GTTTZ5ScY5ISEhISEhYcWRiHtCwjhYtmwZvvvd7+K8887Dr3/9a7z5zW/GkUceif8duRaUd7x9JjR2AgBHCloQ90w0NNKKYkFoR1fZ7JzkwraYbiDtqwU7zIgexWp6FBN1DyMosPjPBZ75yzcxf/583HLLLZg7dy4efvhhrLbaalhvvfWw8cYb4/HHH8f8+fMxMjKCHXbYATvssANmzJiBGTNmYOutt0ae5y/ZmCYkJCQkJCQ8NyTinpCwgrjnnntw0UUX4Vvf+hYWLlyIQw89FAceeCD23ntvHHv3R+GgULrKD66VT5Lp6LKW4MLRjgCQK4sJxlthmLAPqT5WNz2MqFHstMYv8ctf+scNN9yAO+64A0uWLMGmm26KadOmYYcddsCuu+6KV7/61XjmmWfw5z//GX/84x+x9tprY8aMGXj1q18NpdRYh5SQkJCQkJCwCiER94SEZwkiws0334xLLrkEs2fPxvz58zF9+nTsuOOOePWrXx0f6623HiZNmoT/fOCfMNJ1UYlnkm6CTu+LT72X/fANf4Zrr70WP/vZzzBnzhzMmzcPW265JfbYYw/sscce2GGHHbDllltiaGjopRyChISEhISEhJcAibgnJDxPPP7447juuutwxx134MEHH8RDDz2EBx98EAsXLkRRFACA4eFhrLXWWlh77bUxefJkTJ48GWussQYmTZqENdZYA91uF7/4xS9wzTXXYMqUKXjDG96A17/+9dhnn32w7rrrvsRHmJCQkJCQkPByQCLuCQkrCUSEXq+HxYsXY/HixXjyySfxxBNPYNGiRVi0aBH++te/4q9//SsWL16MJUuWYOedd8ab3/xmbL311snekpCQkJCQkDCA8Yh79mLvTELC3xKUUhgeHsbw8DCmTJnyUu9OQkJCQkJCwt8wUteVhISEhISEhISEhFUAibgnJCQkJCQkJCQkrAJIxD0hISEhISEhISFhFUAi7gkJCQkJCQkJCQmrABJxT0hISEhISEhISFgFkIh7QkJCQkJCQkJCwiqARNwTEhISEhISEhISVgEk4p6QkJCQkJCQkJCwCiAR94SEhISEhISEhIRVAIm4JyQkJCQkJCQkJKwCSMQ9ISEhISEhISEhYRVAIu4JCQkJCQkJCQkJqwAUEY2/gFIPv0j7kpCQkJCQkJCQkPBKx6NE9Lq2L5ZL3BMSEhISEhISEhISXnokq0xCQkJCQkJCQkLCKoBE3BMSEhISEhISEhJWASTinpCQkJCQkJCQkLAKIBH3hISEhISEhISEhFUAibgnJCQkJCQkJCQkrAJIxD0hISEhISEhISFhFcD/DzXve23vSuNsAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig_property = dict()\n", "fig_property['figsize'] = (12,4)\n", @@ -392,13 +373,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-23 13:19:25,085 - root - INFO: \n", - "2021-09-23 13:19:25,086 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:25,086 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:25,087 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:25,136 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:25,137 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:25,160 - root - INFO: Converting to requested CRS\n" + "2021-10-01 10:56:14,981 - root - INFO: \n", + "2021-10-01 10:56:14,983 - root - INFO: Loading shapes\n", + "2021-10-01 10:56:14,985 - root - INFO: ------------------------------\n", + "2021-10-01 10:56:14,987 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-10-01 10:56:15,001 - root - INFO: ... found 44 shapes\n", + "2021-10-01 10:56:15,002 - root - INFO: Converting to shapely\n", + "2021-10-01 10:56:15,023 - root - INFO: Converting to requested CRS\n" ] }, { @@ -427,27 +408,7 @@ "execution_count": 11, "id": "e5a14591", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:25,325 - root - INFO: BOUNDS: (-149.3337383807433, 68.15814340504932, -148.79207171405866, 68.33619896061079)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig_property = dict()\n", "fig_property['figsize'] = (12,4)\n", @@ -502,44 +463,7 @@ "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:25,482 - root - INFO: \n", - "2021-09-23 13:19:25,482 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:25,483 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:25,483 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:25,484 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:25,535 - root - INFO: ... got raster of shape: (570, 1879)\n", - "2021-09-23 13:19:25,544 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:25,578 - root - INFO: shape bounds: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n", - "2021-09-23 13:19:25,583 - root - INFO: casting mask of dtype: float32 to: nan\n", - "2021-09-23 13:19:25,584 - root - INFO: ... got raster bounds: (-149.32401615852078, 68.32647673838824, -148.802071714059, 68.16814340504965)\n", - "2021-09-23 13:19:25,695 - root - INFO: BOUNDS: (-149.32401615852078, 68.16814340504965, -148.802071714059, 68.32647673838824)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.32373838074332, 68.16835009523078, -148.80217986384457, 68.32619896061078)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "lc_profile, lc_raster = workflow.get_raster_on_shape(filenames['land_cover'],\n", " huc_shape, huc_crs, \n", @@ -600,7 +524,7 @@ "id": "25d16b4d", "metadata": {}, "source": [ - "## Validate: get hillslope parameters for one subcatchment " + "## Get hillslope parameters for one subcatchment " ] }, { @@ -615,75 +539,108 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-09-23 13:19:25,805 - root - INFO: \n", - "2021-09-23 13:19:25,805 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:25,806 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:25,806 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:25,811 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:25,812 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:25,866 - root - INFO: \n", - "2021-09-23 13:19:25,866 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:25,867 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:25,867 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:25,868 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:25,917 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-23 13:19:25,927 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:25,959 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-23 13:19:25,961 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:25,961 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-23 13:19:25,964 - root - INFO: \n", - "2021-09-23 13:19:25,965 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:25,965 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:25,965 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:25,966 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:26,009 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-23 13:19:26,018 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:26,050 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-23 13:19:26,052 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:26,053 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-23 13:19:26,056 - root - INFO: \n", - "2021-09-23 13:19:26,057 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:26,057 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:26,057 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:26,058 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:26,102 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-23 13:19:26,111 - root - INFO: Masking to shape\n" + "2021-10-01 10:56:15,081 - root - INFO: \n", + "2021-10-01 10:56:15,081 - root - INFO: Loading shapes\n", + "2021-10-01 10:56:15,082 - root - INFO: ------------------------------\n", + "2021-10-01 10:56:15,083 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", + "2021-10-01 10:56:15,087 - root - INFO: ... found 44 shapes\n", + "2021-10-01 10:56:15,088 - root - INFO: Converting to shapely\n", + "2021-10-01 10:56:15,141 - root - INFO: \n", + "2021-10-01 10:56:15,142 - root - INFO: Loading Raster\n", + "2021-10-01 10:56:15,143 - root - INFO: ------------------------------\n", + "2021-10-01 10:56:15,143 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", + "2021-10-01 10:56:15,144 - root - INFO: Collecting raster\n", + "2021-10-01 10:56:15,190 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-10-01 10:56:15,200 - root - INFO: Masking to shape\n", + "2021-10-01 10:56:15,232 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-10-01 10:56:15,235 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", + "2021-10-01 10:56:15,235 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-10-01 10:56:15,239 - root - INFO: \n", + "2021-10-01 10:56:15,240 - root - INFO: Loading Raster\n", + "2021-10-01 10:56:15,240 - root - INFO: ------------------------------\n", + "2021-10-01 10:56:15,241 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", + "2021-10-01 10:56:15,242 - root - INFO: Collecting raster\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-10-01 10:56:15,289 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-10-01 10:56:15,298 - root - INFO: Masking to shape\n", + "2021-10-01 10:56:15,328 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-10-01 10:56:15,330 - root - INFO: casting mask of dtype: float32 to: -999.0\n", + "2021-10-01 10:56:15,331 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-10-01 10:56:15,335 - root - INFO: \n", + "2021-10-01 10:56:15,335 - root - INFO: Loading Raster\n", + "2021-10-01 10:56:15,336 - root - INFO: ------------------------------\n", + "2021-10-01 10:56:15,337 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", + "2021-10-01 10:56:15,339 - root - INFO: Collecting raster\n", + "2021-10-01 10:56:15,388 - root - INFO: ... got raster of shape: (130, 305)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n" + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-09-23 13:19:26,143 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-23 13:19:26,145 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:26,146 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-23 13:19:26,148 - root - INFO: \n", - "2021-09-23 13:19:26,148 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:26,149 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:26,149 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:26,149 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:26,191 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-23 13:19:26,200 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:26,231 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-23 13:19:26,233 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:26,234 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n" + "2021-10-01 10:56:15,398 - root - INFO: Masking to shape\n", + "2021-10-01 10:56:15,434 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-10-01 10:56:15,437 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", + "2021-10-01 10:56:15,438 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", + "2021-10-01 10:56:15,442 - root - INFO: \n", + "2021-10-01 10:56:15,443 - root - INFO: Loading Raster\n", + "2021-10-01 10:56:15,444 - root - INFO: ------------------------------\n", + "2021-10-01 10:56:15,444 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", + "2021-10-01 10:56:15,445 - root - INFO: Collecting raster\n", + "2021-10-01 10:56:15,493 - root - INFO: ... got raster of shape: (130, 305)\n", + "2021-10-01 10:56:15,503 - root - INFO: Masking to shape\n", + "2021-10-01 10:56:15,536 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "2021-10-01 10:56:15,538 - root - INFO: casting mask of dtype: float32 to: 255.0\n", + "2021-10-01 10:56:15,539 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n" + "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", + "error: 0.0002331351861357689\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", + " proj_string = self.to_proj4()\n" ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ @@ -691,12 +648,14 @@ " filenames, huc, subcatch_demo_id,\n", " target_crs=target_crs,\n", " hillslope_keep_fraction=hillslope_keep_fraction,\n", - " hillslope_bin_dx=hillslope_bin_dx)\n", + " hillslope_bin_dx=hillslope_bin_dx,\n", + " plot_smoothed=True)\n", "\n", "mesh_demo_pars = meshing.parameterizeMesh(hillslope_demo_pars, mesh_dx,\n", - " riparian_slope_min=riparian_slope_min,\n", - " hillslope_slope_min=hillslope_slope_min,\n", - " min_area_ratio=min_area_ratio)\n", + " toeslope_min_slope=toeslope_min_slope,\n", + " hillslope_min_slope=hillslope_min_slope,\n", + " min_area_ratio=min_area_ratio)\n", + "\n", "# print(hillslope.keys())" ] }, @@ -713,58 +672,35 @@ "execution_count": 15, "id": "8d9e358a", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/3hg/opt/anaconda3/envs/watershed_workflow/lib/python3.9/site-packages/pyproj/crs/crs.py:543: UserWarning: You will likely lose important projection information when converting to a PROJ string from another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems\n", - " proj_string = self.to_proj4()\n", - "2021-09-23 13:19:26,397 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n", - "2021-09-23 13:19:26,500 - root - INFO: BOUNDS: (-149.177627269627, 68.21008784949548, -149.12596060295863, 68.22231007171811)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "fig = plt.figure(figsize=(6,8))\n", - "plt.tight_layout()\n", - "gs = gridspec.GridSpec(4,1)\n", - "axs = [fig.add_subplot(gs[2,0]), fig.add_subplot(gs[3,0])]\n", - "plot.plot(hillslope_demo_pars, mesh_demo_pars, fig=fig, axs=axs)\n", + "# fig = plt.figure(figsize=(6,8))\n", + "# plt.tight_layout()\n", + "# gs = gridspec.GridSpec(4,1)\n", + "# axs = [fig.add_subplot(gs[2,0]), fig.add_subplot(gs[3,0])]\n", + "# plot.plot(hillslope_demo_pars, mesh_demo_pars, fig=fig, axs=axs)\n", "\n", "\n", - "ax0 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[0,:])\n", - "workflow.plot.raster(hillslope_demo_pars['raster_profile'], hillslope_demo_pars['bins'],\n", - " ax=ax0, cmap='prism')\n", - "subcatch = hillslope_demo_pars['subcatchment']\n", - "subcatch_crs = hillslope_demo_pars['subcatchment_target_crs']\n", - "workflow.plot.shply(subcatch, subcatch_crs, ax=ax0, color='k')\n", - "ax0.set_title(f'subcatchment {subcatch_demo_id}')\n", + "# ax0 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[0,:])\n", + "# workflow.plot.raster(hillslope_demo_pars['raster_profile'], hillslope_demo_pars['bins'],\n", + "# ax=ax0, cmap='prism')\n", + "# subcatch_demo = hillslope_demo_pars['subcatchment']\n", + "# subcatch_crs_demo = hillslope_demo_pars['subcatchment_target_crs']\n", + "# workflow.plot.shply(subcatch_demo, subcatch_crs_demo, ax=ax0, color='k')\n", + "# ax0.set_title(f'subcatchment {subcatch_demo_id}')\n", "\n", - "ax1 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[1,:])\n", - "vmin, vmax = min(hillslope_demo_pars['land_cover']), max(hillslope_demo_pars['land_cover'])\n", - "cmap = plt.get_cmap(('viridis'),vmax-vmin+1)\n", - "lc = workflow.plot.raster(hillslope_demo_pars['raster_profile'],\n", - " hillslope_demo_pars['land_cover_raster'], \n", - " ax=ax1, vmin=vmin-0.5, vmax=vmax+0.5, cmap=cmap)\n", - "workflow.plot.shply(subcatch, subcatch_crs, ax=ax1, color='k')\n", - "position=fig.add_axes([0.95, 0.55, 0.02,0.1])\n", + "# ax1 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[1,:])\n", + "# vmin, vmax = min(hillslope_demo_pars['land_cover']), max(hillslope_demo_pars['land_cover'])\n", + "# cmap = plt.get_cmap(('viridis'),vmax-vmin+1)\n", + "# lc = workflow.plot.raster(hillslope_demo_pars['raster_profile'],\n", + "# hillslope_demo_pars['land_cover_raster'], \n", + "# ax=ax1, vmin=vmin-0.5, vmax=vmax+0.5, cmap=cmap)\n", + "# workflow.plot.shply(subcatch_demo, subcatch_crs_demo, ax=ax1, color='k')\n", + "# position=fig.add_axes([0.95, 0.55, 0.02,0.1])\n", "\n", - "fig.colorbar(lc,ticks=np.arange(vmin,vmax+1),cax=position)\n", + "# fig.colorbar(lc,ticks=np.arange(vmin,vmax+1),cax=position)\n", "\n", - "plt.show()" + "# plt.show()" ] }, { @@ -780,6784 +716,253 @@ "execution_count": 16, "id": "44f418ed", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:26,690 - root - INFO: \n", - "2021-09-23 13:19:26,691 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:26,691 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:26,692 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:26,697 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:26,698 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:26,751 - root - INFO: \n", - "2021-09-23 13:19:26,752 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:26,752 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:26,752 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:26,753 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:26,800 - root - INFO: ... got raster of shape: (69, 322)\n", - "2021-09-23 13:19:26,809 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:26,840 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "2021-09-23 13:19:26,842 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:26,842 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", - "2021-09-23 13:19:26,845 - root - INFO: \n", - "2021-09-23 13:19:26,846 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:26,846 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:26,846 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:26,847 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:26,890 - root - INFO: ... got raster of shape: (69, 322)\n", - "2021-09-23 13:19:26,899 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:26,930 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "2021-09-23 13:19:26,932 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:26,933 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", - "2021-09-23 13:19:26,936 - root - INFO: \n", - "2021-09-23 13:19:26,937 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:26,937 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:26,937 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:26,938 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:26,981 - root - INFO: ... got raster of shape: (69, 322)\n", - "2021-09-23 13:19:26,990 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "bounds in my_crs: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "bounds in my_crs: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:27,022 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "2021-09-23 13:19:27,023 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:27,024 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", - "2021-09-23 13:19:27,028 - root - INFO: \n", - "2021-09-23 13:19:27,029 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:27,029 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,029 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:27,030 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:27,072 - root - INFO: ... got raster of shape: (69, 322)\n", - "2021-09-23 13:19:27,081 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:27,114 - root - INFO: shape bounds: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "2021-09-23 13:19:27,116 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:27,117 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23401615851776, 68.18897673838367)\n", - "2021-09-23 13:19:27,139 - root - INFO: \n", - "2021-09-23 13:19:27,140 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:27,141 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,141 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:27,145 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:27,146 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:27,199 - root - INFO: \n", - "2021-09-23 13:19:27,199 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:27,200 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,200 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:27,201 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:27,243 - root - INFO: ... got raster of shape: (64, 331)\n", - "2021-09-23 13:19:27,252 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.32346060296518, 68.18897673838367, -149.2340161585178, 68.20814340505098)\n", - "bounds in my_crs: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:27,283 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "2021-09-23 13:19:27,285 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:27,286 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", - "2021-09-23 13:19:27,289 - root - INFO: \n", - "2021-09-23 13:19:27,290 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:27,291 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,292 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:27,293 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:27,335 - root - INFO: ... got raster of shape: (64, 331)\n", - "2021-09-23 13:19:27,343 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:27,373 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "2021-09-23 13:19:27,375 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:27,376 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", - "2021-09-23 13:19:27,381 - root - INFO: \n", - "2021-09-23 13:19:27,381 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:27,382 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,383 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:27,384 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:27,424 - root - INFO: ... got raster of shape: (64, 331)\n", - "2021-09-23 13:19:27,434 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:27,464 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "2021-09-23 13:19:27,466 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:27,467 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", - "2021-09-23 13:19:27,472 - root - INFO: \n", - "2021-09-23 13:19:27,472 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:27,473 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,473 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:27,474 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:27,517 - root - INFO: ... got raster of shape: (64, 331)\n", - "2021-09-23 13:19:27,526 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "bounds in my_crs: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "bounds in my_crs: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:27,556 - root - INFO: shape bounds: (-149.32346060296518, 68.1800878494945, -149.2315161585177, 68.19758784949508)\n", - "2021-09-23 13:19:27,559 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:27,560 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.19786562727286, -149.23151615851768, 68.1800878494945)\n", - "2021-09-23 13:19:27,581 - root - INFO: \n", - "2021-09-23 13:19:27,582 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:27,582 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,582 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:27,587 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:27,588 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:27,640 - root - INFO: \n", - "2021-09-23 13:19:27,641 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:27,641 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,641 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:27,643 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:27,683 - root - INFO: ... got raster of shape: (97, 237)\n", - "2021-09-23 13:19:27,692 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:27,722 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "2021-09-23 13:19:27,724 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:27,725 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", - "2021-09-23 13:19:27,728 - root - INFO: \n", - "2021-09-23 13:19:27,729 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:27,729 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,729 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:27,731 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:27,773 - root - INFO: ... got raster of shape: (97, 237)\n", - "2021-09-23 13:19:27,782 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:27,811 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "2021-09-23 13:19:27,813 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:27,814 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", - "2021-09-23 13:19:27,817 - root - INFO: \n", - "2021-09-23 13:19:27,817 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:27,818 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,818 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:27,820 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:27,861 - root - INFO: ... got raster of shape: (97, 237)\n", - "2021-09-23 13:19:27,870 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "bounds in my_crs: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "bounds in my_crs: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:27,900 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "2021-09-23 13:19:27,902 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:27,903 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", - "2021-09-23 13:19:27,907 - root - INFO: \n", - "2021-09-23 13:19:27,908 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:27,908 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:27,908 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:27,909 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:27,952 - root - INFO: ... got raster of shape: (97, 237)\n", - "2021-09-23 13:19:27,960 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:27,992 - root - INFO: shape bounds: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "2021-09-23 13:19:27,994 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:27,994 - root - INFO: ... got raster bounds: (-149.25429393629622, 68.20564340505089, -149.1884606029607, 68.17869896060556)\n", - "2021-09-23 13:19:28,016 - root - INFO: \n", - "2021-09-23 13:19:28,016 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:28,017 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,017 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:28,022 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:28,023 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:28,075 - root - INFO: \n", - "2021-09-23 13:19:28,075 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:28,076 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,076 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:28,078 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:28,121 - root - INFO: ... got raster of shape: (59, 233)\n", - "2021-09-23 13:19:28,130 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.25429393629622, 68.17869896060556, -149.1884606029607, 68.20564340505089)\n", - "bounds in my_crs: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:28,158 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "2021-09-23 13:19:28,161 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:28,162 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", - "2021-09-23 13:19:28,165 - root - INFO: \n", - "2021-09-23 13:19:28,165 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:28,166 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,166 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:28,167 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:28,209 - root - INFO: ... got raster of shape: (59, 233)\n", - "2021-09-23 13:19:28,219 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:28,250 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "2021-09-23 13:19:28,252 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:28,252 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", - "2021-09-23 13:19:28,256 - root - INFO: \n", - "2021-09-23 13:19:28,257 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:28,257 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,258 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:28,259 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:28,300 - root - INFO: ... got raster of shape: (59, 233)\n", - "2021-09-23 13:19:28,309 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:28,339 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "2021-09-23 13:19:28,342 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:28,342 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", - "2021-09-23 13:19:28,345 - root - INFO: \n", - "2021-09-23 13:19:28,345 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:28,346 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,346 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:28,347 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:28,389 - root - INFO: ... got raster of shape: (59, 233)\n", - "2021-09-23 13:19:28,397 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "bounds in my_crs: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "bounds in my_crs: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:28,426 - root - INFO: shape bounds: (-149.27262726963016, 68.1992545161618, -149.2079050474058, 68.21564340505122)\n", - "2021-09-23 13:19:28,428 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:28,429 - root - INFO: ... got raster bounds: (-149.27262726963016, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", - "2021-09-23 13:19:28,449 - root - INFO: \n", - "2021-09-23 13:19:28,450 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:28,450 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,450 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:28,456 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:28,456 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:28,508 - root - INFO: \n", - "2021-09-23 13:19:28,508 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:28,509 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,509 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:28,510 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:28,554 - root - INFO: ... got raster of shape: (98, 377)\n", - "2021-09-23 13:19:28,562 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:28,591 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "2021-09-23 13:19:28,593 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:28,594 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", - "2021-09-23 13:19:28,597 - root - INFO: \n", - "2021-09-23 13:19:28,598 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:28,598 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,599 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:28,599 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:28,644 - root - INFO: ... got raster of shape: (98, 377)\n", - "2021-09-23 13:19:28,653 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:28,683 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "2021-09-23 13:19:28,685 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:28,686 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", - "2021-09-23 13:19:28,689 - root - INFO: \n", - "2021-09-23 13:19:28,690 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:28,690 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,690 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:28,691 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:28,734 - root - INFO: ... got raster of shape: (98, 377)\n", - "2021-09-23 13:19:28,743 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "bounds in my_crs: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "bounds in my_crs: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:28,773 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "2021-09-23 13:19:28,775 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:28,776 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", - "2021-09-23 13:19:28,781 - root - INFO: \n", - "2021-09-23 13:19:28,782 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:28,782 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,783 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:28,784 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:28,825 - root - INFO: ... got raster of shape: (98, 377)\n", - "2021-09-23 13:19:28,834 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:28,863 - root - INFO: shape bounds: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "2021-09-23 13:19:28,865 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:28,866 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17123838073792, 68.20731007171761)\n", - "2021-09-23 13:19:28,884 - root - INFO: \n", - "2021-09-23 13:19:28,885 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:28,886 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,886 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:28,891 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:28,892 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:28,942 - root - INFO: \n", - "2021-09-23 13:19:28,943 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:28,943 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:28,944 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:28,945 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:28,986 - root - INFO: ... got raster of shape: (46, 147)\n", - "2021-09-23 13:19:28,996 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.27568282518584, 68.20731007171761, -149.17123838073792, 68.23425451616296)\n", - "bounds in my_crs: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:29,030 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "2021-09-23 13:19:29,032 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:29,032 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", - "2021-09-23 13:19:29,036 - root - INFO: \n", - "2021-09-23 13:19:29,036 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,037 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,037 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:29,038 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:29,080 - root - INFO: ... got raster of shape: (46, 147)\n", - "2021-09-23 13:19:29,089 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:29,121 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "2021-09-23 13:19:29,123 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:29,123 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", - "2021-09-23 13:19:29,126 - root - INFO: \n", - "2021-09-23 13:19:29,126 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,126 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,127 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:29,127 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:29,169 - root - INFO: ... got raster of shape: (46, 147)\n", - "2021-09-23 13:19:29,177 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:29,207 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "2021-09-23 13:19:29,209 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:29,210 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", - "2021-09-23 13:19:29,211 - root - INFO: \n", - "2021-09-23 13:19:29,212 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,213 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,213 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:29,214 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:29,256 - root - INFO: ... got raster of shape: (46, 147)\n", - "2021-09-23 13:19:29,265 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "bounds in my_crs: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "bounds in my_crs: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:29,296 - root - INFO: shape bounds: (-149.21262726962817, 68.19675451616172, -149.17179393629348, 68.20953229393992)\n", - "2021-09-23 13:19:29,298 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:29,298 - root - INFO: ... got raster bounds: (-149.21262726962817, 68.20953229393992, -149.17179393629348, 68.19675451616172)\n", - "2021-09-23 13:19:29,316 - root - INFO: \n", - "2021-09-23 13:19:29,316 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:29,317 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,317 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:29,323 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:29,324 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:29,377 - root - INFO: \n", - "2021-09-23 13:19:29,378 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,378 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,379 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:29,381 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:29,422 - root - INFO: ... got raster of shape: (96, 194)\n", - "2021-09-23 13:19:29,431 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:29,461 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "2021-09-23 13:19:29,464 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:29,464 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", - "2021-09-23 13:19:29,467 - root - INFO: \n", - "2021-09-23 13:19:29,468 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,468 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,468 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:29,470 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:29,513 - root - INFO: ... got raster of shape: (96, 194)\n", - "2021-09-23 13:19:29,521 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:29,550 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "2021-09-23 13:19:29,553 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:29,553 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", - "2021-09-23 13:19:29,557 - root - INFO: \n", - "2021-09-23 13:19:29,557 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,557 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,558 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:29,560 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:29,600 - root - INFO: ... got raster of shape: (96, 194)\n", - "2021-09-23 13:19:29,610 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "bounds in my_crs: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "bounds in my_crs: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:29,641 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "2021-09-23 13:19:29,643 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:29,644 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", - "2021-09-23 13:19:29,647 - root - INFO: \n", - "2021-09-23 13:19:29,647 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,648 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,648 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:29,650 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:29,690 - root - INFO: ... got raster of shape: (96, 194)\n", - "2021-09-23 13:19:29,699 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:29,730 - root - INFO: shape bounds: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "2021-09-23 13:19:29,732 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:29,733 - root - INFO: ... got raster bounds: (-149.17123838073792, 68.22453229394041, -149.11734949184725, 68.19786562727286)\n", - "2021-09-23 13:19:29,754 - root - INFO: \n", - "2021-09-23 13:19:29,755 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:29,755 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,756 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:29,761 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:29,762 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:29,813 - root - INFO: \n", - "2021-09-23 13:19:29,814 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,815 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,815 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:29,816 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:29,856 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-23 13:19:29,864 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.17123838073792, 68.19786562727286, -149.11734949184725, 68.22453229394041)\n", - "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:29,895 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-23 13:19:29,897 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:29,897 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-23 13:19:29,900 - root - INFO: \n", - "2021-09-23 13:19:29,901 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,901 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,901 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:29,902 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:29,944 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-23 13:19:29,952 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:29,980 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-23 13:19:29,982 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:29,982 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-23 13:19:29,986 - root - INFO: \n", - "2021-09-23 13:19:29,986 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:29,987 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:29,987 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:29,988 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,030 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-23 13:19:30,039 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:30,068 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-23 13:19:30,070 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:30,071 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-23 13:19:30,073 - root - INFO: \n", - "2021-09-23 13:19:30,074 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:30,074 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,075 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:30,075 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,116 - root - INFO: ... got raster of shape: (44, 186)\n", - "2021-09-23 13:19:30,125 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "bounds in my_crs: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:30,155 - root - INFO: shape bounds: (-149.17734949184924, 68.2100878494955, -149.12596060295863, 68.22231007171811)\n", - "2021-09-23 13:19:30,157 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:30,158 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22231007171811, -149.12596060295863, 68.21008784949548)\n", - "2021-09-23 13:19:30,173 - root - INFO: \n", - "2021-09-23 13:19:30,173 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:30,173 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,174 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:30,178 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:30,179 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:30,231 - root - INFO: \n", - "2021-09-23 13:19:30,232 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:30,232 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,233 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:30,234 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,275 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-23 13:19:30,284 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:30,314 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "2021-09-23 13:19:30,316 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:30,317 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-23 13:19:30,318 - root - INFO: \n", - "2021-09-23 13:19:30,318 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:30,319 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,319 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:30,320 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,361 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-23 13:19:30,370 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:30,399 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "2021-09-23 13:19:30,401 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:30,402 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-23 13:19:30,403 - root - INFO: \n", - "2021-09-23 13:19:30,404 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:30,404 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,405 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:30,406 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,448 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-23 13:19:30,456 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "bounds in my_crs: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "bounds in my_crs: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:30,486 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "2021-09-23 13:19:30,488 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:30,489 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-23 13:19:30,490 - root - INFO: \n", - "2021-09-23 13:19:30,491 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:30,491 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,492 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:30,492 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,534 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-23 13:19:30,543 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:30,573 - root - INFO: shape bounds: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "2021-09-23 13:19:30,575 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:30,575 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-23 13:19:30,591 - root - INFO: \n", - "2021-09-23 13:19:30,591 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:30,592 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,592 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:30,596 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:30,597 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:30,658 - root - INFO: \n", - "2021-09-23 13:19:30,659 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:30,659 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,660 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:30,661 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,701 - root - INFO: ... got raster of shape: (19, 30)\n", - "2021-09-23 13:19:30,710 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12207171406962, 68.21453229394008, -149.11457171406937, 68.2248100717182)\n", - "bounds in my_crs: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:30,740 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "2021-09-23 13:19:30,742 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:30,743 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-23 13:19:30,744 - root - INFO: \n", - "2021-09-23 13:19:30,744 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:30,745 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,745 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:30,746 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,787 - root - INFO: ... got raster of shape: (19, 30)\n", - "2021-09-23 13:19:30,796 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:30,827 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "2021-09-23 13:19:30,829 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:30,830 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-23 13:19:30,831 - root - INFO: \n", - "2021-09-23 13:19:30,832 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:30,833 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,833 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:30,834 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,882 - root - INFO: ... got raster of shape: (19, 30)\n", - "2021-09-23 13:19:30,893 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:30,929 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "2021-09-23 13:19:30,930 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:30,931 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-23 13:19:30,932 - root - INFO: \n", - "2021-09-23 13:19:30,933 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:30,933 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:30,934 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:30,935 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:30,977 - root - INFO: ... got raster of shape: (19, 30)\n", - "2021-09-23 13:19:30,985 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "bounds in my_crs: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "bounds in my_crs: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:31,014 - root - INFO: shape bounds: (-149.12234949184742, 68.22453229394041, -149.11429393629157, 68.22981007171836)\n", - "2021-09-23 13:19:31,017 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:31,018 - root - INFO: ... got raster bounds: (-149.12262726962518, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-23 13:19:31,030 - root - INFO: \n", - "2021-09-23 13:19:31,030 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:31,030 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,031 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:31,036 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:31,036 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:31,092 - root - INFO: \n", - "2021-09-23 13:19:31,093 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:31,093 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,094 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:31,095 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:31,138 - root - INFO: ... got raster of shape: (117, 192)\n", - "2021-09-23 13:19:31,147 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:31,177 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "2021-09-23 13:19:31,180 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:31,181 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", - "2021-09-23 13:19:31,184 - root - INFO: \n", - "2021-09-23 13:19:31,185 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:31,185 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,186 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:31,186 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:31,231 - root - INFO: ... got raster of shape: (117, 192)\n", - "2021-09-23 13:19:31,243 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:31,278 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "2021-09-23 13:19:31,280 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:31,281 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", - "2021-09-23 13:19:31,283 - root - INFO: \n", - "2021-09-23 13:19:31,284 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:31,284 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,284 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:31,285 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:31,328 - root - INFO: ... got raster of shape: (117, 192)\n", - "2021-09-23 13:19:31,336 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "bounds in my_crs: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "bounds in my_crs: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:31,367 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "2021-09-23 13:19:31,369 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:31,370 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", - "2021-09-23 13:19:31,375 - root - INFO: \n", - "2021-09-23 13:19:31,375 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:31,376 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,376 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:31,377 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:31,419 - root - INFO: ... got raster of shape: (117, 192)\n", - "2021-09-23 13:19:31,427 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:31,457 - root - INFO: shape bounds: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "2021-09-23 13:19:31,459 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:31,460 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07207171406796, 68.19953229393958)\n", - "2021-09-23 13:19:31,476 - root - INFO: \n", - "2021-09-23 13:19:31,477 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:31,477 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,478 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:31,483 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:31,484 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:31,534 - root - INFO: \n", - "2021-09-23 13:19:31,534 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:31,535 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,536 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:31,536 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:31,581 - root - INFO: ... got raster of shape: (95, 128)\n", - "2021-09-23 13:19:31,589 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12540504740306, 68.19953229393958, -149.07207171406796, 68.23203229394066)\n", - "bounds in my_crs: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:31,619 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "2021-09-23 13:19:31,621 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:31,622 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", - "2021-09-23 13:19:31,626 - root - INFO: \n", - "2021-09-23 13:19:31,626 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:31,627 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,627 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:31,628 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:31,673 - root - INFO: ... got raster of shape: (95, 128)\n", - "2021-09-23 13:19:31,682 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:31,712 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "2021-09-23 13:19:31,714 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:31,715 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", - "2021-09-23 13:19:31,718 - root - INFO: \n", - "2021-09-23 13:19:31,718 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:31,718 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,719 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:31,719 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:31,763 - root - INFO: ... got raster of shape: (95, 128)\n", - "2021-09-23 13:19:31,772 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:31,805 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "2021-09-23 13:19:31,807 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:31,808 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", - "2021-09-23 13:19:31,812 - root - INFO: \n", - "2021-09-23 13:19:31,813 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:31,813 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,814 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:31,815 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:31,856 - root - INFO: ... got raster of shape: (95, 128)\n", - "2021-09-23 13:19:31,864 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "bounds in my_crs: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "bounds in my_crs: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:31,897 - root - INFO: shape bounds: (-149.1159606029583, 68.2248100717182, -149.08040504740157, 68.25092118283018)\n", - "2021-09-23 13:19:31,899 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:31,900 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25119896060797, -149.08040504740157, 68.2248100717182)\n", - "2021-09-23 13:19:31,911 - root - INFO: \n", - "2021-09-23 13:19:31,912 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:31,913 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,913 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:31,918 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:31,919 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:31,974 - root - INFO: \n", - "2021-09-23 13:19:31,974 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:31,975 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:31,975 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:31,976 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,018 - root - INFO: ... got raster of shape: (99, 206)\n", - "2021-09-23 13:19:32,028 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:32,061 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "2021-09-23 13:19:32,063 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:32,063 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", - "2021-09-23 13:19:32,069 - root - INFO: \n", - "2021-09-23 13:19:32,069 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:32,070 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,070 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:32,072 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,117 - root - INFO: ... got raster of shape: (99, 206)\n", - "2021-09-23 13:19:32,127 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:32,158 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "2021-09-23 13:19:32,160 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:32,161 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", - "2021-09-23 13:19:32,165 - root - INFO: \n", - "2021-09-23 13:19:32,165 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:32,165 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,166 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:32,166 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,208 - root - INFO: ... got raster of shape: (99, 206)\n", - "2021-09-23 13:19:32,216 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "bounds in my_crs: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "bounds in my_crs: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:32,247 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "2021-09-23 13:19:32,249 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:32,249 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", - "2021-09-23 13:19:32,253 - root - INFO: \n", - "2021-09-23 13:19:32,254 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:32,254 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,254 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:32,255 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,296 - root - INFO: ... got raster of shape: (99, 206)\n", - "2021-09-23 13:19:32,305 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:32,337 - root - INFO: shape bounds: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "2021-09-23 13:19:32,339 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:32,340 - root - INFO: ... got raster bounds: (-149.0859606029573, 68.2439767383855, -149.0287383807332, 68.21647673838459)\n", - "2021-09-23 13:19:32,353 - root - INFO: \n", - "2021-09-23 13:19:32,354 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:32,354 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,355 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:32,359 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:32,360 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:32,413 - root - INFO: \n", - "2021-09-23 13:19:32,413 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:32,414 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,414 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:32,415 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,457 - root - INFO: ... got raster of shape: (68, 215)\n", - "2021-09-23 13:19:32,467 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08568282517953, 68.21647673838459, -149.0287383807332, 68.2439767383855)\n", - "bounds in my_crs: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:32,498 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "2021-09-23 13:19:32,500 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:32,501 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", - "2021-09-23 13:19:32,505 - root - INFO: \n", - "2021-09-23 13:19:32,506 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:32,506 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,507 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:32,508 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,550 - root - INFO: ... got raster of shape: (68, 215)\n", - "2021-09-23 13:19:32,560 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:32,591 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "2021-09-23 13:19:32,593 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:32,594 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", - "2021-09-23 13:19:32,597 - root - INFO: \n", - "2021-09-23 13:19:32,597 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:32,598 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,598 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:32,599 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,640 - root - INFO: ... got raster of shape: (68, 215)\n", - "2021-09-23 13:19:32,648 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:32,679 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "2021-09-23 13:19:32,680 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:32,681 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", - "2021-09-23 13:19:32,685 - root - INFO: \n", - "2021-09-23 13:19:32,685 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:32,685 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,686 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:32,687 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,729 - root - INFO: ... got raster of shape: (68, 215)\n", - "2021-09-23 13:19:32,738 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "bounds in my_crs: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "bounds in my_crs: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:32,768 - root - INFO: shape bounds: (-149.08984949184634, 68.23231007171844, -149.0304050473999, 68.25092118283018)\n", - "2021-09-23 13:19:32,770 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:32,771 - root - INFO: ... got raster bounds: (-149.0901272696241, 68.25119896060797, -149.0304050473999, 68.23231007171844)\n", - "2021-09-23 13:19:32,786 - root - INFO: \n", - "2021-09-23 13:19:32,787 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:32,787 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,788 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:32,793 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:32,794 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:32,846 - root - INFO: \n", - "2021-09-23 13:19:32,846 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:32,847 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,847 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:32,848 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,892 - root - INFO: ... got raster of shape: (86, 196)\n", - "2021-09-23 13:19:32,901 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:32,931 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "2021-09-23 13:19:32,933 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:32,934 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", - "2021-09-23 13:19:32,937 - root - INFO: \n", - "2021-09-23 13:19:32,937 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:32,938 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:32,938 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:32,939 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:32,984 - root - INFO: ... got raster of shape: (86, 196)\n", - "2021-09-23 13:19:32,993 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:33,024 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "2021-09-23 13:19:33,025 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:33,026 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", - "2021-09-23 13:19:33,029 - root - INFO: \n", - "2021-09-23 13:19:33,030 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,030 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,030 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:33,031 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:33,074 - root - INFO: ... got raster of shape: (86, 196)\n", - "2021-09-23 13:19:33,083 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "bounds in my_crs: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "bounds in my_crs: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:33,116 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "2021-09-23 13:19:33,118 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:33,119 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", - "2021-09-23 13:19:33,123 - root - INFO: \n", - "2021-09-23 13:19:33,124 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,124 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,125 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:33,126 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:33,170 - root - INFO: ... got raster of shape: (86, 196)\n", - "2021-09-23 13:19:33,179 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:33,211 - root - INFO: shape bounds: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "2021-09-23 13:19:33,213 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:33,214 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.26814340505297, -148.97596060295365, 68.24425451616328)\n", - "2021-09-23 13:19:33,230 - root - INFO: \n", - "2021-09-23 13:19:33,230 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:33,231 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,231 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:33,236 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:33,237 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:33,290 - root - INFO: \n", - "2021-09-23 13:19:33,291 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,291 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,292 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:33,293 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:33,334 - root - INFO: ... got raster of shape: (69, 203)\n", - "2021-09-23 13:19:33,343 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.0304050473999, 68.2442545161633, -148.97596060295365, 68.26814340505297)\n", - "bounds in my_crs: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:33,372 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "2021-09-23 13:19:33,374 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:33,375 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", - "2021-09-23 13:19:33,378 - root - INFO: \n", - "2021-09-23 13:19:33,378 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,378 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,379 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:33,379 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:33,419 - root - INFO: ... got raster of shape: (69, 203)\n", - "2021-09-23 13:19:33,428 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:33,460 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "2021-09-23 13:19:33,461 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:33,462 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", - "2021-09-23 13:19:33,465 - root - INFO: \n", - "2021-09-23 13:19:33,465 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,466 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,466 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:33,467 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:33,507 - root - INFO: ... got raster of shape: (69, 203)\n", - "2021-09-23 13:19:33,516 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:33,546 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "2021-09-23 13:19:33,548 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:33,549 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", - "2021-09-23 13:19:33,551 - root - INFO: \n", - "2021-09-23 13:19:33,551 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,552 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,552 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:33,552 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:33,594 - root - INFO: ... got raster of shape: (69, 203)\n", - "2021-09-23 13:19:33,602 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "bounds in my_crs: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "bounds in my_crs: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:33,631 - root - INFO: shape bounds: (-149.0306828251777, 68.2353656272741, -148.97457171406472, 68.25453229394141)\n", - "2021-09-23 13:19:33,633 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:33,634 - root - INFO: ... got raster bounds: (-149.03096060295547, 68.25453229394141, -148.97457171406472, 68.2353656272741)\n", - "2021-09-23 13:19:33,650 - root - INFO: \n", - "2021-09-23 13:19:33,650 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:33,651 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,651 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:33,656 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:33,657 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:33,708 - root - INFO: \n", - "2021-09-23 13:19:33,709 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,709 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,710 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:33,711 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:33,755 - root - INFO: ... got raster of shape: (89, 263)\n", - "2021-09-23 13:19:33,763 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:33,794 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "2021-09-23 13:19:33,796 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:33,796 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", - "2021-09-23 13:19:33,800 - root - INFO: \n", - "2021-09-23 13:19:33,800 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,800 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,801 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:33,801 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:33,845 - root - INFO: ... got raster of shape: (89, 263)\n", - "2021-09-23 13:19:33,853 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:33,883 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "2021-09-23 13:19:33,885 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:33,886 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", - "2021-09-23 13:19:33,889 - root - INFO: \n", - "2021-09-23 13:19:33,890 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,890 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,891 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:33,892 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:33,936 - root - INFO: ... got raster of shape: (89, 263)\n", - "2021-09-23 13:19:33,944 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "bounds in my_crs: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "bounds in my_crs: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:33,973 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "2021-09-23 13:19:33,975 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:33,976 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", - "2021-09-23 13:19:33,980 - root - INFO: \n", - "2021-09-23 13:19:33,981 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:33,981 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:33,981 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:33,982 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:34,024 - root - INFO: ... got raster of shape: (89, 263)\n", - "2021-09-23 13:19:34,032 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:34,064 - root - INFO: shape bounds: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "2021-09-23 13:19:34,065 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:34,066 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28064340505338, -148.94040504739692, 68.25592118283033)\n", - "2021-09-23 13:19:34,083 - root - INFO: \n", - "2021-09-23 13:19:34,084 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:34,084 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,084 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:34,090 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:34,091 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:34,143 - root - INFO: \n", - "2021-09-23 13:19:34,144 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:34,145 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,145 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:34,146 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:34,188 - root - INFO: ... got raster of shape: (100, 191)\n", - "2021-09-23 13:19:34,196 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.01318282517713, 68.25592118283035, -148.94040504739692, 68.28064340505338)\n", - "bounds in my_crs: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:34,226 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "2021-09-23 13:19:34,228 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:34,229 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", - "2021-09-23 13:19:34,232 - root - INFO: \n", - "2021-09-23 13:19:34,233 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:34,233 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,233 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:34,234 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:34,276 - root - INFO: ... got raster of shape: (100, 191)\n", - "2021-09-23 13:19:34,284 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:34,315 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "2021-09-23 13:19:34,317 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:34,318 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", - "2021-09-23 13:19:34,321 - root - INFO: \n", - "2021-09-23 13:19:34,321 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:34,322 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,322 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:34,323 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:34,363 - root - INFO: ... got raster of shape: (100, 191)\n", - "2021-09-23 13:19:34,372 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:34,401 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "2021-09-23 13:19:34,403 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:34,404 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", - "2021-09-23 13:19:34,406 - root - INFO: \n", - "2021-09-23 13:19:34,407 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:34,408 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,408 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:34,409 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:34,451 - root - INFO: ... got raster of shape: (100, 191)\n", - "2021-09-23 13:19:34,461 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "bounds in my_crs: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "bounds in my_crs: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:34,492 - root - INFO: shape bounds: (-148.97623838073144, 68.24786562727452, -148.92318282517414, 68.27564340505322)\n", - "2021-09-23 13:19:34,494 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:34,495 - root - INFO: ... got raster bounds: (-148.97623838073144, 68.27564340505322, -148.92318282517414, 68.24786562727452)\n", - "2021-09-23 13:19:34,510 - root - INFO: \n", - "2021-09-23 13:19:34,511 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:34,511 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,512 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:34,516 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:34,517 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:34,570 - root - INFO: \n", - "2021-09-23 13:19:34,571 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:34,571 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,572 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:34,573 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:34,617 - root - INFO: ... got raster of shape: (92, 198)\n", - "2021-09-23 13:19:34,625 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:34,655 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "2021-09-23 13:19:34,657 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:34,659 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", - "2021-09-23 13:19:34,661 - root - INFO: \n", - "2021-09-23 13:19:34,662 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:34,662 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,662 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:34,663 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:34,708 - root - INFO: ... got raster of shape: (92, 198)\n", - "2021-09-23 13:19:34,716 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:34,747 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "2021-09-23 13:19:34,749 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:34,750 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", - "2021-09-23 13:19:34,753 - root - INFO: \n", - "2021-09-23 13:19:34,753 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:34,754 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,754 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:34,755 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:34,799 - root - INFO: ... got raster of shape: (92, 198)\n", - "2021-09-23 13:19:34,808 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "bounds in my_crs: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "bounds in my_crs: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:34,839 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "2021-09-23 13:19:34,840 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:34,841 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", - "2021-09-23 13:19:34,845 - root - INFO: \n", - "2021-09-23 13:19:34,845 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:34,846 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,846 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:34,847 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:34,888 - root - INFO: ... got raster of shape: (92, 198)\n", - "2021-09-23 13:19:34,897 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:34,928 - root - INFO: shape bounds: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "2021-09-23 13:19:34,930 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:34,931 - root - INFO: ... got raster bounds: (-148.95179393628618, 68.30203229394299, -148.89679393628435, 68.27647673838658)\n", - "2021-09-23 13:19:34,947 - root - INFO: \n", - "2021-09-23 13:19:34,948 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:34,948 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:34,949 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:34,954 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:34,954 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:35,009 - root - INFO: \n", - "2021-09-23 13:19:35,009 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,010 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,010 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:35,011 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,053 - root - INFO: ... got raster of shape: (98, 188)\n", - "2021-09-23 13:19:35,062 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.95179393628618, 68.27647673838658, -148.89679393628435, 68.30203229394299)\n", - "bounds in my_crs: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:35,092 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "2021-09-23 13:19:35,094 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:35,095 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", - "2021-09-23 13:19:35,099 - root - INFO: \n", - "2021-09-23 13:19:35,100 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,100 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,101 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:35,101 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,144 - root - INFO: ... got raster of shape: (98, 188)\n", - "2021-09-23 13:19:35,153 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:35,184 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "2021-09-23 13:19:35,185 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:35,186 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", - "2021-09-23 13:19:35,190 - root - INFO: \n", - "2021-09-23 13:19:35,191 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,191 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,191 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:35,192 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,233 - root - INFO: ... got raster of shape: (98, 188)\n", - "2021-09-23 13:19:35,241 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:35,271 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "2021-09-23 13:19:35,273 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:35,274 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", - "2021-09-23 13:19:35,277 - root - INFO: \n", - "2021-09-23 13:19:35,278 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,278 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,279 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:35,279 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,321 - root - INFO: ... got raster of shape: (98, 188)\n", - "2021-09-23 13:19:35,330 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "bounds in my_crs: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "bounds in my_crs: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:35,360 - root - INFO: shape bounds: (-148.94012726961913, 68.26425451616396, -148.88790504739518, 68.29147673838708)\n", - "2021-09-23 13:19:35,362 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:35,363 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29147673838708, -148.88790504739518, 68.26425451616394)\n", - "2021-09-23 13:19:35,379 - root - INFO: \n", - "2021-09-23 13:19:35,379 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:35,379 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,380 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:35,385 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:35,385 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:35,438 - root - INFO: \n", - "2021-09-23 13:19:35,439 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,439 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,440 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:35,441 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,484 - root - INFO: ... got raster of shape: (79, 96)\n", - "2021-09-23 13:19:35,492 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:35,523 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "2021-09-23 13:19:35,525 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:35,525 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", - "2021-09-23 13:19:35,529 - root - INFO: \n", - "2021-09-23 13:19:35,529 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,529 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,530 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:35,531 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,571 - root - INFO: ... got raster of shape: (79, 96)\n", - "2021-09-23 13:19:35,580 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:35,612 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "2021-09-23 13:19:35,614 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:35,614 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", - "2021-09-23 13:19:35,617 - root - INFO: \n", - "2021-09-23 13:19:35,617 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,618 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,618 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:35,619 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,661 - root - INFO: ... got raster of shape: (79, 96)\n", - "2021-09-23 13:19:35,670 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "bounds in my_crs: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "bounds in my_crs: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:35,700 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "2021-09-23 13:19:35,702 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:35,703 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", - "2021-09-23 13:19:35,706 - root - INFO: \n", - "2021-09-23 13:19:35,706 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,707 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,707 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:35,709 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,751 - root - INFO: ... got raster of shape: (79, 96)\n", - "2021-09-23 13:19:35,759 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:35,789 - root - INFO: shape bounds: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "2021-09-23 13:19:35,792 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:35,792 - root - INFO: ... got raster bounds: (-148.89679393628435, 68.29619896060946, -148.8701272696168, 68.27425451616429)\n", - "2021-09-23 13:19:35,808 - root - INFO: \n", - "2021-09-23 13:19:35,808 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:35,809 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,809 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:35,814 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:35,814 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:35,866 - root - INFO: \n", - "2021-09-23 13:19:35,866 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,867 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,867 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:35,868 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,909 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-23 13:19:35,917 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:35,947 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "2021-09-23 13:19:35,949 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:35,950 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.89679393628435, 68.27425451616429, -148.8701272696168, 68.29592118283168)\n", - "bounds in my_crs: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:35,952 - root - INFO: \n", - "2021-09-23 13:19:35,953 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:35,953 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:35,953 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:35,954 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:35,995 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-23 13:19:36,004 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:36,034 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "2021-09-23 13:19:36,036 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:36,037 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", - "2021-09-23 13:19:36,039 - root - INFO: \n", - "2021-09-23 13:19:36,040 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:36,041 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,041 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:36,042 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:36,084 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-23 13:19:36,092 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:36,122 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "2021-09-23 13:19:36,123 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:36,124 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", - "2021-09-23 13:19:36,126 - root - INFO: \n", - "2021-09-23 13:19:36,126 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:36,127 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,127 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:36,127 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:36,168 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-23 13:19:36,177 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "bounds in my_crs: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "bounds in my_crs: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:36,207 - root - INFO: shape bounds: (-148.9109606029515, 68.29175451616487, -148.88707171406182, 68.30147673838741)\n", - "2021-09-23 13:19:36,208 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:36,209 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", - "2021-09-23 13:19:36,223 - root - INFO: \n", - "2021-09-23 13:19:36,223 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:36,224 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,224 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:36,229 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:36,230 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:36,282 - root - INFO: \n", - "2021-09-23 13:19:36,283 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:36,283 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,284 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:36,287 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:36,332 - root - INFO: ... got raster of shape: (122, 301)\n", - "2021-09-23 13:19:36,341 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:36,373 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "2021-09-23 13:19:36,376 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:36,376 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", - "2021-09-23 13:19:36,379 - root - INFO: \n", - "2021-09-23 13:19:36,380 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:36,380 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,380 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:36,384 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:36,428 - root - INFO: ... got raster of shape: (122, 301)\n", - "2021-09-23 13:19:36,437 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:36,469 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "2021-09-23 13:19:36,472 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:36,473 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", - "2021-09-23 13:19:36,475 - root - INFO: \n", - "2021-09-23 13:19:36,476 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:36,476 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,477 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:36,480 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:36,525 - root - INFO: ... got raster of shape: (122, 301)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "bounds in my_crs: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "bounds in my_crs: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:36,533 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:36,566 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "2021-09-23 13:19:36,568 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:36,569 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", - "2021-09-23 13:19:36,574 - root - INFO: \n", - "2021-09-23 13:19:36,575 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:36,575 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,576 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:36,580 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:36,622 - root - INFO: ... got raster of shape: (122, 301)\n", - "2021-09-23 13:19:36,631 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:36,663 - root - INFO: shape bounds: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "2021-09-23 13:19:36,666 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:36,666 - root - INFO: ... got raster bounds: (-148.88596060295066, 68.31314340505446, -148.80234949183676, 68.27925451616444)\n", - "2021-09-23 13:19:36,695 - root - INFO: \n", - "2021-09-23 13:19:36,696 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:36,696 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,697 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:36,702 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:36,703 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:36,755 - root - INFO: \n", - "2021-09-23 13:19:36,756 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:36,757 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,757 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:36,758 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:36,800 - root - INFO: ... got raster of shape: (69, 204)\n", - "2021-09-23 13:19:36,808 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.88596060295066, 68.27925451616446, -148.8023494918368, 68.31314340505446)\n", - "bounds in my_crs: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:36,838 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "2021-09-23 13:19:36,840 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:36,841 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", - "2021-09-23 13:19:36,843 - root - INFO: \n", - "2021-09-23 13:19:36,844 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:36,844 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,845 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:36,845 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:36,888 - root - INFO: ... got raster of shape: (69, 204)\n", - "2021-09-23 13:19:36,897 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:36,927 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "2021-09-23 13:19:36,929 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:36,930 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", - "2021-09-23 13:19:36,932 - root - INFO: \n", - "2021-09-23 13:19:36,933 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:36,933 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:36,933 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:36,934 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:36,977 - root - INFO: ... got raster of shape: (69, 204)\n", - "2021-09-23 13:19:36,986 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:37,015 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "2021-09-23 13:19:37,017 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:37,018 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", - "2021-09-23 13:19:37,020 - root - INFO: \n", - "2021-09-23 13:19:37,021 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:37,021 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,022 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:37,023 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:37,065 - root - INFO: ... got raster of shape: (69, 204)\n", - "2021-09-23 13:19:37,075 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "bounds in my_crs: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "bounds in my_crs: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:37,107 - root - INFO: shape bounds: (-148.89068282517306, 68.29619896060946, -148.83429393628228, 68.31536562727676)\n", - "2021-09-23 13:19:37,109 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:37,110 - root - INFO: ... got raster bounds: (-148.89096060295083, 68.31536562727676, -148.83429393628228, 68.29619896060946)\n", - "2021-09-23 13:19:37,126 - root - INFO: \n", - "2021-09-23 13:19:37,127 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:37,127 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,128 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:37,132 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:37,133 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:37,184 - root - INFO: \n", - "2021-09-23 13:19:37,185 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:37,185 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,186 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:37,188 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:37,228 - root - INFO: ... got raster of shape: (124, 328)\n", - "2021-09-23 13:19:37,237 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:37,266 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "2021-09-23 13:19:37,268 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:37,269 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", - "2021-09-23 13:19:37,272 - root - INFO: \n", - "2021-09-23 13:19:37,273 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:37,273 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,274 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:37,276 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:37,318 - root - INFO: ... got raster of shape: (124, 328)\n", - "2021-09-23 13:19:37,327 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:37,359 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "2021-09-23 13:19:37,361 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:37,362 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", - "2021-09-23 13:19:37,365 - root - INFO: \n", - "2021-09-23 13:19:37,366 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:37,366 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,366 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:37,368 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:37,409 - root - INFO: ... got raster of shape: (124, 328)\n", - "2021-09-23 13:19:37,417 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "bounds in my_crs: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "bounds in my_crs: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:37,448 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "2021-09-23 13:19:37,450 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:37,451 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", - "2021-09-23 13:19:37,455 - root - INFO: \n", - "2021-09-23 13:19:37,456 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:37,456 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,456 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:37,458 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:37,500 - root - INFO: ... got raster of shape: (124, 328)\n", - "2021-09-23 13:19:37,509 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:37,542 - root - INFO: shape bounds: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "2021-09-23 13:19:37,544 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:37,545 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.26036562727494, -149.1117939362915, 68.22592118282935)\n", - "2021-09-23 13:19:37,566 - root - INFO: \n", - "2021-09-23 13:19:37,567 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:37,567 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,568 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:37,573 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:37,573 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:37,625 - root - INFO: \n", - "2021-09-23 13:19:37,626 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:37,627 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,627 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:37,629 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:37,672 - root - INFO: ... got raster of shape: (95, 310)\n", - "2021-09-23 13:19:37,680 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.20290504740564, 68.22592118282935, -149.1117939362915, 68.26036562727494)\n", - "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:37,711 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "2021-09-23 13:19:37,713 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:37,713 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", - "2021-09-23 13:19:37,716 - root - INFO: \n", - "2021-09-23 13:19:37,717 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:37,717 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,717 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:37,719 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:37,759 - root - INFO: ... got raster of shape: (95, 310)\n", - "2021-09-23 13:19:37,769 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:37,799 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "2021-09-23 13:19:37,801 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:37,802 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", - "2021-09-23 13:19:37,804 - root - INFO: \n", - "2021-09-23 13:19:37,805 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:37,805 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,805 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:37,807 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:37,850 - root - INFO: ... got raster of shape: (95, 310)\n", - "2021-09-23 13:19:37,859 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:37,890 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "2021-09-23 13:19:37,893 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:37,893 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", - "2021-09-23 13:19:37,897 - root - INFO: \n", - "2021-09-23 13:19:37,897 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:37,897 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:37,898 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:37,899 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:37,941 - root - INFO: ... got raster of shape: (95, 310)\n", - "2021-09-23 13:19:37,949 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "bounds in my_crs: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:37,980 - root - INFO: shape bounds: (-149.2034606029612, 68.22814340505164, -149.11734949184725, 68.25453229394141)\n", - "2021-09-23 13:19:37,982 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:37,983 - root - INFO: ... got raster bounds: (-149.2034606029612, 68.25453229394141, -149.11734949184722, 68.22814340505164)\n", - "2021-09-23 13:19:38,006 - root - INFO: \n", - "2021-09-23 13:19:38,007 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:38,008 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,008 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:38,013 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:38,014 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:38,065 - root - INFO: \n", - "2021-09-23 13:19:38,065 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:38,066 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,066 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:38,067 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:38,112 - root - INFO: ... got raster of shape: (67, 367)\n", - "2021-09-23 13:19:38,121 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:38,149 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "2021-09-23 13:19:38,151 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:38,152 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", - "2021-09-23 13:19:38,155 - root - INFO: \n", - "2021-09-23 13:19:38,156 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:38,156 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,157 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:38,158 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:38,203 - root - INFO: ... got raster of shape: (67, 367)\n", - "2021-09-23 13:19:38,211 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:38,241 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "2021-09-23 13:19:38,243 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:38,244 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", - "2021-09-23 13:19:38,247 - root - INFO: \n", - "2021-09-23 13:19:38,247 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:38,247 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,248 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:38,248 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:38,292 - root - INFO: ... got raster of shape: (67, 367)\n", - "2021-09-23 13:19:38,301 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:38,331 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "2021-09-23 13:19:38,333 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:38,334 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", - "2021-09-23 13:19:38,337 - root - INFO: \n", - "2021-09-23 13:19:38,338 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:38,338 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,339 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:38,339 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:38,383 - root - INFO: ... got raster of shape: (67, 367)\n", - "2021-09-23 13:19:38,392 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:38,421 - root - INFO: shape bounds: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "2021-09-23 13:19:38,424 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:38,425 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.32619896061045, -148.94151615850805, 68.30758784949873)\n", - "2021-09-23 13:19:38,445 - root - INFO: \n", - "2021-09-23 13:19:38,445 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:38,446 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,446 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:38,451 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:38,451 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:38,503 - root - INFO: \n", - "2021-09-23 13:19:38,503 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:38,504 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,504 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:38,505 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:38,545 - root - INFO: ... got raster of shape: (53, 365)\n", - "2021-09-23 13:19:38,555 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.04318282517812, 68.30758784949873, -148.94151615850808, 68.32619896061045)\n", - "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:38,585 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "2021-09-23 13:19:38,587 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:38,588 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", - "2021-09-23 13:19:38,592 - root - INFO: \n", - "2021-09-23 13:19:38,592 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:38,593 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,593 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:38,593 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:38,644 - root - INFO: ... got raster of shape: (53, 365)\n", - "2021-09-23 13:19:38,652 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:38,682 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "2021-09-23 13:19:38,684 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:38,685 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", - "2021-09-23 13:19:38,689 - root - INFO: \n", - "2021-09-23 13:19:38,690 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:38,690 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,691 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:38,692 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:38,733 - root - INFO: ... got raster of shape: (53, 365)\n", - "2021-09-23 13:19:38,741 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:38,772 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "2021-09-23 13:19:38,774 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:38,775 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", - "2021-09-23 13:19:38,778 - root - INFO: \n", - "2021-09-23 13:19:38,779 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:38,779 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,780 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:38,780 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:38,821 - root - INFO: ... got raster of shape: (53, 365)\n", - "2021-09-23 13:19:38,829 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "bounds in my_crs: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:38,858 - root - INFO: shape bounds: (-149.04318282517812, 68.29814340505396, -148.94207171406364, 68.31286562727668)\n", - "2021-09-23 13:19:38,860 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:38,861 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94207171406364, 68.29814340505396)\n", - "2021-09-23 13:19:38,882 - root - INFO: \n", - "2021-09-23 13:19:38,882 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:38,883 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,883 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:38,888 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:38,888 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:38,942 - root - INFO: \n", - "2021-09-23 13:19:38,943 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:38,944 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:38,944 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:38,948 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:38,991 - root - INFO: ... got raster of shape: (114, 209)\n", - "2021-09-23 13:19:38,999 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:39,032 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "2021-09-23 13:19:39,035 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:39,035 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", - "2021-09-23 13:19:39,037 - root - INFO: \n", - "2021-09-23 13:19:39,038 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,038 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,038 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:39,042 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:39,085 - root - INFO: ... got raster of shape: (114, 209)\n", - "2021-09-23 13:19:39,094 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:39,128 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "2021-09-23 13:19:39,130 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:39,131 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", - "2021-09-23 13:19:39,133 - root - INFO: \n", - "2021-09-23 13:19:39,133 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,134 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,134 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:39,137 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:39,179 - root - INFO: ... got raster of shape: (114, 209)\n", - "2021-09-23 13:19:39,187 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:39,220 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "2021-09-23 13:19:39,223 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:39,223 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", - "2021-09-23 13:19:39,226 - root - INFO: \n", - "2021-09-23 13:19:39,227 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,227 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,228 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:39,231 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:39,274 - root - INFO: ... got raster of shape: (114, 209)\n", - "2021-09-23 13:19:39,283 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:39,315 - root - INFO: shape bounds: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "2021-09-23 13:19:39,317 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:39,318 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.88373838072837, 68.29203229394265)\n", - "2021-09-23 13:19:39,336 - root - INFO: \n", - "2021-09-23 13:19:39,337 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:39,337 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,338 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:39,342 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:39,343 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:39,396 - root - INFO: \n", - "2021-09-23 13:19:39,397 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,397 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,398 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:39,399 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:39,440 - root - INFO: ... got raster of shape: (48, 192)\n", - "2021-09-23 13:19:39,448 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.94179393628585, 68.29203229394265, -148.88373838072837, 68.32369896061037)\n", - "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:39,478 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "2021-09-23 13:19:39,480 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:39,481 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", - "2021-09-23 13:19:39,484 - root - INFO: \n", - "2021-09-23 13:19:39,484 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,485 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,485 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:39,486 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:39,528 - root - INFO: ... got raster of shape: (48, 192)\n", - "2021-09-23 13:19:39,536 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:39,566 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "2021-09-23 13:19:39,568 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:39,569 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", - "2021-09-23 13:19:39,572 - root - INFO: \n", - "2021-09-23 13:19:39,572 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,573 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,573 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:39,574 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:39,615 - root - INFO: ... got raster of shape: (48, 192)\n", - "2021-09-23 13:19:39,624 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:39,654 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "2021-09-23 13:19:39,657 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:39,658 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", - "2021-09-23 13:19:39,660 - root - INFO: \n", - "2021-09-23 13:19:39,661 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,662 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,662 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:39,663 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:39,706 - root - INFO: ... got raster of shape: (48, 192)\n", - "2021-09-23 13:19:39,715 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "bounds in my_crs: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:39,745 - root - INFO: shape bounds: (-148.942905047397, 68.29619896060946, -148.8895717140619, 68.30925451616545)\n", - "2021-09-23 13:19:39,747 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:39,748 - root - INFO: ... got raster bounds: (-148.942905047397, 68.30953229394324, -148.8895717140619, 68.29619896060946)\n", - "2021-09-23 13:19:39,759 - root - INFO: \n", - "2021-09-23 13:19:39,759 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:39,760 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,760 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:39,765 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:39,766 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:39,817 - root - INFO: \n", - "2021-09-23 13:19:39,818 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,818 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,819 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:39,820 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:39,862 - root - INFO: ... got raster of shape: (66, 302)\n", - "2021-09-23 13:19:39,871 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:39,903 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "2021-09-23 13:19:39,904 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:39,905 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", - "2021-09-23 13:19:39,908 - root - INFO: \n", - "2021-09-23 13:19:39,908 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,908 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,909 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:39,910 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:39,951 - root - INFO: ... got raster of shape: (66, 302)\n", - "2021-09-23 13:19:39,960 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:39,990 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "2021-09-23 13:19:39,992 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:39,993 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", - "2021-09-23 13:19:39,996 - root - INFO: \n", - "2021-09-23 13:19:39,997 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:39,997 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:39,997 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:39,999 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:40,040 - root - INFO: ... got raster of shape: (66, 302)\n", - "2021-09-23 13:19:40,050 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:40,083 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "2021-09-23 13:19:40,085 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:40,085 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", - "2021-09-23 13:19:40,089 - root - INFO: \n", - "2021-09-23 13:19:40,089 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:40,090 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,090 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:40,092 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:40,134 - root - INFO: ... got raster of shape: (66, 302)\n", - "2021-09-23 13:19:40,143 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:40,174 - root - INFO: shape bounds: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "2021-09-23 13:19:40,176 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:40,177 - root - INFO: ... got raster bounds: (-149.08262726962386, 68.2995322939429, -148.9987383807322, 68.28119896060896)\n", - "2021-09-23 13:19:40,197 - root - INFO: \n", - "2021-09-23 13:19:40,197 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:40,198 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,198 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:40,203 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:40,204 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:40,255 - root - INFO: \n", - "2021-09-23 13:19:40,255 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:40,256 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,256 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:40,257 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:40,298 - root - INFO: ... got raster of shape: (75, 294)\n", - "2021-09-23 13:19:40,307 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08262726962386, 68.28119896060896, -148.9987383807322, 68.2995322939429)\n", - "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:40,337 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "2021-09-23 13:19:40,339 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:40,340 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", - "2021-09-23 13:19:40,343 - root - INFO: \n", - "2021-09-23 13:19:40,344 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:40,345 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,345 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:40,346 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:40,386 - root - INFO: ... got raster of shape: (75, 294)\n", - "2021-09-23 13:19:40,394 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:40,424 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "2021-09-23 13:19:40,425 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:40,426 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", - "2021-09-23 13:19:40,431 - root - INFO: \n", - "2021-09-23 13:19:40,432 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:40,432 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,433 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:40,433 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:40,475 - root - INFO: ... got raster of shape: (75, 294)\n", - "2021-09-23 13:19:40,484 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:40,513 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "2021-09-23 13:19:40,515 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:40,516 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", - "2021-09-23 13:19:40,519 - root - INFO: \n", - "2021-09-23 13:19:40,520 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:40,520 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,520 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:40,521 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:40,562 - root - INFO: ... got raster of shape: (75, 294)\n", - "2021-09-23 13:19:40,571 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "bounds in my_crs: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:40,601 - root - INFO: shape bounds: (-149.08012726962377, 68.29147673838708, -148.9984606029544, 68.3123100717211)\n", - "2021-09-23 13:19:40,603 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:40,604 - root - INFO: ... got raster bounds: (-149.08012726962377, 68.3123100717211, -148.9984606029544, 68.29147673838708)\n", - "2021-09-23 13:19:40,619 - root - INFO: \n", - "2021-09-23 13:19:40,619 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:40,620 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,620 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:40,625 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:40,625 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:40,680 - root - INFO: \n", - "2021-09-23 13:19:40,681 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:40,681 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,682 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:40,683 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:40,724 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-23 13:19:40,733 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:40,763 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "2021-09-23 13:19:40,766 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:40,766 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-23 13:19:40,770 - root - INFO: \n", - "2021-09-23 13:19:40,770 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:40,771 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,771 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:40,772 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:40,813 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-23 13:19:40,822 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:40,852 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "2021-09-23 13:19:40,854 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:40,855 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-23 13:19:40,860 - root - INFO: \n", - "2021-09-23 13:19:40,861 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:40,862 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,863 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:40,864 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:40,914 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-23 13:19:40,924 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:40,957 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "2021-09-23 13:19:40,959 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:40,959 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-23 13:19:40,964 - root - INFO: \n", - "2021-09-23 13:19:40,964 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:40,965 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:40,965 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:40,966 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:41,010 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-23 13:19:41,019 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:41,050 - root - INFO: shape bounds: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "2021-09-23 13:19:41,052 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:41,053 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-23 13:19:41,069 - root - INFO: \n", - "2021-09-23 13:19:41,070 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:41,071 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,071 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:41,076 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:41,077 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:41,130 - root - INFO: \n", - "2021-09-23 13:19:41,130 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:41,131 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,131 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:41,132 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:41,174 - root - INFO: ... got raster of shape: (107, 212)\n", - "2021-09-23 13:19:41,183 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.03457171406671, 68.27508784949765, -148.94012726961913, 68.29703229394282)\n", - "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:41,212 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "2021-09-23 13:19:41,215 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:41,215 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", - "2021-09-23 13:19:41,219 - root - INFO: \n", - "2021-09-23 13:19:41,219 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:41,220 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,220 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:41,221 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:41,266 - root - INFO: ... got raster of shape: (107, 212)\n", - "2021-09-23 13:19:41,275 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:41,305 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "2021-09-23 13:19:41,307 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:41,308 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", - "2021-09-23 13:19:41,312 - root - INFO: \n", - "2021-09-23 13:19:41,312 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:41,312 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,313 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:41,314 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:41,355 - root - INFO: ... got raster of shape: (107, 212)\n", - "2021-09-23 13:19:41,363 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:41,393 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "2021-09-23 13:19:41,395 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:41,396 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", - "2021-09-23 13:19:41,399 - root - INFO: \n", - "2021-09-23 13:19:41,400 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:41,400 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,401 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:41,401 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:41,444 - root - INFO: ... got raster of shape: (107, 212)\n", - "2021-09-23 13:19:41,453 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "bounds in my_crs: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:41,484 - root - INFO: shape bounds: (-148.9984606029544, 68.27647673838658, -148.93957171406356, 68.30619896060979)\n", - "2021-09-23 13:19:41,486 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:41,487 - root - INFO: ... got raster bounds: (-148.9984606029544, 68.30619896060979, -148.93957171406356, 68.27647673838658)\n", - "2021-09-23 13:19:41,501 - root - INFO: \n", - "2021-09-23 13:19:41,501 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:41,501 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,502 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:41,506 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:41,507 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:41,562 - root - INFO: \n", - "2021-09-23 13:19:41,563 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:41,563 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,564 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:41,565 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:41,607 - root - INFO: ... got raster of shape: (130, 305)\n", - "2021-09-23 13:19:41,615 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:41,647 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "2021-09-23 13:19:41,648 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:41,649 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", - "2021-09-23 13:19:41,653 - root - INFO: \n", - "2021-09-23 13:19:41,653 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:41,654 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,654 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:41,655 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:41,698 - root - INFO: ... got raster of shape: (130, 305)\n", - "2021-09-23 13:19:41,707 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:41,736 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "2021-09-23 13:19:41,739 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:41,740 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", - "2021-09-23 13:19:41,744 - root - INFO: \n", - "2021-09-23 13:19:41,744 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:41,745 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,745 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:41,746 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:41,789 - root - INFO: ... got raster of shape: (130, 305)\n", - "2021-09-23 13:19:41,798 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:41,829 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "2021-09-23 13:19:41,831 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:41,832 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", - "2021-09-23 13:19:41,836 - root - INFO: \n", - "2021-09-23 13:19:41,837 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:41,837 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,838 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:41,838 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:41,879 - root - INFO: ... got raster of shape: (130, 305)\n", - "2021-09-23 13:19:41,888 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:41,918 - root - INFO: shape bounds: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "2021-09-23 13:19:41,920 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:41,922 - root - INFO: ... got raster bounds: (-149.21512726962825, 68.20453229393975, -149.13040504740323, 68.16842118282744)\n", - "2021-09-23 13:19:41,942 - root - INFO: \n", - "2021-09-23 13:19:41,942 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:41,943 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:41,943 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:41,949 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:41,950 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:42,001 - root - INFO: \n", - "2021-09-23 13:19:42,002 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,002 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,003 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:42,005 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:42,049 - root - INFO: ... got raster of shape: (122, 176)\n", - "2021-09-23 13:19:42,058 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21512726962825, 68.16842118282744, -149.13040504740323, 68.20425451616197)\n", - "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:42,090 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "2021-09-23 13:19:42,092 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:42,093 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", - "2021-09-23 13:19:42,096 - root - INFO: \n", - "2021-09-23 13:19:42,096 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,097 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,097 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:42,099 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:42,141 - root - INFO: ... got raster of shape: (122, 176)\n", - "2021-09-23 13:19:42,150 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:42,181 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "2021-09-23 13:19:42,184 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:42,184 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", - "2021-09-23 13:19:42,186 - root - INFO: \n", - "2021-09-23 13:19:42,187 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,187 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,188 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:42,190 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:42,230 - root - INFO: ... got raster of shape: (122, 176)\n", - "2021-09-23 13:19:42,238 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:42,269 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "2021-09-23 13:19:42,272 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:42,272 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", - "2021-09-23 13:19:42,275 - root - INFO: \n", - "2021-09-23 13:19:42,276 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,276 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,276 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:42,278 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:42,321 - root - INFO: ... got raster of shape: (122, 176)\n", - "2021-09-23 13:19:42,329 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "bounds in my_crs: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:42,360 - root - INFO: shape bounds: (-149.2117939362948, 68.17675451616105, -149.1629050474043, 68.21064340505106)\n", - "2021-09-23 13:19:42,363 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:42,364 - root - INFO: ... got raster bounds: (-149.2117939362948, 68.21064340505106, -149.1629050474043, 68.17675451616104)\n", - "2021-09-23 13:19:42,384 - root - INFO: \n", - "2021-09-23 13:19:42,384 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:42,385 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,385 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:42,391 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:42,392 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:42,446 - root - INFO: \n", - "2021-09-23 13:19:42,447 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,447 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,448 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:42,449 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:42,490 - root - INFO: ... got raster of shape: (75, 333)\n", - "2021-09-23 13:19:42,499 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:42,529 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "2021-09-23 13:19:42,532 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:42,532 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", - "2021-09-23 13:19:42,536 - root - INFO: \n", - "2021-09-23 13:19:42,537 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,537 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,537 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:42,538 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:42,579 - root - INFO: ... got raster of shape: (75, 333)\n", - "2021-09-23 13:19:42,588 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:42,617 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "2021-09-23 13:19:42,619 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:42,620 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", - "2021-09-23 13:19:42,623 - root - INFO: \n", - "2021-09-23 13:19:42,623 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,624 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,624 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:42,625 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:42,665 - root - INFO: ... got raster of shape: (75, 333)\n", - "2021-09-23 13:19:42,674 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:42,706 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "2021-09-23 13:19:42,708 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:42,709 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", - "2021-09-23 13:19:42,713 - root - INFO: \n", - "2021-09-23 13:19:42,713 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,714 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,714 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:42,715 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:42,756 - root - INFO: ... got raster of shape: (75, 333)\n", - "2021-09-23 13:19:42,765 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:42,796 - root - INFO: shape bounds: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "2021-09-23 13:19:42,798 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:42,799 - root - INFO: ... got raster bounds: (-149.21096060296145, 68.27953229394224, -149.11846060295838, 68.25869896060821)\n", - "2021-09-23 13:19:42,815 - root - INFO: \n", - "2021-09-23 13:19:42,815 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:42,815 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,816 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:42,820 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:42,821 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:42,872 - root - INFO: \n", - "2021-09-23 13:19:42,872 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,873 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,873 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:42,874 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:42,915 - root - INFO: ... got raster of shape: (59, 297)\n", - "2021-09-23 13:19:42,925 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:42,954 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21068282518368, 68.25869896060821, -149.11846060295838, 68.27925451616446)\n", - "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:42,956 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:42,957 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", - "2021-09-23 13:19:42,962 - root - INFO: \n", - "2021-09-23 13:19:42,962 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:42,963 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:42,963 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:42,964 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,005 - root - INFO: ... got raster of shape: (59, 297)\n", - "2021-09-23 13:19:43,013 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:43,044 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", - "2021-09-23 13:19:43,046 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:43,047 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", - "2021-09-23 13:19:43,050 - root - INFO: \n", - "2021-09-23 13:19:43,051 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,051 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,051 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:43,052 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,093 - root - INFO: ... got raster of shape: (59, 297)\n", - "2021-09-23 13:19:43,101 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:43,132 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", - "2021-09-23 13:19:43,134 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:43,135 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", - "2021-09-23 13:19:43,138 - root - INFO: \n", - "2021-09-23 13:19:43,139 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,139 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,139 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:43,140 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,182 - root - INFO: ... got raster of shape: (59, 297)\n", - "2021-09-23 13:19:43,190 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", - "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", - "bounds in my_crs: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:43,220 - root - INFO: shape bounds: (-149.20984949185032, 68.25314340505247, -149.12762726962535, 68.26925451616412)\n", - "2021-09-23 13:19:43,222 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:43,222 - root - INFO: ... got raster bounds: (-149.2101272696281, 68.26953229394191, -149.12762726962535, 68.25314340505247)\n", - "2021-09-23 13:19:43,240 - root - INFO: \n", - "2021-09-23 13:19:43,241 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:43,241 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,242 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:43,247 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:43,248 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:43,299 - root - INFO: \n", - "2021-09-23 13:19:43,300 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,301 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,301 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:43,302 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,343 - root - INFO: ... got raster of shape: (103, 231)\n", - "2021-09-23 13:19:43,352 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:43,383 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "2021-09-23 13:19:43,385 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:43,386 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", - "2021-09-23 13:19:43,390 - root - INFO: \n", - "2021-09-23 13:19:43,390 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,390 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,391 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:43,391 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,434 - root - INFO: ... got raster of shape: (103, 231)\n", - "2021-09-23 13:19:43,442 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:43,471 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "2021-09-23 13:19:43,474 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:43,474 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", - "2021-09-23 13:19:43,479 - root - INFO: \n", - "2021-09-23 13:19:43,479 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,479 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,480 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:43,481 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,522 - root - INFO: ... got raster of shape: (103, 231)\n", - "2021-09-23 13:19:43,531 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:43,561 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "2021-09-23 13:19:43,564 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:43,564 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", - "2021-09-23 13:19:43,569 - root - INFO: \n", - "2021-09-23 13:19:43,570 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,570 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,571 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:43,572 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,613 - root - INFO: ... got raster of shape: (103, 231)\n", - "2021-09-23 13:19:43,621 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:43,653 - root - INFO: shape bounds: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "2021-09-23 13:19:43,655 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:43,655 - root - INFO: ... got raster bounds: (-149.12762726962535, 68.28703229394249, -149.06346060295655, 68.25842118283043)\n", - "2021-09-23 13:19:43,671 - root - INFO: \n", - "2021-09-23 13:19:43,671 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:43,672 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,672 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:43,677 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:43,678 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:43,728 - root - INFO: \n", - "2021-09-23 13:19:43,729 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,729 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,730 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:43,731 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,772 - root - INFO: ... got raster of shape: (50, 188)\n", - "2021-09-23 13:19:43,780 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:43,811 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12734949184758, 68.25842118283043, -149.06346060295655, 68.28703229394249)\n", - "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:43,814 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:43,814 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", - "2021-09-23 13:19:43,816 - root - INFO: \n", - "2021-09-23 13:19:43,817 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,817 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,817 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:43,818 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,859 - root - INFO: ... got raster of shape: (50, 188)\n", - "2021-09-23 13:19:43,868 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:43,899 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "2021-09-23 13:19:43,901 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:43,902 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", - "2021-09-23 13:19:43,905 - root - INFO: \n", - "2021-09-23 13:19:43,906 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,906 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,906 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:43,907 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:43,948 - root - INFO: ... got raster of shape: (50, 188)\n", - "2021-09-23 13:19:43,957 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:43,986 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "2021-09-23 13:19:43,988 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:43,989 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", - "2021-09-23 13:19:43,991 - root - INFO: \n", - "2021-09-23 13:19:43,992 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:43,992 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:43,992 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:43,993 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:44,034 - root - INFO: ... got raster of shape: (50, 188)\n", - "2021-09-23 13:19:44,042 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "bounds in my_crs: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:44,073 - root - INFO: shape bounds: (-149.1315161585144, 68.2481434050523, -149.0795717140682, 68.26203229394166)\n", - "2021-09-23 13:19:44,075 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:44,076 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26203229394166, -149.0795717140682, 68.2481434050523)\n", - "2021-09-23 13:19:44,091 - root - INFO: \n", - "2021-09-23 13:19:44,091 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:44,092 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,092 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:44,098 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:44,099 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:44,194 - root - INFO: \n", - "2021-09-23 13:19:44,195 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:44,195 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,196 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:44,197 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:44,240 - root - INFO: ... got raster of shape: (155, 254)\n", - "2021-09-23 13:19:44,249 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:44,279 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "2021-09-23 13:19:44,281 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:44,283 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", - "2021-09-23 13:19:44,287 - root - INFO: \n", - "2021-09-23 13:19:44,287 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:44,288 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,288 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:44,290 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:44,334 - root - INFO: ... got raster of shape: (155, 254)\n", - "2021-09-23 13:19:44,343 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:44,373 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "2021-09-23 13:19:44,375 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:44,376 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", - "2021-09-23 13:19:44,379 - root - INFO: \n", - "2021-09-23 13:19:44,380 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:44,380 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,381 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:44,382 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:44,425 - root - INFO: ... got raster of shape: (155, 254)\n", - "2021-09-23 13:19:44,434 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:44,464 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "2021-09-23 13:19:44,467 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:44,467 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", - "2021-09-23 13:19:44,473 - root - INFO: \n", - "2021-09-23 13:19:44,474 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:44,474 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,474 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:44,476 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:44,519 - root - INFO: ... got raster of shape: (155, 254)\n", - "2021-09-23 13:19:44,528 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:44,559 - root - INFO: shape bounds: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "2021-09-23 13:19:44,561 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:44,562 - root - INFO: ... got raster bounds: (-149.0795717140682, 68.28703229394249, -149.00901615851032, 68.2439767383855)\n", - "2021-09-23 13:19:44,586 - root - INFO: \n", - "2021-09-23 13:19:44,587 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:44,587 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,588 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:44,593 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:44,594 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:44,648 - root - INFO: \n", - "2021-09-23 13:19:44,648 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:44,649 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,649 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:44,650 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:44,690 - root - INFO: ... got raster of shape: (39, 185)\n", - "2021-09-23 13:19:44,699 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.0795717140682, 68.2439767383855, -149.00901615851032, 68.28703229394249)\n", - "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:44,730 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "2021-09-23 13:19:44,732 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:44,733 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", - "2021-09-23 13:19:44,735 - root - INFO: \n", - "2021-09-23 13:19:44,736 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:44,736 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,737 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:44,737 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:44,779 - root - INFO: ... got raster of shape: (39, 185)\n", - "2021-09-23 13:19:44,787 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:44,820 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "2021-09-23 13:19:44,821 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:44,822 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", - "2021-09-23 13:19:44,824 - root - INFO: \n", - "2021-09-23 13:19:44,825 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:44,825 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,825 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:44,826 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:44,868 - root - INFO: ... got raster of shape: (39, 185)\n", - "2021-09-23 13:19:44,877 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:44,907 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "2021-09-23 13:19:44,909 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:44,909 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", - "2021-09-23 13:19:44,912 - root - INFO: \n", - "2021-09-23 13:19:44,912 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:44,913 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:44,913 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:44,914 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:44,956 - root - INFO: ... got raster of shape: (39, 185)\n", - "2021-09-23 13:19:44,966 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "bounds in my_crs: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:44,995 - root - INFO: shape bounds: (-149.08290504740165, 68.24731007171894, -149.03151615851107, 68.25814340505264)\n", - "2021-09-23 13:19:44,997 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:44,998 - root - INFO: ... got raster bounds: (-149.08290504740165, 68.25814340505264, -149.03151615851107, 68.24731007171894)\n", - "2021-09-23 13:19:45,012 - root - INFO: \n", - "2021-09-23 13:19:45,012 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:45,013 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,013 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:45,018 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:45,019 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:45,072 - root - INFO: \n", - "2021-09-23 13:19:45,072 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:45,073 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,073 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:45,077 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:45,121 - root - INFO: ... got raster of shape: (121, 413)\n", - "2021-09-23 13:19:45,130 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:45,162 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "2021-09-23 13:19:45,165 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:45,166 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", - "2021-09-23 13:19:45,169 - root - INFO: \n", - "2021-09-23 13:19:45,169 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:45,170 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,170 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:45,173 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:45,216 - root - INFO: ... got raster of shape: (121, 413)\n", - "2021-09-23 13:19:45,224 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:45,254 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "2021-09-23 13:19:45,257 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:45,257 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", - "2021-09-23 13:19:45,260 - root - INFO: \n", - "2021-09-23 13:19:45,261 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:45,261 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,262 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:45,265 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:45,308 - root - INFO: ... got raster of shape: (121, 413)\n", - "2021-09-23 13:19:45,317 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:45,349 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "2021-09-23 13:19:45,351 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:45,352 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", - "2021-09-23 13:19:45,357 - root - INFO: \n", - "2021-09-23 13:19:45,357 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:45,358 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,358 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:45,362 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:45,405 - root - INFO: ... got raster of shape: (121, 413)\n", - "2021-09-23 13:19:45,414 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:45,445 - root - INFO: shape bounds: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "2021-09-23 13:19:45,448 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:45,449 - root - INFO: ... got raster bounds: (-149.23262726962884, 68.25453229394141, -149.11790504740281, 68.22092118282919)\n", - "2021-09-23 13:19:45,485 - root - INFO: \n", - "2021-09-23 13:19:45,486 - root - INFO: Loading shapes\n", - "2021-09-23 13:19:45,486 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,487 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_subcatchments.shp'\n", - "2021-09-23 13:19:45,492 - root - INFO: ... found 44 shapes\n", - "2021-09-23 13:19:45,493 - root - INFO: Converting to shapely\n", - "2021-09-23 13:19:45,543 - root - INFO: \n", - "2021-09-23 13:19:45,544 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:45,545 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,545 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:45,546 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:45,587 - root - INFO: ... got raster of shape: (73, 306)\n", - "2021-09-23 13:19:45,596 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.23262726962884, 68.22092118282919, -149.11790504740281, 68.25453229394141)\n", - "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:45,625 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "2021-09-23 13:19:45,627 - root - INFO: casting mask of dtype: float32 to: -32768.0\n", - "2021-09-23 13:19:45,628 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", - "2021-09-23 13:19:45,632 - root - INFO: \n", - "2021-09-23 13:19:45,632 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:45,632 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,633 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_elev_above_streams.tif'\n", - "2021-09-23 13:19:45,633 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:45,676 - root - INFO: ... got raster of shape: (73, 306)\n", - "2021-09-23 13:19:45,685 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:45,715 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "2021-09-23 13:19:45,717 - root - INFO: casting mask of dtype: float32 to: -999.0\n", - "2021-09-23 13:19:45,717 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", - "2021-09-23 13:19:45,721 - root - INFO: \n", - "2021-09-23 13:19:45,721 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:45,722 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,722 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_aspect.tif'\n", - "2021-09-23 13:19:45,723 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:45,764 - root - INFO: ... got raster of shape: (73, 306)\n", - "2021-09-23 13:19:45,772 - root - INFO: Masking to shape\n", - "2021-09-23 13:19:45,802 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "2021-09-23 13:19:45,804 - root - INFO: casting mask of dtype: float32 to: -9999.0\n", - "2021-09-23 13:19:45,805 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n", - "2021-09-23 13:19:45,808 - root - INFO: \n", - "2021-09-23 13:19:45,809 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:45,809 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:45,810 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:45,810 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:45,851 - root - INFO: ... got raster of shape: (73, 306)\n", - "2021-09-23 13:19:45,860 - root - INFO: Masking to shape\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "bounds in my_crs: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:45,889 - root - INFO: shape bounds: (-149.23207171407327, 68.22008784949583, -149.14707171407045, 68.24008784949649)\n", - "2021-09-23 13:19:45,892 - root - INFO: casting mask of dtype: float32 to: 255.0\n", - "2021-09-23 13:19:45,893 - root - INFO: ... got raster bounds: (-149.23207171407327, 68.24036562727427, -149.14707171407045, 68.22008784949583)\n" - ] - } - ], - "source": [ - "# hillslope_pars = []\n", - "# mesh_pars = []\n", - "# subcatch_all_ids = 1+np.arange(len(subcatchments))\n", - "# for subcatch_id in subcatch_all_ids:\n", - "# hillslope_pars.append(hillslopes.parameterizeSubcatchment(\n", - "# filenames, huc, subcatch_id,\n", - "# target_crs=target_crs,\n", - "# hillslope_keep_fraction=hillslope_keep_fraction,\n", - "# hillslope_bin_dx=hillslope_bin_dx))\n", - " \n", - "# for i in range(len(hillslope_pars)): \n", - "# mesh_pars.append(meshing.parameterizeMesh(hillslope_pars[i], mesh_dx,\n", - "# riparian_slope_min=riparian_slope_min,\n", - "# hillslope_slope_min=hillslope_slope_min,\n", - "# min_area_ratio=min_area_ratio))" - ] - }, - { - "cell_type": "markdown", - "id": "d89ac989", - "metadata": {}, - "source": [ - "## Plot all hillslopes" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "789b2ed3", - "metadata": {}, - "outputs": [], - "source": [ - "# fig = plt.figure(figsize=(20,30),dpi=80)\n", - "# nx, ny = 6,8\n", - "# sep=0.02\n", - "\n", - "# axs = []\n", - "# for i in range(nx):\n", - "# for j in range(ny):\n", - "# sub_id = i*ny+j+1\n", - "# if sub_id > len(subcatchments):\n", - "# continue\n", - " \n", - "# gs = gridspec.GridSpec(4,1,bottom=j/ny+sep, left=i/nx+sep, top=(j+1)/ny - sep, right=(i+1)/nx - sep)\n", - "# ax1 = fig.add_subplot(gs[2,0])\n", - "# ax2 = fig.add_subplot(gs[3,0])\n", - "# axs = [ax1,ax2]\n", - "# h_par = hillslope_pars[sub_id-1]\n", - "# m_par = mesh_pars[sub_id-1] \n", - "# plot.plot(h_par, m_par, fig=fig, axs=axs)\n", - " \n", - "# ax0 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[0,0])\n", - "# ax0.set_title(f'subcatchment {sub_id}')\n", - "# workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", - "# hillslope_pars[sub_id-1]['bins'], ax=ax0, cmap='prism')\n", - "# subcatch = hillslope_pars[sub_id-1]['subcatchment']\n", - "# subcatch_crs = hillslope_pars[sub_id-1]['subcatchment_target_crs'] \n", - "# workflow.plot.shply(subcatch, subcatch_crs, ax=ax0, color='k')\n", - " \n", - "# ax1 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[1,0])\n", - "# vmin, vmax = min(hillslope_pars[sub_id-1]['land_cover']), max(hillslope_pars[sub_id-1]['land_cover'])\n", - "# cmap = plt.get_cmap(('viridis'),vmax-vmin+1)\n", - "# lc = workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", - "# hillslope_pars[sub_id-1]['land_cover_raster'], \n", - "# ax=ax1, vmin=vmin-0.5, vmax=vmax+0.5, cmap=cmap)\n", - "# workflow.plot.shply(subcatch, subcatch_crs, ax=ax1, color='k')\n", - "# position=fig.add_axes([i/nx+sep+0.13, j/ny+sep+0.045, 0.006,0.04])\n", - "\n", - "# fig.colorbar(lc,ticks=np.arange(vmin,vmax+1),cax=position)\n", - "\n", - "# plt.tight_layout()\n", - "# plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "d60fb0f2", - "metadata": {}, - "source": [ - "# Generate mesh" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "4916162d", - "metadata": {}, - "outputs": [], - "source": [ - "layer_info = meshing.layeringStructure(organic_cells=30, organic_cell_dz=0.02, \n", - " increase2depth=9.4, increase_cells=20, largest_dz=2.0,\n", - " bottom_depth=46)\n", - "layer_types, layer_data, layer_ncells = layer_info" - ] - }, - { - "cell_type": "markdown", - "id": "366f43ba", - "metadata": {}, - "source": [ - "## Column spinup mesh" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "d75f2a06", - "metadata": {}, - "outputs": [], - "source": [ - "if os.path.isfile(os.path.join(mesh_dir,'column.exo')):\n", - " os.remove(os.path.join(mesh_dir,'column.exo'))\n", - "colum_mesh = meshing.createColumnMesh(layer_info, \n", - " os.path.join(mesh_dir,'column.exo'))" - ] - }, - { - "cell_type": "markdown", - "id": "973ad6c6", - "metadata": {}, - "source": [ - "## 2D for a given subcatchment" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "4396c703", - "metadata": {}, - "outputs": [], - "source": [ - "m2 = meshing.createHillslopeMesh2D(mesh_demo_pars)\n", - "m3 = meshing.createHillslopeMesh3D(m2, mesh_demo_pars, layer_info,\n", - " os.path.join(mesh_dir,f'sag_hillslope{subcatch_demo_id}.exo'))" - ] - }, - { - "cell_type": "markdown", - "id": "889672f6", - "metadata": {}, - "source": [ - "## 3D for a given subcatchment" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "4bf13c05", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:46,324 - root - INFO: \n", - "2021-09-23 13:19:46,324 - root - INFO: Meshing\n", - "2021-09-23 13:19:46,325 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:46,333 - root - INFO: Triangulating...\n", - "2021-09-23 13:19:46,333 - root - INFO: 8 points and 8 facets\n", - "2021-09-23 13:19:46,334 - root - INFO: checking graph consistency\n", - "2021-09-23 13:19:46,334 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:19:46,335 - root - INFO: building graph data structures\n", - "2021-09-23 13:19:46,336 - root - INFO: triangle.build...\n", - "2021-09-23 13:19:46,446 - root - INFO: ...built: 4932 mesh points and 9596 triangles\n", - "2021-09-23 13:19:46,447 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:19:46,676 - root - INFO: min area = 61.36431884765625\n", - "2021-09-23 13:19:46,677 - root - INFO: max area = 199.99404907226562\n", - "2021-09-23 13:19:46,800 - root - INFO: \n", - "2021-09-23 13:19:46,800 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:46,801 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:46,801 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:19:46,802 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:46,845 - root - INFO: ... got raster of shape: (46, 180)\n", - "2021-09-23 13:19:46,854 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n", - "2021-09-23 13:19:46,864 - root - INFO: \n", - "2021-09-23 13:19:46,865 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:19:46,865 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:46,939 - root - INFO: \n", - "2021-09-23 13:19:46,940 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:46,940 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:46,941 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:19:46,942 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:46,981 - root - INFO: ... got raster of shape: (46, 180)\n", - "2021-09-23 13:19:46,990 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n", - "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:47,047 - root - INFO: \n", - "2021-09-23 13:19:47,047 - root - INFO: Loading Raster\n", - "2021-09-23 13:19:47,047 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:47,048 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:19:47,048 - root - INFO: Collecting raster\n", - "2021-09-23 13:19:47,091 - root - INFO: ... got raster of shape: (46, 180)\n", - "2021-09-23 13:19:47,100 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n", - "\n", - "You are using exodus.py v 1.20.5 (seacas-py3), a python wrapper of some of the exodus library.\n", - "\n", - "Copyright (c) 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 National Technology &\n", - "Engineering Solutions of Sandia, LLC (NTESS). Under the terms of\n", - "Contract DE-NA0003525 with NTESS, the U.S. Government retains certain\n", - "rights in this software.\n", - "\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment8.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment8.exo\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "subcatch_demo_smooth = hillslope_demo_pars['subcatchment_smooth']\n", - "m2, lc = meshing.createSubcatchmentMesh2D(filenames, subcatch_demo_smooth, subcatch_crs,\n", - " mesh_demo_pars, plot=True)\n", - "m3 = meshing.createSubcatchmentMesh3D(m2, lc, layer_info,\n", - " os.path.join(mesh_dir, f'sag_subcatchment{subcatch_demo_id}.exo'))" - ] - }, - { - "cell_type": "markdown", - "id": "d121163b", - "metadata": {}, - "source": [ - "## 2D for all subcatchments" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "457de366", - "metadata": {}, - "outputs": [], - "source": [ - "# subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", - "# for subcatch_id in subcatch_all_ids:\n", - "# index = subcatch_id - 1\n", - "# m2 = meshing.createHillslopeMesh2D(mesh_pars[index])\n", - "# m3 = meshing.createHillslopeMesh3D(m2, mesh_pars[index], meshing.layeringStructure(),\n", - "# os.path.join(mesh_dir,f'sag_hillslope{subcatch_id}.exo'))" - ] - }, - { - "cell_type": "markdown", - "id": "5e846eff", - "metadata": {}, - "source": [ - "## 3D for all subcatchments" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "d32ea0e5", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:19:59,872 - root - INFO: \n", - "2021-09-23 13:19:59,873 - root - INFO: Meshing\n", - "2021-09-23 13:19:59,874 - root - INFO: ------------------------------\n", - "2021-09-23 13:19:59,874 - root - INFO: Triangulating...\n", - "2021-09-23 13:19:59,875 - root - INFO: 18 points and 18 facets\n", - "2021-09-23 13:19:59,875 - root - INFO: checking graph consistency\n", - "2021-09-23 13:19:59,876 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:19:59,876 - root - INFO: building graph data structures\n", - "2021-09-23 13:19:59,877 - root - INFO: triangle.build...\n", - "2021-09-23 13:20:00,160 - root - INFO: ...built: 14261 mesh points and 28029 triangles\n", - "2021-09-23 13:20:00,161 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:20:00,821 - root - INFO: min area = 49.853485107421875\n", - "2021-09-23 13:20:00,822 - root - INFO: max area = 199.99191284179688\n", - "2021-09-23 13:20:01,146 - root - INFO: \n", - "2021-09-23 13:20:01,147 - root - INFO: Loading Raster\n", - "2021-09-23 13:20:01,148 - root - INFO: ------------------------------\n", - "2021-09-23 13:20:01,148 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:20:01,149 - root - INFO: Collecting raster\n", - "2021-09-23 13:20:01,195 - root - INFO: ... got raster of shape: (69, 319)\n", - "2021-09-23 13:20:01,204 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23484949185112, 68.18897673838367)\n", - "2021-09-23 13:20:01,215 - root - INFO: \n", - "2021-09-23 13:20:01,216 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:20:01,217 - root - INFO: ------------------------------\n", - "2021-09-23 13:20:01,371 - root - INFO: \n", - "2021-09-23 13:20:01,372 - root - INFO: Loading Raster\n", - "2021-09-23 13:20:01,372 - root - INFO: ------------------------------\n", - "2021-09-23 13:20:01,373 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:20:01,374 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.32333181192908, 68.18904867385021, -149.23495351407024, 68.20809989576648)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:20:01,416 - root - INFO: ... got raster of shape: (69, 319)\n", - "2021-09-23 13:20:01,424 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23484949185112, 68.18897673838367)\n", - "2021-09-23 13:20:01,518 - root - INFO: \n", - "2021-09-23 13:20:01,519 - root - INFO: Loading Raster\n", - "2021-09-23 13:20:01,520 - root - INFO: ------------------------------\n", - "2021-09-23 13:20:01,520 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:20:01,521 - root - INFO: Collecting raster\n", - "2021-09-23 13:20:01,562 - root - INFO: ... got raster of shape: (69, 319)\n", - "2021-09-23 13:20:01,572 - root - INFO: ... got raster bounds: (-149.32346060296518, 68.20814340505098, -149.23484949185112, 68.18897673838367)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.32333181192908, 68.18904867385021, -149.23495351407024, 68.20809989576648)\n", - "bounds in my_crs: (-149.32333181192908, 68.18904867385021, -149.23495351407024, 68.20809989576648)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment1.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment1.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:20:35,175 - root - INFO: \n", - "2021-09-23 13:20:35,176 - root - INFO: Meshing\n", - "2021-09-23 13:20:35,176 - root - INFO: ------------------------------\n", - "2021-09-23 13:20:35,177 - root - INFO: Triangulating...\n", - "2021-09-23 13:20:35,178 - root - INFO: 19 points and 19 facets\n", - "2021-09-23 13:20:35,179 - root - INFO: checking graph consistency\n", - "2021-09-23 13:20:35,179 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:20:35,180 - root - INFO: building graph data structures\n", - "2021-09-23 13:20:35,181 - root - INFO: triangle.build...\n", - "2021-09-23 13:20:35,449 - root - INFO: ...built: 13807 mesh points and 27147 triangles\n", - "2021-09-23 13:20:35,450 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:20:36,100 - root - INFO: min area = 60.220672607421875\n", - "2021-09-23 13:20:36,101 - root - INFO: max area = 199.98150634765625\n", - "2021-09-23 13:20:36,382 - root - INFO: \n", - "2021-09-23 13:20:36,383 - root - INFO: Loading Raster\n", - "2021-09-23 13:20:36,383 - root - INFO: ------------------------------\n", - "2021-09-23 13:20:36,384 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:20:36,385 - root - INFO: Collecting raster\n", - "2021-09-23 13:20:36,433 - root - INFO: ... got raster of shape: (65, 330)\n", - "2021-09-23 13:20:36,443 - root - INFO: ... got raster bounds: (-149.32373838074298, 68.19786562727286, -149.23207171407327, 68.1798100717167)\n", - "2021-09-23 13:20:36,453 - root - INFO: \n", - "2021-09-23 13:20:36,454 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:20:36,455 - root - INFO: ------------------------------\n", - "2021-09-23 13:20:36,594 - root - INFO: \n", - "2021-09-23 13:20:36,595 - root - INFO: Loading Raster\n", - "2021-09-23 13:20:36,595 - root - INFO: ------------------------------\n", - "2021-09-23 13:20:36,596 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:20:36,597 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.32349899933536, 68.18007214137471, -149.23231844816064, 68.19760352339726)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:20:36,642 - root - INFO: ... got raster of shape: (65, 330)\n", - "2021-09-23 13:20:36,651 - root - INFO: ... got raster bounds: (-149.32373838074298, 68.19786562727286, -149.23207171407327, 68.1798100717167)\n", - "2021-09-23 13:20:36,746 - root - INFO: \n", - "2021-09-23 13:20:36,747 - root - INFO: Loading Raster\n", - "2021-09-23 13:20:36,747 - root - INFO: ------------------------------\n", - "2021-09-23 13:20:36,748 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:20:36,749 - root - INFO: Collecting raster\n", - "2021-09-23 13:20:36,794 - root - INFO: ... got raster of shape: (65, 330)\n", - "2021-09-23 13:20:36,803 - root - INFO: ... got raster bounds: (-149.32373838074298, 68.19786562727286, -149.23207171407327, 68.1798100717167)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.32349899933536, 68.18007214137471, -149.23231844816064, 68.19760352339726)\n", - "bounds in my_crs: (-149.32349899933536, 68.18007214137471, -149.23231844816064, 68.19760352339726)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment2.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment2.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:21:09,384 - root - INFO: \n", - "2021-09-23 13:21:09,385 - root - INFO: Meshing\n", - "2021-09-23 13:21:09,385 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:09,386 - root - INFO: Triangulating...\n", - "2021-09-23 13:21:09,387 - root - INFO: 16 points and 16 facets\n", - "2021-09-23 13:21:09,387 - root - INFO: checking graph consistency\n", - "2021-09-23 13:21:09,388 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:21:09,388 - root - INFO: building graph data structures\n", - "2021-09-23 13:21:09,389 - root - INFO: triangle.build...\n", - "2021-09-23 13:21:09,689 - root - INFO: ...built: 16183 mesh points and 31951 triangles\n", - "2021-09-23 13:21:09,690 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:21:10,365 - root - INFO: min area = 59.8853759765625\n", - "2021-09-23 13:21:10,366 - root - INFO: max area = 199.969482421875\n", - "2021-09-23 13:21:10,711 - root - INFO: \n", - "2021-09-23 13:21:10,712 - root - INFO: Loading Raster\n", - "2021-09-23 13:21:10,712 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:10,713 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:21:10,714 - root - INFO: Collecting raster\n", - "2021-09-23 13:21:10,761 - root - INFO: ... got raster of shape: (96, 235)\n", - "2021-09-23 13:21:10,771 - root - INFO: ... got raster bounds: (-149.25373838074066, 68.20536562727311, -149.1884606029607, 68.17869896060556)\n", - "2021-09-23 13:21:10,780 - root - INFO: \n", - "2021-09-23 13:21:10,780 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:21:10,781 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:10,952 - root - INFO: \n", - "2021-09-23 13:21:10,953 - root - INFO: Loading Raster\n", - "2021-09-23 13:21:10,953 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:10,954 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:21:10,955 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.25371456417372, 68.17875098194455, -149.18872340913728, 68.20521902133713)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:21:11,001 - root - INFO: ... got raster of shape: (96, 235)\n", - "2021-09-23 13:21:11,010 - root - INFO: ... got raster bounds: (-149.25373838074066, 68.20536562727311, -149.1884606029607, 68.17869896060556)\n", - "2021-09-23 13:21:11,113 - root - INFO: \n", - "2021-09-23 13:21:11,114 - root - INFO: Loading Raster\n", - "2021-09-23 13:21:11,114 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:11,115 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:21:11,116 - root - INFO: Collecting raster\n", - "2021-09-23 13:21:11,164 - root - INFO: ... got raster of shape: (96, 235)\n", - "2021-09-23 13:21:11,175 - root - INFO: ... got raster bounds: (-149.25373838074066, 68.20536562727311, -149.1884606029607, 68.17869896060556)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.25371456417372, 68.17875098194455, -149.18872340913728, 68.20521902133713)\n", - "bounds in my_crs: (-149.25371456417372, 68.17875098194455, -149.18872340913728, 68.20521902133713)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment3.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment3.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:21:47,979 - root - INFO: \n", - "2021-09-23 13:21:47,979 - root - INFO: Meshing\n", - "2021-09-23 13:21:47,980 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:47,981 - root - INFO: Triangulating...\n", - "2021-09-23 13:21:47,982 - root - INFO: 11 points and 11 facets\n", - "2021-09-23 13:21:47,982 - root - INFO: checking graph consistency\n", - "2021-09-23 13:21:47,982 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:21:47,983 - root - INFO: building graph data structures\n", - "2021-09-23 13:21:47,984 - root - INFO: triangle.build...\n", - "2021-09-23 13:21:48,194 - root - INFO: ...built: 10834 mesh points and 21327 triangles\n", - "2021-09-23 13:21:48,195 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:21:48,659 - root - INFO: min area = 58.8323974609375\n", - "2021-09-23 13:21:48,660 - root - INFO: max area = 199.98284912109375\n", - "2021-09-23 13:21:48,875 - root - INFO: \n", - "2021-09-23 13:21:48,875 - root - INFO: Loading Raster\n", - "2021-09-23 13:21:48,876 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:48,876 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:21:48,878 - root - INFO: Collecting raster\n", - "2021-09-23 13:21:48,922 - root - INFO: ... got raster of shape: (59, 231)\n", - "2021-09-23 13:21:48,931 - root - INFO: ... got raster bounds: (-149.2720717140746, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n", - "2021-09-23 13:21:48,940 - root - INFO: \n", - "2021-09-23 13:21:48,941 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:21:48,941 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:49,053 - root - INFO: \n", - "2021-09-23 13:21:49,054 - root - INFO: Loading Raster\n", - "2021-09-23 13:21:49,055 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:49,055 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:21:49,056 - root - INFO: Collecting raster\n", - "2021-09-23 13:21:49,101 - root - INFO: ... got raster of shape: (59, 231)\n", - "2021-09-23 13:21:49,110 - root - INFO: ... got raster bounds: (-149.2720717140746, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.27179877026592, 68.19927082938099, -149.20801699376824, 68.21563762826689)\n", - "bounds in my_crs: (-149.27179877026592, 68.19927082938099, -149.20801699376824, 68.21563762826689)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:21:49,187 - root - INFO: \n", - "2021-09-23 13:21:49,188 - root - INFO: Loading Raster\n", - "2021-09-23 13:21:49,188 - root - INFO: ------------------------------\n", - "2021-09-23 13:21:49,189 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:21:49,189 - root - INFO: Collecting raster\n", - "2021-09-23 13:21:49,236 - root - INFO: ... got raster of shape: (59, 231)\n", - "2021-09-23 13:21:49,245 - root - INFO: ... got raster bounds: (-149.2720717140746, 68.21564340505122, -149.2079050474058, 68.19925451616179)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.27179877026592, 68.19927082938099, -149.20801699376824, 68.21563762826689)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment4.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment4.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:22:14,429 - root - INFO: \n", - "2021-09-23 13:22:14,430 - root - INFO: Meshing\n", - "2021-09-23 13:22:14,430 - root - INFO: ------------------------------\n", - "2021-09-23 13:22:14,431 - root - INFO: Triangulating...\n", - "2021-09-23 13:22:14,431 - root - INFO: 18 points and 18 facets\n", - "2021-09-23 13:22:14,432 - root - INFO: checking graph consistency\n", - "2021-09-23 13:22:14,432 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:22:14,433 - root - INFO: building graph data structures\n", - "2021-09-23 13:22:14,433 - root - INFO: triangle.build...\n", - "2021-09-23 13:22:14,893 - root - INFO: ...built: 26624 mesh points and 52678 triangles\n", - "2021-09-23 13:22:14,894 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:22:15,974 - root - INFO: min area = 52.785980224609375\n", - "2021-09-23 13:22:15,974 - root - INFO: max area = 199.97225952148438\n", - "2021-09-23 13:22:16,437 - root - INFO: \n", - "2021-09-23 13:22:16,438 - root - INFO: Loading Raster\n", - "2021-09-23 13:22:16,439 - root - INFO: ------------------------------\n", - "2021-09-23 13:22:16,439 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:22:16,440 - root - INFO: Collecting raster\n", - "2021-09-23 13:22:16,486 - root - INFO: ... got raster of shape: (99, 374)\n", - "2021-09-23 13:22:16,496 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17207171407128, 68.20703229393983)\n", - "2021-09-23 13:22:16,506 - root - INFO: \n", - "2021-09-23 13:22:16,507 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:22:16,507 - root - INFO: ------------------------------\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.27573517147246, 68.207289642888, -149.17231387605082, 68.23426687242299)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:22:16,724 - root - INFO: \n", - "2021-09-23 13:22:16,724 - root - INFO: Loading Raster\n", - "2021-09-23 13:22:16,725 - root - INFO: ------------------------------\n", - "2021-09-23 13:22:16,725 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:22:16,726 - root - INFO: Collecting raster\n", - "2021-09-23 13:22:16,769 - root - INFO: ... got raster of shape: (99, 374)\n", - "2021-09-23 13:22:16,778 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17207171407128, 68.20703229393983)\n", - "2021-09-23 13:22:16,913 - root - INFO: \n", - "2021-09-23 13:22:16,914 - root - INFO: Loading Raster\n", - "2021-09-23 13:22:16,914 - root - INFO: ------------------------------\n", - "2021-09-23 13:22:16,915 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:22:16,916 - root - INFO: Collecting raster\n", - "2021-09-23 13:22:16,960 - root - INFO: ... got raster of shape: (99, 374)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.27573517147246, 68.207289642888, -149.17231387605082, 68.23426687242299)\n", - "bounds in my_crs: (-149.27573517147246, 68.207289642888, -149.17231387605082, 68.23426687242299)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:22:16,969 - root - INFO: ... got raster bounds: (-149.2759606029636, 68.23453229394075, -149.17207171407128, 68.20703229393983)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment5.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment5.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:23:17,638 - root - INFO: \n", - "2021-09-23 13:23:17,639 - root - INFO: Meshing\n", - "2021-09-23 13:23:17,640 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:17,640 - root - INFO: Triangulating...\n", - "2021-09-23 13:23:17,641 - root - INFO: 10 points and 10 facets\n", - "2021-09-23 13:23:17,641 - root - INFO: checking graph consistency\n", - "2021-09-23 13:23:17,642 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:23:17,643 - root - INFO: building graph data structures\n", - "2021-09-23 13:23:17,643 - root - INFO: triangle.build...\n", - "2021-09-23 13:23:17,773 - root - INFO: ...built: 6428 mesh points and 12588 triangles\n", - "2021-09-23 13:23:17,777 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:23:18,066 - root - INFO: min area = 30.5418701171875\n", - "2021-09-23 13:23:18,067 - root - INFO: max area = 199.99493408203125\n", - "2021-09-23 13:23:18,212 - root - INFO: \n", - "2021-09-23 13:23:18,213 - root - INFO: Loading Raster\n", - "2021-09-23 13:23:18,213 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:18,214 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:23:18,214 - root - INFO: Collecting raster\n", - "2021-09-23 13:23:18,261 - root - INFO: ... got raster of shape: (48, 152)\n", - "2021-09-23 13:23:18,270 - root - INFO: ... got raster bounds: (-149.21346060296153, 68.2098100717177, -149.17123838073792, 68.19647673838392)\n", - "2021-09-23 13:23:18,280 - root - INFO: \n", - "2021-09-23 13:23:18,280 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:23:18,281 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:18,363 - root - INFO: \n", - "2021-09-23 13:23:18,364 - root - INFO: Loading Raster\n", - "2021-09-23 13:23:18,364 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:18,365 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:23:18,365 - root - INFO: Collecting raster\n", - "2021-09-23 13:23:18,407 - root - INFO: ... got raster of shape: (48, 152)\n", - "2021-09-23 13:23:18,416 - root - INFO: ... got raster bounds: (-149.21346060296153, 68.2098100717177, -149.17123838073792, 68.19647673838392)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21318529930883, 68.19654310128655, -149.17137472521458, 68.20967710288205)\n", - "bounds in my_crs: (-149.21318529930883, 68.19654310128655, -149.17137472521458, 68.20967710288205)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:23:18,477 - root - INFO: \n", - "2021-09-23 13:23:18,478 - root - INFO: Loading Raster\n", - "2021-09-23 13:23:18,478 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:18,479 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:23:18,479 - root - INFO: Collecting raster\n", - "2021-09-23 13:23:18,522 - root - INFO: ... got raster of shape: (48, 152)\n", - "2021-09-23 13:23:18,531 - root - INFO: ... got raster bounds: (-149.21346060296153, 68.2098100717177, -149.17123838073792, 68.19647673838392)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21318529930883, 68.19654310128655, -149.17137472521458, 68.20967710288205)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment6.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment6.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:23:33,101 - root - INFO: \n", - "2021-09-23 13:23:33,102 - root - INFO: Meshing\n", - "2021-09-23 13:23:33,103 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:33,104 - root - INFO: Triangulating...\n", - "2021-09-23 13:23:33,104 - root - INFO: 10 points and 10 facets\n", - "2021-09-23 13:23:33,105 - root - INFO: checking graph consistency\n", - "2021-09-23 13:23:33,105 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:23:33,106 - root - INFO: building graph data structures\n", - "2021-09-23 13:23:33,107 - root - INFO: triangle.build...\n", - "2021-09-23 13:23:33,386 - root - INFO: ...built: 13061 mesh points and 25746 triangles\n", - "2021-09-23 13:23:33,387 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:23:33,952 - root - INFO: min area = 31.566497802734375\n", - "2021-09-23 13:23:33,953 - root - INFO: max area = 199.987060546875\n", - "2021-09-23 13:23:34,201 - root - INFO: \n", - "2021-09-23 13:23:34,202 - root - INFO: Loading Raster\n", - "2021-09-23 13:23:34,202 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:34,202 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:23:34,203 - root - INFO: Collecting raster\n", - "2021-09-23 13:23:34,249 - root - INFO: ... got raster of shape: (93, 190)\n", - "2021-09-23 13:23:34,258 - root - INFO: ... got raster bounds: (-149.17012726962676, 68.22425451616263, -149.11734949184722, 68.19842118282844)\n", - "2021-09-23 13:23:34,267 - root - INFO: \n", - "2021-09-23 13:23:34,268 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:23:34,268 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:34,396 - root - INFO: \n", - "2021-09-23 13:23:34,396 - root - INFO: Loading Raster\n", - "2021-09-23 13:23:34,397 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:34,397 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:23:34,398 - root - INFO: Collecting raster\n", - "2021-09-23 13:23:34,443 - root - INFO: ... got raster of shape: (93, 190)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.17008126329404, 68.19860441435323, -149.11752268914583, 68.224084697891)\n", - "bounds in my_crs: (-149.17008126329404, 68.19860441435323, -149.11752268914583, 68.224084697891)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:23:34,452 - root - INFO: ... got raster bounds: (-149.17012726962676, 68.22425451616263, -149.11734949184722, 68.19842118282844)\n", - "2021-09-23 13:23:34,542 - root - INFO: \n", - "2021-09-23 13:23:34,543 - root - INFO: Loading Raster\n", - "2021-09-23 13:23:34,544 - root - INFO: ------------------------------\n", - "2021-09-23 13:23:34,544 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:23:34,545 - root - INFO: Collecting raster\n", - "2021-09-23 13:23:34,588 - root - INFO: ... got raster of shape: (93, 190)\n", - "2021-09-23 13:23:34,597 - root - INFO: ... got raster bounds: (-149.17012726962676, 68.22425451616263, -149.11734949184722, 68.19842118282844)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.17008126329404, 68.19860441435323, -149.11752268914583, 68.224084697891)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment7.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment7.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:24:03,815 - root - INFO: \n", - "2021-09-23 13:24:03,816 - root - INFO: Meshing\n", - "2021-09-23 13:24:03,817 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:03,817 - root - INFO: Triangulating...\n", - "2021-09-23 13:24:03,818 - root - INFO: 8 points and 8 facets\n", - "2021-09-23 13:24:03,818 - root - INFO: checking graph consistency\n", - "2021-09-23 13:24:03,819 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:24:03,820 - root - INFO: building graph data structures\n", - "2021-09-23 13:24:03,820 - root - INFO: triangle.build...\n", - "2021-09-23 13:24:03,924 - root - INFO: ...built: 4932 mesh points and 9596 triangles\n", - "2021-09-23 13:24:03,927 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:24:04,147 - root - INFO: min area = 61.36431884765625\n", - "2021-09-23 13:24:04,147 - root - INFO: max area = 199.99404907226562\n", - "2021-09-23 13:24:04,264 - root - INFO: \n", - "2021-09-23 13:24:04,265 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:04,265 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:04,266 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:24:04,267 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:04,308 - root - INFO: ... got raster of shape: (46, 180)\n", - "2021-09-23 13:24:04,316 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n", - "2021-09-23 13:24:04,326 - root - INFO: \n", - "2021-09-23 13:24:04,326 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:24:04,327 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:04,399 - root - INFO: \n", - "2021-09-23 13:24:04,400 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:04,401 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:04,401 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:24:04,402 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:04,441 - root - INFO: ... got raster of shape: (46, 180)\n", - "2021-09-23 13:24:04,449 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n", - "2021-09-23 13:24:04,504 - root - INFO: \n", - "2021-09-23 13:24:04,505 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:04,505 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:04,506 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n", - "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:24:04,507 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:04,551 - root - INFO: ... got raster of shape: (46, 180)\n", - "2021-09-23 13:24:04,560 - root - INFO: ... got raster bounds: (-149.177627269627, 68.22258784949591, -149.12762726962535, 68.20981007171771)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.17752425651716, 68.2100293487316, -149.1277460038376, 68.22241031118037)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment8.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment8.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:24:15,607 - root - INFO: \n", - "2021-09-23 13:24:15,607 - root - INFO: Meshing\n", - "2021-09-23 13:24:15,608 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:15,608 - root - INFO: Triangulating...\n", - "2021-09-23 13:24:15,609 - root - INFO: 5 points and 5 facets\n", - "2021-09-23 13:24:15,609 - root - INFO: checking graph consistency\n", - "2021-09-23 13:24:15,610 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:24:15,610 - root - INFO: building graph data structures\n", - "2021-09-23 13:24:15,611 - root - INFO: triangle.build...\n", - "2021-09-23 13:24:15,633 - root - INFO: ...built: 943 mesh points and 1765 triangles\n", - "2021-09-23 13:24:15,634 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:24:15,683 - root - INFO: min area = 64.89346313476562\n", - "2021-09-23 13:24:15,684 - root - INFO: max area = 199.94284057617188\n", - "2021-09-23 13:24:15,736 - root - INFO: \n", - "2021-09-23 13:24:15,737 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:15,737 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:15,738 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:24:15,739 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:15,780 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-23 13:24:15,788 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-23 13:24:15,797 - root - INFO: \n", - "2021-09-23 13:24:15,798 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:24:15,799 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:15,844 - root - INFO: \n", - "2021-09-23 13:24:15,845 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:15,846 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:15,846 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:24:15,847 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:15,887 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-23 13:24:15,896 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n", - "2021-09-23 13:24:15,938 - root - INFO: \n", - "2021-09-23 13:24:15,939 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:15,939 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:15,940 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:24:15,940 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12195772397504, 68.2146470306309, -149.11469670554692, 68.22476698259781)\n", - "bounds in my_crs: (-149.12195772397504, 68.2146470306309, -149.11469670554692, 68.22476698259781)\n", - "bounds in my_crs: (-149.12195772397504, 68.2146470306309, -149.11469670554692, 68.22476698259781)" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:24:15,982 - root - INFO: ... got raster of shape: (37, 27)\n", - "2021-09-23 13:24:15,991 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.2248100717182, -149.11457171406937, 68.21453229394008)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment9.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:24:18,174 - root - INFO: \n", - "2021-09-23 13:24:18,175 - root - INFO: Meshing\n", - "2021-09-23 13:24:18,176 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:18,176 - root - INFO: Triangulating...\n", - "2021-09-23 13:24:18,177 - root - INFO: 4 points and 4 facets\n", - "2021-09-23 13:24:18,178 - root - INFO: checking graph consistency\n", - "2021-09-23 13:24:18,178 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:24:18,180 - root - INFO: building graph data structures\n", - "2021-09-23 13:24:18,180 - root - INFO: triangle.build...\n", - "2021-09-23 13:24:18,190 - root - INFO: ...built: 403 mesh points and 740 triangles\n", - "2021-09-23 13:24:18,191 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:24:18,218 - root - INFO: min area = 63.197265625\n", - "2021-09-23 13:24:18,219 - root - INFO: max area = 197.10922241210938\n", - "2021-09-23 13:24:18,265 - root - INFO: \n", - "2021-09-23 13:24:18,266 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:18,266 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:18,266 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:24:18,267 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:18,309 - root - INFO: ... got raster of shape: (19, 28)\n", - "2021-09-23 13:24:18,318 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-23 13:24:18,327 - root - INFO: \n", - "2021-09-23 13:24:18,328 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:24:18,329 - root - INFO: ------------------------------\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment9.exo\n", - "bounds in my_crs: (-149.1220145604678, 68.224633298062, -149.11450991948863, 68.22964545511863)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:24:18,374 - root - INFO: \n", - "2021-09-23 13:24:18,375 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:18,375 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:18,375 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:24:18,376 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:18,421 - root - INFO: ... got raster of shape: (19, 28)\n", - "2021-09-23 13:24:18,430 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n", - "2021-09-23 13:24:18,471 - root - INFO: \n", - "2021-09-23 13:24:18,471 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:18,472 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:18,473 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:24:18,473 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:18,514 - root - INFO: ... got raster of shape: (19, 28)\n", - "2021-09-23 13:24:18,523 - root - INFO: ... got raster bounds: (-149.12207171406962, 68.22981007171836, -149.11429393629157, 68.22453229394041)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.1220145604678, 68.224633298062, -149.11450991948863, 68.22964545511863)\n", - "bounds in my_crs: (-149.1220145604678, 68.224633298062, -149.11450991948863, 68.22964545511863)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:24:19,504 - root - INFO: \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment10.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment10.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:24:19,505 - root - INFO: Meshing\n", - "2021-09-23 13:24:19,505 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:19,506 - root - INFO: Triangulating...\n", - "2021-09-23 13:24:19,507 - root - INFO: 17 points and 17 facets\n", - "2021-09-23 13:24:19,507 - root - INFO: checking graph consistency\n", - "2021-09-23 13:24:19,507 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:24:19,508 - root - INFO: building graph data structures\n", - "2021-09-23 13:24:19,509 - root - INFO: triangle.build...\n", - "2021-09-23 13:24:19,825 - root - INFO: ...built: 17219 mesh points and 33992 triangles\n", - "2021-09-23 13:24:19,826 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:24:20,547 - root - INFO: min area = 62.965301513671875\n", - "2021-09-23 13:24:20,548 - root - INFO: max area = 199.99411010742188\n", - "2021-09-23 13:24:20,902 - root - INFO: \n", - "2021-09-23 13:24:20,903 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:20,904 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:20,904 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:24:20,905 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:20,952 - root - INFO: ... got raster of shape: (117, 191)\n", - "2021-09-23 13:24:20,961 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07234949184576, 68.19953229393958)\n", - "2021-09-23 13:24:20,976 - root - INFO: \n", - "2021-09-23 13:24:20,977 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:24:20,978 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:21,136 - root - INFO: \n", - "2021-09-23 13:24:21,136 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:21,137 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:21,137 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:24:21,138 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.1252712902553, 68.19958418193676, -149.0724953180663, 68.23194119249688)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:24:21,180 - root - INFO: ... got raster of shape: (117, 191)\n", - "2021-09-23 13:24:21,189 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07234949184576, 68.19953229393958)\n", - "2021-09-23 13:24:21,291 - root - INFO: \n", - "2021-09-23 13:24:21,291 - root - INFO: Loading Raster\n", - "2021-09-23 13:24:21,292 - root - INFO: ------------------------------\n", - "2021-09-23 13:24:21,292 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:24:21,293 - root - INFO: Collecting raster\n", - "2021-09-23 13:24:21,335 - root - INFO: ... got raster of shape: (117, 191)\n", - "2021-09-23 13:24:21,344 - root - INFO: ... got raster bounds: (-149.12540504740306, 68.23203229394066, -149.07234949184576, 68.19953229393958)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.1252712902553, 68.19958418193676, -149.0724953180663, 68.23194119249688)\n", - "bounds in my_crs: (-149.1252712902553, 68.19958418193676, -149.0724953180663, 68.23194119249688)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment11.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment11.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:25:00,161 - root - INFO: \n", - "2021-09-23 13:25:00,162 - root - INFO: Meshing\n", - "2021-09-23 13:25:00,163 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:00,164 - root - INFO: Triangulating...\n", - "2021-09-23 13:25:00,164 - root - INFO: 7 points and 7 facets\n", - "2021-09-23 13:25:00,165 - root - INFO: checking graph consistency\n", - "2021-09-23 13:25:00,165 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:25:00,166 - root - INFO: building graph data structures\n", - "2021-09-23 13:25:00,166 - root - INFO: triangle.build...\n", - "2021-09-23 13:25:00,404 - root - INFO: ...built: 11500 mesh points and 22655 triangles\n", - "2021-09-23 13:25:00,406 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:25:00,925 - root - INFO: min area = 39.735809326171875\n", - "2021-09-23 13:25:00,927 - root - INFO: max area = 199.99679565429688\n", - "2021-09-23 13:25:01,157 - root - INFO: \n", - "2021-09-23 13:25:01,158 - root - INFO: Loading Raster\n", - "2021-09-23 13:25:01,159 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:01,159 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:25:01,160 - root - INFO: Collecting raster\n", - "2021-09-23 13:25:01,206 - root - INFO: ... got raster of shape: (94, 128)\n", - "2021-09-23 13:25:01,215 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25092118283018, -149.08040504740157, 68.22481007171821)\n", - "2021-09-23 13:25:01,224 - root - INFO: \n", - "2021-09-23 13:25:01,225 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:25:01,226 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:01,342 - root - INFO: \n", - "2021-09-23 13:25:01,343 - root - INFO: Loading Raster\n", - "2021-09-23 13:25:01,343 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:01,344 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:25:01,345 - root - INFO: Collecting raster\n", - "2021-09-23 13:25:01,388 - root - INFO: ... got raster of shape: (94, 128)\n", - "2021-09-23 13:25:01,397 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25092118283018, -149.08040504740157, 68.22481007171821)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.1159483824004, 68.2248164661218, -149.0804188841349, 68.25091454444949)\n", - "bounds in my_crs: (-149.1159483824004, 68.2248164661218, -149.0804188841349, 68.25091454444949)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:25:01,476 - root - INFO: \n", - "2021-09-23 13:25:01,477 - root - INFO: Loading Raster\n", - "2021-09-23 13:25:01,477 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:01,478 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:25:01,478 - root - INFO: Collecting raster\n", - "2021-09-23 13:25:01,523 - root - INFO: ... got raster of shape: (94, 128)\n", - "2021-09-23 13:25:01,531 - root - INFO: ... got raster bounds: (-149.1159606029583, 68.25092118283018, -149.08040504740157, 68.22481007171821)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.1159483824004, 68.2248164661218, -149.0804188841349, 68.25091454444949)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment12.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment12.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:25:28,597 - root - INFO: \n", - "2021-09-23 13:25:28,598 - root - INFO: Meshing\n", - "2021-09-23 13:25:28,598 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:28,599 - root - INFO: Triangulating...\n", - "2021-09-23 13:25:28,600 - root - INFO: 12 points and 12 facets\n", - "2021-09-23 13:25:28,600 - root - INFO: checking graph consistency\n", - "2021-09-23 13:25:28,601 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:25:28,601 - root - INFO: building graph data structures\n", - "2021-09-23 13:25:28,602 - root - INFO: triangle.build...\n", - "2021-09-23 13:25:28,852 - root - INFO: ...built: 14357 mesh points and 28318 triangles\n", - "2021-09-23 13:25:28,853 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:25:29,519 - root - INFO: min area = 57.526275634765625\n", - "2021-09-23 13:25:29,520 - root - INFO: max area = 199.99566650390625\n", - "2021-09-23 13:25:29,790 - root - INFO: \n", - "2021-09-23 13:25:29,791 - root - INFO: Loading Raster\n", - "2021-09-23 13:25:29,792 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:29,792 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:25:29,793 - root - INFO: Collecting raster\n", - "2021-09-23 13:25:29,837 - root - INFO: ... got raster of shape: (96, 205)\n", - "2021-09-23 13:25:29,847 - root - INFO: ... got raster bounds: (-149.08568282517953, 68.2439767383855, -149.0287383807332, 68.21731007171795)\n", - "2021-09-23 13:25:29,856 - root - INFO: \n", - "2021-09-23 13:25:29,856 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:25:29,856 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:29,996 - root - INFO: \n", - "2021-09-23 13:25:29,997 - root - INFO: Loading Raster\n", - "2021-09-23 13:25:29,998 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:29,998 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:25:29,999 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08555398967127, 68.21735876156187, -149.02887005478019, 68.24383919593815)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:25:30,038 - root - INFO: ... got raster of shape: (96, 205)\n", - "2021-09-23 13:25:30,048 - root - INFO: ... got raster bounds: (-149.08568282517953, 68.2439767383855, -149.0287383807332, 68.21731007171795)\n", - "2021-09-23 13:25:30,138 - root - INFO: \n", - "2021-09-23 13:25:30,139 - root - INFO: Loading Raster\n", - "2021-09-23 13:25:30,139 - root - INFO: ------------------------------\n", - "2021-09-23 13:25:30,140 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:25:30,141 - root - INFO: Collecting raster\n", - "2021-09-23 13:25:30,183 - root - INFO: ... got raster of shape: (96, 205)\n", - "2021-09-23 13:25:30,191 - root - INFO: ... got raster bounds: (-149.08568282517953, 68.2439767383855, -149.0287383807332, 68.21731007171795)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08555398967127, 68.21735876156187, -149.02887005478019, 68.24383919593815)\n", - "bounds in my_crs: (-149.08555398967127, 68.21735876156187, -149.02887005478019, 68.24383919593815)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment13.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment13.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:26:05,227 - root - INFO: \n", - "2021-09-23 13:26:05,228 - root - INFO: Meshing\n", - "2021-09-23 13:26:05,228 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:05,228 - root - INFO: Triangulating...\n", - "2021-09-23 13:26:05,231 - root - INFO: 7 points and 7 facets\n", - "2021-09-23 13:26:05,233 - root - INFO: checking graph consistency\n", - "2021-09-23 13:26:05,234 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:26:05,235 - root - INFO: building graph data structures\n", - "2021-09-23 13:26:05,236 - root - INFO: triangle.build...\n", - "2021-09-23 13:26:05,579 - root - INFO: ...built: 12402 mesh points and 24442 triangles\n", - "2021-09-23 13:26:05,580 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:26:06,126 - root - INFO: min area = 39.55126953125\n", - "2021-09-23 13:26:06,127 - root - INFO: max area = 199.97433471679688\n", - "2021-09-23 13:26:06,416 - root - INFO: \n", - "2021-09-23 13:26:06,417 - root - INFO: Loading Raster\n", - "2021-09-23 13:26:06,417 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:06,418 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:26:06,419 - root - INFO: Collecting raster\n", - "2021-09-23 13:26:06,474 - root - INFO: ... got raster of shape: (68, 218)\n", - "2021-09-23 13:26:06,485 - root - INFO: ... got raster bounds: (-149.0904050474019, 68.25092118283018, -149.02984949184435, 68.23203229394066)\n", - "2021-09-23 13:26:06,498 - root - INFO: \n", - "2021-09-23 13:26:06,499 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:26:06,499 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:06,641 - root - INFO: \n", - "2021-09-23 13:26:06,642 - root - INFO: Loading Raster\n", - "2021-09-23 13:26:06,643 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:06,644 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:26:06,644 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.09027776606652, 68.2321531453996, -149.02999166915717, 68.25089018150955)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:26:06,695 - root - INFO: ... got raster of shape: (68, 218)\n", - "2021-09-23 13:26:06,708 - root - INFO: ... got raster bounds: (-149.0904050474019, 68.25092118283018, -149.02984949184435, 68.23203229394066)\n", - "2021-09-23 13:26:06,800 - root - INFO: \n", - "2021-09-23 13:26:06,801 - root - INFO: Loading Raster\n", - "2021-09-23 13:26:06,802 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:06,802 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:26:06,803 - root - INFO: Collecting raster\n", - "2021-09-23 13:26:06,858 - root - INFO: ... got raster of shape: (68, 218)\n", - "2021-09-23 13:26:06,867 - root - INFO: ... got raster bounds: (-149.0904050474019, 68.25092118283018, -149.02984949184435, 68.23203229394066)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.09027776606652, 68.2321531453996, -149.02999166915717, 68.25089018150955)\n", - "bounds in my_crs: (-149.09027776606652, 68.2321531453996, -149.02999166915717, 68.25089018150955)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment14.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment14.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:26:36,122 - root - INFO: \n", - "2021-09-23 13:26:36,123 - root - INFO: Meshing\n", - "2021-09-23 13:26:36,123 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:36,124 - root - INFO: Triangulating...\n", - "2021-09-23 13:26:36,125 - root - INFO: 11 points and 11 facets\n", - "2021-09-23 13:26:36,125 - root - INFO: checking graph consistency\n", - "2021-09-23 13:26:36,126 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:26:36,127 - root - INFO: building graph data structures\n", - "2021-09-23 13:26:36,127 - root - INFO: triangle.build...\n", - "2021-09-23 13:26:36,466 - root - INFO: ...built: 14740 mesh points and 29109 triangles\n", - "2021-09-23 13:26:36,467 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:26:37,094 - root - INFO: min area = 60.285186767578125\n", - "2021-09-23 13:26:37,095 - root - INFO: max area = 199.97903442382812\n", - "2021-09-23 13:26:37,369 - root - INFO: \n", - "2021-09-23 13:26:37,370 - root - INFO: Loading Raster\n", - "2021-09-23 13:26:37,370 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:37,371 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:26:37,372 - root - INFO: Collecting raster\n", - "2021-09-23 13:26:37,413 - root - INFO: ... got raster of shape: (88, 198)\n", - "2021-09-23 13:26:37,422 - root - INFO: ... got raster bounds: (-149.0306828251777, 68.26842118283076, -148.97568282517588, 68.24397673838551)\n", - "2021-09-23 13:26:37,431 - root - INFO: \n", - "2021-09-23 13:26:37,432 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:26:37,432 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:37,565 - root - INFO: \n", - "2021-09-23 13:26:37,565 - root - INFO: Loading Raster\n", - "2021-09-23 13:26:37,566 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:37,566 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:26:37,567 - root - INFO: Collecting raster\n", - "2021-09-23 13:26:37,606 - root - INFO: ... got raster of shape: (88, 198)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.03048446793935, 68.24422492626324, -148.97588227121466, 68.26816107683497)\n", - "bounds in my_crs: (-149.03048446793935, 68.24422492626324, -148.97588227121466, 68.26816107683497)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:26:37,615 - root - INFO: ... got raster bounds: (-149.0306828251777, 68.26842118283076, -148.97568282517588, 68.24397673838551)\n", - "2021-09-23 13:26:37,701 - root - INFO: \n", - "2021-09-23 13:26:37,702 - root - INFO: Loading Raster\n", - "2021-09-23 13:26:37,702 - root - INFO: ------------------------------\n", - "2021-09-23 13:26:37,703 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:26:37,704 - root - INFO: Collecting raster\n", - "2021-09-23 13:26:37,743 - root - INFO: ... got raster of shape: (88, 198)\n", - "2021-09-23 13:26:37,752 - root - INFO: ... got raster bounds: (-149.0306828251777, 68.26842118283076, -148.97568282517588, 68.24397673838551)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.03048446793935, 68.24422492626324, -148.97588227121466, 68.26816107683497)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment15.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment15.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:27:13,827 - root - INFO: \n", - "2021-09-23 13:27:13,828 - root - INFO: Meshing\n", - "2021-09-23 13:27:13,829 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:13,829 - root - INFO: Triangulating...\n", - "2021-09-23 13:27:13,831 - root - INFO: 12 points and 12 facets\n", - "2021-09-23 13:27:13,831 - root - INFO: checking graph consistency\n", - "2021-09-23 13:27:13,832 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:27:13,833 - root - INFO: building graph data structures\n", - "2021-09-23 13:27:13,834 - root - INFO: triangle.build...\n", - "2021-09-23 13:27:13,971 - root - INFO: ...built: 6756 mesh points and 13181 triangles\n", - "2021-09-23 13:27:13,974 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:27:14,311 - root - INFO: min area = 56.0380859375\n", - "2021-09-23 13:27:14,311 - root - INFO: max area = 199.96469116210938\n", - "2021-09-23 13:27:14,459 - root - INFO: \n", - "2021-09-23 13:27:14,459 - root - INFO: Loading Raster\n", - "2021-09-23 13:27:14,460 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:14,461 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:27:14,461 - root - INFO: Collecting raster\n", - "2021-09-23 13:27:14,500 - root - INFO: ... got raster of shape: (69, 200)\n", - "2021-09-23 13:27:14,508 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.25453229394141, -148.97484949184252, 68.2353656272741)\n", - "2021-09-23 13:27:14,518 - root - INFO: \n", - "2021-09-23 13:27:14,518 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:27:14,519 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:14,602 - root - INFO: \n", - "2021-09-23 13:27:14,602 - root - INFO: Loading Raster\n", - "2021-09-23 13:27:14,603 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:14,603 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:27:14,604 - root - INFO: Collecting raster\n", - "2021-09-23 13:27:14,644 - root - INFO: ... got raster of shape: (69, 200)\n", - "2021-09-23 13:27:14,653 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.25453229394141, -148.97484949184252, 68.2353656272741)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.030312656111, 68.23544774934933, -148.97494286142927, 68.25448400386779)\n", - "bounds in my_crs: (-149.030312656111, 68.23544774934933, -148.97494286142927, 68.25448400386779)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:27:14,716 - root - INFO: \n", - "2021-09-23 13:27:14,716 - root - INFO: Loading Raster\n", - "2021-09-23 13:27:14,717 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:14,717 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:27:14,718 - root - INFO: Collecting raster\n", - "2021-09-23 13:27:14,756 - root - INFO: ... got raster of shape: (69, 200)\n", - "2021-09-23 13:27:14,765 - root - INFO: ... got raster bounds: (-149.0304050473999, 68.25453229394141, -148.97484949184252, 68.2353656272741)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.030312656111, 68.23544774934933, -148.97494286142927, 68.25448400386779)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment16.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment16.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:27:30,881 - root - INFO: \n", - "2021-09-23 13:27:30,882 - root - INFO: Meshing\n", - "2021-09-23 13:27:30,883 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:30,883 - root - INFO: Triangulating...\n", - "2021-09-23 13:27:30,884 - root - INFO: 13 points and 13 facets\n", - "2021-09-23 13:27:30,885 - root - INFO: checking graph consistency\n", - "2021-09-23 13:27:30,885 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:27:30,886 - root - INFO: building graph data structures\n", - "2021-09-23 13:27:30,887 - root - INFO: triangle.build...\n", - "2021-09-23 13:27:31,228 - root - INFO: ...built: 19301 mesh points and 38159 triangles\n", - "2021-09-23 13:27:31,229 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:27:32,157 - root - INFO: min area = 33.711090087890625\n", - "2021-09-23 13:27:32,158 - root - INFO: max area = 199.98992919921875\n", - "2021-09-23 13:27:32,521 - root - INFO: \n", - "2021-09-23 13:27:32,522 - root - INFO: Loading Raster\n", - "2021-09-23 13:27:32,522 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:32,523 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:27:32,523 - root - INFO: Collecting raster\n", - "2021-09-23 13:27:32,568 - root - INFO: ... got raster of shape: (91, 264)\n", - "2021-09-23 13:27:32,577 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28092118283118, -148.94012726961913, 68.25564340505257)\n", - "2021-09-23 13:27:32,587 - root - INFO: \n", - "2021-09-23 13:27:32,588 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:27:32,588 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:32,758 - root - INFO: \n", - "2021-09-23 13:27:32,759 - root - INFO: Loading Raster\n", - "2021-09-23 13:27:32,760 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:32,760 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:27:32,761 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.01323342717478, 68.25590210213116, -148.9403544805741, 68.28066175352585)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:27:32,813 - root - INFO: ... got raster of shape: (91, 264)\n", - "2021-09-23 13:27:32,822 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28092118283118, -148.94012726961913, 68.25564340505257)\n", - "2021-09-23 13:27:32,929 - root - INFO: \n", - "2021-09-23 13:27:32,930 - root - INFO: Loading Raster\n", - "2021-09-23 13:27:32,930 - root - INFO: ------------------------------\n", - "2021-09-23 13:27:32,931 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:27:32,932 - root - INFO: Collecting raster\n", - "2021-09-23 13:27:32,975 - root - INFO: ... got raster of shape: (91, 264)\n", - "2021-09-23 13:27:32,984 - root - INFO: ... got raster bounds: (-149.0134606029549, 68.28092118283118, -148.94012726961913, 68.25564340505257)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.01323342717478, 68.25590210213116, -148.9403544805741, 68.28066175352585)\n", - "bounds in my_crs: (-149.01323342717478, 68.25590210213116, -148.9403544805741, 68.28066175352585)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment17.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment17.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:28:19,449 - root - INFO: \n", - "2021-09-23 13:28:19,450 - root - INFO: Meshing\n", - "2021-09-23 13:28:19,451 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:19,452 - root - INFO: Triangulating...\n", - "2021-09-23 13:28:19,452 - root - INFO: 11 points and 11 facets\n", - "2021-09-23 13:28:19,453 - root - INFO: checking graph consistency\n", - "2021-09-23 13:28:19,453 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:28:19,454 - root - INFO: building graph data structures\n", - "2021-09-23 13:28:19,454 - root - INFO: triangle.build...\n", - "2021-09-23 13:28:19,690 - root - INFO: ...built: 10157 mesh points and 19949 triangles\n", - "2021-09-23 13:28:19,691 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:28:20,197 - root - INFO: min area = 40.16156005859375\n", - "2021-09-23 13:28:20,197 - root - INFO: max area = 199.96157836914062\n", - "2021-09-23 13:28:20,414 - root - INFO: \n", - "2021-09-23 13:28:20,415 - root - INFO: Loading Raster\n", - "2021-09-23 13:28:20,415 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:20,416 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:28:20,416 - root - INFO: Collecting raster\n", - "2021-09-23 13:28:20,463 - root - INFO: ... got raster of shape: (100, 187)\n", - "2021-09-23 13:28:20,472 - root - INFO: ... got raster bounds: (-148.97568282517588, 68.27564340505322, -148.9237383807297, 68.24786562727452)\n", - "2021-09-23 13:28:20,481 - root - INFO: \n", - "2021-09-23 13:28:20,482 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:28:20,483 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:20,593 - root - INFO: \n", - "2021-09-23 13:28:20,594 - root - INFO: Loading Raster\n", - "2021-09-23 13:28:20,594 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:20,595 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:28:20,595 - root - INFO: Collecting raster\n", - "2021-09-23 13:28:20,640 - root - INFO: ... got raster of shape: (100, 187)\n", - "2021-09-23 13:28:20,649 - root - INFO: ... got raster bounds: (-148.97568282517588, 68.27564340505322, -148.9237383807297, 68.24786562727452)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.97544054998755, 68.24802136627605, -148.92374290221164, 68.2754465236705)\n", - "bounds in my_crs: (-148.97544054998755, 68.24802136627605, -148.92374290221164, 68.2754465236705)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:28:20,723 - root - INFO: \n", - "2021-09-23 13:28:20,723 - root - INFO: Loading Raster\n", - "2021-09-23 13:28:20,724 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:20,725 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:28:20,726 - root - INFO: Collecting raster\n", - "2021-09-23 13:28:20,773 - root - INFO: ... got raster of shape: (100, 187)\n", - "2021-09-23 13:28:20,781 - root - INFO: ... got raster bounds: (-148.97568282517588, 68.27564340505322, -148.9237383807297, 68.24786562727452)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.97544054998755, 68.24802136627605, -148.92374290221164, 68.2754465236705)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment18.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment18.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:28:45,494 - root - INFO: \n", - "2021-09-23 13:28:45,495 - root - INFO: Meshing\n", - "2021-09-23 13:28:45,496 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:45,496 - root - INFO: Triangulating...\n", - "2021-09-23 13:28:45,497 - root - INFO: 11 points and 11 facets\n", - "2021-09-23 13:28:45,497 - root - INFO: checking graph consistency\n", - "2021-09-23 13:28:45,498 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:28:45,498 - root - INFO: building graph data structures\n", - "2021-09-23 13:28:45,499 - root - INFO: triangle.build...\n", - "2021-09-23 13:28:45,749 - root - INFO: ...built: 13602 mesh points and 26815 triangles\n", - "2021-09-23 13:28:45,750 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:28:46,346 - root - INFO: min area = 62.41168212890625\n", - "2021-09-23 13:28:46,347 - root - INFO: max area = 199.99432373046875\n", - "2021-09-23 13:28:46,609 - root - INFO: \n", - "2021-09-23 13:28:46,611 - root - INFO: Loading Raster\n", - "2021-09-23 13:28:46,611 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:46,612 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:28:46,612 - root - INFO: Collecting raster\n", - "2021-09-23 13:28:46,659 - root - INFO: ... got raster of shape: (94, 200)\n", - "2021-09-23 13:28:46,667 - root - INFO: ... got raster bounds: (-148.95207171406398, 68.30231007172077, -148.89651615850659, 68.2761989606088)\n", - "2021-09-23 13:28:46,677 - root - INFO: \n", - "2021-09-23 13:28:46,678 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:28:46,678 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:46,809 - root - INFO: \n", - "2021-09-23 13:28:46,809 - root - INFO: Loading Raster\n", - "2021-09-23 13:28:46,810 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:46,811 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:28:46,812 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.95191254087308, 68.27643226672154, -148.89667548409713, 68.3020752808257)\n", - "bounds in my_crs: (-148.95191254087308, 68.27643226672154, -148.89667548409713, 68.3020752808257)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:28:46,857 - root - INFO: ... got raster of shape: (94, 200)\n", - "2021-09-23 13:28:46,866 - root - INFO: ... got raster bounds: (-148.95207171406398, 68.30231007172077, -148.89651615850659, 68.2761989606088)\n", - "2021-09-23 13:28:46,954 - root - INFO: \n", - "2021-09-23 13:28:46,955 - root - INFO: Loading Raster\n", - "2021-09-23 13:28:46,955 - root - INFO: ------------------------------\n", - "2021-09-23 13:28:46,956 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:28:46,957 - root - INFO: Collecting raster\n", - "2021-09-23 13:28:47,011 - root - INFO: ... got raster of shape: (94, 200)\n", - "2021-09-23 13:28:47,020 - root - INFO: ... got raster bounds: (-148.95207171406398, 68.30231007172077, -148.89651615850659, 68.2761989606088)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.95191254087308, 68.27643226672154, -148.89667548409713, 68.3020752808257)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment19.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment19.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:29:18,162 - root - INFO: \n", - "2021-09-23 13:29:18,163 - root - INFO: Meshing\n", - "2021-09-23 13:29:18,164 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:18,164 - root - INFO: Triangulating...\n", - "2021-09-23 13:29:18,165 - root - INFO: 12 points and 12 facets\n", - "2021-09-23 13:29:18,166 - root - INFO: checking graph consistency\n", - "2021-09-23 13:29:18,166 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:29:18,167 - root - INFO: building graph data structures\n", - "2021-09-23 13:29:18,167 - root - INFO: triangle.build...\n", - "2021-09-23 13:29:18,400 - root - INFO: ...built: 13447 mesh points and 26529 triangles\n", - "2021-09-23 13:29:18,401 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:29:18,958 - root - INFO: min area = 30.117584228515625\n", - "2021-09-23 13:29:18,960 - root - INFO: max area = 199.97067260742188\n", - "2021-09-23 13:29:19,221 - root - INFO: \n", - "2021-09-23 13:29:19,222 - root - INFO: Loading Raster\n", - "2021-09-23 13:29:19,222 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:19,223 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:29:19,224 - root - INFO: Collecting raster\n", - "2021-09-23 13:29:19,268 - root - INFO: ... got raster of shape: (100, 187)\n", - "2021-09-23 13:29:19,277 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29175451616487, -148.88818282517295, 68.26397673838618)\n", - "2021-09-23 13:29:19,285 - root - INFO: \n", - "2021-09-23 13:29:19,286 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:29:19,286 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:19,415 - root - INFO: \n", - "2021-09-23 13:29:19,416 - root - INFO: Loading Raster\n", - "2021-09-23 13:29:19,416 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:19,417 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:29:19,417 - root - INFO: Collecting raster\n", - "2021-09-23 13:29:19,457 - root - INFO: ... got raster of shape: (100, 187)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.93997970821187, 68.2642068923835, -148.88833346973985, 68.29151277341492)\n", - "bounds in my_crs: (-148.93997970821187, 68.2642068923835, -148.88833346973985, 68.29151277341492)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:29:19,466 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29175451616487, -148.88818282517295, 68.26397673838618)\n", - "2021-09-23 13:29:19,552 - root - INFO: \n", - "2021-09-23 13:29:19,553 - root - INFO: Loading Raster\n", - "2021-09-23 13:29:19,553 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:19,554 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:29:19,554 - root - INFO: Collecting raster\n", - "2021-09-23 13:29:19,596 - root - INFO: ... got raster of shape: (100, 187)\n", - "2021-09-23 13:29:19,603 - root - INFO: ... got raster bounds: (-148.94012726961913, 68.29175451616487, -148.88818282517295, 68.26397673838618)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.93997970821187, 68.2642068923835, -148.88833346973985, 68.29151277341492)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment20.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment20.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:29:50,329 - root - INFO: \n", - "2021-09-23 13:29:50,330 - root - INFO: Meshing\n", - "2021-09-23 13:29:50,331 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:50,332 - root - INFO: Triangulating...\n", - "2021-09-23 13:29:50,332 - root - INFO: 7 points and 7 facets\n", - "2021-09-23 13:29:50,332 - root - INFO: checking graph consistency\n", - "2021-09-23 13:29:50,333 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:29:50,334 - root - INFO: building graph data structures\n", - "2021-09-23 13:29:50,334 - root - INFO: triangle.build...\n", - "2021-09-23 13:29:50,508 - root - INFO: ...built: 6608 mesh points and 12970 triangles\n", - "2021-09-23 13:29:50,510 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:29:50,785 - root - INFO: min area = 43.099029541015625\n", - "2021-09-23 13:29:50,785 - root - INFO: max area = 199.95602416992188\n", - "/Users/3hg/opt/watershed_workflow/workflow/hilev.py:823: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n", - " plt.figure()\n", - "2021-09-23 13:29:50,945 - root - INFO: \n", - "2021-09-23 13:29:50,946 - root - INFO: Loading Raster\n", - "2021-09-23 13:29:50,946 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:50,947 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:29:50,948 - root - INFO: Collecting raster\n", - "2021-09-23 13:29:50,990 - root - INFO: ... got raster of shape: (76, 97)\n", - "2021-09-23 13:29:50,999 - root - INFO: ... got raster bounds: (-148.89734949183995, 68.2953656272761, -148.8704050473946, 68.27425451616429)\n", - "2021-09-23 13:29:51,008 - root - INFO: \n", - "2021-09-23 13:29:51,009 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:29:51,009 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:51,092 - root - INFO: \n", - "2021-09-23 13:29:51,093 - root - INFO: Loading Raster\n", - "2021-09-23 13:29:51,093 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:51,094 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:29:51,095 - root - INFO: Collecting raster\n", - "2021-09-23 13:29:51,135 - root - INFO: ... got raster of shape: (76, 97)\n", - "2021-09-23 13:29:51,145 - root - INFO: ... got raster bounds: (-148.89734949183995, 68.2953656272761, -148.8704050473946, 68.27425451616429)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.89718738747706, 68.2742911759621, -148.87057232368306, 68.29525279044076)\n", - "bounds in my_crs: (-148.89718738747706, 68.2742911759621, -148.87057232368306, 68.29525279044076)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:29:51,206 - root - INFO: \n", - "2021-09-23 13:29:51,207 - root - INFO: Loading Raster\n", - "2021-09-23 13:29:51,207 - root - INFO: ------------------------------\n", - "2021-09-23 13:29:51,207 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:29:51,208 - root - INFO: Collecting raster\n", - "2021-09-23 13:29:51,248 - root - INFO: ... got raster of shape: (76, 97)\n", - "2021-09-23 13:29:51,256 - root - INFO: ... got raster bounds: (-148.89734949183995, 68.2953656272761, -148.8704050473946, 68.27425451616429)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.89718738747706, 68.2742911759621, -148.87057232368306, 68.29525279044076)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment21.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment21.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:30:06,124 - root - INFO: \n", - "2021-09-23 13:30:06,125 - root - INFO: Meshing\n", - "2021-09-23 13:30:06,125 - root - INFO: ------------------------------\n", - "2021-09-23 13:30:06,126 - root - INFO: Triangulating...\n", - "2021-09-23 13:30:06,127 - root - INFO: 7 points and 7 facets\n", - "2021-09-23 13:30:06,127 - root - INFO: checking graph consistency\n", - "2021-09-23 13:30:06,128 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:30:06,128 - root - INFO: building graph data structures\n", - "2021-09-23 13:30:06,129 - root - INFO: triangle.build...\n", - "2021-09-23 13:30:06,187 - root - INFO: ...built: 2742 mesh points and 5329 triangles\n", - "2021-09-23 13:30:06,192 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:30:06,317 - root - INFO: min area = 70.24395751953125\n", - "2021-09-23 13:30:06,318 - root - INFO: max area = 199.92208862304688\n", - "2021-09-23 13:30:06,405 - root - INFO: \n", - "2021-09-23 13:30:06,405 - root - INFO: Loading Raster\n", - "2021-09-23 13:30:06,406 - root - INFO: ------------------------------\n", - "2021-09-23 13:30:06,406 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:30:06,407 - root - INFO: Collecting raster\n", - "2021-09-23 13:30:06,447 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-23 13:30:06,456 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", - "2021-09-23 13:30:06,464 - root - INFO: \n", - "2021-09-23 13:30:06,465 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:30:06,465 - root - INFO: ------------------------------\n", - "2021-09-23 13:30:06,523 - root - INFO: \n", - "2021-09-23 13:30:06,523 - root - INFO: Loading Raster\n", - "2021-09-23 13:30:06,524 - root - INFO: ------------------------------\n", - "2021-09-23 13:30:06,524 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:30:06,525 - root - INFO: Collecting raster\n", - "2021-09-23 13:30:06,564 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-23 13:30:06,573 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n", - "2021-09-23 13:30:06,621 - root - INFO: \n", - "2021-09-23 13:30:06,622 - root - INFO: Loading Raster\n", - "2021-09-23 13:30:06,622 - root - INFO: ------------------------------\n", - "2021-09-23 13:30:06,623 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:30:06,624 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.910918589009, 68.29176938492151, -148.88725686690233, 68.30146371124668)\n", - "bounds in my_crs: (-148.910918589009, 68.29176938492151, -148.88725686690233, 68.30146371124668)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:30:06,663 - root - INFO: ... got raster of shape: (35, 86)\n", - "2021-09-23 13:30:06,672 - root - INFO: ... got raster bounds: (-148.9109606029515, 68.30147673838741, -148.88707171406182, 68.29175451616486)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.910918589009, 68.29176938492151, -148.88725686690233, 68.30146371124668)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment22.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:30:13,043 - root - INFO: \n", - "2021-09-23 13:30:13,044 - root - INFO: Meshing\n", - "2021-09-23 13:30:13,045 - root - INFO: ------------------------------\n", - "2021-09-23 13:30:13,045 - root - INFO: Triangulating...\n", - "2021-09-23 13:30:13,046 - root - INFO: 11 points and 11 facets\n", - "2021-09-23 13:30:13,047 - root - INFO: checking graph consistency\n", - "2021-09-23 13:30:13,047 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:30:13,048 - root - INFO: building graph data structures\n", - "2021-09-23 13:30:13,049 - root - INFO: triangle.build...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment22.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:30:13,560 - root - INFO: ...built: 25109 mesh points and 49729 triangles\n", - "2021-09-23 13:30:13,561 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:30:14,626 - root - INFO: min area = 33.818603515625\n", - "2021-09-23 13:30:14,627 - root - INFO: max area = 199.98837280273438\n", - "2021-09-23 13:30:15,098 - root - INFO: \n", - "2021-09-23 13:30:15,099 - root - INFO: Loading Raster\n", - "2021-09-23 13:30:15,100 - root - INFO: ------------------------------\n", - "2021-09-23 13:30:15,100 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:30:15,101 - root - INFO: Collecting raster\n", - "2021-09-23 13:30:15,147 - root - INFO: ... got raster of shape: (118, 299)\n", - "2021-09-23 13:30:15,156 - root - INFO: ... got raster bounds: (-148.8854050473951, 68.3123100717211, -148.8023494918368, 68.27953229394224)\n", - "2021-09-23 13:30:15,166 - root - INFO: \n", - "2021-09-23 13:30:15,167 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:30:15,167 - root - INFO: ------------------------------\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.88521273906292, 68.27969771246877, -148.8025928025057, 68.31223501391474)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:30:15,377 - root - INFO: \n", - "2021-09-23 13:30:15,377 - root - INFO: Loading Raster\n", - "2021-09-23 13:30:15,378 - root - INFO: ------------------------------\n", - "2021-09-23 13:30:15,378 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:30:15,379 - root - INFO: Collecting raster\n", - "2021-09-23 13:30:15,422 - root - INFO: ... got raster of shape: (118, 299)\n", - "2021-09-23 13:30:15,431 - root - INFO: ... got raster bounds: (-148.8854050473951, 68.3123100717211, -148.8023494918368, 68.27953229394224)\n", - "2021-09-23 13:30:15,558 - root - INFO: \n", - "2021-09-23 13:30:15,559 - root - INFO: Loading Raster\n", - "2021-09-23 13:30:15,559 - root - INFO: ------------------------------\n", - "2021-09-23 13:30:15,560 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:30:15,561 - root - INFO: Collecting raster\n", - "2021-09-23 13:30:15,604 - root - INFO: ... got raster of shape: (118, 299)\n", - "2021-09-23 13:30:15,612 - root - INFO: ... got raster bounds: (-148.8854050473951, 68.3123100717211, -148.8023494918368, 68.27953229394224)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.88521273906292, 68.27969771246877, -148.8025928025057, 68.31223501391474)\n", - "bounds in my_crs: (-148.88521273906292, 68.27969771246877, -148.8025928025057, 68.31223501391474)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment23.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment23.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:31:12,622 - root - INFO: \n", - "2021-09-23 13:31:12,623 - root - INFO: Meshing\n", - "2021-09-23 13:31:12,623 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:12,624 - root - INFO: Triangulating...\n", - "2021-09-23 13:31:12,625 - root - INFO: 12 points and 12 facets\n", - "2021-09-23 13:31:12,625 - root - INFO: checking graph consistency\n", - "2021-09-23 13:31:12,626 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:31:12,627 - root - INFO: building graph data structures\n", - "2021-09-23 13:31:12,627 - root - INFO: triangle.build...\n", - "2021-09-23 13:31:12,810 - root - INFO: ...built: 8381 mesh points and 16425 triangles\n", - "2021-09-23 13:31:12,812 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:31:13,170 - root - INFO: min area = 57.891387939453125\n", - "2021-09-23 13:31:13,170 - root - INFO: max area = 199.97000122070312\n", - "2021-09-23 13:31:13,346 - root - INFO: \n", - "2021-09-23 13:31:13,347 - root - INFO: Loading Raster\n", - "2021-09-23 13:31:13,347 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:13,348 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:31:13,348 - root - INFO: Collecting raster\n", - "2021-09-23 13:31:13,396 - root - INFO: ... got raster of shape: (69, 198)\n", - "2021-09-23 13:31:13,404 - root - INFO: ... got raster bounds: (-148.89068282517306, 68.31536562727676, -148.83568282517123, 68.29619896060946)\n", - "2021-09-23 13:31:13,414 - root - INFO: \n", - "2021-09-23 13:31:13,415 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:31:13,415 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:13,511 - root - INFO: \n", - "2021-09-23 13:31:13,512 - root - INFO: Loading Raster\n", - "2021-09-23 13:31:13,512 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:13,513 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:31:13,513 - root - INFO: Collecting raster\n", - "2021-09-23 13:31:13,558 - root - INFO: ... got raster of shape: (69, 198)\n", - "2021-09-23 13:31:13,566 - root - INFO: ... got raster bounds: (-148.89068282517306, 68.31536562727676, -148.83568282517123, 68.29619896060946)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.89050828534556, 68.29630970675676, -148.83569652200882, 68.31529633597262)\n", - "bounds in my_crs: (-148.89050828534556, 68.29630970675676, -148.83569652200882, 68.31529633597262)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:31:13,634 - root - INFO: \n", - "2021-09-23 13:31:13,635 - root - INFO: Loading Raster\n", - "2021-09-23 13:31:13,635 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:13,635 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:31:13,636 - root - INFO: Collecting raster\n", - "2021-09-23 13:31:13,680 - root - INFO: ... got raster of shape: (69, 198)\n", - "2021-09-23 13:31:13,689 - root - INFO: ... got raster bounds: (-148.89068282517306, 68.31536562727676, -148.83568282517123, 68.29619896060946)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.89050828534556, 68.29630970675676, -148.83569652200882, 68.31529633597262)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment24.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment24.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:31:32,748 - root - INFO: \n", - "2021-09-23 13:31:32,749 - root - INFO: Meshing\n", - "2021-09-23 13:31:32,749 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:32,750 - root - INFO: Triangulating...\n", - "2021-09-23 13:31:32,751 - root - INFO: 14 points and 14 facets\n", - "2021-09-23 13:31:32,751 - root - INFO: checking graph consistency\n", - "2021-09-23 13:31:32,752 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:31:32,752 - root - INFO: building graph data structures\n", - "2021-09-23 13:31:32,753 - root - INFO: triangle.build...\n", - "2021-09-23 13:31:33,082 - root - INFO: ...built: 17656 mesh points and 34733 triangles\n", - "2021-09-23 13:31:33,083 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:31:33,812 - root - INFO: min area = 45.799346923828125\n", - "2021-09-23 13:31:33,813 - root - INFO: max area = 199.99880981445312\n", - "2021-09-23 13:31:34,144 - root - INFO: \n", - "2021-09-23 13:31:34,145 - root - INFO: Loading Raster\n", - "2021-09-23 13:31:34,146 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:34,146 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:31:34,147 - root - INFO: Collecting raster\n", - "2021-09-23 13:31:34,194 - root - INFO: ... got raster of shape: (122, 323)\n", - "2021-09-23 13:31:34,204 - root - INFO: ... got raster bounds: (-149.20234949185007, 68.26036562727494, -149.11262726962488, 68.22647673838492)\n", - "2021-09-23 13:31:34,214 - root - INFO: \n", - "2021-09-23 13:31:34,215 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:31:34,215 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:34,373 - root - INFO: \n", - "2021-09-23 13:31:34,374 - root - INFO: Loading Raster\n", - "2021-09-23 13:31:34,374 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:34,375 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:31:34,376 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.2023114423899, 68.22649059997109, -149.11282179624425, 68.26026451666776)\n", - "bounds in my_crs: (-149.2023114423899, 68.22649059997109, -149.11282179624425, 68.26026451666776)" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:31:34,429 - root - INFO: ... got raster of shape: (122, 323)\n", - "2021-09-23 13:31:34,439 - root - INFO: ... got raster bounds: (-149.20234949185007, 68.26036562727494, -149.11262726962488, 68.22647673838492)\n", - "2021-09-23 13:31:34,544 - root - INFO: \n", - "2021-09-23 13:31:34,545 - root - INFO: Loading Raster\n", - "2021-09-23 13:31:34,546 - root - INFO: ------------------------------\n", - "2021-09-23 13:31:34,546 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:31:34,547 - root - INFO: Collecting raster\n", - "2021-09-23 13:31:34,591 - root - INFO: ... got raster of shape: (122, 323)\n", - "2021-09-23 13:31:34,601 - root - INFO: ... got raster bounds: (-149.20234949185007, 68.26036562727494, -149.11262726962488, 68.22647673838492)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "bounds in my_crs: (-149.2023114423899, 68.22649059997109, -149.11282179624425, 68.26026451666776)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment25.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment25.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:32:15,189 - root - INFO: \n", - "2021-09-23 13:32:15,190 - root - INFO: Meshing\n", - "2021-09-23 13:32:15,190 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:15,191 - root - INFO: Triangulating...\n", - "2021-09-23 13:32:15,192 - root - INFO: 16 points and 16 facets\n", - "2021-09-23 13:32:15,193 - root - INFO: checking graph consistency\n", - "2021-09-23 13:32:15,193 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:32:15,194 - root - INFO: building graph data structures\n", - "2021-09-23 13:32:15,194 - root - INFO: triangle.build...\n", - "2021-09-23 13:32:15,416 - root - INFO: ...built: 12325 mesh points and 24185 triangles\n", - "2021-09-23 13:32:15,416 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:32:15,931 - root - INFO: min area = 54.143829345703125\n", - "2021-09-23 13:32:15,932 - root - INFO: max area = 199.97232055664062\n", - "2021-09-23 13:32:16,166 - root - INFO: \n", - "2021-09-23 13:32:16,167 - root - INFO: Loading Raster\n", - "2021-09-23 13:32:16,167 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:16,168 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:32:16,169 - root - INFO: Collecting raster\n", - "2021-09-23 13:32:16,214 - root - INFO: ... got raster of shape: (91, 304)\n", - "2021-09-23 13:32:16,223 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.25425451616363, -149.11846060295838, 68.22897673838501)\n", - "2021-09-23 13:32:16,233 - root - INFO: \n", - "2021-09-23 13:32:16,234 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:32:16,234 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:16,355 - root - INFO: \n", - "2021-09-23 13:32:16,356 - root - INFO: Loading Raster\n", - "2021-09-23 13:32:16,357 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:16,357 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:32:16,358 - root - INFO: Collecting raster\n", - "2021-09-23 13:32:16,398 - root - INFO: ... got raster of shape: (91, 304)\n", - "2021-09-23 13:32:16,406 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.25425451616363, -149.11846060295838, 68.22897673838501)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.2027125613783, 68.22906514462669, -149.11872166444675, 68.25409188894433)\n", - "bounds in my_crs: (-149.2027125613783, 68.22906514462669, -149.11872166444675, 68.25409188894433)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:32:16,487 - root - INFO: \n", - "2021-09-23 13:32:16,488 - root - INFO: Loading Raster\n", - "2021-09-23 13:32:16,489 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:16,489 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:32:16,490 - root - INFO: Collecting raster\n", - "2021-09-23 13:32:16,532 - root - INFO: ... got raster of shape: (91, 304)\n", - "2021-09-23 13:32:16,541 - root - INFO: ... got raster bounds: (-149.20290504740564, 68.25425451616363, -149.11846060295838, 68.22897673838501)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.2027125613783, 68.22906514462669, -149.11872166444675, 68.25409188894433)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment26.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment26.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:32:43,976 - root - INFO: \n", - "2021-09-23 13:32:43,977 - root - INFO: Meshing\n", - "2021-09-23 13:32:43,978 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:43,978 - root - INFO: Triangulating...\n", - "2021-09-23 13:32:43,979 - root - INFO: 15 points and 15 facets\n", - "2021-09-23 13:32:43,980 - root - INFO: checking graph consistency\n", - "2021-09-23 13:32:43,980 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:32:43,981 - root - INFO: building graph data structures\n", - "2021-09-23 13:32:43,982 - root - INFO: triangle.build...\n", - "2021-09-23 13:32:44,317 - root - INFO: ...built: 17860 mesh points and 35224 triangles\n", - "2021-09-23 13:32:44,318 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:32:45,076 - root - INFO: min area = 49.17083740234375\n", - "2021-09-23 13:32:45,077 - root - INFO: max area = 199.99969482421875\n", - "2021-09-23 13:32:45,399 - root - INFO: \n", - "2021-09-23 13:32:45,400 - root - INFO: Loading Raster\n", - "2021-09-23 13:32:45,400 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:45,400 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:32:45,401 - root - INFO: Collecting raster\n", - "2021-09-23 13:32:45,444 - root - INFO: ... got raster of shape: (67, 366)\n", - "2021-09-23 13:32:45,452 - root - INFO: ... got raster bounds: (-149.04318282517812, 68.32619896061045, -148.94151615850808, 68.30758784949873)\n", - "2021-09-23 13:32:45,462 - root - INFO: \n", - "2021-09-23 13:32:45,462 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:32:45,463 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:45,619 - root - INFO: \n", - "2021-09-23 13:32:45,620 - root - INFO: Loading Raster\n", - "2021-09-23 13:32:45,621 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:45,621 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:32:45,622 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.04318244732482, 68.3075879275871, -148.9415163590378, 68.32619886093677)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:32:45,664 - root - INFO: ... got raster of shape: (67, 366)\n", - "2021-09-23 13:32:45,673 - root - INFO: ... got raster bounds: (-149.04318282517812, 68.32619896061045, -148.94151615850808, 68.30758784949873)\n", - "2021-09-23 13:32:45,776 - root - INFO: \n", - "2021-09-23 13:32:45,777 - root - INFO: Loading Raster\n", - "2021-09-23 13:32:45,778 - root - INFO: ------------------------------\n", - "2021-09-23 13:32:45,778 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:32:45,779 - root - INFO: Collecting raster\n", - "2021-09-23 13:32:45,823 - root - INFO: ... got raster of shape: (67, 366)\n", - "2021-09-23 13:32:45,832 - root - INFO: ... got raster bounds: (-149.04318282517812, 68.32619896061045, -148.94151615850808, 68.30758784949873)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.04318244732482, 68.3075879275871, -148.9415163590378, 68.32619886093677)\n", - "bounds in my_crs: (-149.04318244732482, 68.3075879275871, -148.9415163590378, 68.32619886093677)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment27.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment27.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:33:25,933 - root - INFO: \n", - "2021-09-23 13:33:25,934 - root - INFO: Meshing\n", - "2021-09-23 13:33:25,934 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:25,935 - root - INFO: Triangulating...\n", - "2021-09-23 13:33:25,936 - root - INFO: 16 points and 16 facets\n", - "2021-09-23 13:33:25,936 - root - INFO: checking graph consistency\n", - "2021-09-23 13:33:25,937 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:33:25,937 - root - INFO: building graph data structures\n", - "2021-09-23 13:33:25,938 - root - INFO: triangle.build...\n", - "2021-09-23 13:33:26,129 - root - INFO: ...built: 10247 mesh points and 20021 triangles\n", - "2021-09-23 13:33:26,131 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:33:26,559 - root - INFO: min area = 32.547149658203125\n", - "2021-09-23 13:33:26,560 - root - INFO: max area = 199.9788818359375\n", - "2021-09-23 13:33:26,759 - root - INFO: \n", - "2021-09-23 13:33:26,760 - root - INFO: Loading Raster\n", - "2021-09-23 13:33:26,761 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:26,761 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:33:26,762 - root - INFO: Collecting raster\n", - "2021-09-23 13:33:26,806 - root - INFO: ... got raster of shape: (54, 366)\n", - "2021-09-23 13:33:26,816 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94179393628585, 68.29786562727618)\n", - "2021-09-23 13:33:26,826 - root - INFO: \n", - "2021-09-23 13:33:26,826 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:33:26,827 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:26,932 - root - INFO: \n", - "2021-09-23 13:33:26,933 - root - INFO: Loading Raster\n", - "2021-09-23 13:33:26,934 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:26,934 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:33:26,935 - root - INFO: Collecting raster\n", - "2021-09-23 13:33:26,976 - root - INFO: ... got raster of shape: (54, 366)\n", - "2021-09-23 13:33:26,984 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94179393628585, 68.29786562727618)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.04326109267967, 68.29809678948162, -148.9420293378915, 68.31282624167491)\n", - "bounds in my_crs: (-149.04326109267967, 68.29809678948162, -148.9420293378915, 68.31282624167491)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:33:27,060 - root - INFO: \n", - "2021-09-23 13:33:27,061 - root - INFO: Loading Raster\n", - "2021-09-23 13:33:27,061 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:27,062 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:33:27,063 - root - INFO: Collecting raster\n", - "2021-09-23 13:33:27,105 - root - INFO: ... got raster of shape: (54, 366)\n", - "2021-09-23 13:33:27,115 - root - INFO: ... got raster bounds: (-149.0434606029559, 68.31286562727668, -148.94179393628585, 68.29786562727618)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.04326109267967, 68.29809678948162, -148.9420293378915, 68.31282624167491)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment28.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment28.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:33:49,630 - root - INFO: \n", - "2021-09-23 13:33:49,631 - root - INFO: Meshing\n", - "2021-09-23 13:33:49,632 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:49,632 - root - INFO: Triangulating...\n", - "2021-09-23 13:33:49,633 - root - INFO: 10 points and 10 facets\n", - "2021-09-23 13:33:49,634 - root - INFO: checking graph consistency\n", - "2021-09-23 13:33:49,634 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:33:49,635 - root - INFO: building graph data structures\n", - "2021-09-23 13:33:49,635 - root - INFO: triangle.build...\n", - "2021-09-23 13:33:49,862 - root - INFO: ...built: 11915 mesh points and 23383 triangles\n", - "2021-09-23 13:33:49,863 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:33:50,360 - root - INFO: min area = 23.0093994140625\n", - "2021-09-23 13:33:50,361 - root - INFO: max area = 199.97549438476562\n", - "2021-09-23 13:33:50,590 - root - INFO: \n", - "2021-09-23 13:33:50,591 - root - INFO: Loading Raster\n", - "2021-09-23 13:33:50,592 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:50,592 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:33:50,593 - root - INFO: Collecting raster\n", - "2021-09-23 13:33:50,638 - root - INFO: ... got raster of shape: (112, 205)\n", - "2021-09-23 13:33:50,647 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.8848494918395, 68.29258784949823)\n", - "2021-09-23 13:33:50,656 - root - INFO: \n", - "2021-09-23 13:33:50,657 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:33:50,658 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:50,778 - root - INFO: \n", - "2021-09-23 13:33:50,779 - root - INFO: Loading Raster\n", - "2021-09-23 13:33:50,779 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:50,780 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:33:50,780 - root - INFO: Collecting raster\n", - "2021-09-23 13:33:50,823 - root - INFO: ... got raster of shape: (112, 205)\n", - "2021-09-23 13:33:50,833 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.8848494918395, 68.29258784949823)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.94155418719984, 68.29263214767145, -148.8849378668285, 68.32350695237726)\n", - "bounds in my_crs: (-148.94155418719984, 68.29263214767145, -148.8849378668285, 68.32350695237726)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:33:50,928 - root - INFO: \n", - "2021-09-23 13:33:50,929 - root - INFO: Loading Raster\n", - "2021-09-23 13:33:50,929 - root - INFO: ------------------------------\n", - "2021-09-23 13:33:50,930 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:33:50,930 - root - INFO: Collecting raster\n", - "2021-09-23 13:33:50,973 - root - INFO: ... got raster of shape: (112, 205)\n", - "2021-09-23 13:33:50,982 - root - INFO: ... got raster bounds: (-148.94179393628585, 68.32369896061037, -148.8848494918395, 68.29258784949823)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.94155418719984, 68.29263214767145, -148.8849378668285, 68.32350695237726)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment29.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment29.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:34:17,858 - root - INFO: \n", - "2021-09-23 13:34:17,859 - root - INFO: Meshing\n", - "2021-09-23 13:34:17,860 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:17,860 - root - INFO: Triangulating...\n", - "2021-09-23 13:34:17,861 - root - INFO: 8 points and 8 facets\n", - "2021-09-23 13:34:17,862 - root - INFO: checking graph consistency\n", - "2021-09-23 13:34:17,862 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:34:17,863 - root - INFO: building graph data structures\n", - "2021-09-23 13:34:17,863 - root - INFO: triangle.build...\n", - "2021-09-23 13:34:17,967 - root - INFO: ...built: 5451 mesh points and 10614 triangles\n", - "2021-09-23 13:34:17,969 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:34:18,210 - root - INFO: min area = 62.992156982421875\n", - "2021-09-23 13:34:18,211 - root - INFO: max area = 199.96957397460938\n", - "2021-09-23 13:34:18,339 - root - INFO: \n", - "2021-09-23 13:34:18,340 - root - INFO: Loading Raster\n", - "2021-09-23 13:34:18,340 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:18,341 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:34:18,342 - root - INFO: Collecting raster\n", - "2021-09-23 13:34:18,383 - root - INFO: ... got raster of shape: (49, 194)\n", - "2021-09-23 13:34:18,392 - root - INFO: ... got raster bounds: (-148.9431828251748, 68.30953229394324, -148.88929393628413, 68.29592118283168)\n", - "2021-09-23 13:34:18,401 - root - INFO: \n", - "2021-09-23 13:34:18,402 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:34:18,402 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:18,479 - root - INFO: \n", - "2021-09-23 13:34:18,480 - root - INFO: Loading Raster\n", - "2021-09-23 13:34:18,481 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:18,481 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:34:18,482 - root - INFO: Collecting raster\n", - "2021-09-23 13:34:18,522 - root - INFO: ... got raster of shape: (49, 194)\n", - "2021-09-23 13:34:18,531 - root - INFO: ... got raster bounds: (-148.9431828251748, 68.30953229394324, -148.88929393628413, 68.29592118283168)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.9429899607772, 68.29616867587684, -148.88945611412026, 68.3092619420527)\n", - "bounds in my_crs: (-148.9429899607772, 68.29616867587684, -148.88945611412026, 68.3092619420527)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:34:18,590 - root - INFO: \n", - "2021-09-23 13:34:18,591 - root - INFO: Loading Raster\n", - "2021-09-23 13:34:18,591 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:18,592 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:34:18,592 - root - INFO: Collecting raster\n", - "2021-09-23 13:34:18,633 - root - INFO: ... got raster of shape: (49, 194)\n", - "2021-09-23 13:34:18,641 - root - INFO: ... got raster bounds: (-148.9431828251748, 68.30953229394324, -148.88929393628413, 68.29592118283168)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.9429899607772, 68.29616867587684, -148.88945611412026, 68.3092619420527)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment30.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment30.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:34:30,436 - root - INFO: \n", - "2021-09-23 13:34:30,437 - root - INFO: Meshing\n", - "2021-09-23 13:34:30,437 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:30,438 - root - INFO: Triangulating...\n", - "2021-09-23 13:34:30,438 - root - INFO: 11 points and 11 facets\n", - "2021-09-23 13:34:30,439 - root - INFO: checking graph consistency\n", - "2021-09-23 13:34:30,439 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:34:30,440 - root - INFO: building graph data structures\n", - "2021-09-23 13:34:30,441 - root - INFO: triangle.build...\n", - "2021-09-23 13:34:30,735 - root - INFO: ...built: 15583 mesh points and 30785 triangles\n", - "2021-09-23 13:34:30,736 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:34:31,424 - root - INFO: min area = 26.471435546875\n", - "2021-09-23 13:34:31,425 - root - INFO: max area = 199.99542236328125\n", - "2021-09-23 13:34:31,736 - root - INFO: \n", - "2021-09-23 13:34:31,736 - root - INFO: Loading Raster\n", - "2021-09-23 13:34:31,737 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:31,738 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:34:31,739 - root - INFO: Collecting raster\n", - "2021-09-23 13:34:31,782 - root - INFO: ... got raster of shape: (65, 294)\n", - "2021-09-23 13:34:31,791 - root - INFO: ... got raster bounds: (-149.0823494918461, 68.2995322939429, -149.0006828251767, 68.28147673838674)\n", - "2021-09-23 13:34:31,801 - root - INFO: \n", - "2021-09-23 13:34:31,802 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:34:31,802 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:31,949 - root - INFO: \n", - "2021-09-23 13:34:31,950 - root - INFO: Loading Raster\n", - "2021-09-23 13:34:31,950 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:31,951 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:34:31,952 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.0822999104471, 68.28165869208681, -149.000694989483, 68.29927283191988)\n", - "bounds in my_crs: (-149.0822999104471, 68.28165869208681, -149.000694989483, 68.29927283191988)" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:34:31,998 - root - INFO: ... got raster of shape: (65, 294)\n", - "2021-09-23 13:34:32,007 - root - INFO: ... got raster bounds: (-149.0823494918461, 68.2995322939429, -149.0006828251767, 68.28147673838674)\n", - "2021-09-23 13:34:32,108 - root - INFO: \n", - "2021-09-23 13:34:32,109 - root - INFO: Loading Raster\n", - "2021-09-23 13:34:32,109 - root - INFO: ------------------------------\n", - "2021-09-23 13:34:32,109 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:34:32,110 - root - INFO: Collecting raster\n", - "2021-09-23 13:34:32,151 - root - INFO: ... got raster of shape: (65, 294)\n", - "2021-09-23 13:34:32,160 - root - INFO: ... got raster bounds: (-149.0823494918461, 68.2995322939429, -149.0006828251767, 68.28147673838674)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "bounds in my_crs: (-149.0822999104471, 68.28165869208681, -149.000694989483, 68.29927283191988)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment31.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment31.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:35:07,609 - root - INFO: \n", - "2021-09-23 13:35:07,610 - root - INFO: Meshing\n", - "2021-09-23 13:35:07,610 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:07,611 - root - INFO: Triangulating...\n", - "2021-09-23 13:35:07,612 - root - INFO: 11 points and 11 facets\n", - "2021-09-23 13:35:07,612 - root - INFO: checking graph consistency\n", - "2021-09-23 13:35:07,613 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:35:07,613 - root - INFO: building graph data structures\n", - "2021-09-23 13:35:07,614 - root - INFO: triangle.build...\n", - "2021-09-23 13:35:07,844 - root - INFO: ...built: 12043 mesh points and 23643 triangles\n", - "2021-09-23 13:35:07,845 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:35:08,350 - root - INFO: min area = 64.85797119140625\n", - "2021-09-23 13:35:08,351 - root - INFO: max area = 199.99276733398438\n", - "2021-09-23 13:35:08,578 - root - INFO: \n", - "2021-09-23 13:35:08,579 - root - INFO: Loading Raster\n", - "2021-09-23 13:35:08,580 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:08,580 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:35:08,581 - root - INFO: Collecting raster\n", - "2021-09-23 13:35:08,624 - root - INFO: ... got raster of shape: (75, 293)\n", - "2021-09-23 13:35:08,633 - root - INFO: ... got raster bounds: (-149.079849491846, 68.3123100717211, -148.99846060295442, 68.29147673838708)\n", - "2021-09-23 13:35:08,642 - root - INFO: \n", - "2021-09-23 13:35:08,643 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:35:08,643 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:08,763 - root - INFO: \n", - "2021-09-23 13:35:08,764 - root - INFO: Loading Raster\n", - "2021-09-23 13:35:08,764 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:08,765 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:35:08,766 - root - INFO: Collecting raster\n", - "2021-09-23 13:35:08,806 - root - INFO: ... got raster of shape: (75, 293)\n", - "2021-09-23 13:35:08,815 - root - INFO: ... got raster bounds: (-149.079849491846, 68.3123100717211, -148.99846060295442, 68.29147673838708)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.07981036634234, 68.29168072407305, -148.99867185565884, 68.31220554044705)\n", - "bounds in my_crs: (-149.07981036634234, 68.29168072407305, -148.99867185565884, 68.31220554044705)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:35:08,898 - root - INFO: \n", - "2021-09-23 13:35:08,899 - root - INFO: Loading Raster\n", - "2021-09-23 13:35:08,899 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:08,900 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:35:08,901 - root - INFO: Collecting raster\n", - "2021-09-23 13:35:08,940 - root - INFO: ... got raster of shape: (75, 293)\n", - "2021-09-23 13:35:08,948 - root - INFO: ... got raster bounds: (-149.079849491846, 68.3123100717211, -148.99846060295442, 68.29147673838708)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.07981036634234, 68.29168072407305, -148.99867185565884, 68.31220554044705)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment32.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment32.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:35:35,463 - root - INFO: \n", - "2021-09-23 13:35:35,464 - root - INFO: Meshing\n", - "2021-09-23 13:35:35,465 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:35,465 - root - INFO: Triangulating...\n", - "2021-09-23 13:35:35,466 - root - INFO: 18 points and 18 facets\n", - "2021-09-23 13:35:35,466 - root - INFO: checking graph consistency\n", - "2021-09-23 13:35:35,467 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:35:35,468 - root - INFO: building graph data structures\n", - "2021-09-23 13:35:35,468 - root - INFO: triangle.build...\n", - "2021-09-23 13:35:35,764 - root - INFO: ...built: 16988 mesh points and 33461 triangles\n", - "2021-09-23 13:35:35,765 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:35:36,451 - root - INFO: min area = 37.18145751953125\n", - "2021-09-23 13:35:36,452 - root - INFO: max area = 199.98504638671875\n", - "2021-09-23 13:35:36,766 - root - INFO: \n", - "2021-09-23 13:35:36,766 - root - INFO: Loading Raster\n", - "2021-09-23 13:35:36,767 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:36,767 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:35:36,768 - root - INFO: Collecting raster\n", - "2021-09-23 13:35:36,814 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-23 13:35:36,822 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-23 13:35:36,831 - root - INFO: \n", - "2021-09-23 13:35:36,832 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:35:36,833 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:36,987 - root - INFO: \n", - "2021-09-23 13:35:36,987 - root - INFO: Loading Raster\n", - "2021-09-23 13:35:36,988 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:36,989 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:35:36,989 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.0345521774872, 68.27509463587238, -148.9401525596163, 68.29702461236208)\n", - "bounds in my_crs: (-149.0345521774872, 68.27509463587238, -148.9401525596163, 68.29702461236208)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:35:37,029 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-23 13:35:37,039 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n", - "2021-09-23 13:35:37,143 - root - INFO: \n", - "2021-09-23 13:35:37,143 - root - INFO: Loading Raster\n", - "2021-09-23 13:35:37,144 - root - INFO: ------------------------------\n", - "2021-09-23 13:35:37,144 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:35:37,145 - root - INFO: Collecting raster\n", - "2021-09-23 13:35:37,186 - root - INFO: ... got raster of shape: (79, 340)\n", - "2021-09-23 13:35:37,194 - root - INFO: ... got raster bounds: (-149.03457171406671, 68.29703229394282, -148.94012726961913, 68.27508784949765)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.0345521774872, 68.27509463587238, -148.9401525596163, 68.29702461236208)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment33.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment33.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:36:15,458 - root - INFO: \n", - "2021-09-23 13:36:15,459 - root - INFO: Meshing\n", - "2021-09-23 13:36:15,459 - root - INFO: ------------------------------\n", - "2021-09-23 13:36:15,460 - root - INFO: Triangulating...\n", - "2021-09-23 13:36:15,460 - root - INFO: 10 points and 10 facets\n", - "2021-09-23 13:36:15,461 - root - INFO: checking graph consistency\n", - "2021-09-23 13:36:15,461 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:36:15,462 - root - INFO: building graph data structures\n", - "2021-09-23 13:36:15,462 - root - INFO: triangle.build...\n", - "2021-09-23 13:36:15,699 - root - INFO: ...built: 13474 mesh points and 26516 triangles\n", - "2021-09-23 13:36:15,700 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:36:16,255 - root - INFO: min area = 40.51702880859375\n", - "2021-09-23 13:36:16,255 - root - INFO: max area = 199.99880981445312\n", - "2021-09-23 13:36:16,517 - root - INFO: \n", - "2021-09-23 13:36:16,517 - root - INFO: Loading Raster\n", - "2021-09-23 13:36:16,518 - root - INFO: ------------------------------\n", - "2021-09-23 13:36:16,519 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:36:16,519 - root - INFO: Collecting raster\n", - "2021-09-23 13:36:16,564 - root - INFO: ... got raster of shape: (104, 209)\n", - "2021-09-23 13:36:16,573 - root - INFO: ... got raster bounds: (-148.99818282517663, 68.30619896060979, -148.94012726961915, 68.27731007171994)\n", - "2021-09-23 13:36:16,581 - root - INFO: \n", - "2021-09-23 13:36:16,581 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:36:16,582 - root - INFO: ------------------------------\n", - "2021-09-23 13:36:16,710 - root - INFO: \n", - "2021-09-23 13:36:16,711 - root - INFO: Loading Raster\n", - "2021-09-23 13:36:16,712 - root - INFO: ------------------------------\n", - "2021-09-23 13:36:16,713 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:36:16,714 - root - INFO: Collecting raster\n", - "2021-09-23 13:36:16,756 - root - INFO: ... got raster of shape: (104, 209)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.997934749547, 68.27740223437527, -148.94026169165255, 68.30600280906724)\n", - "bounds in my_crs: (-148.997934749547, 68.27740223437527, -148.94026169165255, 68.30600280906724)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:36:16,764 - root - INFO: ... got raster bounds: (-148.99818282517663, 68.30619896060979, -148.94012726961915, 68.27731007171994)\n", - "2021-09-23 13:36:16,849 - root - INFO: \n", - "2021-09-23 13:36:16,849 - root - INFO: Loading Raster\n", - "2021-09-23 13:36:16,850 - root - INFO: ------------------------------\n", - "2021-09-23 13:36:16,850 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:36:16,851 - root - INFO: Collecting raster\n", - "2021-09-23 13:36:16,895 - root - INFO: ... got raster of shape: (104, 209)\n", - "2021-09-23 13:36:16,903 - root - INFO: ... got raster bounds: (-148.99818282517663, 68.30619896060979, -148.94012726961915, 68.27731007171994)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-148.997934749547, 68.27740223437527, -148.94026169165255, 68.30600280906724)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment34.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment34.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:36:47,298 - root - INFO: \n", - "2021-09-23 13:36:47,299 - root - INFO: Meshing\n", - "2021-09-23 13:36:47,299 - root - INFO: ------------------------------\n", - "2021-09-23 13:36:47,300 - root - INFO: Triangulating...\n", - "2021-09-23 13:36:47,300 - root - INFO: 18 points and 18 facets\n", - "2021-09-23 13:36:47,301 - root - INFO: checking graph consistency\n", - "2021-09-23 13:36:47,301 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:36:47,302 - root - INFO: building graph data structures\n", - "2021-09-23 13:36:47,303 - root - INFO: triangle.build...\n", - "2021-09-23 13:36:47,734 - root - INFO: ...built: 22599 mesh points and 44577 triangles\n", - "2021-09-23 13:36:47,735 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:36:48,697 - root - INFO: min area = 38.10565185546875\n", - "2021-09-23 13:36:48,698 - root - INFO: max area = 199.99783325195312\n", - "2021-09-23 13:36:49,119 - root - INFO: \n", - "2021-09-23 13:36:49,120 - root - INFO: Loading Raster\n", - "2021-09-23 13:36:49,120 - root - INFO: ------------------------------\n", - "2021-09-23 13:36:49,121 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:36:49,121 - root - INFO: Collecting raster\n", - "2021-09-23 13:36:49,167 - root - INFO: ... got raster of shape: (130, 307)\n", - "2021-09-23 13:36:49,175 - root - INFO: ... got raster bounds: (-149.21540504740605, 68.20425451616197, -149.13012726962543, 68.16814340504966)\n", - "2021-09-23 13:36:49,185 - root - INFO: \n", - "2021-09-23 13:36:49,186 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:36:49,186 - root - INFO: ------------------------------\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21528825036145, 68.16836076034137, -149.1302441086783, 68.20423048506441)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:36:49,379 - root - INFO: \n", - "2021-09-23 13:36:49,380 - root - INFO: Loading Raster\n", - "2021-09-23 13:36:49,380 - root - INFO: ------------------------------\n", - "2021-09-23 13:36:49,381 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:36:49,381 - root - INFO: Collecting raster\n", - "2021-09-23 13:36:49,426 - root - INFO: ... got raster of shape: (130, 307)\n", - "2021-09-23 13:36:49,435 - root - INFO: ... got raster bounds: (-149.21540504740605, 68.20425451616197, -149.13012726962543, 68.16814340504966)\n", - "2021-09-23 13:36:49,553 - root - INFO: \n", - "2021-09-23 13:36:49,554 - root - INFO: Loading Raster\n", - "2021-09-23 13:36:49,554 - root - INFO: ------------------------------\n", - "2021-09-23 13:36:49,555 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:36:49,556 - root - INFO: Collecting raster\n", - "2021-09-23 13:36:49,600 - root - INFO: ... got raster of shape: (130, 307)\n", - "2021-09-23 13:36:49,608 - root - INFO: ... got raster bounds: (-149.21540504740605, 68.20425451616197, -149.13012726962543, 68.16814340504966)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21528825036145, 68.16836076034137, -149.1302441086783, 68.20423048506441)\n", - "bounds in my_crs: (-149.21528825036145, 68.16836076034137, -149.1302441086783, 68.20423048506441)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment35.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment35.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:37:40,746 - root - INFO: \n", - "2021-09-23 13:37:40,747 - root - INFO: Meshing\n", - "2021-09-23 13:37:40,748 - root - INFO: ------------------------------\n", - "2021-09-23 13:37:40,748 - root - INFO: Triangulating...\n", - "2021-09-23 13:37:40,749 - root - INFO: 10 points and 10 facets\n", - "2021-09-23 13:37:40,749 - root - INFO: checking graph consistency\n", - "2021-09-23 13:37:40,750 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:37:40,751 - root - INFO: building graph data structures\n", - "2021-09-23 13:37:40,751 - root - INFO: triangle.build...\n", - "2021-09-23 13:37:40,987 - root - INFO: ...built: 11036 mesh points and 21668 triangles\n", - "2021-09-23 13:37:40,989 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:37:41,462 - root - INFO: min area = 63.3148193359375\n", - "2021-09-23 13:37:41,463 - root - INFO: max area = 199.98712158203125\n", - "2021-09-23 13:37:41,677 - root - INFO: \n", - "2021-09-23 13:37:41,678 - root - INFO: Loading Raster\n", - "2021-09-23 13:37:41,678 - root - INFO: ------------------------------\n", - "2021-09-23 13:37:41,679 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:37:41,680 - root - INFO: Collecting raster\n", - "2021-09-23 13:37:41,724 - root - INFO: ... got raster of shape: (113, 172)\n", - "2021-09-23 13:37:41,733 - root - INFO: ... got raster bounds: (-149.21123838073925, 68.20842118282877, -149.16346060295987, 68.17703229393884)\n", - "2021-09-23 13:37:41,742 - root - INFO: \n", - "2021-09-23 13:37:41,743 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:37:41,743 - root - INFO: ------------------------------\n", - "2021-09-23 13:37:41,857 - root - INFO: \n", - "2021-09-23 13:37:41,858 - root - INFO: Loading Raster\n", - "2021-09-23 13:37:41,859 - root - INFO: ------------------------------\n", - "2021-09-23 13:37:41,859 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:37:41,860 - root - INFO: Collecting raster\n", - "2021-09-23 13:37:41,905 - root - INFO: ... got raster of shape: (113, 172)\n", - "2021-09-23 13:37:41,915 - root - INFO: ... got raster bounds: (-149.21123838073925, 68.20842118282877, -149.16346060295987, 68.17703229393884)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21111680470045, 68.17708998948528, -149.16368676757662, 68.20835557380545)\n", - "bounds in my_crs: (-149.21111680470045, 68.17708998948528, -149.16368676757662, 68.20835557380545)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:37:41,990 - root - INFO: \n", - "2021-09-23 13:37:41,991 - root - INFO: Loading Raster\n", - "2021-09-23 13:37:41,992 - root - INFO: ------------------------------\n", - "2021-09-23 13:37:41,992 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:37:41,993 - root - INFO: Collecting raster\n", - "2021-09-23 13:37:42,037 - root - INFO: ... got raster of shape: (113, 172)\n", - "2021-09-23 13:37:42,046 - root - INFO: ... got raster bounds: (-149.21123838073925, 68.20842118282877, -149.16346060295987, 68.17703229393884)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21111680470045, 68.17708998948528, -149.16368676757662, 68.20835557380545)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment36.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment36.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:38:06,530 - root - INFO: \n", - "2021-09-23 13:38:06,531 - root - INFO: Meshing\n", - "2021-09-23 13:38:06,531 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:06,532 - root - INFO: Triangulating...\n", - "2021-09-23 13:38:06,533 - root - INFO: 14 points and 14 facets\n", - "2021-09-23 13:38:06,533 - root - INFO: checking graph consistency\n", - "2021-09-23 13:38:06,534 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:38:06,534 - root - INFO: building graph data structures\n", - "2021-09-23 13:38:06,535 - root - INFO: triangle.build...\n", - "2021-09-23 13:38:06,823 - root - INFO: ...built: 15671 mesh points and 30843 triangles\n", - "2021-09-23 13:38:06,824 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:38:07,490 - root - INFO: min area = 40.692535400390625\n", - "2021-09-23 13:38:07,491 - root - INFO: max area = 199.9931640625\n", - "2021-09-23 13:38:07,787 - root - INFO: \n", - "2021-09-23 13:38:07,788 - root - INFO: Loading Raster\n", - "2021-09-23 13:38:07,788 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:07,789 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:38:07,790 - root - INFO: Collecting raster\n", - "2021-09-23 13:38:07,834 - root - INFO: ... got raster of shape: (74, 332)\n", - "2021-09-23 13:38:07,843 - root - INFO: ... got raster bounds: (-149.21068282518368, 68.27925451616446, -149.1184606029584, 68.25869896060821)\n", - "2021-09-23 13:38:07,852 - root - INFO: \n", - "2021-09-23 13:38:07,853 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:38:07,853 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:07,998 - root - INFO: \n", - "2021-09-23 13:38:07,999 - root - INFO: Loading Raster\n", - "2021-09-23 13:38:07,999 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:08,000 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:38:08,001 - root - INFO: Collecting raster\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21058383854665, 68.25875188874285, -149.11858107162087, 68.27921603669684)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:38:08,045 - root - INFO: ... got raster of shape: (74, 332)\n", - "2021-09-23 13:38:08,054 - root - INFO: ... got raster bounds: (-149.21068282518368, 68.27925451616446, -149.1184606029584, 68.25869896060821)\n", - "2021-09-23 13:38:08,149 - root - INFO: \n", - "2021-09-23 13:38:08,150 - root - INFO: Loading Raster\n", - "2021-09-23 13:38:08,150 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:08,151 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:38:08,152 - root - INFO: Collecting raster\n", - "2021-09-23 13:38:08,196 - root - INFO: ... got raster of shape: (74, 332)\n", - "2021-09-23 13:38:08,206 - root - INFO: ... got raster bounds: (-149.21068282518368, 68.27925451616446, -149.1184606029584, 68.25869896060821)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.21058383854665, 68.25875188874285, -149.11858107162087, 68.27921603669684)\n", - "bounds in my_crs: (-149.21058383854665, 68.25875188874285, -149.11858107162087, 68.27921603669684)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment37.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment37.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:38:44,210 - root - INFO: \n", - "2021-09-23 13:38:44,211 - root - INFO: Meshing\n", - "2021-09-23 13:38:44,212 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:44,213 - root - INFO: Triangulating...\n", - "2021-09-23 13:38:44,213 - root - INFO: 15 points and 15 facets\n", - "2021-09-23 13:38:44,214 - root - INFO: checking graph consistency\n", - "2021-09-23 13:38:44,214 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:38:44,215 - root - INFO: building graph data structures\n", - "2021-09-23 13:38:44,215 - root - INFO: triangle.build...\n", - "2021-09-23 13:38:44,440 - root - INFO: ...built: 12033 mesh points and 23616 triangles\n", - "2021-09-23 13:38:44,441 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:38:44,950 - root - INFO: min area = 36.9022216796875\n", - "2021-09-23 13:38:44,951 - root - INFO: max area = 199.97848510742188\n", - "2021-09-23 13:38:45,181 - root - INFO: \n", - "2021-09-23 13:38:45,182 - root - INFO: Loading Raster\n", - "2021-09-23 13:38:45,183 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:45,184 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:38:45,184 - root - INFO: Collecting raster\n", - "2021-09-23 13:38:45,227 - root - INFO: ... got raster of shape: (60, 295)\n", - "2021-09-23 13:38:45,236 - root - INFO: ... got raster bounds: (-149.20929393629473, 68.26953229394191, -149.12734949184755, 68.25286562727469)\n", - "2021-09-23 13:38:45,246 - root - INFO: \n", - "2021-09-23 13:38:45,246 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:38:45,247 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:45,368 - root - INFO: \n", - "2021-09-23 13:38:45,368 - root - INFO: Loading Raster\n", - "2021-09-23 13:38:45,369 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:45,370 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:38:45,371 - root - INFO: Collecting raster\n", - "2021-09-23 13:38:45,413 - root - INFO: ... got raster of shape: (60, 295)\n", - "2021-09-23 13:38:45,421 - root - INFO: ... got raster bounds: (-149.20929393629473, 68.26953229394191, -149.12734949184755, 68.25286562727469)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.2090664982718, 68.2531278493561, -149.12758580017228, 68.26926522876465)\n", - "bounds in my_crs: (-149.2090664982718, 68.2531278493561, -149.12758580017228, 68.26926522876465)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:38:45,505 - root - INFO: \n", - "2021-09-23 13:38:45,505 - root - INFO: Loading Raster\n", - "2021-09-23 13:38:45,506 - root - INFO: ------------------------------\n", - "2021-09-23 13:38:45,506 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:38:45,507 - root - INFO: Collecting raster\n", - "2021-09-23 13:38:45,547 - root - INFO: ... got raster of shape: (60, 295)\n", - "2021-09-23 13:38:45,556 - root - INFO: ... got raster bounds: (-149.20929393629473, 68.26953229394191, -149.12734949184755, 68.25286562727469)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.2090664982718, 68.2531278493561, -149.12758580017228, 68.26926522876465)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment38.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment38.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:39:13,121 - root - INFO: \n", - "2021-09-23 13:39:13,122 - root - INFO: Meshing\n", - "2021-09-23 13:39:13,122 - root - INFO: ------------------------------\n", - "2021-09-23 13:39:13,123 - root - INFO: Triangulating...\n", - "2021-09-23 13:39:13,124 - root - INFO: 13 points and 13 facets\n", - "2021-09-23 13:39:13,124 - root - INFO: checking graph consistency\n", - "2021-09-23 13:39:13,125 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:39:13,125 - root - INFO: building graph data structures\n", - "2021-09-23 13:39:13,126 - root - INFO: triangle.build...\n", - "2021-09-23 13:39:13,620 - root - INFO: ...built: 24931 mesh points and 49387 triangles\n", - "2021-09-23 13:39:13,621 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:39:14,693 - root - INFO: min area = 26.36248779296875\n", - "2021-09-23 13:39:14,694 - root - INFO: max area = 199.99612426757812\n", - "2021-09-23 13:39:15,139 - root - INFO: \n", - "2021-09-23 13:39:15,140 - root - INFO: Loading Raster\n", - "2021-09-23 13:39:15,141 - root - INFO: ------------------------------\n", - "2021-09-23 13:39:15,141 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:39:15,142 - root - INFO: Collecting raster\n", - "2021-09-23 13:39:15,186 - root - INFO: ... got raster of shape: (103, 224)\n", - "2021-09-23 13:39:15,195 - root - INFO: ... got raster bounds: (-149.12734949184758, 68.28703229394249, -149.0651272696233, 68.25842118283043)\n", - "2021-09-23 13:39:15,204 - root - INFO: \n", - "2021-09-23 13:39:15,204 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:39:15,205 - root - INFO: ------------------------------\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12712334902193, 68.25851002377757, -149.06535466536658, 68.28694002551227)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:39:15,414 - root - INFO: \n", - "2021-09-23 13:39:15,415 - root - INFO: Loading Raster\n", - "2021-09-23 13:39:15,415 - root - INFO: ------------------------------\n", - "2021-09-23 13:39:15,415 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:39:15,416 - root - INFO: Collecting raster\n", - "2021-09-23 13:39:15,458 - root - INFO: ... got raster of shape: (103, 224)\n", - "2021-09-23 13:39:15,466 - root - INFO: ... got raster bounds: (-149.12734949184758, 68.28703229394249, -149.0651272696233, 68.25842118283043)\n", - "2021-09-23 13:39:15,591 - root - INFO: \n", - "2021-09-23 13:39:15,592 - root - INFO: Loading Raster\n", - "2021-09-23 13:39:15,593 - root - INFO: ------------------------------\n", - "2021-09-23 13:39:15,593 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:39:15,594 - root - INFO: Collecting raster\n", - "2021-09-23 13:39:15,637 - root - INFO: ... got raster of shape: (103, 224)\n", - "2021-09-23 13:39:15,646 - root - INFO: ... got raster bounds: (-149.12734949184758, 68.28703229394249, -149.0651272696233, 68.25842118283043)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.12712334902193, 68.25851002377757, -149.06535466536658, 68.28694002551227)\n", - "bounds in my_crs: (-149.12712334902193, 68.25851002377757, -149.06535466536658, 68.28694002551227)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment39.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment39.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:40:15,248 - root - INFO: \n", - "2021-09-23 13:40:15,249 - root - INFO: Meshing\n", - "2021-09-23 13:40:15,250 - root - INFO: ------------------------------\n", - "2021-09-23 13:40:15,250 - root - INFO: Triangulating...\n", - "2021-09-23 13:40:15,251 - root - INFO: 8 points and 8 facets\n", - "2021-09-23 13:40:15,251 - root - INFO: checking graph consistency\n", - "2021-09-23 13:40:15,252 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:40:15,253 - root - INFO: building graph data structures\n", - "2021-09-23 13:40:15,253 - root - INFO: triangle.build...\n", - "2021-09-23 13:40:15,421 - root - INFO: ...built: 8334 mesh points and 16395 triangles\n", - "2021-09-23 13:40:15,424 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:40:15,780 - root - INFO: min area = 45.765380859375\n", - "2021-09-23 13:40:15,781 - root - INFO: max area = 199.96609497070312\n", - "2021-09-23 13:40:15,952 - root - INFO: \n", - "2021-09-23 13:40:15,953 - root - INFO: Loading Raster\n", - "2021-09-23 13:40:15,953 - root - INFO: ------------------------------\n", - "2021-09-23 13:40:15,954 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:40:15,955 - root - INFO: Collecting raster\n", - "2021-09-23 13:40:16,002 - root - INFO: ... got raster of shape: (52, 187)\n", - "2021-09-23 13:40:16,010 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26231007171944, -149.07984949184598, 68.24786562727452)\n", - "2021-09-23 13:40:16,020 - root - INFO: \n", - "2021-09-23 13:40:16,021 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:40:16,021 - root - INFO: ------------------------------\n", - "2021-09-23 13:40:16,117 - root - INFO: \n", - "2021-09-23 13:40:16,117 - root - INFO: Loading Raster\n", - "2021-09-23 13:40:16,118 - root - INFO: ------------------------------\n", - "2021-09-23 13:40:16,119 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:40:16,120 - root - INFO: Collecting raster\n", - "2021-09-23 13:40:16,170 - root - INFO: ... got raster of shape: (52, 187)\n", - "2021-09-23 13:40:16,179 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26231007171944, -149.07984949184598, 68.24786562727452)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.13165740523283, 68.24808995964166, -149.08004542148709, 68.26204188665757)\n", - "bounds in my_crs: (-149.13165740523283, 68.24808995964166, -149.08004542148709, 68.26204188665757)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:40:16,245 - root - INFO: \n", - "2021-09-23 13:40:16,246 - root - INFO: Loading Raster\n", - "2021-09-23 13:40:16,246 - root - INFO: ------------------------------\n", - "2021-09-23 13:40:16,247 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:40:16,248 - root - INFO: Collecting raster\n", - "2021-09-23 13:40:16,293 - root - INFO: ... got raster of shape: (52, 187)\n", - "2021-09-23 13:40:16,301 - root - INFO: ... got raster bounds: (-149.13179393629215, 68.26231007171944, -149.07984949184598, 68.24786562727452)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.13165740523283, 68.24808995964166, -149.08004542148709, 68.26204188665757)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment40.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment40.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:40:35,244 - root - INFO: \n", - "2021-09-23 13:40:35,245 - root - INFO: Meshing\n", - "2021-09-23 13:40:35,246 - root - INFO: ------------------------------\n", - "2021-09-23 13:40:35,247 - root - INFO: Triangulating...\n", - "2021-09-23 13:40:35,247 - root - INFO: 11 points and 11 facets\n", - "2021-09-23 13:40:35,247 - root - INFO: checking graph consistency\n", - "2021-09-23 13:40:35,248 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:40:35,249 - root - INFO: building graph data structures\n", - "2021-09-23 13:40:35,249 - root - INFO: triangle.build...\n", - "2021-09-23 13:40:35,685 - root - INFO: ...built: 26111 mesh points and 51680 triangles\n", - "2021-09-23 13:40:35,686 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:40:36,742 - root - INFO: min area = 43.3514404296875\n", - "2021-09-23 13:40:36,743 - root - INFO: max area = 199.99447631835938\n", - "2021-09-23 13:40:37,204 - root - INFO: \n", - "2021-09-23 13:40:37,205 - root - INFO: Loading Raster\n", - "2021-09-23 13:40:37,205 - root - INFO: ------------------------------\n", - "2021-09-23 13:40:37,206 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:40:37,207 - root - INFO: Collecting raster\n", - "2021-09-23 13:40:37,253 - root - INFO: ... got raster of shape: (143, 252)\n", - "2021-09-23 13:40:37,262 - root - INFO: ... got raster bounds: (-149.0792939362904, 68.28703229394249, -149.0092939362881, 68.24731007171894)\n", - "2021-09-23 13:40:37,271 - root - INFO: \n", - "2021-09-23 13:40:37,272 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:40:37,272 - root - INFO: ------------------------------\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.07918774814783, 68.24755074395696, -149.00951023659192, 68.28685749523802)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:40:37,491 - root - INFO: \n", - "2021-09-23 13:40:37,492 - root - INFO: Loading Raster\n", - "2021-09-23 13:40:37,492 - root - INFO: ------------------------------\n", - "2021-09-23 13:40:37,493 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:40:37,493 - root - INFO: Collecting raster\n", - "2021-09-23 13:40:37,536 - root - INFO: ... got raster of shape: (143, 252)\n", - "2021-09-23 13:40:37,545 - root - INFO: ... got raster bounds: (-149.0792939362904, 68.28703229394249, -149.0092939362881, 68.24731007171894)\n", - "2021-09-23 13:40:37,675 - root - INFO: \n", - "2021-09-23 13:40:37,675 - root - INFO: Loading Raster\n", - "2021-09-23 13:40:37,676 - root - INFO: ------------------------------\n", - "2021-09-23 13:40:37,677 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:40:37,678 - root - INFO: Collecting raster\n", - "2021-09-23 13:40:37,719 - root - INFO: ... got raster of shape: (143, 252)\n", - "2021-09-23 13:40:37,728 - root - INFO: ... got raster bounds: (-149.0792939362904, 68.28703229394249, -149.0092939362881, 68.24731007171894)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.07918774814783, 68.24755074395696, -149.00951023659192, 68.28685749523802)\n", - "bounds in my_crs: (-149.07918774814783, 68.24755074395696, -149.00951023659192, 68.28685749523802)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment41.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment41.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:41:37,013 - root - INFO: \n", - "2021-09-23 13:41:37,014 - root - INFO: Meshing\n", - "2021-09-23 13:41:37,014 - root - INFO: ------------------------------\n", - "2021-09-23 13:41:37,015 - root - INFO: Triangulating...\n", - "2021-09-23 13:41:37,016 - root - INFO: 5 points and 5 facets\n", - "2021-09-23 13:41:37,016 - root - INFO: checking graph consistency\n", - "2021-09-23 13:41:37,017 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:41:37,017 - root - INFO: building graph data structures\n", - "2021-09-23 13:41:37,018 - root - INFO: triangle.build...\n", - "2021-09-23 13:41:37,117 - root - INFO: ...built: 4598 mesh points and 8931 triangles\n", - "2021-09-23 13:41:37,120 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:41:37,320 - root - INFO: min area = 31.330963134765625\n", - "2021-09-23 13:41:37,321 - root - INFO: max area = 199.88494873046875\n", - "2021-09-23 13:41:37,434 - root - INFO: \n", - "2021-09-23 13:41:37,435 - root - INFO: Loading Raster\n", - "2021-09-23 13:41:37,436 - root - INFO: ------------------------------\n", - "2021-09-23 13:41:37,436 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:41:37,437 - root - INFO: Collecting raster\n", - "2021-09-23 13:41:37,481 - root - INFO: ... got raster of shape: (41, 187)\n", - "2021-09-23 13:41:37,490 - root - INFO: ... got raster bounds: (-149.08318282517945, 68.25842118283043, -149.03123838073327, 68.24703229394116)\n", - "2021-09-23 13:41:37,499 - root - INFO: \n", - "2021-09-23 13:41:37,499 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:41:37,500 - root - INFO: ------------------------------\n", - "2021-09-23 13:41:37,569 - root - INFO: \n", - "2021-09-23 13:41:37,569 - root - INFO: Loading Raster\n", - "2021-09-23 13:41:37,570 - root - INFO: ------------------------------\n", - "2021-09-23 13:41:37,570 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:41:37,571 - root - INFO: Collecting raster\n", - "2021-09-23 13:41:37,615 - root - INFO: ... got raster of shape: (41, 187)\n", - "2021-09-23 13:41:37,623 - root - INFO: ... got raster bounds: (-149.08318282517945, 68.25842118283043, -149.03123838073327, 68.24703229394116)\n", - "2021-09-23 13:41:37,678 - root - INFO: \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08304453156916, 68.24726363416434, -149.03129198917352, 68.25815882709514)\n", - "bounds in my_crs: (-149.08304453156916, 68.24726363416434, -149.03129198917352, 68.25815882709514)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:41:37,679 - root - INFO: Loading Raster\n", - "2021-09-23 13:41:37,679 - root - INFO: ------------------------------\n", - "2021-09-23 13:41:37,680 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:41:37,680 - root - INFO: Collecting raster\n", - "2021-09-23 13:41:37,724 - root - INFO: ... got raster of shape: (41, 187)\n", - "2021-09-23 13:41:37,732 - root - INFO: ... got raster bounds: (-149.08318282517945, 68.25842118283043, -149.03123838073327, 68.24703229394116)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.08304453156916, 68.24726363416434, -149.03129198917352, 68.25815882709514)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment42.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment42.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:41:47,679 - root - INFO: \n", - "2021-09-23 13:41:47,680 - root - INFO: Meshing\n", - "2021-09-23 13:41:47,680 - root - INFO: ------------------------------\n", - "2021-09-23 13:41:47,681 - root - INFO: Triangulating...\n", - "2021-09-23 13:41:47,682 - root - INFO: 19 points and 19 facets\n", - "2021-09-23 13:41:47,682 - root - INFO: checking graph consistency\n", - "2021-09-23 13:41:47,683 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:41:47,683 - root - INFO: building graph data structures\n", - "2021-09-23 13:41:47,684 - root - INFO: triangle.build...\n", - "2021-09-23 13:41:48,060 - root - INFO: ...built: 21748 mesh points and 42873 triangles\n", - "2021-09-23 13:41:48,060 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:41:48,953 - root - INFO: min area = 33.698883056640625\n", - "2021-09-23 13:41:48,954 - root - INFO: max area = 199.99661254882812\n", - "2021-09-23 13:41:49,351 - root - INFO: \n", - "2021-09-23 13:41:49,352 - root - INFO: Loading Raster\n", - "2021-09-23 13:41:49,352 - root - INFO: ------------------------------\n", - "2021-09-23 13:41:49,353 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:41:49,354 - root - INFO: Collecting raster\n", - "2021-09-23 13:41:49,401 - root - INFO: ... got raster of shape: (119, 408)\n", - "2021-09-23 13:41:49,409 - root - INFO: ... got raster bounds: (-149.23179393629547, 68.25397673838583, -149.11846060295838, 68.22092118282917)\n", - "2021-09-23 13:41:49,419 - root - INFO: \n", - "2021-09-23 13:41:49,419 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:41:49,420 - root - INFO: ------------------------------\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.23159565302103, 68.22111530657942, -149.118589984177, 68.25376279024279)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:41:49,607 - root - INFO: \n", - "2021-09-23 13:41:49,607 - root - INFO: Loading Raster\n", - "2021-09-23 13:41:49,608 - root - INFO: ------------------------------\n", - "2021-09-23 13:41:49,609 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:41:49,609 - root - INFO: Collecting raster\n", - "2021-09-23 13:41:49,652 - root - INFO: ... got raster of shape: (119, 408)\n", - "2021-09-23 13:41:49,661 - root - INFO: ... got raster bounds: (-149.23179393629547, 68.25397673838583, -149.11846060295838, 68.22092118282917)\n", - "2021-09-23 13:41:49,777 - root - INFO: \n", - "2021-09-23 13:41:49,777 - root - INFO: Loading Raster\n", - "2021-09-23 13:41:49,778 - root - INFO: ------------------------------\n", - "2021-09-23 13:41:49,778 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:41:49,779 - root - INFO: Collecting raster\n", - "2021-09-23 13:41:49,823 - root - INFO: ... got raster of shape: (119, 408)\n", - "2021-09-23 13:41:49,832 - root - INFO: ... got raster bounds: (-149.23179393629547, 68.25397673838583, -149.11846060295838, 68.22092118282917)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.23159565302103, 68.22111530657942, -149.118589984177, 68.25376279024279)\n", - "bounds in my_crs: (-149.23159565302103, 68.22111530657942, -149.118589984177, 68.25376279024279)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment43.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment43.exo\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:42:39,129 - root - INFO: \n", - "2021-09-23 13:42:39,130 - root - INFO: Meshing\n", - "2021-09-23 13:42:39,130 - root - INFO: ------------------------------\n", - "2021-09-23 13:42:39,131 - root - INFO: Triangulating...\n", - "2021-09-23 13:42:39,132 - root - INFO: 11 points and 11 facets\n", - "2021-09-23 13:42:39,132 - root - INFO: checking graph consistency\n", - "2021-09-23 13:42:39,132 - root - INFO: tolerance is set to 1\n", - "2021-09-23 13:42:39,133 - root - INFO: building graph data structures\n", - "2021-09-23 13:42:39,133 - root - INFO: triangle.build...\n", - "2021-09-23 13:42:39,336 - root - INFO: ...built: 11453 mesh points and 22492 triangles\n", - "2021-09-23 13:42:39,337 - root - INFO: Plotting triangulation diagnostics\n", - "2021-09-23 13:42:39,811 - root - INFO: min area = 55.202911376953125\n", - "2021-09-23 13:42:39,812 - root - INFO: max area = 199.9888916015625\n", - "2021-09-23 13:42:40,032 - root - INFO: \n", - "2021-09-23 13:42:40,033 - root - INFO: Loading Raster\n", - "2021-09-23 13:42:40,033 - root - INFO: ------------------------------\n", - "2021-09-23 13:42:40,034 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_dem.tif'\n", - "2021-09-23 13:42:40,035 - root - INFO: Collecting raster\n", - "2021-09-23 13:42:40,075 - root - INFO: ... got raster of shape: (72, 308)\n", - "2021-09-23 13:42:40,085 - root - INFO: ... got raster bounds: (-149.23234949185107, 68.24036562727427, -149.14679393629268, 68.22036562727361)\n", - "2021-09-23 13:42:40,094 - root - INFO: \n", - "2021-09-23 13:42:40,095 - root - INFO: Elevating Triangulation to DEM\n", - "2021-09-23 13:42:40,096 - root - INFO: ------------------------------\n", - "2021-09-23 13:42:40,214 - root - INFO: \n", - "2021-09-23 13:42:40,215 - root - INFO: Loading Raster\n", - "2021-09-23 13:42:40,215 - root - INFO: ------------------------------\n", - "2021-09-23 13:42:40,216 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_landcover.tif'\n", - "2021-09-23 13:42:40,217 - root - INFO: Collecting raster\n", - "2021-09-23 13:42:40,256 - root - INFO: ... got raster of shape: (72, 308)\n", - "2021-09-23 13:42:40,265 - root - INFO: ... got raster bounds: (-149.23234949185107, 68.24036562727427, -149.14679393629268, 68.22036562727361)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.23208710974703, 68.2206396935597, -149.1470597859579, 68.24009278991055)\n", - "bounds in my_crs: (-149.23208710974703, 68.2206396935597, -149.1470597859579, 68.24009278991055)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2021-09-23 13:42:40,345 - root - INFO: \n", - "2021-09-23 13:42:40,346 - root - INFO: Loading Raster\n", - "2021-09-23 13:42:40,346 - root - INFO: ------------------------------\n", - "2021-09-23 13:42:40,347 - root - INFO: Loading file: '../huc/190604020404/data_preprocessed-meshing/huc_190604020404_flowpath_lengths.tif'\n", - "2021-09-23 13:42:40,348 - root - INFO: Collecting raster\n", - "2021-09-23 13:42:40,387 - root - INFO: ... got raster of shape: (72, 308)\n", - "2021-09-23 13:42:40,395 - root - INFO: ... got raster bounds: (-149.23234949185107, 68.24036562727427, -149.14679393629268, 68.22036562727361)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "bounds in my_crs: (-149.23208710974703, 68.2206396935597, -149.1470597859579, 68.24009278991055)\n", - "Opening exodus file: ../huc/190604020404/mesh/sag_subcatchment44.exo\n", - "Closing exodus file: ../huc/190604020404/mesh/sag_subcatchment44.exo\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAum0lEQVR4nO3debwU1Z338c+XRUQiIAoOLggxqKOoKLihBtcETSKOcdcEjQbHMYuZxyQSx3XiMxpNjMYlonFLXOMSiU8wKm7RCAiKIiojEUJQIq4IRonA7/mjTkNz6b63+3Lrdl/u9/169aurT9Wp/nV3df+66lSdo4jAzMwsDx1qHYCZma29nGTMzCw3TjJmZpYbJxkzM8uNk4yZmeWmU60DaG0bbbRR9O/fv9Zh2Fpq6tSp70RE71o8t7dty1Nzt+12l2T69+/PlClTah2GraUk/bVWz+1t2/LU3G3bh8vMzCw3TjJmZpYbJxkzM8uNk4yZmeXGScbM2o2LT7pilcfLli3jJydfWaNo2gcnGbOcSdpc0mOSXpE0Q9J3U3kvSQ9Lei3db1BUZ4ykWZJmSvpi7aJfexzY4QgeufFPHNjhCCBLMCM6H83DNzzBl3seW+Po1l7t7hRmsxpYCvyfiHhO0vrAVEkPAycAEyLiIklnAmcCP5S0LXA0sB2wCfCIpK0iYlmN4l/rFBJNwZIPP61RJGs/78mY5Swi5kfEc2l6EfAKsCkwErg5LXYzcGiaHgncERFLImI2MAvYtVWDNmshTjJmrUhSf2AnYBKwcUTMhywRAX3SYpsCfyuqNi+VlVrfaElTJE15++23c4vbrLl8uMwa1f/M/9esenMu+lILR9L2SfoMcA9wekR8KKnsoiXKSo4uGBFjgbEAQ4cO9QiEVne8J2PWCiR1Jkswt0bEvan4LUl90/y+wIJUPg/YvKj6ZsCbrRWrWUtykjHLmbJdll8Br0TEz4pmjQNGpelRwP1F5UdL6iJpADAQmNxa8Zq1JB8uM8vfnsDXgOmSpqWyHwEXAXdJOgmYCxwBEBEzJN0FvEx2ZtppPrPM2ionGbOcRcRTlG5nAdi/TJ0LgQtzC8qslfhwmZmZ5cZJxszMcpNrkpE0R9J0SdMkTUllVXelIWlIWs8sSVekhlRSw+idqXxSugbBzMzqRGvsyewbEYMjYmh6fCZZVxoDgQnpMQ260hgBXC2pY6pzDTCa7CybgWk+wEnA+xHxOeAy4OJWeD1mZlahWhwuq6orjXT9QPeIeCYiArilQZ3Cuu4G9i/s5ZiZWe3lnWQCeEjSVEmjU1m1XWlsmqYblq9SJyKWAguBDRsG4a43zMxqI+9TmPeMiDcl9QEelvRqI8uW60qjsS42Kup+w11vmJnVRq57MhHxZrpfANxH1pNstV1pzEvTDctXqSOpE9ADeC+P12JmZtXLLclI6pbGzkBSN+ALwEtU2ZVGOqS2SNLuqb3l6w3qFNZ1OPBoarcxM7M6kOfhso2B+1I7fCfgtoh4UNKzVN+VxqnATUBXYHy6QdYf1K8lzSLbgzk6x9djZmZVyi3JRMTrwI4lyt+lyq40ImIKMKhE+SekJGVmZvXHV/ybmVlunGTMzCw3TjJmZpYbJxkzM8uNk4yZmeXGScbMzHLjJGNmZrlxkjFrBZJukLRA0ktFZYMlTSyMtyRp16J5JcdWMmtrnGTMWsdNrBwHqeAnwPkRMRg4Jz1uamwlszbFScasFUTEk6zeeWsA3dN0D1Z2/FpybKVWCdSsheXd1b+ZlXc68EdJl5L94RuWyjcFJhYtVzyG0irSOE2jAfr165dboGbN5T0Zs9o5FfheRGwOfI+sw1eocJwkyMZKioihETG0d+/eOYVp1nxOMma1Mwq4N03/lpWHxMqNrWTW5jjJmNXOm8DwNL0f8FqaLjm2Ug3iM1tjbpMxawWSbgf2ATaSNA84F/gmcHka1fUTUttKE2MrmbUpTjJmrSAijikza0iZ5UuOrWTW1vhwmZmZ5cZJxszMcuMkY2ZmuXGSMTOz3DjJmJlZbpxkzMwsN04yZmaWGycZMzPLjZOMmZnlxknGzMxy4yRjZma5cZIxM7PcOMmYmVlunGTMzCw3uScZSR0lPS/pgfS4l6SHJb2W7jcoWnaMpFmSZkr6YlH5EEnT07wrJCmVd5F0ZyqfJKl/3q/HzMwq1xp7Mt8FXil6fCYwISIGAhPSYyRtCxwNbAeMAK6W1DHVuYZsQKeB6TYilZ8EvB8RnwMuAy7O96WYmVk1ck0ykjYDvgRcX1Q8Erg5Td8MHFpUfkdELImI2cAsYFdJfYHuEfFMRARwS4M6hXXdDexf2MsxM7Pay3tP5ufAD4DlRWUbR8R8gHTfJ5VvCvytaLl5qWzTNN2wfJU6EbEUWAhs2KKvwMzMmi23JCPpy8CCiJhaaZUSZdFIeWN1GsYyWtIUSVPefvvtCsMxazmSbpC0QNJLDcq/ndogZ0j6SVF5yfZJs7amU47r3hM4RNLBwLpAd0m/Ad6S1Dci5qdDYQvS8vOAzYvqbwa8mco3K1FeXGeepE5AD+C9hoFExFhgLMDQoUNXS0JmTTnkkEOaXKZXr16Nzb4JuJLscC8AkvYlO+S7Q0QskdQnlRe3T24CPCJpq4hY1tz4zWoltyQTEWOAMQCS9gHOiIjjJV0CjAIuSvf3pyrjgNsk/YzsizUQmBwRyyQtkrQ7MAn4OvCLojqjgGeAw4FHU7uNWYt65ZVXuP7668vOjwhOO+20xuY/WeLsx1OBiyJiSVqm8IdrRfskMFvSLGBXsu3crE3Jc0+mnIuAuySdBMwFjgCIiBmS7gJeBpYCpxX9czuV7J9gV2B8ugH8Cvh1+hK+R/bvz6zFXXjhhQwfPrzRZc4991yOOuqoala7FbC3pAuBT8j+iD1L1tY4sWi54nbIVUgaTXbmJf369avmuc1aRaskmYh4HHg8Tb8L7F9muQuBC0uUTwEGlSj/hJSkzPJ05JFHVrRMlUmmE7ABsDuwC9mfr89SYVsj+FCw1T9f8W9WgWXLlnHttddy9tln8/TTT68y78c//nFzVzsPuDcyk8nOwtyI8u2TZm2Ok4xZBU455RSeeOIJNtxwQ77zne/wn//5nyvm3Xvvvc1d7e+A/QAkbQWsA7xD1tZ4dOrRYgCpfXINwjerGScZswpMnjyZ2267jdNPP51JkyaxePFiDjvsMJYsWUIl55pIup2s4X5rSfNSm+QNwGfTac13AKPSXs0MoNA++SCrtk+atSm1aPg3a3P++c9/rpju1KkTY8eO5YILLmC//fZj8eLFTdaPiGPKzDq+zPIl2yfN2hrvyZhVYOjQoTz44IOrlJ1zzjmceOKJzJkzpzZBmbUBTjJmFfjNb37DiBEjVis/+eST+fTTT2sQkVnb4CRjVoVly9w0YlYNJxmzCi1atIiRI0fWOgyzNsVJxqwC8+fP54ADDmD06NG1DsWsTfHZZWYV2Hvvvbnkkksq6ijTzFbynoxZBTbYYAPeeOONWodh1uY4yZhV4PHHH2f8+PFcddVVtQ7FrE1xkjGrQLdu3Rg3bhzPP/98rUMxa1OcZMwq1LFjx0bHlDGz1bnh36wZPvzwQ5YuXbricROjYpq1W04yZlW49tprOeecc+jatStSNuyLJF5//fUaR2ZWn5xkzKpw6aWXMmPGDDbaaKNah2LWJrhNxqwKW265Jeutt16twzBrM7wnY1aF//mf/2HYsGHstttudOnSZUX5FVdcUcOozOqXk4xZFU455RT2228/tt9+ezp08IEAs6Y4yZhVoVOnTvzsZz+rdRhmbYb/iplVYd9992Xs2LHMnz+f9957b8XNzErznoxZFW677TYga5spqOQUZkk3AF8GFkTEoAbzzgAuAXpHxDupbAxwErAM+E5E/LHlXoVZ63GSMavC7Nmzm1v1JuBK4JbiQkmbAwcCc4vKtgWOBrYDNgEekbRVRHjENGtzGj1cJunDJm6LJP1vawVrVivPPffcGi0TEU8CpY6rXQb8AIiispHAHRGxJCJmA7OAXauJ16xeNLUn85eI2KmxBSS5x0Bb65144ok8/vjjRETZZU466aSq1inpEOCNiHih0HtAsikwsejxvFRWah2jgdEA/fr1q+r5zVpDU0nmqxWso5JlzNq0hQsXMmTIkEaTTO/evSten6T1gLOAL5SaXaKs5BNHxFhgLMDQoUPLB2dWI40mmYhYrTVT0pcj4oHGljFb28yZM6ei5RrskTRmS2AAUNiL2Qx4TtKuZHsumxctuxnwZqUrNqsnzTmF+YIWj8KsnYmI6RHRJyL6R0R/ssSyc0T8HRgHHC2pi6QBwEBgcg3DNWu25iSZiv+qmVlG0u3AM8DWkuZJKtuAExEzgLuAl4EHgdN8Zpm1Vc05hfmUFo/CbC0XEcc0Mb9/g8cXAhfmGZNZa2jqFOadG5ZFxOSmlknl60qaLOkFSTMknZ/Ke0l6WNJr6X6DojpjJM2SNFPSF4vKh0ianuZdoXQQOx1OuDOVT5LUv6pXb9YM77//PpMnT+bJJ59ccTOz0prak7lR0j40fojsV0Cp05yXAPtFxGJJnYGnJI0HDgMmRMRFks4EzgR+2MQFaNeQnaY5EfgDMAIYT3ZF9PsR8TlJRwMXA0dV8LrNmuX666/n8ssvZ968eQwePJiJEyeyxx578Oijj9Y6NLO61FSbTA9gahO3T0tVjMzi9LBzugXZhWY3p/KbgUPTdMkL0CT1BbpHxDORnT96S4M6hXXdDexf2Msxy8Pll1/Os88+yxZbbMFjjz3G888/X9Wpy2btTVOnMPdfk5VL6kiWiD4HXBURkyRtHBHz0/rnS+qTFi93AdqnabpheaHO39K6lkpaCGwIvNMgDl+wZi1i3XXXZd111wVgyZIlbLPNNsycObPGUZnVr1z7LkuHugZL6gncJ2lQI4uXuwCtsQvTKrpozResWUvZbLPN+OCDDzj00EM58MAD2WCDDdhkk01qHZZZ3WqVDjIj4gNJj5O1pbwlqW/ai+kLLEiLlbsAbV6ablheXGeepE5kh/fc77rl5r777gPgvPPOY99992XhwoWMGDGixlGZ1a/cxpOR1DvtwSCpK3AA8CrZhWaj0mKjgPvTdMkL0NKhtUWSdk/tLV9vUKewrsOBR6Oxfj/MWsBTTz3FjTfeyPDhw9ljjz144403ah2SWd2qaE9G0oSI2L+psgb6AjendpkOwF0R8YCkZ4C70sVoc4EjILsATVLhArSlrHoB2qlkXaV3JTurbHwq/xXwa0mzyPZgjq7k9Zg11/nnn8+UKVOYOXMmJ554Ip9++inHH388Tz/9dK1DM6tLjSYZSesC6wEbpetZCm0g3clOMy4rIl6kxKnNEfEuUDI5lbsALSKmAKu150TEJ6QkZdYa7rvvPp5//nl23jm7PGyTTTZh0aJFNY7KrH41tSdzCnA6WUKZysok8yFwVX5hmdWnddZZB0krOsL86KOPahyRWX1rtE0mIi6PiAHAGRHx2YgYkG47RsSVrRSjWd048sgjOeWUU/jggw+47rrrOOCAA/jmN79Z67DM6lZFbTIR8QtJw4D+xXUi4paylczWMhHBUUcdxauvvkr37t2ZOXMmF1xwAQceeGCtQzOrW5U2/P+abPyLaUChMb5w9b1ZuyCJQw89lKlTpzqxmFWo0utkhgLb+vRga+923313nn32WXbZZZdah2LWJlSaZF4C/gWYn2MsZnXvscce49prr2WLLbagW7duRASSePHFF2sdmlldqjTJbAS8LGkyWe/KAETEIblEZVanxo8f3/RCZrZCpUnmvDyDMGsrtthiCwAWLFjAJ598UuNozOpfRd3KRMQTpW55B2dWb8aNG8fAgQMZMGAAw4cPp3///hx00EFN1pN0g6QFkl4qKrtE0quSXpR0X6EbpjSv5AB+Zm1NRUlG0iJJH6bbJ5KWSfow7+DM6s3ZZ5/NxIkT2WqrrZg9ezYTJkxgzz33rKTqTWQdxBZ7GBgUETsA/wuMAWgwgN8I4OrUPZNZm1Ppnsz6EdE93dYFvgr4Ykxrdzp37syGG27I8uXLWb58Ofvuuy/Tpk1rsl5EPEmDHsIj4qGIWJoeTmRlb+MlB/BrsRdh1oqa1dV/RPwuDZ1s1q707NmTxYsX8/nPf57jjjuOPn360KlTi4yY8Q3gzjRdbgA/szan0osxDyt62IHsuhlfM2Ptzv3330/Xrl257LLLuPXWW1m4cCHnnHPOGq1T0llkPY/fWigqsVjJ75tHfbV6V+lfsK8UTS8F5pDt0pu1K926dQOgQ4cOjBo1qomlmyZpFPBlYP+ii53LDeC3Go/6avWu0r7LTsw7ELP2RtII4IfA8Ij4R9GsccBtkn5G1gP6QGByDUI0W2OVnl22WTrFcoGktyTdI2mzpmuaGYCk24FngK0lzUuD9l0JrA88LGmapF9CNoAfUBjA70FWHcDPrE2p9HDZjcBtrBwg7PhU5l4Crd35+OOPmTt3LltvvXXFdSLimBLFv2pk+ZID+Jm1NRXtyQC9I+LGiFiabjcBvXOMy6wu/f73v2fw4MGMGJFd8jJt2jQOOcS9K5mVU2mSeUfS8ZI6ptvxwLt5BmZWj8477zwmT55Mz549ARg8eDBz5sypaUxm9azSJPMN4Ejg72Q9MR+eyszalU6dOtGjR49ah2HWZlR6dtlcwMcErN0bNGgQt912G8uWLeO1117jiiuuYNiwYbUOy6xuVXp22c0NOu/bQNINuUVlVqd+8YtfMGPGDLp06cIxxxxD9+7d+fnPf17rsMzqVqVnl+0QER8UHkTE+5J2yicks/q13nrrceGFF3LhhT7xy6wSlSaZDpI2iIj3AST1qqKuWZv3la98BalUby+ZcePGtWI0Zm1HpYnip8CfJd1N1ofSkfgcfmtHzjjjjFqHYNYmVdrwf4ukKcB+ZJ33HRYRL+camVkdGT58eK1DMGuTKj7klZKKE4u1a9tvv/1qh8169OjB0KFD+a//+q8aRWVWv9yuYlaFgw46iI4dO3LssccCcMcddxAR9OjRgxNOOKG2wZnVIScZsyo8/fTTPP300yseb7/99uy55548/fTT/OY3v6lhZGb1qdIr/s0MWLx4MZMmTVrxePLkySxevBigpUbINFur5JZkJG0u6TFJr0iaIem7qbyXpIclvZbuNyiqM0bSLEkzJX2xqHyIpOlp3hVKB8UldZF0ZyqfJKl/Xq/HDOD666/n5JNPZsCAAfTv35+TTz6Z6667jo8++ogxY8bUOjyzupPnnsxS4P9ExL8CuwOnSdoWOBOYEBEDgQnpMWne0cB2wAjgakkd07quIRtidmC6jUjlJwHvR8TngMuAi3N8PWbssssuTJ8+nWnTpjFt2jRefPFFdt11V7p168aRRx5Z6/DM6k5u+/cRMZ+sM00iYpGkV4BNyYZt3ictdjPwONnogCOBOyJiCTBb0ixgV0lzgO4R8QyApFuAQ4Hxqc55aV13A1dKUtEwtmYtasmSJdxzzz3MmTOHpUuXrig/55xzahiVWf1qlYPI6TDWTsAkYOOUgIiI+ZL6pMU2BSYWVZuXyj5N0w3LC3X+lta1VNJCYEPgnQbPP5psT4h+/fq12Ouy9mfkyJH06NGDIUOG0KVLl1qHY1b3ck8ykj4D3AOcHhEfNtI1R6kZ0Uh5Y3VWLYgYC4wFGDp0qPdyrNnmzZvHgw8+WOswzNqMXM8uk9SZLMHcGhH3puK3JPVN8/sCC1L5PGDzouqbAW+m8s1KlK9SR1InoAfwXsu/ErPMsGHDmD59etX1JN0gaYGkl4rKqj4JxqytyfPsMpGNYf5KRPysaNY4YFSaHgXcX1R+dDpjbABZA//kdGhtkaTd0zq/3qBOYV2HA4+6Pcby9NRTTzFkyBC23nprdthhB7bffnt22GGHSqrexMoTVgqacxKMWZuS5+GyPYGvAdMlTUtlPwIuAu6SdBIwFzgCICJmSLqLrOuapcBpEbEs1TuV7EvalazBf3wq/xXw63SSwHtkX0yz3IwfP77phUqIiCdLnGJf1UkwwDPNenKzGsrz7LKnKN1mArB/mToXUqJ354iYAgwqUf4JKUmZtYYtttgCgAULFvDJJ5+s6eqqPQnGrM3xFf9mVRg3bhwDBw5kwIABDB8+nP79+3PQQQe19NNUdEILZGdOSpoiacrbb7/d0nGYrTEnGbMqnH322UycOJGtttqK2bNnM2HCBPbcc8/mrq7ak2BWExFjI2JoRAzt3bt3c+Mwy42TjFkVOnfuzIYbbsjy5ctZvnw5++67L9OmTWvu6qo6CWZN4jarFffoZ1aFnj17snjxYj7/+c9z3HHH0adPn4o6xpR0O1kj/0aS5gHn0ryTYMzaFCcZsyrcf//9rLvuulx22WXceuutLFy4sKIuZSLimDKzqjoJxqytcZIxq0K3bt1WTI8aNaqRJc0M3CZjVpG99toLgPXXX5/u3buvuBUem1lp3pMxq8BTTz0FwKJFi2ociVnb4j0ZswotX76cQYNWuybYzBrhJGNWoQ4dOrDjjjsyd+7cWodi1mb4cJlZFebPn8922223YjTMgnHjxtUwKrP65SRjVoVzzz231iGYtSlOMmZV+MMf/sDFF1+8StkPf/hDhg8fXqOIzOqb22TMqvDwww+vVtbc7v/N2gPvyZhV4JprruHqq6/m9ddfX2WQskWLFq1JB5lmaz0nGbMKHHvssRx00EGMGTOGiy66aEX5+uuvT69evWoYmVl9c5Ixq0CPHj3o0aMHt99+e61DMWtT3CZjZma5cZIxM7PcOMmYmVlunGTMzCw3TjJmZpYbJxkzM8uNk4xZjUn6nqQZkl6SdLukdSX1kvSwpNfS/Qa1jtOsOZxkzGpI0qbAd4ChETEI6AgcDZwJTIiIgcCE9NiszXGSMau9TkBXSZ2A9YA3gZHAzWn+zcChtQnNbM04yZjVUES8AVwKzAXmAwsj4iFg44iYn5aZD/QpVV/SaElTJE15++23Wytss4o5yZjVUGprGQkMADYBukk6vtL6ETE2IoZGxNDevXvnFaZZsznJmNXWAcDsiHg7Ij4F7gWGAW9J6guQ7hfUMEazZnOSMautucDuktaTJGB/4BVgHDAqLTMKuL9G8ZmtkdySjKQbJC2Q9FJRWdnTMiWNkTRL0kxJXywqHyJpepp3RfoiIqmLpDtT+SRJ/fN6LWZ5iYhJwN3Ac8B0su/kWOAi4EBJrwEHpsdmbU6eezI3ASMalJU8LVPStmSnbW6X6lwtqWOqcw0wGhiYboV1ngS8HxGfAy4DVh0T16yNiIhzI2KbiBgUEV+LiCUR8W5E7B8RA9P9e7WO06w5cksyEfEk0PCLUe60zJHAHenLNRuYBeyajkV3j4hnIiKAWxrUKazrbmD/wl6OmZnVh9Zukyl3WuamwN+KlpuXyjZN0w3LV6kTEUuBhcCGpZ7Up3mamdVGvTT8l9oDiUbKG6uzeqFP8zQzq4nWTjLlTsucB2xetNxmZFc9z0vTDctXqZOulO7B6ofnzMyshlo7yZQ7LXMccHQ6Y2wAWQP/5HRIbZGk3VN7y9cb1Cms63Dg0dRuY2ZmdaJTXiuWdDuwD7CRpHnAuWSnYd4l6SSy6wOOAIiIGZLuAl4GlgKnRcSytKpTyc5U6wqMTzeAXwG/ljSLbA/m6Lxei5mZNU9uSSYijikza/8yy18IXFiifAowqET5J6QkZWa2Jtbp1rHphaxZ6qXh38ysZpaXPI/IWoKTjJm1e0uXLK11CGstJxkza/e22umztQ5hreUkY2bt3o77blfrENZaTjJm1i6oQ/l2l249urViJO2Lk4yZtQuxvPxldOt0ze1E23bPScbM2oWOncv/3HXp0rUVI2lfnGTMrH1opD+Qfyz6R+vF0c44yZhZu7Dbl3cuO2//4/duxUjaFycZM2sXZk9fOZpIv3/ddJV+3OfOmFeihrUEt3aZWbvQrcd6AHTs1IG5r7yxyrzP9PTZZXnxnoxZjUnqKeluSa9KekXSHpJ6SXpY0mvpfoNax9nWnXfv9znopP3Y56g9V5T99wNjOOQ/RrD1Lp+rYWRrNycZs9q7HHgwIrYBdgReAc4EJkTEQGBCemxrYON+vdlky39hwq1/YsD2/Vh/g25cfsq1/Nt3D651aGs1JxmzGpLUHfg82dAVRMQ/I+IDYCRwc1rsZuDQWsS3NvndleP51Y9uY79j9+KaqT/hp4+fz6dLPuX7+53He39/v9bhrbWcZMxq67PA28CNkp6XdL2kbsDGadA+0n2fUpUljZY0RdKUt99+u/WiboOGfnEwh333S/zgpm/RsVNHBmy/BZdMOJf9jt2bnn161Dq8tZaTjFltdQJ2Bq6JiJ2Aj6ji0FhEjI2IoRExtHfv3nnFuFbYbGBfTr3sBDp2Wjl2zIDtt+CbFx9Phw7+KcyL31mz2poHzIuISenx3WRJ5y1JfQHS/YIaxWe2RpxkzGooIv4O/E3S1qlof7JhyMcBo1LZKOD+GoRntsZ8nYxZ7X0buFXSOsDrwIlkfwDvknQSMBcPNW5tlJOMWY1FxDRgaIlZ+7dyKGYtzofLzKxd+Hjxxzzx22dWKVv0/mKe/t3kGkXUPjjJmFm7cPdPH+DHR/2M+674A5AlmB9+4b/5v8f+nHfn+zqZvPhwmZm1C8f86N94ffpfufr0G1n8/kc888AU5kyfy7n3fp8N+7rXnrx4T8bM2oVOnTtx1u2nM3i/Qdxy/l28NvV1zr33++x2cPkhAGzNOcmYWbvx8eJP+PCdRSsevznr7zWMpn1wkjGzdqHQBvO3V9/g/Pt+wF6H7cbVp9+4oo3G8uEkY2btwrir/riiDWbYyF046/bT2euw3bjhrNvc8J8jN/ybWbtw9JhD2e1LO/O5nQYAK9to/vryPDf858h7MmbWLnTs2HFFgino1LkTW+7YvzYBtRNOMmZmlhsnGTMzy02bTzKSRkiaKWmWJA9Ra2ZWR9p0kpHUEbgKOAjYFjhG0ra1jcrMzAradJIBdgVmRcTrEfFP4A6ysdHNzKwOtPVTmDcF/lb0eB6wW8OFJI0GRqeHiyXNLLO+jYB3WjTC5quXWJoVhy7OIZK28Z5s0ZqBFJs6deo7kv5aZnZbeO9aW73EUi9xQA7bdltPMipRFqsVRIwFxja5MmlKRJQa16PV1Uss9RIH1E8s9RJHQxHRu9y8eom5XuKA+omlXuKAfGJp64fL5gGbFz3eDHizRrGYmVkDbT3JPAsMlDQgDV17NNnY6GZmVgfa9OGyiFgq6VvAH4GOwA0RMWMNVtnkIbVWVC+x1EscUD+x1Esc1aiXmOslDqifWOolDsghFkWs1oRhZmbWItr64TIzM6tjTjJmZpabdpdkJPWS9LCk19J9yT6+Jc2RNF3SNElTqq3fEnFI2lzSY5JekTRD0neL5p0n6Y0U3zRJBzcjhka75FHmijT/RUk7V1q3heM4Lj3/i5L+LGnHonklP6ccY9lH0sKi9/2cSuu2tCq25ZJxNbYNSRqTlp8p6YutEMslkl5Nn/F9knqm8v6SPi6K8ZfVrLdoftXbcnO/682NpaW/72v4nrTc719EtKsb8BPgzDR9JnBxmeXmABs1t35LxAH0BXZO0+sD/wtsmx6fB5yxBu9DR+AvwGeBdYAXCusuWuZgYDzZ9Ui7A5MqrdvCcQwDNkjTBxXiaOxzyjGWfYAHmlO3FttyY3GV24bIumh6AegCDEj1O+YcyxeATmn64kJ9oD/wUi225UpeUwvH0mLf9zWJo7HvVXPek3a3J0PW7czNafpm4NBWrl/xeiJifkQ8l6YXAa+Q9XLQEirpkmckcEtkJgI9JfWtsG6LxRERf46IwtCFE8muh8rDmryuWnRxVMm22Jy4RgJ3RMSSiJgNzErryS2WiHgoIpam5ar9jPPalpvzXW92LC38fV+T96QxVb8n7THJbBwR8yH7EQf6lFkugIckTVXWLU219VsqDiA7bADsBEwqKv5W2s29odJd+SKluuRpuEGXW6aSui0ZR7GTyP59FZT7nPKMZQ9JL0gaL2m7Kuu2pEq2oabiKrUNNee1tEQsBd9g1c94gKTnJT0hae9mrrc523JzvutrEssKLfB9X9M4Wuz3r01fJ1OOpEeAfykx66wqVrNnRLwpqQ/wsKRXI+LJGsSBpM8A9wCnR8SHqfga4L/JNob/Bn5K9uWseLUlyhqez15umYq682nBOLIFpX3JksxeRcVr/DlVGctzwBYRsTgdF/8dMLDCutUHtObbUGNxlduGStbJOZZsAeksYClwayqaD/SLiHclDQF+J2m7ou9BRettZJmW/tzWJJZsZst839c0jhb7Xq2VSSYiDig3T9JbhV3TtGu4oMw63kz3CyTdR7b7+SRQUf2WikNSZ7IN7taIuLdo3W8VLXMd8EC55yqjki55yi2zTgV1WzIOJO0AXA8cFBHvFsob+ZxyiaX4xy0i/iDpakkbVfo6qtUC21DZuBrZhkrWyTOWtI5RwJeB/SMd9I+IJcCSND1V0l+ArYDikzzy2pYr/q63UCwt+X1fozha4vdvhaYabda2G3AJqzZc/aTEMt2A9Yum/wyMqLR+C8Yh4Bbg5yXm9S2a/h7ZMfRqnr8T8DpZw26hYXC7Bst8iVUbBidXWreF4+hH1i4wrNLPKcdY/oWVFzHvCsxN70+LvSctvA2VjavcNgRsx6oN/6/TdMP/msYyAngZ6N2gTu/Cc5M1Yr8B9GqNbbmS19TC36sW+76vYRwt+vuX2xegXm/AhsAE4LV03yuVbwL8oWhjfiHdZgBnNVU/pzj2Itt9fRGYlm4Hp3m/BqaneeOKN8IqYjiY7AyWvxReI/DvwL8XbfRXpfnTgaGN1V2Dz6SpOK4H3i96D6Y09TnlGMu30nO9QNZAPayxurXelhuLq7FtiOwQ2F+AmWR7j3nHMousfaDwGf8ylX+16P1+DvhKa23L5V5TXt8rWvj7vgZxtOjvn7uVMTOz3LTHs8vMzKyVOMmYmVlunGTMzCw3TjJmZpYbJxkzM8tNzZJM6lX0jDR9gaTGLvQ6VNK2rRfdKs/dRdIjqTfSo1r5uf/cys93ROoB9rEG5f0lHdtIvU0k3Z1DPCdIurKl11vB8w6upJfbEvX+XdLXS5T3l/RSFetZlra3Taqos7ekl6t5HrPWUBd7MhFxTkQ80sgih5L1DFsLOwGdI2JwRNxZPENSxzyesLDeiBjWUuuq0EnAf0TEvg3K+wMlk4ykThHxZkQc3swQ69FgsmsMViOpbC8ZEfHLiLilBZ7/47S9VdxjQET8iTIxtxVt6I9nodv9C6qsd6uk9yStTd+VJrVqkpF0lrLxDR4Bti4qv6nwxku6KP0je1HSpZKGAYcAl6R/d1tK+qakZ5V1UniPpPWK1nOFsjFHXi/+MCX9QNn4CC9IuiiVbSnpQWWdwP1J0jYN4u0D/AYYXPTccySdI+kp4AhJx6T1viTp4qK6iyVdnNb9iKRdJT2e4jqkxHuzj7KxJG4juzAKSYvT/Z1adayPmyR9VVJHZeNwPJver1PKravBc60Ws7JxUfYCfinpkgZVLgL2Tu/B99Iexm8l/Z6sE70V/9TT9J8kPZduw4pielzS3crGDblVktK8g1PZU+nzW63LDEm902f9bLrtWWKZjmmbmZ7ej2+n8iHKOlecKumPSj3NpnguljRZ0v8q2xtYB7gAOCq93qPSj8pYSQ8Bt0jaQtKE9BwTJPVL6yv+kRyStrVngNOKYtwuPd+0VH9gw9dR4nVVtS2tDer8jyfAZRFxTtOLrRQRx5FdSNm+5H1VctGVokPIfvDWA7qTXeF7Rpp3E3A40IvsCuPCRaI9i+cXX3VaNP1j4NtFy/2WLHluS9bVNWRjkPwZWC89LlyNPAEYmKZ3Ax4tEfc+FI0fQjbOwg+KrmaeS9b1RSfgUeDQNC9IV0oD9wEPAZ2BHYFpZZ7nI2BAUdnidP9vwM1peh2yK6O7AqOB/0rlXcj6cxpQal1F62ws5scpuhK6kffgBLJ+jwrvY3/SmB/p8103TQ9k5dX5+wALyfpH6gA8Q5bU1k2vZ0Ba7vbCc6XnuTJN3wbslab7Aa+UiPNUsn6fCuOS9Erv+Z9J3ZUARwE3FL3enxZdHf1Iw+dNj88DpgJd0+PfA6PS9DeA3xUtV9imXwSGp+lLit6fXwDHFX2WXUu8jsUNHle0LVHB2Cv1diPrWWAm8Ej67Ff5TUjTF5F1OfMicCnZ+ELvAbPJrorfEvgm8CzZVer3sPK7fhNwRdoGXmfV35EfkP0mvQBclMq2BB5Mn/efgG1KxLzicy56fHP6XOYAh5GNuzI9ratz0bI3FcfQHm6t2UHm3sB9EfEPAEmlMvqHwCfA9ZL+H+U7gRsk6cdAT+AzwB+L5v0uIpYDL0vaOJUdANxYeO6IeE9ZT6fDgN+mP9SQ/VBXonDYbBfg8Yh4O72mW4HPk/XM+0+yDQyyjW1JRHwqaTrZj0EpkyMbv6Oh8cAVkrqQ9fH0ZER8LOkLwA5aucfWg+yH/Z+NrKuxmKvxcES8V6K8M3ClpMHAMrLODItf37z0vNPI3ofFwOtFsd5OljwbOgDYtuiz6i5p/cjG3She5peRxiVJn/MgYBBZT7KQDeY0v6hOoRPCqZT/XADGRcTHaXoPsh8SyLr7+EnxgpJ6kP1BeqJomYPS9DPAWZI2A+6NiNcaec6C5mxLdU9Zr8pHkx2S7kTWbczUBsv0IvuTtU1EhKSeEfFB+v14ICLuTst9EBHXpekfkx36/UVaTV+yPzTbkO1J3C3pILK9od0i4h/peQDGknW78pqk3YCrgf0qeDlbAvuS/bl9BvhqRPxAWeeSX6L679dao7V7YW60D5uIWCppV2B/so3vW5T+gG8i+/f9gqQTyP4lFywpmlbRfcPn7gB8EBGDK4y92EcN1l/Kp5H+ugDLWdmT7HKVP67/UanCiPhE0uPAF8n+id9e9PzfjojiJIukfcqtq4mYq1Fu/d8D3iL7l92B7E9DQfFns4xs+6s0ng7AHkU/9KWU+pwFzIiIPcrUKcRUiKeccq+XMs9ZcluPiNskTSL74fmjpJMj4tFG1g3N25bagrXpj+f4osTfkVX/FPSvcB1rpdZsk3kS+DdJXSWtD3yl4QLpQ+4REX8ATidrgAVYRDYcacH6wHxl3WIfV8FzPwR8QyvbbnpF1mX7bElHpDKpaOz4Ck0ChkvaSFkD+zHAE03Uaa47gBPJvpiFL9AfgVPT+4CkrSR1yyHmhu9/Y3oA89OX+mtkX7jGvAp8VtkgTZAl0VIeIvvTAWRngJVZ5t8LP7zp3+lMoLekPVJZZ60caKycpl7vn8n+BEG2/T1VPDMiPgAWStqraJlC3J8l23O7guxf9Q5NxLK2a/KPJ1lv1/eQ7Xk8WGbRm4BvRcT2wPlkh2ELqv7jWXT710peBEWJn9X/FLTlPwJrrNWSTGTDit5Jdgz1HrLjnQ2tDzwg6UWyH77vpfI7gO8rGx1vS+Bssh/Lh8l+pJp67gfJvtBT0mGaM9Ks44CTJBV6Gx1Z5WuaD4wBHiP1EhsR91ezjio8RHZY65HIhlOFrHfil4HnlDW8X0sTG3QzY34RWJoasr/XxLJXA6MkTSQ7VNbYHgBpz+Q/gAeVnUzxFlnbTUPfAYamxvKXyXqTbeh6svamF9Nnemx6rw4HLk5l08j+rTbmMbJDc+VOW/8OcGLaTr8GfLfEMicCV6WG/+K9r6OAl9J2uA1Z1+7t1dr4x9MacC/MVnOSPhPZSJOFrsdfi4jLah1XrUhaHBGfaUa9/mTtFINaPqp8KBsJ8+vAX8lOJnk5Ii6VdBPZobGngfvJ9kwEXBoRNys7u/A6sj2Iw4EvkDXk/5XsENX6EXFCYT1FbTcr3ltJZ6bn/ifZcAQ/kjSAbBTKvmTti3dExCqnKks6j+zkjEvLPC5+jobzVomnPXCSsZpLe0ejyM62eh74ZuFYeXsk6U2yEQcPjgqvlZG0N9le5LsRsU+O4bV7DRNHlXVvwknGzMzKUXYt1GiyvZyKr5VJZ3IOIztZp9rh0tssJxkzM8tNXXQrY2ZmaycnGTMzy42TjJmZ5cZJxszMcvP/AT4dteCs4ANHAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEJCAYAAABGw1qNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAuyElEQVR4nO3de5wU1Z338c9XQBAUBAWDosLyYAyiYpygQePdBE0ibBJv0Q0qCcbHaDTJRlmjmGx4FqPRaKJGQhTdKGq8RMyKNyJxvYGoKKKyEEFFiRCv4CoK/J4/6gw0Q89M90z3dM/M9/16zWuqT52q+nV3df+6qk6do4jAzMysHDardABmZtZ2OcmYmVnZOMmYmVnZOMmYmVnZOMmYmVnZOMmYmVnZlC3JSLpW0nJJz+eU9ZL0gKSF6X/PnHnjJC2StEDSl3LK95Y0L827QpJSeWdJt6TyWZL6l+u5mJlZ05TzSGYKMKJO2bnAjIgYBMxIj5E0GDgO2C0tc5WkDmmZq4GxwKD0V7vOMcA7EfF/gMuAi8r2TMzMrEk6lmvFEfFwnqOLkcBBafp6YCZwTiq/OSJWA4slLQKGSVoCdI+IxwEk3QCMAqanZS5M67oN+I0kRSN3l2677bbRv3/dsMxK46mnnvpHRPSuxLa9b1s5NXXfLluSqcd2EbEMICKWSeqTyncAnsiptzSVfZKm65bXLvNaWtcaSe8B2wD/aCiA/v37M2fOnOY+D7O8JL1SqW1737Zyauq+XS0X/pWnLBoob2iZTVcujZU0R9KcFStWNDFEMzMrVksnmTcl9QVI/5en8qXAjjn1+gFvpPJ+eco3WkZSR6AH8Ha+jUbEpIioiYia3r0rcibDzKxdaukkMw0YnaZHA3fllB+XWowNILvAPzudWlspad/UquxbdZapXdc3gL80dj3GzMxaVtmuyUiaSnaRf1tJS4HxwETgVkljgFeBowEiYr6kW4EXgDXA6RGxNq3qNLKWaluQXfCfnsp/D/xnaiTwNlnrNDMzqyLlbF12fD2zDq2n/gRgQp7yOcCQPOUfkZKUWTWTtCNwA/ApYB0wKSIul9QLuAXoDywBjomId9Iy48ia6a8FzoyI+yoQepsz75EX2H3/wesfr1u3jvmPvbRRmZVWtVz4N2vL1gA/jIjPAPsCp6d7w5py35g10Rc3P5ofHDCeX5x8JZAlmC91PJYfHDCeP146rcLRtV1OMmZlFhHLIuLpNL0SeJGsCf5IsvvFSP9Hpen1941FxGJgETCsRYNug2JN9v+B62fyi5Ov5Esdj10/774bZlYmqHbAScasBaUblPcCZlHnvjEg976x13IWy70/zErggetnblywdl1F4mgPnGTMWoikLYHbgbMi4v2GquYp8z1gZbT1dj0qHUKb1dJ3/Fsr0//c/2rScksmfrnEkbRukjqRJZgbI+KOVPympL6p94tC7hvbRERMAiYB1NTUuAl/E72z/N1Kh9Bm+UjGrMzSPV6/B16MiEtzZhV131hLxdsevfPmykqH0Gb5SMas/PYD/gWYJ2luKvs3mnbfmJXByredZMrFScaszCLiEfJfZ4Ei7xsza218uszM2j3fhVQ+TjJm1u6518PycZIxM/uk0gG0XU4yZmZWNk4yZmZWNk4yZmb1tf2zZnOSMTPzhf+ycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxM7OycZIxawGSrpW0XNLzOWVDJT0haa6kOZKG5cwbJ2mRpAWSvlSZqM2az0nGrGVMAUbUKfsF8NOIGApckB4jaTBwHLBbWuYqSR1aLFKzEnKSMWsBEfEw8HbdYqB7mu4BvJGmRwI3R8TqiFgMLAKGYdYKdax0AGbt2FnAfZIuIfvBNzyV7wA8kVNvaSoza3V8JGNWOacBZ0fEjsDZwO9Teb7BgPOO3ShpbLqeM2fFihVlCtOs6ZxkzCpnNHBHmv4jG06JLQV2zKnXjw2n0jYSEZMioiYianr37l22QM2aqiJJRtLZkuZLel7SVEldJPWS9ICkhel/z5z6eVvaSNpb0rw07wpJ+X4BmlWrN4AD0/QhwMI0PQ04TlJnSQOAQcDsCsRn1mwtnmQk7QCcCdRExBCgA1lLmnOBGRExCJiRHjfW0uZqYCzZh3AQm7beMasKkqYCjwOflrRU0hjgO8AvJT0L/D+yfZmImA/cCrwA3AucHhFrKxO5WfNU6sJ/R2ALSZ8AXcl+0Y0DDkrzrwdmAueQ09IGWCxpETBM0hKge0Q8DiDpBmAUML3FnoVZgSLi+Hpm7V1P/QnAhPJFZNYyWvxIJiJeBy4BXgWWAe9FxP3AdhGxLNVZBvRJi+wAvJazitqWNjuk6brlZmZWJSpxuqwn2dHJAGB7oJukExtaJE9ZNFCeb5tugWNmVgGVuPB/GLA4IlZExCdkrWuGA29K6guQ/i9P9etrabM0Tdct34Rb4JiZVUYlksyrwL6SuqbWYIcCL5K1qBmd6owG7krTeVvapFNqKyXtm9bzrZxlzMysCrT4hf+ImCXpNuBpYA3wDDAJ2BK4NbW6eRU4OtWfL6m2pc0aNm5pcxpZn1BbkF3w90V/M7MqUpHWZRExHhhfp3g12VFNvvp5W9pExBxgSMkDNDOzkvAd/2ZmVjZOMmZmVjZOMmZmVjZOMmZmVjZOMmZmVjZOMmZmVjZOMmZmVjZOMmZmVjZOMmZmVjZOMmZmVjZOMmZmVjaVGhnTrFU56qijGq3Tq1evFojErHVxkjErwIsvvsjkyZPrnR8RnH766S0YkVnr4CRjVoAJEyZw4IEHNlhn/PjxHHvssXnnSboW+AqwPCKG5JSfAXyPbBiL/4qIH6fyccAYYC1wZkTcV4rnYdbSfE3GrADHHHNMc+tMAUbkFkg6mGwo8j0iYjfgklQ+GDgO2C0tc5WkDk2J26zSnGTMCrB27VquueYazj//fB599NGN5v385z9vdPmIeBh4u07xacDEiFid6tQOOT4SuDkiVkfEYmARMKyZT8GsIpxkzApw6qmn8te//pVtttmGM888kx/84Afr591xxx1NXe0uwBckzZL0V0mfS+U7AK/l1FuaysxaHScZswLMnj2bm266ibPOOotZs2axatUqvva1r7F69Woioqmr7Qj0BPYF/pVs+HEBylM370YkjZU0R9KcFStWNDUOs7JxkjErwMcff7x+umPHjkyaNImhQ4dyyCGHsGrVqqaudilwR2RmA+uAbVP5jjn1+gFv5FtBREyKiJqIqOndu3dT4zArGycZswLU1NRw7733blR2wQUXcPLJJ7NkyZKmrvZPwCEAknYBNgf+AUwDjpPUWdIAYBAwu6kbMaskN2E2K8Af/vCHvOXf/va3+fa3v93o8pKmAgcB20paCowHrgWulfQ88DEwOrJzb/Ml3Qq8QNa0+fSIWFuK52HW0pxkzIqwdu1aOnQovjVxRBxfz6wT66k/AZhQ9IbMqoxPl5kVaOXKlYwcObLSYZi1Kk4yZgVYtmwZhx12GGPHjq10KGatik+XmRXgC1/4AhdffHFBHWWa2QY+kjErQM+ePXn99dcrHYZZq+MkY1aAmTNnMn36dK688spKh2LWqjjJmBWgW7duTJs2jWeeeabSoZi1Kk4yZgXq0KFDg2PKmNmmfOHfrAnef/991qxZs/6xR8U0y89JxqwI11xzDRdccAFbbLEFWV+WIImXX365wpGZVScnGbMiXHLJJcyfP59tt9220qGYtQq+JmNWhIEDB9K1a9dKh2HWavhIxqwI//Ef/8Hw4cPZZ5996Ny58/ryK664ooJRmVUvJxmzIpx66qkccsgh7L777my2mU8EmDWmIklG0tbAZGAI2Yh/pwALgFuA/sAS4JiIeCfVHweMAdYCZ0bEfal8b2AKsAVwD/D9aMYwhWaN6dixI5deemmlwzBrNSr1U+xy4N6I2BXYE3gROBeYERGDgBnpMZIGA8cBuwEjgKsk1fa1fjUwlmxQp0FpvlnZHHzwwUyaNIlly5bx9ttvr/8zs/xa/EhGUnfgAOAkgIj4GPhY0kiyQZ0ArgdmAucAI4GbI2I1sFjSImCYpCVA94h4PK33BmAUML2Fnoq1QzfddBOQXZup5SbMZvWrxOmyfwJWANdJ2hN4Cvg+sF1ELAOIiGWS+qT6OwBP5Cy/NJV9kqbrlm9C0liyIx522mmn0j0Ta3cWL15c6RDMWpVKnC7rCHwWuDoi9gI+IJ0aq4fylEUD5ZsWRkyKiJqIqOndu3ex8Zrx9NNPl6SOWXvT4JGMpPcbWV7AsojYpYhtLgWWRsSs9Pg2siTzpqS+6SimL7A8p/6OOcv3A95I5f3ylJuV3Mknn8zMmTNpqF3JmDFjWjAis9ahsdNlf0tHG/WSVFS3tBHxd0mvSfp0RCwADgVeSH+jgYnp/11pkWnATZIuBbYnu8A/OyLWSlopaV9gFvAt4NfFxGJWqPfee4+99967wSTjo2SzTTWWZL5ewDoKqVPXGcCNkjYHXgZOJjt1d6ukMcCrwNEAETFf0q1kSWgNcHpErE3rOY0NTZin44v+ViZLliwpqF5tf2Z5yq8FvgIsj4ghdeb9CLgY6B0R/0hleZvtm7U2DSaZiNikyYykr0TEnxuq05iImAvU5Jl1aD31JwAT8pTPIbvXxqzaTQF+A9yQWyhpR+Bwsh9WtWW5zfa3Bx6UtEvOjyuzVqMpF/5/VvIozNq4iHgYyHdDzWXAj9m40cr6ZvsRsRhYBAwrf5RmpdeUJJP/fICZFUXSUcDrEfFsnVk7AK/lPK63eb5ZtWvKfTKnljwKs1bknXfeYeHChXz00Ufryw444ICi1iGpK3Ae8MV8s/OU5W1x4HvArNo11oT5sxGxUeP/iJjdWB2ztmry5MlcfvnlLF26lKFDh/LEE0/w+c9/nr/85S/FrmogMAB4NjUW6Ac8LWkY9Tfb30RETAImAdTU1LjfPqs6jZ0uu05ST0m96vsDft8SgZpVg8svv5wnn3ySnXfemYceeohnnnmmSU2XI2JeRPSJiP4R0Z8ssXw2Iv5O1mz/OEmdJQ0gNdsv5fMwaymNnS7rQdbtS0PXYVaULhyz6talSxe6dOkCwOrVq9l1111ZsGBBo8tJmkrWN9+2kpYC4yMi7w+0Rprtm7UqjTVh7t9CcZi1Cv369ePdd99l1KhRHH744fTs2ZPtt9++0eUi4vhG5vev8zhvs32z1saDlpkV4c477wTgwgsv5OCDD+a9995jxAiPMGFWHycZsyI98sgjLFy4kJNPPpkVK1bw+uuvM2DAgEqHZVaVPH6sWRF++tOfctFFF60fT+aTTz7hxBNPrHBUZtWroCQjaUYhZWZt3Z133sm0adPo1q0bANtvvz0rV66scFRm1aux+2S6AF3JWsT0ZEMrs+5kfSqZtSubb745ktZ3hPnBBx9UOCKz6tbYNZlTgbPIEkpuU+b3gSvLF5ZZdTrmmGM49dRTeffdd/nd737Htddey3e+851Kh2VWtRprwnw5cLmkMyLCY7VYuxYRHHvssbz00kt0796dBQsW8LOf/YzDDz+80qGZVa2CWpdFxK8lDQf65y4TETfUu5BZGyOJUaNG8dRTTzmxmBWo0Av//wlcAuwPfC795RsPxqxN23fffXnyyScrHYZZq1HofTI1wOBoaOxZs3bgoYce4pprrmHnnXemW7duRASSeO655yodmllVKjTJPA98ClhWxljMqt706R7h26wYhSaZbYEXJM0GVtcWRsRRZYnKrErtvPPOACxfvnyj8WTMLL9Ck8yF5QzCrLWYNm0aP/zhD3njjTfo06cPr7zyCp/5zGeYP39+pUMzq0qFti77a7kDMWsNzj//fJ544gkOO+wwnnnmGR566CGmTp1a6bDMqlahrctWSno//X0kaa2k98sdnFm16dSpE9tssw3r1q1j3bp1HHzwwcydO7fSYZlVrUKPZLbKfSxpFDCsHAGZVbOtt96aVatWccABB3DCCSfQp08fOnZ0Z+Zm9WlSL8wR8SfgkNKGYlb97rrrLrp27cpll13GiBEjGDhwIHfffXelwzKrWgX9BJP0tZyHm5HdN+N7Zqzdqe19ebPNNmP06NEVjsas+hV6nP/VnOk1wBJgZMmjMTOzNqXQazInlzsQMzNrewptXdZP0p2Slkt6U9LtkvqVOzizavThhx+yYMGCopaRdG36/DyfU3axpJckPZc+X1vnzBsnaZGkBZK+VLrozVpWoRf+rwOmkY0rswNwdyoza1fuvvtuhg4dyogRIwCYO3cuRx1VUMcXU4ARdcoeAIZExB7A/wDjACQNBo4DdkvLXCWpQ0megFkLKzTJ9I6I6yJiTfqbAvQuY1xmVenCCy9k9uzZbL311gAMHTqUJUuWNLpcRDwMvF2n7P6IWJMePgHUnh0YCdwcEasjYjGwCN8yYK1UoUnmH5JOlNQh/Z0IvFXOwMyqUceOHenRo0c5Vn0KUNv75g7AaznzlqayTUgaK2mOpDkrVqwoR1xmzVJokjkFOAb4O1lPzN9IZWbtypAhQ7jppptYu3YtCxcu5IwzzmD48OHNWqek88habd5YW5SnWt5bBiJiUkTURERN794+uWDVp6AkExGvRsRREdE7IvpExKiIeKXcwZlVm1//+tfMnz+fzp07c/zxx9O9e3d+9atfNXl9kkYDXwFOyBmvaSmwY061fsAbTd6IWQUVejPm9cD3I+Ld9Lgn8MuI8NGMtStdu3ZlwoQJTJgwodnrkjQCOAc4MCL+N2fWNOAmSZeSNbYZBMxu9gbNKqDQmzH3qE0wABHxjqS9mrPh1FpmDvB6RHxFUi/gFqA/2c2ex0TEO6nuOGAMsBY4MyLuS+V7k7Xa2QK4hywRuicCK7mvfvWrSPnOYmWmTZvW4PKSpgIHAdtKWgqMJ2tN1hl4IK37iYj4bkTMl3Qr8ALZabTTI2JtKZ6HWUsrNMlsJqlnzpd+ryKWrc/3gReB7unxucCMiJgo6dz0+Jw6zTm3Bx6UtEv60F0NjCVrmXMPWXNPD11oJfejH/2oWctHxPF5in/fQP0JQPMPl8wqrNBE8UvgMUm3kV2APIZmfADSjZxfTuv4QSoeSfZLD+B6YCbZqYT1zTmBxZIWAcMkLQG6R8TjaZ03AKNwkrEyOPDAAysdglmrVGi3MjdImkPW87KAr0XEC83Y7q+AHwO5QwhsFxHL0vaWSeqTyncgO1KpVduc85M0Xbd8E5LGkh3xsNNOOzUjbGvvdt99901Om/Xo0YOamhp+8pOfVCgqs+pV8CmvlFSak1gAkPQVYHlEPCXpoEIWyRdOA+WbFkZMAiYB1NTU+JqNNdkRRxxBhw4d+OY3vwnAzTffTETQo0cPTjrppMoGZ1aFKjHa0n7AUZKOBLoA3SX9AXhTUt90FNMXWJ7q19eccykb7pDOLTcrm0cffZRHH310/ePdd9+d/fbbj0cffZQ//OEPFYzMrDo1adCy5oiIcRHRLyL6k13Q/0tEnEjWbLN2gI7RwF1pehpwnKTOkgaQmnOmU2srJe2r7PzFt3KWMSuLVatWMWvWrPWPZ8+ezapVqwA8QqZZHtX0qZgI3CppDPAqcDRAI805T2NDE+bp+KK/ldnkyZM55ZRTWLVqFRFB9+7dmTx5Mh988AHjxo3j2GOPrXSIZlWlokkmImaStSIjIt4CDq2nXt7mnBExBxhSvgjNNva5z32OefPm8d577xER6zvKBDjmmGOcZMzqqKYjGbOqt3r1am6//XaWLFnCmjVr1pdfcMEFFYzKrHo5yZgVYeTIkfTo0YO9996bzp07Vzocs6rnJGNWhKVLl3LvvfdWOgyzVqPFW5eZtWbDhw9n3rx5lQ7DrNXwkYxZER555BGmTJnCgAED6Ny5MxGBJJ577rlKh2ZWlZxkzIowfbpbyZsVw0nGrAg777wzAMuXL+ejjz6qcDRm1c/XZMyKMG3aNAYNGsSAAQM48MAD6d+/P0cccUSlwzKrWk4yZkU4//zzeeKJJ9hll11YvHgxM2bMYL/99qt0WGZVy0nGrAidOnVim222Yd26daxbt46DDz6YuXPnVjoss6rlazJmRdh6661ZtWoVBxxwACeccAJ9+vRxx5hmDfCRjFkR7rrrLrbYYgsuu+wyRowYwcCBA7n77rsrHZZZ1fJPMLMidOvWbf306NGjG6i5MUnXArUD9g1JZb2AW4D+wBLgmIh4J80bB4wB1gJnRsR9JXkCZi3MRzJmBdh///0B2Gqrrejevfv6v9rHBZgCjKhTdi4wIyIGATPSYyQNJhtrabe0zFWSOpTkiZi1MB/JmBXgkUceAWDlypVNWj4iHpbUv07xSOCgNH092bAX56TymyNiNbBY0iJgGPB4kzZuVkE+kjEr0Lp16xgypKTDF22XRngl/e+TyncAXsuptzSVmbU6TjJmBdpss83Yc889efXVV8u9KeUpi7wVpbGS5kias2LFijKHZVY8ny4zK8KyZcvYbbfdGDZs2EaNAKZNm9aU1b0pqW9ELJPUF1ieypcCO+bU6we8kW8FETEJmARQU1OTNxGZVZKTjFkRxo8fX8rVTQNGAxPT/7tyym+SdCmwPTAImF3KDZu1FCcZsyLcc889XHTRRRuVnXPOORx44IENLidpKtlF/m0lLQXGkyWXWyWNAV4FjgaIiPmSbgVeANYAp0fE2hI/FbMW4WsyZkV44IEHNikrpPv/iDg+IvpGRKeI6BcRv4+ItyLi0IgYlP6/nVN/QkQMjIhPR4THF7BWy0cyZgW4+uqrueqqq3j55ZfZY4891pevXLnSHWSaNcBJxqwA3/zmNzniiCMYN24cEydOXF++1VZb0atXrwpGZlbdnGTMCtCjRw969OjB1KlTKx2KWaviazJmZlY2TjJmZlY2TjJmZlY2TjJmZlY2TjJmZlY2TjJmZlY2TjJmZlY2TjJmZlY2TjJmZlY2TjJmZlY2LZ5kJO0o6SFJL0qaL+n7qbyXpAckLUz/e+YsM07SIkkLJH0pp3xvSfPSvCsk5RtR0MzMKqQSRzJrgB9GxGeAfYHTJQ0GzgVmRMQgYEZ6TJp3HLAbMAK4SlKHtK6rgbFkgzoNSvPNzKxKtHiSiYhlEfF0ml4JvAjsAIwErk/VrgdGpemRwM0RsToiFgOLgGFpuNruEfF4RARwQ84yZmZWBSp6TUZSf2AvYBawXUQsgywRAX1StR2A13IWW5rKdkjTdcvNzKxKVCzJSNoSuB04KyLeb6hqnrJooDzftsZKmiNpzooVK4oP1szMmqQiSUZSJ7IEc2NE3JGK30ynwEj/l6fypcCOOYv3A95I5f3ylG8iIiZFRE1E1PTu3bt0T8TMzBpUidZlAn4PvBgRl+bMmgaMTtOjgbtyyo+T1FnSALIL/LPTKbWVkvZN6/xWzjJmZlYFKnEksx/wL8AhkuamvyOBicDhkhYCh6fHRMR84FbgBeBe4PSIWJvWdRowmawxwN+A6S36TMxKQNLZqTn/85KmSurSUJN+s9akxYdfjohHyH89BeDQepaZAEzIUz4HGFK66MxalqQdgDOBwRHxoaRbyZrsDyZr0j9R0rlkTfrPqWCoZk3iO/7NKq8jsIWkjkBXsmuL9TXpN2tVnGTMKigiXgcuAV4FlgHvRcT91N+kfyNuOVki/iYsG7+0ZhWUrrWMBAYA2wPdJJ1Y6PJuOWnVzknGrLIOAxZHxIqI+AS4AxhO/U36rRzWVTqAtstJxqyyXgX2ldQ1NcU/lKyrpfqa9Ju1Ki3euszMNoiIWZJuA54m6zz2GWASsCVwq6QxZIno6MpF2fZt3rVTpUNos5xkzCosIsYD4+sUr6aeJv1Wept1aLyONY1Pl5lZu9en/3aVDqHNcpIxs3bv7dffqnQIbZaTjJm1e126bVHpENosJxkza/d22m3HxitZkzjJmFm712nz+rpTtOZykjGzdm/dWn8VlotfWTNr97pt2bnSIbRZTjJm1u598smaSofQZjnJmFm70HHz+u+43G/UPi0YSfviJGNm7cKaj9fWO2/pwtdbMJL2xUnGzNqFjpvX34tWz949WjCS9sVJxszahU5dGkgyn+rVgpG0L04yZtYudOlWfwuyLl03b8FI2hcnGTNrFz43Yq/8MwQ7D/Yd/+XiJGNm7cJbr7+Tf0bAh6s+atlg2hEnGTNrF4YePITNNtu0+5gu3TrTfZutKhBR++AkY2btwvJXVrBuXdCtR1eue+lyTvjJ1wFY/b+rWbd2XYWja7s8MqaZtQt9B32KLlt24Tez/oN+u2zPST87jtUffsz0yTPo2MlDY5aLj2TMrF346P2P+GjVRzx571wAVr6zimdnzueT1Z+wbl1UNrg2zEcyZhUmaWtgMjAECOAUYAFwC9AfWAIcExH1XLm2Qhz/b//My/Ne4aqzrmPVOx/w+J/nsGTeq4y/41/Zpm/PSofXZvlIxqzyLgfujYhdgT2BF4FzgRkRMQiYkR5bM3Ts1JHzpp7F0EOGcMNPb2XhUy8z/o5/ZZ8jP1vp0No0JxmzCpLUHTgA+D1ARHwcEe8CI4HrU7XrgVGViK+t+XDVR7z/j5XrH7+x6O8VjKZ9cJIxq6x/AlYA10l6RtJkSd2A7SJiGUD636eSQbYFK99ZxTlf/Hdee+l1fnrnj9n/a/tw1VnXcecV91Q6tDbNScassjoCnwWujoi9gA8o4tSYpLGS5kias2LFinLF2CZMu/K+9ddgho/8HOdNPYv9v7YP1553E28t8+WucvGFf7PKWgosjYhZ6fFtZEnmTUl9I2KZpL7A8nwLR8QkYBJATU2Nm0g14Lhxo9jny5/l/+w1ANhwjeaVF5b6wn8Z+UjGrIIi4u/Aa5I+nYoOBV4ApgGjU9lo4K4KhNemdOjQYX2CqdWxU0cG7tm/MgG1Ez6SMau8M4AbJW0OvAycTPYD8FZJY4BXgaMrGJ9Zk7X6JCNpBFkT0A7A5IiYWOGQzIoSEXOBmjyzDm3hUMxKrlWfLpPUAbgSOAIYDBwvaXBlozIzs1qtOskAw4BFEfFyRHwM3Ex2f4GZmVWB1p5kdgBey3m8NJWZmVkVaO3XZDYdHCLr+2njStJYYGx6uErSgnrWty3wjxLF1lzVEkuT4tBFZYikdbwmO7dkILmeeuqpf0h6pZ7ZreG1a2nVEku1xAFl2Ldbe5JZCuSOm9oPeKNupdx7CRoiaU5E5LsA2+KqJZZqiQOqJ5ZqiaOuiOhd37xqibla4oDqiaVa4oDyxNLaT5c9CQySNCA1/zyO7P4CMzOrAq36SCYi1kj6HnAfWRPmayNifoXDMjOzpFUnGYCIuAcoVQ93jZ5Sa0HVEku1xAHVE0u1xFGMaom5WuKA6omlWuKAMsSiCHd3ZGZm5dHar8mYmVkVa3dJRlIvSQ9IWpj+5+1+VdISSfMkzZU0p9jlSxGHpB0lPSTpRUnzJX0/Z96Fkl5P8c2VdGQTYhghaYGkRZI26V5emSvS/OckfbbQZUscxwlp+89JekzSnjnz8r5PZYzlIEnv5bzuFxS6bKkVsS/njauhfUjSuFR/gaQvtUAsF0t6Kb3HdyobkhpJ/SV9mBPjb4tZb878ovflpn7WmxpLqT/vzXxNSvf9FxHt6g/4BXBumj4XuKieekuAbZu6fCniAPoCn03TWwH/AwxOjy8EftSM16ED8DeyQbM2B56tXXdOnSOB6WT3I+0LzCp02RLHMRzomaaPqI2jofepjLEcBPy5KctWYl9uKK769iGyLpqeBToDA9LyHcocyxeBjmn6otrlgf7A85XYlwt5TiWOpWSf9+bE0dDnqimvSbs7kqH5w9qWaljcRtcTEcsi4uk0vZJs7PdS9WhQSJc8I4EbIvMEsLWysU1K2Z1Po+uKiMcionZUqSfI7ocqh+Y8r0p0cVTIvtiUuEYCN0fE6ohYDCxK6ylbLBFxf0SsSfWKfY/LtS835bPe5FhK/HlvzmvSkKJfk/aYZAod1jaA+yU9pazHgGKXL1UcQHbaANgLmJVT/L10mHttoYfyOQrpkqe+OqXszqfYdY0h+/VVq773qZyxfF7Ss5KmS9qtyGVLqZB9qLG48u1DTXkupYil1ils/B4PUDY09V8lfaGJ623KvtyUz3pzYlmvBJ/35sZRsu+/Vt+EOR9JDwKfyjPrvCJWs19EvCGpD/CApJci4uEKxIGkLYHbgbMi4v1UfDXw72Q7w78DvyT7cBa82jxldZsa1lenoO58ShhHVlE6mCzJ7J9T3Oz3qchYngZ2johV6bz4n4BBBS5bfEDN34caiqu+fSjvMmWOJasgnQesAW5MRcuAnSLiLUl7A3+StFvO56Cg9TZQp9TvW3NiyWaW5vPe3DhK9rlqk0kmIg6rb56kQoe1fSP9Xy7pTrLDz4cpcFjcUsUhqRPZDndjRNyRs+43c+r8DvhzfduqRyFd8tRXZ/MCli1lHEjaA5gMHBERb9WWN/A+lSWW3C+3iLhH0lWSti30eRSrBPtQvXE1sA/lXaacsaR1jAa+Ahwa6aR/RKwGVqfppyT9DdgFyG3kUa59ueDPeoliKeXnvVlxlOL7b73GLtq0tT/gYja+cPWLPHW6AVvlTD8GjCh0+RLGIeAG4Fd55vXNmT6b7Bx6MdvvSDYK4wA2XBjcrU6dL7PxhcHZhS5b4jh2IrsuMLzQ96mMsXyKDfeXDSMbtVKlfE1KvA/VG1d9+xCwGxtf+H+Zxi/8NzeWEWTDTveus0zv2m2TXcR+HejVEvtyIc+pxJ+rkn3emxlHSb//yvYBqNY/YBtgBrAw/e+VyrcH7snZmZ9Nf/OB8xpbvkxx7E92+PocMDf9HZnm/ScwL82blrsTFhHDkWQtWP5W+xyB7wLfzdnpr0zz5wE1DS3bjPeksTgmA+/kvAZzGnufyhjL99K2niW7QD28oWUrvS83FFdD+xDZKbC/AQvIjh7LHcsisusDte/xb1P513Ne76eBr7bUvlzfcyrX54oSf96bEUdJv/98x7+ZmZVNe2xdZmZmLcRJxszMysZJxszMysZJxszMysZJxszMyqZiSSb1KvqjNP0zSQ3d6DVK0uCWi26jbXeW9GDqjfTYFt72Yy28vaNTD7AP1SnvL+mbDSy3vaTbyhDPSZJ+U+r1FrDdoYX0cptnue9K+lae8v6Sni9iPWvT/rZ9Ect8QdILxWzHrCVUxZFMRFwQEQ82UGUUWc+wlbAX0CkihkbELbkzJHUoxwZr1xsRw0u1rgKNAf5vRBxcp7w/kDfJSOoYEW9ExDeaGGI1Gkp2j8EmJNXbS0ZE/DYibijB9j9M+1vBPQZExH9TT8ytRSv64Vnb7f7PilzuRklvS2pLn5VGtWiSkXSesvENHgQ+nVM+pfaFlzQx/SJ7TtIlkoYDRwEXp193AyV9R9KTyjopvF1S15z1XKFszJGXc99MST9WNj7Cs5ImprKBku5V1gncf0vatU68fYA/AENztr1E0gWSHgGOlnR8Wu/zki7KWXaVpIvSuh+UNEzSzBTXUXlem4OUjSVxE9mNUUhalf7foo3H+pgi6euSOigbh+PJ9HqdWt+66mxrk5iVjYuyP/BbSRfXWWQi8IX0GpydjjD+KOlusk701v9ST9P/Lenp9Dc8J6aZkm5TNm7IjZKU5h2Zyh5J798mXWZI6p3e6yfT33556nRI+8y89Hqckcr3Vta54lOS7lPqaTbFc5Gk2ZL+R9nRwObAz4Bj0/M9Nn2pTJJ0P3CDpJ0lzUjbmCFpp7S+3C/JvdO+9jhwek6Mu6XtzU3LD6r7PPI8r6L2pbagyn94AlwWERc0Xm2DiDiB7EbK9qXcdyXn3Cm6N9kXXlegO9kdvj9K86YA3wB6kd1hXHuT6Na583PvOs2Z/jlwRk69P5Ilz8FkXV1DNgbJY0DX9Lj2buQZwKA0vQ/wlzxxH0TO+CFk4yz8OOdu5lfJur7oCPwFGJXmBelOaeBO4H6gE7AnMLee7XwADMgpW5X+/zNwfZrenOzO6C2AscBPUnlnsv6cBuRbV846G4p5Jjl3QjfwGpxE1u9R7evYnzTmR3p/u6TpQWy4O/8g4D2y/pE2Ax4nS2pd0vMZkOpNrd1W2s5v0vRNwP5peifgxTxxnkbW71PtuCS90mv+GKm7EuBY4Nqc5/vLnLujH6y73fT4QuApYIv0+G5gdJo+BfhTTr3affo54MA0fXHO6/Nr4ISc93KLPM9jVZ3HBe1LFDD2SrX9kfUssAB4ML33G30npOmJZF3OPAdcQja+0NvAYrK74gcC3wGeJLtL/XY2fNanAFekfeBlNv4e+THZd9KzwMRUNhC4N73f/w3smifm9e9zzuPr0/uyBPga2bgr89K6OuXUnZIbQ3v4a8kOMr8A3BkR/wsgKV9Gfx/4CJgs6b+ovxO4IZJ+DmwNbAnclzPvTxGxDnhB0nap7DDgutptR8Tbyno6HQ78Mf2ghuyLuhC1p80+B8yMiBXpOd0IHEDWM+/HZDsYZDvb6oj4RNI8si+DfGZHNn5HXdOBKyR1Juvj6eGI+FDSF4E9tOGIrQfZF/vHDayroZiL8UBEvJ2nvBPwG0lDgbVknRnmPr+labtzyV6HVcDLObFOJUuedR0GDM55r7pL2iqycTdy6/w20rgk6X0eAgwh60kWssGcluUsU9sJ4VPU/74ATIuID9P058m+SCDr7uMXuRUl9SD7gfTXnDpHpOnHgfMk9QPuiIiFDWyzVlP2paqnrFfl48hOSXck6zbmqTp1epH9yNo1IkLS1hHxbvr++HNE3JbqvRsRv0vTPyc79fvrtJq+ZD9odiU7krhN0hFkR0P7RMT/pu0ATCLrdmWhpH2Aq4BDCng6A4GDyX7cPg58PSJ+rKxzyS9T/OerzWjpXpgb7MMmItZIGgYcSrbzfY/8b/AUsl/fz0o6iexXcq3VOdPK+V9325sB70bE0AJjz/VBnfXn80mkny7AOjb0JLtO9Z/X/yBfYUR8JGkm8CWyX+JTc7Z/RkTkJlkkHVTfuhqJuRj1rf9s4E2yX9mbkf1oqJX73qwl2/8KjWcz4PM5X/T55HufBcyPiM/Xs0xtTLXx1Ke+50s928y7r0fETZJmkX3x3Cfp2xHxlwbWDU3bl1qDtvTDc3pO4u/Axj8K+he4jjapJa/JPAz8s6QtJG0FfLVuhfQm94iIe4CzyC7AAqwkG4601lbAMmXdYp9QwLbvB07Rhms3vSLrsn2xpKNTmZQzdnyBZgEHStpW2QX244G/NrJMU90MnEz2waz9AN0HnJZeByTtIqlbGWKu+/o3pAewLH2o/4XsA9eQl4B/UjZIE2RJNJ/7yX50AFkLsHrqfLf2izf9Ol0A9Jb0+VTWSRsGGqtPY8/3MbIfQZDtf4/kzoyId4H3JO2fU6c27n8iO3K7guxX9R6NxNLWNfrDk6y369vJjjzurafqFOB7EbE78FOy07C1iv7hmfP3mUKeBDmJn01/FLTmHwLN1mJJJrJhRW8hO4d6O9n5zrq2Av4s6TmyL76zU/nNwL8qGx1vIHA+2ZflA2RfUo1t+16yD/ScdJrmR2nWCcAYSbW9jY4s8jktA8YBD5F6iY2Iu4pZRxHuJzut9WBkw6lC1jvxC8DTyi68X0MjO3QTY34OWJMuZJ/dSN2rgNGSniA7VdbQEQDpyOT/Avcqa0zxJtm1m7rOBGrSxfIXyHqTrWsy2fWm59J7+s30Wn0DuCiVzSX7tdqQh8hOzdXXbP1M4OS0n/4L8P08dU4GrkwX/nOPvo4Fnk/74a5kXbu3V23xh6fV4V6YreIkbRnZSJO1XY8vjIjLKh1XpUhaFRFbNmG5/mTXKYaUPqryUDYS5reAV8gak7wQEZdImkJ2auxR4C6yIxMBl0TE9cpaF/6O7AjiG8AXyS7kv0J2imqriDipdj05127Wv7aSzk3b/phsOIJ/kzSAbBTKvmTXF2+OiI2aKku6kKxxxiX1PM7dRt15G8XTHjjJWMWlo6PRZK2tngG+U3uuvD2S9AbZiINHRoH3ykj6AtlR5FsRcVAZw2v36iaOIpedgpOMmZnVR9m9UGPJjnIKvlcmteQcTtZYp9jh0lstJxkzMyubquhWxszM2iYnGTMzKxsnGTMzKxsnGTMzKxsnGTMzK5v/D1sSgFU8OsWKAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxCklEQVR4nO3de7xUdb3/8debS4gmCIiGoEKGpxQTY6eG5t3COgmVF8yKjBPmzy526pTU8VInHkfT8milSWpgecnjJcnUVNQ8moCgCKISJGRbOUJeEDxJAp/fH+s7MGxm7z2z96w9s9nv5+Mxj1nzXeu71mfNrDWftb7rpojAzMwsD91qHYCZmW27nGTMzCw3TjJmZpYbJxkzM8uNk4yZmeWmR60D6Gg777xzDB06tNZh2DZq3rx5f4uIgbWYtpdty1Nbl+3ckoyk7YCHgF5pOjdHxHmSzge+AKxKg347Iu5MdSYDE4ENwFci4vepfBQwDegN3Al8NSJCUi/gWmAU8DJwckQsbymuoUOHMnfu3CrOqdlmkv5Sq2l72bY8tXXZzrO5bB1wVETsD4wExkg6OPW7JCJGplchwewDjAf2BcYAl0vqnoa/ApgEDE+vMal8IvBqRLwLuAS4MMf5MTOzCuWWZCKzNn3smV4tXfk5FrgxItZFxDJgKXCgpEFAn4h4NLIrR68FxhXVmZ66bwaOlqQqz4qZmbVRrgf+JXWXNB9YCdwbEbNTry9JWiDpGkn9Utlg4K9F1RtT2eDU3bR8izoRsR5YDQzIY17MzKxyuSaZiNgQESOBIWR7JSPImr72ImtCWwH8MA1eag8kWihvqc4WJE2SNFfS3FWrVpWoYmZmeeiQU5gj4jXgQWBMRLyUks9G4OfAgWmwRmD3ompDgBdT+ZAS5VvUkdQD6Au8UmL6UyOiISIaBg6syYk/ZlYHrvzmL7b4vGHDBq781rTaBNNF5JZkJA2UtFPq7g0cAzybjrEUfBx4KnXPAMZL6iVpGNkB/jkRsQJYI+ngdLzls8DtRXUmpO4TgPvDd/y0OiNpd0kPSHpG0iJJX03l/SXdK2lJeu9XVGeypKWSFkv6cO2i33Yc2+1Ebr74To7tcSKQJZgxPcdz80W/4+Q9JtU4um1XntfJDAKmpzPEugE3RcQdkn4paSRZs9Zy4HSAiFgk6SbgaWA9cGZEbEjjOoPNpzDflV4AVwO/lLSUbA9mfI7zY9ZW64GvR8TjknYE5km6F/gcMDMiLpB0NnA28K0mZ1ruBtwnae+i9cHaYyNZotm4ueiVxldrF882LrckExELgANKlH+mhTpTgCklyucCI0qUvwmc2L5IzfKV9sZXpO41kp4hO2llLHBEGmw6WZPytyg60xJYljaiDgQe7djIt2EbWx/EqsO3lTHrQJKGkm18zQZ2TQmokIh2SYM1d6ZlqfH5pBara13utjJWmaFn/65N9ZZf8NEqR9L5SXo7cAtwVkS83sIlXWWdNQnZSS3AVICGhgYfj7S64z0Zsw4gqSdZgrkuIm5NxS8VToRJ7ytTeXNnWpp1Ok4yZjlLZ0VeDTwTET8q6lV8duQEtjxrcqszLTsqXrNqcnOZWf4OAT4DLEx3wAD4NnABcJOkicDzpJNYWjnT0qxTcZIxy1lEPEzp4ywARzdTp+SZlmadjZvLzMwsN04yZmaWGycZMzPLjZOMmZnlxknGzMxy4yRjZma5cZIxM7PcOMmYmVlunGTMzCw3TjJmZpYbJxkzM8uNk4yZmeXGScbMzHLjJGNmZrlxkjEzs9w4yZiZWW5ySzKStpM0R9KTkhZJ+m4q7y/pXklL0nu/ojqTJS2VtFjSh4vKR0lamPpdlh5nS3o87a9T+WxJQ/OaHzMzq1yeezLrgKMiYn9gJDBG0sHA2cDMiBgOzEyfkbQPMB7YFxgDXC6pexrXFcAksmedD0/9ASYCr0bEu4BLgAtznB8zM6tQbkkmMmvTx57pFcBYYHoqnw6MS91jgRsjYl1ELAOWAgdKGgT0iYhHIyKAa5vUKYzrZuDowl6OmZnVXq7HZCR1lzQfWAncGxGzgV0jYgVAet8lDT4Y+GtR9cZUNjh1Ny3fok5ErAdWAwNKxDFJ0lxJc1etWlWluTMzs9bkmmQiYkNEjASGkO2VjGhh8FJ7INFCeUt1msYxNSIaIqJh4MCBrURtVn2SrpG0UtJTRWUjJc2SND9tBB1Y1K/k8UmzzqZDzi6LiNeAB8mOpbyUmsBI7yvTYI3A7kXVhgAvpvIhJcq3qCOpB9AXeCWPeTBrp2lsPpZY8APgu2lD7Nz0ubXjk2adSp5nlw2UtFPq7g0cAzwLzAAmpMEmALen7hnA+HTG2DCyA/xzUpPaGkkHp+Mtn21SpzCuE4D703Ebs7oSEQ+x9QZQAH1Sd182bzyVPD7ZIYGaVVmPHMc9CJietsC6ATdFxB2SHgVukjQReB44ESAiFkm6CXgaWA+cGREb0rjOINsS7A3clV4AVwO/lLSUbAUen+P8mFXbWcDvJV1Mto6MTuWDgVlFwxUfh9yCpElkZ16yxx575BaoWVvllmQiYgFwQInyl4Gjm6kzBZhSonwusNXxnIh4k5SkzDqhM4CvRcQtkk4i22g6hjKPNUJ2vBGYCtDQ0OC9eKs7vuLfrHYmALem7v9mc5NYc8cnzTodJxmz2nkRODx1HwUsSd0lj0/WID6zdsvzmIyZJZJuAI4AdpbUCJwHfAG4NJ0Z+Sbp2EorxyfNOhUnGbMOEBGnNNNrVDPDlzw+adbZuLnMzMxy4yRjZma5cZIxM7PcOMmYmVlunGTMzCw3TjJmZpYbJxkzM8uNk4yZmeXGScbMzHLjJGNmZrlxkjEzs9w4yZiZWW6cZMzMLDdOMmZmlhsnGTMzy42TjJmZ5cZJxszMcpPbkzEl7Q5cC7wD2AhMjYhLJZ1P9tjZVWnQb0fEnanOZGAisAH4SkT8PpWPAqYBvYE7ga9GREjqlaYxCngZODkiluc1T9Z1HX/88a0O079//w6IxKxzyfPxy+uBr0fE45J2BOZJujf1uyQiLi4eWNI+wHhgX2A34D5Je6dnm19B9vzzWWRJZgxwF1lCejUi3iVpPHAhcHKO82Rd1DPPPMNVV13VbP+I4Mwzz+zAiMw6h9ySTESsAFak7jWSngEGt1BlLHBjRKwDlklaChwoaTnQJyIeBZB0LTCOLMmMBc5P9W8GfiJJERHVnyPryqZMmcLhhx/e4jDnnXceJ5/sbRyzYh1yTEbSUOAAYHYq+pKkBZKukdQvlQ0G/lpUrTGVDU7dTcu3qBMR64HVwIAS058kaa6kuatWrWra26xVJ510UruGScv6SklPNSn/sqTFkhZJ+kFR+WRJS1O/D7cndrNayj3JSHo7cAtwVkS8Ttb0tRcwkmxP54eFQUtUjxbKW6qzZUHE1IhoiIiGgQMHVjYDZsCGDRu48sorOeecc3jkkUe26Pf973+/nFFMI2vm3UTSkWR74++NiH2Bi1N5cdPxGOBySd3bOw9mtZBrkpHUkyzBXBcRtwJExEsRsSEiNgI/Bw5MgzcCuxdVHwK8mMqHlCjfoo6kHkBf4JV85sa6stNPP50//OEPDBgwgK985Sv867/+66Z+t956a6v1I+Ihtl42zwAuSE3ERMTKVL6p6TgilgFL2byemHUquSUZSQKuBp6JiB8VlQ8qGuzjQKH5YAYwXlIvScOA4cCcdGxnjaSD0zg/C9xeVGdC6j4BuN/HYywPc+bM4frrr+ess85i9uzZrF27lk984hOsW7eOdixyewMflDRb0h8kvT+VN9d0vBU3BVu9y3NP5hDgM8BRkuan10eAH0haKGkBcCTwNYCIWATcBDwN3A2cmc4sg2yL7yqyLbo/kx30hyyJDUgnCfwrcHaO82Nd2D/+8Y9N3T169GDq1KmMHDmSo446irVr17Z1tD2AfsDBwL8BN6UNqbKagcFNwVb/8jy77GFKryx3tlBnCjClRPlcYESJ8jeBE9sRpllZGhoauPvuuxkzZvNhlXPPPZfddtuNM844o62jbQRuTXvfcyRtBHam+aZjs07HV/ybleFXv/rVFgmm4F/+5V9466232jra3wBHAUjaG3gb8DeaaTpu60TMainPizHNtjkbNmyge/fKT/SSdANwBLCzpEbgPOAa4Jp0WvM/gAlpr2aRpELT8Xq2bDo261ScZMzKtGbNGk455RTuuOOOiutGxCnN9Pp0M8OXbDo262zcXGZWhhUrVnDMMccwadKkWodi1ql4T8asDB/84Ae56KKLyrpRpplt5j0ZszL069ePF154odZhmHU6TjJmZXjwwQe56667+OlPf1rrUMw6FScZszLssMMOzJgxgyeeeKLWoZh1Kk4yZmXq3r17i8+UMbOt+cC/WRu8/vrrrF+/ftNnPxXTrDQnGbMKXHnllZx77rn07t2b7DZjIInnnnuuxpGZ1ScnGbMKXHzxxSxatIidd9651qGYdQo+JmNWgb322ovtt9++1mGYdRrekzGrwH/+538yevRoDjroIHr16rWp/LLLLqthVGb1y0nGrAKnn346Rx11FPvttx/durkhwKw1TjJmFejRowc/+tGPWh/QzAAfkzGryJFHHsnUqVNZsWIFr7zyyqaXmZXmPRmzClx//fVAdmymwKcwmzXPScasAsuWLat1CGadSovNZZJeb+W1RtKfOipYs1p5/PHHqzKMWVfT2p7MnyPigJYGkOQ7Bto277TTTuPBBx8kezpyaRMnTuzAiMw6h9aSzCfLGEc5w5h1aqtXr2bUqFEtJpmBAwd2YERmnUOLSSYitjqaKemfI+KOloZJw+0OXAu8A9gITI2ISyX1B34NDAWWAydFxKupzmRgIrAB+EpE/D6VjwKmAb2BO4GvRkRI6pWmMQp4GTg5IpaXOe9mZVu+fHlZwxXuZ2Zmmbacwvy9ModbD3w9It4DHAycKWkf4GxgZkQMB2amz6R+44F9gTHA5ZK6p3FdAUwChqfXmFQ+EXg1It4FXAJc2Ib5McudpGskrZT0VIl+35AUknYuKpssaamkxZI+3LHRmlVPW5JMWZtqEbEiIh5P3WuAZ4DBwFhgehpsOjAudY8FboyIdRGxDFgKHChpENAnIh6NrK3i2iZ1CuO6GTha3pS0+jSNzRtHm6Q9/mOB54vKWtrgMutU2pJkTq+0gqShwAHAbGDXiFgBWSICdkmDDQb+WlStMZUNTt1Ny7eoExHrgdXAgBLTnyRprqS5q1atqjR8s3aLiIeAUldtXgJ8Eyg+2FNygyv/KM2qr8VjMpLeV9gbKYiIOa0N06T/24FbgLMi4vUWdjRK9YgWyluqs2VBxFRgKkBDQ0PzR27NyvDqq6+yZMkS3nzzzU1lhx12WMXjkXQ88EJEPNlkvRgMzCr6XLxh1XQck8iaktljjz0qjsEsb62dXfYLSUfQchPZ1WR7KVuR1JMswVwXEbem4pckDYqIFakpbGUqbwR2L6o+BHgxlQ8pUV5cp1FSD6AvpbcWzariqquu4tJLL6WxsZGRI0cya9YsPvCBD3D//fdXNB5J2wPfAT5UqneJspIbR96AsnrXWnNZX2BeK6+3SlVMx0auBp6JiOI7Cs4AJqTuCcDtReXjJfWSNIzsAP+c1KS2RtLBaZyfbVKnMK4TgPujpXNMzdrp0ksv5bHHHmPPPffkgQce4Iknnmjrqct7AcOAJyUtJ9t4elzSO2h+g8us02ntFOah7Rj3IcBngIWS5qeybwMXADdJmkh2sPPENK1Fkm4CniY7M+3MiNiQ6p3B5lOY70ovyJLYLyUtJduDGd+OeM1atd1227HddtsBsG7dOt797nezePHiiscTEQvZfDySlGgaIuJvkmYA10v6EbAbaYOrCuGbdbjc7l0WEQ/TfDPb0c3UmQJMKVE+FxhRovxNUpIy6whDhgzhtddeY9y4cRx77LH069eP3XbbrdV6km4AjgB2ltQInBcRV5catpUNLrNOxTfINKvAbbfdBsD555/PkUceyerVqxkzZqszk7cSEae00n9ok88lN7jMOhsnGbMKPfzwwyxZsoTTTjuNVatW8cILLzBs2LBah2VWl8q6TkbSzHLKzLZ13/3ud7nwwgs3PU/mrbfe4tOf/nSNozKrX61dJ7MdsD1ZO3I/Nh9j6UN2QNKsS7ntttt44okneN/73gfAbrvtxpo1a2oclVn9aq257HTgLLKEMo/NSeZ14Kf5hWVWn972trchadONMN94440aR2RW31psLouISyNiGPCNiHhnRAxLr/0j4icdFKNZ3TjppJM4/fTTee211/j5z3/OMcccwxe+8IVah2VWt8o68B8RP5Y0muz2/D2Kyq/NKS6zuhMRnHzyyTz77LP06dOHxYsX873vfY9jjz221qGZ1a2ykoykX5JdoTyf7FkvkN3mwknGugxJjBs3jnnz5jmxmJWp3FOYG4B9fMsW6+oOPvhgHnvsMd7//vfXOhSzTqHcJPMU2RMuV+QYi1nde+CBB7jyyivZc8892WGHHYgIJLFgwYJah2ZWl8pNMjsDT0uaA6wrFEbE8blEZVan7rrrrtYHMrNNyk0y5+cZhFlnseeeewKwcuXKLZ4nY2allXt22R/yDsSsM5gxYwZf//rXefHFF9lll134y1/+wnve8x4WLVpU69DM6lK5t5VZI+n19HpT0gZJr+cdnFm9Oeecc5g1axZ77703y5YtY+bMmRxyyCG1DsusbpWVZCJix4jok17bAZ8EfDGmdTk9e/ZkwIABbNy4kY0bN3LkkUcyf/78WodlVrfadBfmiPiNpLOrHYxZvdtpp51Yu3Ythx12GKeeeiq77LILPXr4ZuZmzSn3YsxPFH3sRnbdjK+ZsS7n9ttvp3fv3lxyySVcd911rF69mnPPPbfWYZnVrXI3wT5W1L0eWA6MrXo0ZnVuhx12AKBbt25MmDChxtGY1b9yzy47Le9AzMxs21Pu2WVDJN0maaWklyTdImlI3sGZmVnnVlaSAX4BzCB7rsxg4LepzKzL+fvf/87ixYsrqiPpmrSR9lRR2UWSnpW0IG3E7VTUb7KkpZIWS/pw9aI361jlJpmBEfGLiFifXtOAgS1VaGalOl/SC5Lmp9dHivqVXKkkjZK0MPW7TOlpUZJ6Sfp1Kp8taWglM27WFr/97W8ZOXIkY8aMAWD+/Pkcf3xZd1eaBoxpUnYvMCIi3gv8CZgMIGkfYDywb6pzuaTuVZkBsw5WbpL5m6RPS+qeXp8GXm6lzjS2XqkALomIkel1J7S6Ul0BTAKGp1dhnBOBVyPiXcAlwIVlzotZm51//vnMmTOHnXbaCYCRI0eyfPnyVutFxEPAK03K7omI9enjLKDQBD0WuDEi1kXEMmApcGBVZsCsg5WbZD4PnAT8L9mdmE9IZc0qtVK1oORKJWkQ0CciHk2PGbgWGFdUZ3rqvhk4urCXY5aXHj160Ldv3zxG/XmgcPfNwcBfi/o1pjKzTqfcK/6fj4jjI2JgROwSEeMi4i9tnOaXUhv0NZL6pbLmVqrBqbtp+RZ10tbgamBAqQlKmiRprqS5q1atamPYZjBixAiuv/56NmzYwJIlS/jyl7/M6NGj2zVOSd8huzTgukJRicFKXpfmZdvqXblnl01vclCyn6Rr2jC9K8iesDmSbI/oh4VRlhg2Wihvqc7WhRFTI6IhIhoGDmzxUJJZi3784x+zaNEievXqxSmnnEKfPn34r//6rzaPT9IE4J+BU4seCtgI7F402BDgxVL1vWxbvSv3Ysz3RsRrhQ8R8aqkAyqdWES8VOiW9HPgjvSxuZWqkc3t1MXlxXUaJfUA+lJ+85xZm2y//fZMmTKFKVOmtHtcksYA3wIOj4j/K+o1A7he0o/IzugcDsxp9wTNaqDcJNNNUr+IeBVAUv8K6m4iaVBEFJ6u+XGyJ25CMytVRGxId4A+GJgNfBb4cVGdCcCjZMeI7vfjoS0vH/vYx2jpkN+MGTNarC/pBuAIYGdJjcB5ZGeT9QLuTeOeFRFfjIhFkm4CniZrRjszIjZUYz7MOlq5ieKHwB8l3UzWJHUS0OKmXDMr1RGSRqZxLAdOB2hlpTqD7Ey13mQHRgsHR68GfilpKdkezPgy58WsYt/4xjfaVT8iTilRfHULw0+hlXXMrDMo97Yy10qaCxxFdizkExHxdCt1qrJSRcRcYESJ8jeBE1sJ3awqDj/88FqHYNYpld3klZJKi4nFbFu33377bdVs1rdvXxoaGvj3f//3GkVlVr/8IAyzChx33HF0796dT33qUwDceOONRAR9+/blc5/7XG2DM6tDTjJmFXjkkUd45JFHNn3eb7/9OOSQQ3jkkUf41a9+VcPIzOpTuVf8mxmwdu1aZs+evenznDlzWLt2LYCfkGlWgtcKswpcddVVfP7zn2ft2rVEBH369OGqq67ijTfeYPLkyZx88sm1DtGsrjjJmFXg/e9/PwsXLmT16tVExKYbZQKcdNJJTjJmTTjJmFVg3bp13HLLLSxfvpz169dvKj/33HNrGJVZ/XKSMavA2LFj6du3L6NGjaJXr161Dses7jnJmFWgsbGRu+++u9ZhmHUaPrvMrAKjR49m4cKFtQ7DrNPwnoxZBR5++GGmTZvGsGHD6NWrFxGBJBYsWFDr0MzqkpOMWQXuuuuu1gcys02cZMwqsOeeewKwcuVK3nzzzRpHY1b/fEzGrAIzZsxg+PDhDBs2jMMPP5yhQ4dy3HHH1Toss7rlJGNWgXPOOYdZs2ax9957s2zZMmbOnMkhhxxS67DM6paTjFkFevbsyYABA9i4cSMbN27kyCOPZP78+bUOy6xu+ZiMWQV22mkn1q5dy2GHHcapp57KLrvs4htjmrXAezJmFbj99tvp3bs3l1xyCWPGjGGvvfbit7/9ba3DMqtb3gQzq8AOO+ywqXvChAk1jMSsc/CejFkZDj30UAB23HFH+vTps+lV+NwaSddIWinpqaKy/pLulbQkvfcr6jdZ0lJJiyV9OI95MusITjJmZXj44YcBWLNmDa+//vqmV+FzGaYBY5qUnQ3MjIjhwMz0GUn7AOOBfVOdyyV1r8qMmHUwJxmzMm3cuJERI0a0qW5EPAS80qR4LDA9dU8HxhWV3xgR6yJiGbAUOLBNEzarsdySTLWaBySNkrQw9btMklJ5L0m/TuWzJQ3Na17MALp168b+++/P888/X61R7hoRKwDS+y6pfDDw16LhGlPZViRNkjRX0txVq1ZVKy6zqslzT2Ya1WkeuAKYBAxPr8I4JwKvRsS7gEuAC3ObE7NkxYoV7Lvvvhx99NEcf/zxm15VphJlUWrAiJgaEQ0R0TBw4MBqx2HWbrmdXRYRD5XYuxgLHJG6pwMPAt+iqHkAWCZpKXCgpOVAn4h4FEDStWRNCnelOuencd0M/ESSIqLkymhWDeedd141R/eSpEERsULSIGBlKm8Edi8abgjwYjUnbNZROvqYTKXNA4NTd9PyLepExHpgNTCg1ETdpGDVcuedd3L44Ydv8brzzjvbOroZQOE86AnA7UXl41OT8DCyPfg57QrcrEbq5cB/c80DLTUbuEnBOty99967VVk5t/+XdAPwKPBPkholTQQuAI6VtAQ4Nn0mIhYBNwFPA3cDZ0bEhmrNg1lH6uiLMSttHmhM3U3Li+s0SuoB9GXrs3fMquKKK67g8ssv57nnnuO9733vpvI1a9aUdYPMiDilmV5HNzP8FGBKW2I1qycdnWQKzQMXsHXzwPWSfgTsRmoeiIgNktZIOhiYDXwW+HGTcT0KnADc7+MxlpdPfepTHHfccUyePJkLLrhgU/mOO+5I//79axiZWX3LLcmk5oEjgJ0lNQLnkSWXm1JTwfPAiZA1D0gqNA+sZ8vmgTPIzlTrTXbAv9A2cTXwy3SSwCtkZ6eZ5aJv37707duXG264odahmHUqeZ5dVpXmgYiYC2x1BVxEvElKUmZmVp/q5cC/mZltg5xkzMwsN04yZmaWGycZMzPLjZOMmZnlxknGzMxy4yRjZma5cZIxM7PcOMmYmVlunGTMzCw3TjJmZpYbJxkzM8uNk4yZmeXGScbMzHLjJGNmZrlxkjEzs9w4yZiZWW6cZMxqTNLXJC2S9JSkGyRtJ6m/pHslLUnv/Wodp1lbOMmY1ZCkwcBXgIaIGAF0B8YDZwMzI2I4MDN9Nut0nGTMaq8H0FtSD2B74EVgLDA99Z8OjKtNaGbt4yRjVkMR8QJwMfA8sAJYHRH3ALtGxIo0zApgl1L1JU2SNFfS3FWrVnVU2GZlq0mSkbRc0kJJ8yXNTWXNtkFLmixpqaTFkj5cVD4qjWeppMskqRbzY9ZWaTkfCwwDdgN2kPTpcutHxNSIaIiIhoEDB+YVplmb1XJP5siIGBkRDelzyTZoSfuQtVHvC4wBLpfUPdW5ApgEDE+vMR0Yv1k1HAMsi4hVEfEWcCswGnhJ0iCA9L6yhjGatVk9NZc11wY9FrgxItZFxDJgKXBgWvH6RMSjERHAtbjd2jqf54GDJW2f9sSPBp4BZgAT0jATgNtrFJ9Zu/So0XQDuEdSAFdGxFSatEFLKrRBDwZmFdVtTGVvpe6m5VuRNIlsj4c99tijmvNh1i4RMVvSzcDjwHrgCWAq8HbgJkkTyRLRibWL0qztapVkDomIF1MiuVfSsy0MW+o4S7RQvnVhlsSmAjQ0NJQcxqxWIuI84LwmxevI9mrMOrWaNJdFxIvpfSVwG3AgzbdBNwK7F1UfQnaKZ2PqblpuZmZ1osOTjKQdJO1Y6AY+BDxF823QM4DxknpJGkZ2gH9OalpbI+ng1Jb9WdxubWZWV2rRXLYrcFs627gHcH1E3C3pMUq0QUfEIkk3AU+TtVmfGREb0rjOAKYBvYG70svMzOpEhyeZiHgO2L9E+cs00wYdEVOAKSXK5wIjqh2jmZlVRz2dwmxmVhs9ax3AtstJxsxsY60D2HY5yZiZ+Z8wN/5qzazLGzh4QK1D2GY5yZhZlzdwdyeZvDjJmFmX13dAn1qHsM1ykjGzLq9nz1rdYWvb5yRjZl1eyLc0zIuTjJl1eQN361/rELZZTjJm1iV079n8392uQ9/RgZF0LU4yZtYlqFvzT2fv3adXB0bStTjJmFmXsOseA5vtt8vgnTswkq7FScbMuoQjxx+yVVm3Ht3o3rM7Q0f4ibl5cZIxsy5hrwPeuVXZxvUb6f+OndhuBzeX5cVJxsy6hAd//UjJ8r81vsxrK1d3cDRdh5OMmXUJg4btiiR23XPzsZnBe7+D7j17sN0O29Uwsm2bk4xZjUnaSdLNkp6V9IykD0jqL+leSUvSe79ax9nZffJrH2XI3oN4ZcWrfPe2b3LoJw7ihT/9L2PPHMOAQf568+IkY1Z7lwJ3R8S7yZ4a+wxwNjAzIoYDM9Nna4ffXXkf/7tsJefd+m+MHvt+vnPDWRz6iYP43dR7eXnFq7UOb5vlG/aY1ZCkPsBhwOcAIuIfwD8kjQWOSINNBx4EvtXxEW47xk8ex0EffR/vOmAYAD169uA7N5zFX55u9J5MjrwnY1Zb7wRWAb+Q9ISkqyTtAOwaESsA0vsupSpLmiRprqS5q1at6rioO6Hu3btvSjAFPXr2YK/9h9YmoC7CScastnoA7wOuiIgDgDeooGksIqZGRENENAwc2PzFhma14iRjVluNQGNEzE6fbyZLOi9JGgSQ3lfWKD6zdun0SUbSGEmLJS2V5IOj1qlExP8Cf5X0T6noaOBpYAYwIZVNAG6vQXhm7dapD/xL6g78FDiWbIvwMUkzIuLp2kZmVpEvA9dJehvwHHAa2QbgTZImAs8DJ9YwPrM269RJBjgQWBoRzwFIuhEYS7YlaNYpRMR8oKFEr6M7OBSzquvsSWYw8Neiz43AQU0HkjQJmJQ+rpW0uJnx7Qz8raoRtl29xNKmOHRhDpF0ju9kz44MpNi8efP+JukvzfTuDN9dR6uXWOolDshh2e7sSabUAyK2eo5qREwFprY6MmluRJTaouxw9RJLvcQB9RNLvcTRVEQ0e3pZvcRcL3FA/cRSL3FAPrF09gP/jcDuRZ+HAC/WKBYzM2uisyeZx4Dhkoalg6bjyc7KMTOzOtCpm8siYr2kLwG/B7oD10TEonaMstUmtQ5UL7HUSxxQP7HUSxyVqJeY6yUOqJ9Y6iUOyCEWRWx1CMPMzKwqOntzmZmZ1TEnGTMzy02XSzLlPgxK0nJJCyXNlzS30vrViEPS7pIeSA+yWiTpq0X9zpf0QopvvqSPtCGGFm/Jo8xlqf8CSe8rt26V4zg1TX+BpD9K2r+oX8nfKcdYjpC0uuh7P7fcutVWwbJcMq6WliFJk9PwiyV9uANiuUjZQ9sWSLpN0k6pfKikvxfF+LNKxlvUv+Jlua3reltjqfb63s7vpHr/fxHRpV7AD4CzU/fZwIXNDLcc2Lmt9asRBzAIeF/q3hH4E7BP+nw+8I12fA/dgT+T3Wr+bcCThXEXDfMR4C6y65EOBmaXW7fKcYwG+qXu4wpxtPQ75RjLEcAdbalbi2W5pbiaW4aAfdJwvYBhqX73nGP5ENAjdV9YqA8MBZ6qxbJczjxVOZaqre/tiaOl9aot30mX25Mhu+3M9NQ9HRjXwfXLHk9ErIiIx1P3GrInJg5u4/Sa2nRLnsgelFW4JU/TGK+NzCxgJ2V3BC6nbtXiiIg/RkTh0YWzyK6HykN75qua30m5ylkW2xLXWODGiFgXEcuApWk8ucUSEfdExPo0XKW/cV7LclvW9TbHUuX1vT3fSUsq/k66YpIp62FQZHcOuEfSPGW3pam0frXiALJmA+AAYHZR8ZfSbu415e7KFyl1S56mC3Rzw5RTt5pxFJtItvVV0NzvlGcsH5D0pKS7JO1bYd1qKmcZai2uUstQW+alGrEUfJ4tf+Nhyh7o9gdJH2zjeNuyLLdlXW9PLJtUYX1vbxxV+//r1NfJNEfSfcA7SvT6TgWjOSQiXpS0C3CvpGcj4qEaxIGktwO3AGdFxOup+ArgP8gWhv8Afki2cpY92hJlTc9nb26Ysm7nU8U4sgGlI8mSzKFFxe3+nSqM5XFgz4hYm9rFfwMML7Nu5QG1fxlqKa7mlqGSdXKOJRtA+g6wHrguFa0A9oiIlyWNAn4jad+i9aCs8bYwTLV/t/bEkvWszvre3jiqtl5tk0kmIo5prp+klwq7pmrhYVAR8WJ6XynpNrLdz4dID5NqrX614pDUk2yBuy4ibi0a90tFw/wcuKO5aTWjnFvyNDfM28qoW804kPRe4CrguIh4uVDewu+USyzFf24RcaekyyXtXO58VKoKy1CzcbWwDJWsk2csaRwTgH8Gjo7U6B8R64B1qXuepD8DewPFJ3nktSyXva5XKZZqru/tiqMa/3+btHbQZlt7ARex5YGrH5QYZgdgx6LuPwJjyq1fxTgEXAv8V4l+g4q6v0bWhl7J9HuQPbtkGJsPDO7bZJiPsuWBwTnl1q1yHHuQHRcYXe7vlGMs72DzRcwHkj3rRdX8Tqq8DDUbV3PLELAvWx74f47WD/y3N5YxZI/oGNikzsDCtMkOYr8A9O+IZbmcearyelW19b2dcVT1/y+3FaBeX8AAYCawJL33T+W7AXcWLcxPptci4Dut1c8pjkPJdl8XAPPT6yOp3y+BhanfjOKFsIIYPkJ2BsufC/MIfBH4YtFC/9PUfyHQ0FLddvwmrcVxFfBq0Xcwt7XfKcdYvpSm9STZAerRLdWt9bLcUlwtLUNkTWB/BhaT7T3mHctSsuMDhd/4Z6n8k0Xf9+PAxzpqWW5unvJar6jy+t6OOKr6/+fbypiZWW664tllZmbWQZxkzMwsN04yZmaWGycZMzPLjZOMmZnlpmZJJt1V9Bup+3uSWrrQa5ykfTouui2m3UvSfelupCd38LT/2MHTOzHdAfaBJuVDJX2qhXq7Sbo5h3g+J+kn1R5vGdMdWc5dbkvU+6Kkz5YoHyrpqQrGsyEtb7tVUOeDkp6uZDpmHaEu9mQi4tyIuK+FQcaR3Rm2Fg4AekbEyIj4dXEPSd3zmGBhvBExulrjKtNE4P9FxJFNyocCJZOMpB4R8WJEnNDGEOvRSLJrDLYiqdm7ZETEzyLi2ipM/+9peSv7jgER8T80E3Nn0Yk2PAu33f9ehfWuk/SKpG1pXWlVhyYZSd9R9nyD+4B/KiqfVvjiJV2QtsgWSLpY0mjgeOCitHW3l6QvSHpM2U0Kb5G0fdF4LlP2zJHnin9MSd9U9nyEJyVdkMr2knS3spvA/Y+kdzeJdxfgV8DIomkvl3SupIeBEyWdksb7lKQLi+qulXRhGvd9kg6U9GCK6/gS380Ryp4lcT3ZhVFIWpvef60tn/UxTdInJXVX9hyOx9L3dXpz42oyra1iVvZclEOBn0m6qEmVC4APpu/ga2kP478l/ZbsJnqbttRT9/9Iejy9RhfF9KCkm5U9N+Q6SUr9PpLKHk6/31a3zJA0MP3Wj6XXISWG6Z6WmYXp+/hyKh+l7OaK8yT9XulOsymeCyXNkfQnZXsDbwO+B5yc5vfk9KcyVdI9wLWS9pQ0M01jpqQ90viK/yRHpWXtUeDMohj3TdObn+oPbzofJearomVpW1DnG54Al0TEua0PtllEnEp2IWXXkvdVyUVXio4i+8PbHuhDdoXvN1K/acAJQH+yK4wLF4nuVNy/+KrTou7vA18uGu6/yZLnPmS3uobsGSR/BLZPnwtXI88Ehqfug4D7S8R9BEXPDyF7zsI3i65mfp7s1hc9gPuBcalfkK6UBm4D7gF6AvsD85uZzhvAsKKyten948D01P02siujewOTgH9P5b3I7uc0rNS4isbZUswPUnQldAvfwefI7ntU+B6Hkp75kX7f7VL3cDZfnX8EsJrs/kjdgEfJktp2aX6GpeFuKEwrTecnqft64NDUvQfwTIk4zyC771PhuST903f+R9LtSoCTgWuK5veHRVdH39d0uunz+cA8oHf6/FtgQur+PPCbouEKy/QC4PDUfVHR9/Nj4NSi37J3iflY2+RzWcsSZTx7pd5eZHcWWAzcl377Lf4TUvcFZLecWQBcTPZ8oVeAZWRXxe8FfAF4jOwq9VvYvK5PAy5Ly8BzbPk/8k2y/6QngQtS2V7A3en3/h/g3SVi3vQ7F32enn6X5cAnyJ67sjCNq2fRsNOKY+gKr468QeYHgdsi4v8AJJXK6K8DbwJXSfodzd8EboSk7wM7AW8Hfl/U7zcRsRF4WtKuqewY4BeFaUfEK8rudDoa+O+0QQ3ZH3U5Cs1m7wcejIhVaZ6uAw4juzPvP8gWMMgWtnUR8ZakhWR/BqXMiez5HU3dBVwmqRfZPZ4eioi/S/oQ8F5t3mPrS/bH/o8WxtVSzJW4NyJeKVHeE/iJpJHABrKbGRbPX2Oa7nyy72Et8FxRrDeQJc+mjgH2Kfqt+kjaMbLnbhQP87NIzyVJv/MIYATZnWQhe5jTiqI6hZsQzqP53wVgRkT8PXV/gOyPBLLbffygeEBJfck2kP5QNMxxqftR4DuShgC3RsSSFqZZ0JZlqe4pu6vyeLIm6R5kt42Z12SY/mQbWe+OiJC0U0S8lv4/7oiIm9Nwr0XEz1P398mafn+cRjOIbIPm3WR7EjdLOo5sb+igiPi/NB2AqWS3XVki6SDgcuCoMmZnL+BIso3bR4FPRsQ3ld1c8qNUvn5tMzr6Lswt3sMmItZLOhA4mmzh+xKlf+BpZFvfT0r6HNlWcsG6om4VvTeddjfgtYgYWWbsxd5oMv5S3oq06QJsZPOdZDeq+Xb9N0oVRsSbkh4EPky2JX5D0fS/HBHFSRZJRzQ3rlZirkRz4/8a8BLZVnY3so2GguLfZgPZ8lduPN2ADxT90ZdS6ncWsCgiPtBMnUJMhXia09z80sw0Sy7rEXG9pNlkfzy/l/QvEXF/C+OGti1LncG2tOF5V1Hi786WGwVDyxzHNqkjj8k8BHxcUm9JOwIfazpA+pH7RsSdwFlkB2AB1pA9jrRgR2CFsttin1rGtO8BPq/Nx276R3bL9mWSTkxlUtGz48s0Gzhc0s7KDrCfAvyhlTptdSNwGtmKWViBfg+ckb4HJO0taYccYm76/bekL7AirdSfIVvhWvIs8E5lD2mCLImWcg/ZRgeQnQHWzDBfLPzxpq3TxcBASR9IZT21+UFjzWltfv9IthEE2fL3cHHPiHgNWC3p0KJhCnG/k2zP7TKyrer3thLLtq7VDU+yu13fQrbncXczg04DvhQR+wHfJWuGLah4w7Po9Z5yZoKixM/WGwWdeUOg3TosyUT2WNFfk7Wh3kLW3tnUjsAdkhaQ/fF9LZXfCPybsqfj7QWcQ/ZneS/Zn1Rr076bbIWem5ppvpF6nQpMlFS42+jYCudpBTAZeIB0l9iIuL2ScVTgHrJmrfsie5wqZHcnfhp4XNmB9ytpZYFuY8wLgPXpQPbXWhn2cmCCpFlkTWUt7QGQ9kz+H3C3spMpXiI7dtPUV4CGdLD8abK7yTZ1FdnxpgXpN/1U+q5OAC5MZfPJtlZb8gBZ01xzp61/BTgtLaefAb5aYpjTgJ+mA//Fe18nA0+l5fDdZLd276q2xQ1Pa8J3Ybaak/T2yJ40Wbj1+JKIuKTWcdWKpLUR8fY21BtKdpxiRPWjyoeyJ2F+FvgL2ckkT0fExZKmkTWNPQLcTrZnIuDiiJiu7OzCn5PtQZwAfIjsQP5fyJqodoyIzxXGU3TsZtN3K+nsNO1/kD2O4NuShpE9hXIQ2fHFGyNii1OVJZ1PdnLGxc18Lp5G035bxNMVOMlYzaW9owlkZ1s9AXyh0FbeFUl6keyJgx+JMq+VkfRBsr3IlyPiiBzD6/KaJo4K607DScbMzJqj7FqoSWR7OWVfK5PO5BxNdrJOpY9L77ScZMzMLDd1cVsZMzPbNjnJmJlZbpxkzMwsN04yZmaWm/8Pp0Lck7vZLagAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEKCAYAAADAVygjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAzoUlEQVR4nO3de7xUVf3/8debi4DI/WIqImSYCSrGiRAyRDTRUqhUUEtSEjMvZfkt+fYV0OL7hTRJskxEA7yTlzz6AxNRNC+AYAgiEiSoCAEmIJigwOf3x15z3Bxmzpk5Z/aZOed8no/HPGbP2nvt+czMnvnM3nvttWRmOOecc0loUOgAnHPO1V2eZJxzziXGk4xzzrnEeJJxzjmXGE8yzjnnEuNJxjnnXGISSzKSmkpaIOlVScskXRfKx0p6V9LicDs9VmeUpFWSVkg6NVbeS9LSMG+SJIXyJpIeCOXzJXVJ6vU455zLXZJ7MjuBk8zsWKAnMEhSnzBvopn1DLeZAJKOAoYB3YFBwB8kNQzL3wqMBLqF26BQPgLYbGafAyYCExJ8Pc4553KUWJKxyPbwsHG4VXTl52DgfjPbaWargVVAb0kHAS3N7CWLrhydDgyJ1ZkWph8EBqb2cpxzzhVeoyRXHvZEFgGfA35vZvMlnQZcLukCYCHwUzPbDBwCzItVXxvKPgnT5csJ9+8AmNkuSVuBdsB7mWJq3769denSJQ+vzrl9LVq06D0z61CI5/Zt2yWpqtt2oknGzHYDPSW1Bh6R1IPo0NcvifZqfgn8BrgISLcHYhWUU8m8MpJGEh1uo3PnzixcuDC3F+JcliS9Vajn7tKli2/bLjFV3bZrpHWZmW0B5gKDzGyDme02sz3A7UDvsNha4NBYtU7AulDeKU35XnUkNQJaAe+nef7JZlZiZiUdOhTkT6ZzztVLSbYu6xD2YJDUDDgZeCOcY0n5JvBamC4FhoUWY12JTvAvMLP1wDZJfcL5lguAR2N1hofps4CnzXv8dM65opHk4bKDgGnhvEwDYIaZPS7pLkk9iQ5rrQEuATCzZZJmAK8Du4DLwuE2gEuBqUAzYFa4AdwB3CVpFdEezLAEX49zzrkcJZZkzGwJcFya8u9WUGccMC5N+UKgR5ryHcDZ1YvUOedcUvyKf+cSJulQSc9IWh4uTP5RKG8rabakleG+TaxO2guTXfVMunLKXo8//vhjfleuzOWXJxnnkreLqKn+F4A+wGXh4uNrgDlm1g2YEx5XdmGyq6JTGpzNY7f8lVObDQWiBPP1pudTestfGX7kFQWOru5KtAmzcw5C45X1YXqbpOVE13gNBk4Mi00jaoH5c2IXJgOrwznH3sBLNRt53bRn5x5ObTaUPTv3lJWt+8e/ChhR3eZ7Ms7VoNC/3nHAfODAkIBSiahjWKzsIuMgfgGyy4N4gnHJ8iTjXA2RdADwEPBjM/ugokXTlKVtmi9ppKSFkhZu2rQpH2E6l1d+uMxVqMs1/69K9daM/3qeI6ndJDUmSjD3mNnDoXiDpIPMbH24fmxjKM90YfI+zGwyMBmgpKTErxFzRcf3ZJxLWLiI+A5guZndFJsVv5h4OHtfZLzPhck1Fa9z+eR7Ms4lrx/wXWCppMWh7L+B8cAMSSOAtwnXfFVyYbJztYonGecSZmbPk/48C8DADHXSXpjsXG3jh8ucc84lxpOMc865xHiScc45lxhPMs455xLjScY551xiPMk455xLjCcZ55xzifEk45xzLjGeZJxzziXGk4xzzrnEeJJxzjmXGE8yzjnnEuNJxjnnXGISSzKSmkpaIOlVScskXRfK20qaLWlluG8TqzNK0ipJKySdGivvJWlpmDcpjM9BGG/jgVA+Pwxt65xzrkgkuSezEzjJzI4FegKDJPUBrgHmmFk3YE54jKSjgGFAd2AQ8AdJDcO6bgVGEg3e1C3MBxgBbDazzwETgQkJvh7nnHM5SizJWGR7eNg43AwYDEwL5dOAIWF6MHC/me00s9XAKqB3GJa2pZm9ZGYGTC9XJ7WuB4GBqb0c55xzhZfoORlJDcNIgBuB2WY2HzjQzNYDhPuOYfFDgHdi1deGskPCdPnyveqY2S5gK9AukRfjXDVIulPSRkmvxcp6SponabGkhZJ6x+alPXTsXG2TaJIxs91m1hPoRLRX0qOCxdPtgVgF5RXV2XvF0sjwJV64adOmSqJ2LhFT+fQwb8qvgevCd2R0eFzZoWPnapUaaV1mZluAuURfmA3hEBjhfmNYbC1waKxaJ2BdKO+UpnyvOpIaAa2A99M8/2QzKzGzkg4dOuTnRTmXAzN7jn23TQNahulWfLpdpz10XCOBOpdnSbYu6yCpdZhuBpwMvAGUAsPDYsOBR8N0KTAstBjrSnSCf0E4pLZNUp9wvuWCcnVS6zoLeDqct3GuNvgxcIOkd4AbgVGhPNOhY+dqnUYJrvsgYFrYzW8AzDCzxyW9BMyQNAJ4GzgbwMyWSZoBvA7sAi4zs91hXZcSHW5oBswKN4A7gLskrSL6lzgswdfjXL5dClxlZg9JOodoez6ZLA8DQ3QomKjlJZ07d04qTueqLLEkY2ZLgOPSlP8bGJihzjhgXJryhcA+53PMbAchSTlXCw0HfhSm/wxMCdOZDh3vw8wmA5MBSkpKfC/eFR2/4t+5wlkH9A/TJwErw3TaQ8cFiM+5akvycJlzLpB0H3Ai0F7SWmAMcDFwc2i0soNw2KuSQ8fO1SqeZJyrAWZ2boZZvTIsn/bQsXO1jR8uc845lxhPMs455xLjScY551xiPMk455xLjCcZ55xzifEk45xzLjGeZJxzziXGk4xzzrnEeJJxzjmXGE8yzjnnEuNJxjnnXGI8yTjnnEuMJxnnnHOJ8STjnHMuMZ5knHPOJcaTjHM1QNKdkjZKeq1c+RWSVkhaJunXsfJRklaFeafWfMTO5YcPWuZczZgK3AJMTxVIGgAMBo4xs52SOobyo4BhQHfgYOApSUf46JiuNvI9GedqgJk9B7xfrvhSYLyZ7QzLbAzlg4H7zWynma0GVgG9ayxY5/LIk4xzhXMEcIKk+ZKelfSlUH4I8E5subWhzLlaJ7EkI+lQSc9IWh6ON/8olI+V9K6kxeF2eqxO2uPQknpJWhrmTZKkUN5E0gOhfL6kLkm9HucS0AhoA/QB/guYEbZtpVnW0q1A0khJCyUt3LRpU3KROldFSe7J7AJ+amZfIPoSXRaONQNMNLOe4TYT9jkOPQj4g6SGYflbgZFAt3AbFMpHAJvN7HPARGBCgq/HuXxbCzxskQXAHqB9KD80tlwnYF26FZjZZDMrMbOSDh06JB6wc7lK7MS/ma0H1ofpbZKWU/Euf9lxaGC1pFVAb0lrgJZm9hKApOnAEGBWqDM21H8QuEWSzCztvz7nqurMM8+sdJm2bdvmutq/ACcBcyUdAewHvAeUAvdKuonoxH83YEGuK3euGNRI67JwGOs4YD7QD7hc0gXAQqK9nc1ECWherFrqOPQnYbp8OcSOXZvZLklbgXZEX1Tn8mb58uVMmTIl43wz47LLLss4X9J9wIlAe0lrgTHAncCdoVnzx8Dw8AdpmaQZwOtERwQu85ZlrrZKPMlIOgB4CPixmX0g6Vbgl0THmH8J/Aa4iMzHoSs6Pp3VsWtJI4kOt9G5c+dcX4JzjBs3jv79+1e4zJgxYxg6dGjaeWZ2boZq38mw/DhgXC4xOleMEm1dJqkxUYK5x8weBjCzDWa228z2ALfzadPMTMeh14bp8uV71ZHUCGjFvs1E/bi1q7ZzzjknL8s4V98k2bpMwB3AcjO7KVZ+UGyxbwKpK6BLgWGhxVhXwnHocG5nm6Q+YZ0XAI/G6gwP02cBT/v5GJeE3bt3c9ttt3Httdfywgsv7DXvV7/6VYGicq74Jbkn0w/4LnBSuebKvw7NkZcAA4CrAMxsGZA6Dv0Eex+HvhSYQnRR2j+JTvpDlMTahUYCPwGuSfD1uHrskksu4dlnn6Vdu3ZceeWV/OQnPymb9/DDDxcwMueKW5Kty54n/TmTmRXUSXsc2swWAj3SlO8Azq5GmM5lZcGCBSxZsgSAyy+/nB/+8Id861vf4r777sN3np3LzK/4dy4LH3/8cdl0o0aNmDx5Mj179uSkk05i+/btBYzMueLmSca5LJSUlPDEE0/sVTZ69GguvPBC1qxZU5ignKsFPMk4l4W7776bQYMG7VP+/e9/n08++aQAETlXO3iScS4Hu3f7NZHO5cKTjHNZ2rZtG4MHDy50GM7VKp5knMvC+vXrOfnkkxk5cmShQ3GuVvGRMZ3LwgknnMANN9yQVUeZzrlP+Z6Mc1lo06YN7777bqHDcK7W8STjXBbmzp3LrFmz+P3vf1/oUJyrVTzJOJeF5s2bU1payt///vdCh+JcreJJxrksNWzYsMIxZZxz+/Ik41wVfPDBB7z//vtlt8pIulPSxjBAWfl5V0sySe1jZaMkrZK0QtKpeQ7fuRrjrcucy8Ftt93G6NGjadasGdHIEyCJN998s7KqU4FbgOnxQkmHAqcAb8fKjgKGAd2Jhl9+StIRPjqmq408yTiXgxtvvJFly5bRvn37yheOMbPnwjDk5U0EfsanYyQBDAbuN7OdwOowlEVv4KWqRe1c4fjhMudycPjhh7P//vvnZV2SzgTeNbNXy806BHgn9nhtKHOu1vE9Gedy8H//93/07duXL3/5yzRp0qSsfNKkSTmtR9L+wC+Ar6WbnaYs7aA1kkYCIwE6d+6cUwzO1QRPMs7l4JJLLuGkk07i6KOPpkGDah0IOBzoCrwazu10Al6R1Jtoz+XQ2LKdgHXpVmJmk4HJACUlJT56mis6nmScy0GjRo246aabqr0eM1sKdEw9lrQGKDGz9ySVAvdKuonoxH83YEG1n9S5AvBzMs7lYMCAAUyePJn169fn2oT5PqIT95+XtFbSiEzLmtkyYAbwOvAEcJm3LHO1le/JOJeDe++9F4jOzaRk04TZzM6tZH6Xco/HAeOqGKZzRcOTjHM5WL16daFDcK5WqfBwmaQPKrltk/SPmgrWuUJ55ZVX8rKMc/VNZedk/mlmLSu4tQA+TFdR0qGSnpG0XNIyST8K5W0lzZa0Mty3idVJ25WGpF6SloZ5kxSa40hqIumBUD4/w8VuzlXbhRdeyObNm/c6D1P+NmJExtMsztVblR0u+3YW68i0zC7gp2b2iqQWwCJJs4HvAXPMbLyka4BrgJ9X0pXGrUTXAswDZgKDgFnACGCzmX1O0jBgAjA0i5idy8nWrVvp1asXZplbCXfo0KEGI3KudqgwyZjZPmczJX3DzB6vaJlQvh5YH6a3SVpOdNXyYODEsNg0YC7wczJ0pRGadrY0s5fC808HhhAlmcHA2LCuB4FbJMkq+iVwrgrWrFmT1XKp/sycc5GqNGG+PtcK4TDWccB84MCQgFKJKHWtQKauNA4J0+XL96pjZruArUC7XONzzjmXjKokmZz+qkk6AHgI+LGZfZDjeq2C8orqlI9hpKSFkhZu2rSpspCdc87lSVWSzCXZLiipMVGCucfMHg7FGyQdFOYfBGwM5Zm60lgbpsuX71VHUiOgFbDPlXFmNtnMSsysxI+bO+dczamsCfMXy5eZ2YLKlgnlAu4AlptZvB+OUmB4mB7Op12clwLDQouxroSuNMIhtW2S+oR1XlCuTmpdZwFP+/kYl7TNmzezYMECnnvuubKbcy69ylqX/UnSiVR8iOwOovMt5fUDvgsslbQ4lP03MB6YEbrVeBs4G6KuNCSlutLYxd5daVxKNOhTM6IT/rNiz31XaCTwPlHrNOcSM2XKFG6++WbWrl1Lz549mTdvHscffzxPP/10oUNzrihVlmRaAYuoOMmkPclhZs9XUG9ghjppu9Iws4VAjzTlOwhJyrmacPPNN/Pyyy/Tp08fnnnmGd544w3GjBlT6LCcK1qVNWHuUkNxOFcrNG3alKZNmwKwc+dOjjzySFasWFHgqJwrXt53mXM56NSpE1u2bGHIkCGccsoptGnThoMPPrjQYTlXtDzJOJeDRx55BICxY8cyYMAAtm7dyqBBgwoclXPFy5OMczl6/vnnWblyJRdeeCGbNm3i3XffpWvXroUOy7milNV1MpLmZFPmXF133XXXMWHChLLxZD755BO+853vVFpP0p2SNkp6LVZ2g6Q3JC2R9Iik1rF5aTuLda62qew6maaS2gLtJbUJPSi3Dd3E+IFoV+888sgjlJaW0rx5cwAOPvhgtm3blk3VqUQdu8bNBnqY2THAP4BRAOU6ix0E/EFSw7y8AOdqWGV7MpcQNWE+Mtynbo8Cv082NOeKz3777Yekso4wP/ww7UgX+zCz5yjXG4WZPRn63IOoh/FUzxZlncWa2WpgFdA7D+E7V+MqTDJmdrOZdQWuNrPPmlnXcDvWzG6poRidKxrnnHMOl1xyCVu2bOH222/n5JNP5uKLL87Hqi/i04uMM3UW61ytk9WJfzP7naS+QJd4HTObnlBczhUdM2Po0KG88cYbtGzZkhUrVnD99ddzyimnVGu9kn5B1MvFPamidE+foe5IorGW6Ny5c7XicC4JWSUZSXcBhwOLgVRXLwZ4knH1hiSGDBnCokWLqp1YYuscDnwDGBjrdy9TZ7H7MLPJwGSAkpIS77fPFZ1smzCXAEd555OuvuvTpw8vv/wyX/rSl6q9LkmDiAbs629m/4nNKgXulXQTUQObbsCCNKtwruhlm2ReAz5DGOnSufrqmWee4bbbbuOwww6jefPmmBmSWLJkSYX1JN1HNCJse0lrgTFErcmaALNDQ4J5ZvaDSjqLda5WyTbJtAdel7QA2JkqNLMzE4nKuSI1a9asyhdKw8zOTVN8RwXLp+0s1rnaJtskMzbJIJyrLQ477DAANm7cyI4dOwocjXPFL9vWZc8mHYhztUFpaSk//elPWbduHR07duStt97iC1/4AsuWLSt0aM4VpWy7ldkm6YNw2yFpt6QPkg7OuWJz7bXXMm/ePI444ghWr17NnDlz6NevX6HDcq5oZZVkzKyFmbUMt6bAtwG/GNPVO40bN6Zdu3bs2bOHPXv2MGDAABYvXlzosJwrWlXqhdnM/iLpmnwH41yxa926Ndu3b+erX/0q559/Ph07dqRRI+/M3LlMsr0Y81uxhw2Irpvxa2ZcvfPoo4/SrFkzJk6cyD333MPWrVsZPXp0ocNyrmhl+xfsjNj0LmANUSd+ztUrqd6XGzRowPDhwwscjXPFL9vWZRcmHYhzzrm6J9vWZZ3CoEobJW2Q9JCkTpXXdM45V59llWSAPxH1p3QwUZfjj4WyjDKMBDhW0ruSFofb6bF5aUcClNRL0tIwb5JC/xuSmkh6IJTPDwOpOZe4jz76iBUrVhQ6DOdqhWyTTAcz+5OZ7Qq3qUCHSupMZd+RAAEmmlnPcJsJlY4EeCtRV+bdwi21zhHAZjP7HDARmJDla3Guyh577DF69uzJoEHRZrh48WLOPNN7V3Iuk2yTzHuSviOpYbh9B/h3RRXSjQRYgbQjAUo6CGhpZi+FHqCnA0NidaaF6QeBgam9HOeSMnbsWBYsWEDr1q0B6NmzJ2vWrCloTM4Vs2yTzEXAOcC/iHpiPiuUVcXlkpaEw2ltQlmmkQAPCdPly/eqE4aw3Qq0q2JMzmWlUaNGtGrVqtBhOFdrZHvF/9tmdqaZdTCzjmY2xMzeqsLz3Uo0+FlPomT1m1CeaSTAikYIzGn0QEkLJS3ctGlTTgE7F9ejRw/uvfdedu/ezcqVK7niiivo27dvocNyrmhl27psmqTWscdtJN2Z65OZ2QYz221me4Dbgd5hVqaRANeG6fLle9WR1AhoRYbDc2Y22cxKzKykQ4fKTiU5l9nvfvc7li1bRpMmTTj33HNp2bIlv/3tbwsdlnNFK9uLMY8xsy2pB2a2WdJxuT6ZpIPMLDXw2TeJBkODDCMBmtnu0DlnH2A+cAHwu1id4cBLRIfvnvaRO13S9t9/f8aNG8e4cT7Ui3PZyDbJNJDUxsw2A0hqW1ndDCMBniipJ9FhrTXAJQCVjAR4KVFLtWbArHCDaMCnuyStItqDGZbla3EuZ2eccQYVtSspLS2tsH7Y8/8GsNHMeoSytsADQBei78M5se/YKKIWlLuBK83sr9V+Ec4VQLZJ5jfAi5IeJEoQ51DJqH35GgnQzBYCPdKU7wDOrjhs5/Lj6quvru4qphL1XD49VnYNMMfMxocOZ68Bfl6uSf/BwFOSjvAhmF1tlG23MtMlLQROIjrh/i0zez3RyJwrIv37969WfTN7Ls0Fw4OJ9vYhao4/F/g5sSb9wOqwt96b6NCwc7VK1n2Uh6TiicXVa0cfffQ+h81atWpFSUkJ//M//5Pr6g5MnaM0s/WSOobyQ4B5seXiTfedq1V8IAzncnDaaafRsGFDzjvvPADuv/9+zIxWrVrxve99L19Pk1PzfKIeMejcuXO+nt+5vPEk41wOXnjhBV544YWyx0cffTT9+vXjhRde4O677851dRtSLS5D7xYbQ3mmJv37MLPJwGSAkpISb13pik62V/w754Dt27czf/78sscLFixg+/btAFUZITPVDJ9w/2isfFjoBLYroUl/NcJ2rmB8T8a5HEyZMoWLLrqI7du3Y2a0bNmSKVOm8OGHHzJq1CiGDh2atl6GJv3jgRmSRgBvE1pLVtKk37laxZOMczn40pe+xNKlS9m6dStmVtZRJsA555yTMclkaNIPMDDD8mmb9DtX23iScS4HO3fu5KGHHmLNmjXs2rWrrHz06NEFjMq54uVJxrkcDB48mFatWtGrVy+aNGlS6HCcK3qeZJzLwdq1a3niiScKHYZztYa3LnMuB3379mXp0qWFDsO5WsP3ZJzLwfPPP8/UqVPp2rUrTZo0wcyQxJIlSwodmnNFyZOMczmYNWtW5Qs558p4knEuB4cddhgAGzduZMeOHQWOxrni5+dknMtBaWkp3bp1o2vXrvTv358uXbpw2mmnFTos54qWJxnncnDttdcyb948jjjiCFavXs2cOXPo169focNyrmh5knEuB40bN6Zdu3bs2bOHPXv2MGDAABYvXlzosJwrWn5OxrkctG7dmu3bt/PVr36V888/n44dO1alY0zn6g3fk3EuB48++ijNmjVj4sSJDBo0iMMPP5zHHnus0GE5V7T8L5hzOWjevHnZ9PDhwytY0jkHvifjXFa+8pWvANCiRQtatmxZdks9ds6l53syzmXh+eefB2Dbtm0FjsS52iWxPRlJd0raKOm1WFlbSbMlrQz3bWLzRklaJWmFpFNj5b0kLQ3zJklSKG8i6YFQPl9Sl6Rei3MAe/bsoUePHnlfr6SrJC2T9Jqk+yQ1rei74lxtkuThsqnAoHJl1wBzzKwbMCc8RtJRwDCge6jzB0kNQ51bgZFEQ9B2i61zBLDZzD4HTAQmJPZKnAMaNGjAsccey9tvv523dUo6BLgSKDGzHkBDou9C2u+Kc7VNYofLzOy5NHsXg4mGoAWYBswFfh7K7zezncBqSauA3pLWAC3N7CUASdOBIcCsUGdsWNeDwC2SZGaWzCtyDtavX0/37t3p3bv3Xo0ASktLq7PaRkAzSZ8A+wPrgFGk/644V6vU9DmZA81sPYCZrZfUMZQfAsyLLbc2lH0SpsuXp+q8E9a1S9JWoB3wXnLhu/puzJgxeV2fmb0r6UbgbeAj4Ekze1JSpu+Kc7VKsbQuU5oyq6C8ojr7rlwaKWmhpIWbNm2qYojOwcyZM+nfv/9et5kzZ1Z5feFcy2CgK3Aw0FzSd3Ko79u2K2o1nWQ2SDoIINxvDOVrgUNjy3UiOmSwNkyXL9+rjqRGQCvg/XRPamaTzazEzEo6dOiQp5fi6qPZs2fvU1bN7v9PBlab2SYz+wR4GOhL5u/KXnzbdsWuppNMKZC6gm048GisfFhoMdaV6AT/gnC4YJukPqFV2QXl6qTWdRbwtJ+PcUm59dZbOfroo1mxYgXHHHNM2a1r164cc8wx1Vn120AfSfuHbXwgsJzM3xXnapXEzslIuo/oxGV7SWuBMcB4YIakEURfrrMBzGyZpBnA68Au4DIz2x1WdSlRS7VmRCf8U38b7wDuCo0E3idqkeNcIs477zxOO+00Ro0axfjx48vKW7RoQdu2bau8XjObL+lB4BWibf/vwGTgANJ8V5yrbZJsXXZuhlkDMyw/DhiXpnwhsM/FCWa2A//iuRrSqlUrWrVqxX333Zf3dZvZGKI/YXE7yfBdca42KZYT/8455+ogTzLOOecS40nGOedcYjzJOOecS4wnGeecc4nxJOOccy4xnmScc65h5Yu4qvEk45yr99p+pnWhQ6izPMk45+q9ps33K3QIdZYnGedcvXd4z66FDqHO8iTjnKsf0g0OEhz02QNrLo56xpOMc65e+EwFiaTv10tqMJL6xZOMc65eOG5A97TlErQ/tH0NR1N/eJJxztUL/3oz7bhvmMF/tn1Uw9HUH55knHP1wr/Xb9m3MJyn2bJxa43GUp94knGuwCS1lvSgpDckLZd0vKS2kmZLWhnu2xQ6ztrumP5f2LfQQA1Fx84+dHVSPMk4V3g3A0+Y2ZHAsUTDL18DzDGzbsCc8NhVw9dHnkKb8hddCkpOOZbPHOZJJimeZJwrIEktga8SDSeOmX1sZluAwcC0sNg0YEgh4qtLXp61mM3/2kLT5k3Kylq1b8myF1ewZdMHBYysbvMk41xhfRbYBPxJ0t8lTZHUHDjQzNYDhPuOhQyyLjj2xKPYv0Uzdny4s6xs66YP+EzXA71bmQR5knGusBoBXwRuNbPjgA/J4dCYpJGSFkpauGnTpqRirBMmXTaF/2z7iGYHNOXh9//EpTddAMCbr65h6fPLCxxd3eVJxrnCWgusNbP54fGDRElng6SDAMJ92va3ZjbZzErMrKRDBz+vUJGLxp1L644t+Wj7Dq49Yzz3T3iU5q3257DunTii1+GFDq/O8iTjXAGZ2b+AdyR9PhQNBF4HSoHhoWw48GgBwqtTep/2RR5YdzsnDu3LshdWsHnDVib+7ZfcvuQmmu7fpPIVuCopSJKRtEbSUkmLJS0MZRmbbEoaJWmVpBWSTo2V9wrrWSVpkqQKeidyrmhdAdwjaQnQE/hfYDxwiqSVwCnhsaumd1euZ8mzr5c9fnji45hZASOq+xoV8LkHmNl7scepJpvjJV0THv9c0lHAMKA7cDDwlKQjzGw3cCswEpgHzAQGAbNq8kU4V11mthhI13nWwBoOpU57Z8W7XD1gLHv2GFNeu4m5D7zI3b98EICrbv8BDRr4gZ0kFDLJlDcYODFMTwPmAj8P5feb2U5gtaRVQG9Ja4CWZvYSgKTpRM08Pck45/ax+JllmBk3Pj2Gw446lAvGngPAk9PmsmXjVtp+xq93TUKhkowBT0oy4DYzm0y5JpuSUk02DyHaU0lZG8o+CdPly51zbh9n/OBr9D/neFq2bQGAJC4Yew7f+vHXadHmgAJHV3cVKsn0M7N1IZHMlvRGBcumO89iFZTvuwJpJNFhNTp37pxrrM65OiKVYFIkeYJJWEEOQprZunC/EXgE6E3mJptrgUNj1TsB60J5pzTl6Z7Pm3k651wB1HiSkdRcUovUNPA14DUyN9ksBYZJaiKpK9ANWBAOrW2T1Ce0KrsAb+bpnHNFpRCHyw4EHgmtjRsB95rZE5JeBmZIGgG8DZwNYGbLJM0gunZgF3BZaFkGcCkwFWhGdMLfT/o751wRqfEkY2ZvEvU0W77832Rosmlm44BxacoXAj3yHaNzzrn88IbhzjnnEuNJxjnnXGI8yTjnnEuMJxnnnHOJ8STjnHMuMZ5knHPOJcaTjHPOucR4knHO1RvbNm/PqszljycZ51y98Ngfn2TEUT/mrdffKSubPnYGPzjuv3j/X5sLGFnd5knGuQKT1FDS3yU9Hh5nHCXWVV3PAd2RxH8NvI63Xn+H6WNncNf1f+aLA4+mdcdWhQ6vzvIk41zh/QhYHnucGiW2GzAnPHbVdOjnD+HGZ8Yiie/3+Al3Xf9nBl04wEfFTJi/s84VkKROwNeBKbHiwUSjwxLuh9RwWHXWoZ8/hGNO7F72+Ns/OcMTTML83XWusH4L/AzYEyvba5RYoGOaekA0IJ+khZIWbtq0KdFAa7v3/7WZK47/b+be/wLd+32eNge24uoBY/jNxbcWOrQ6zZOMcwUi6RvARjNbVNV1+IB82bvqhNG8MX8lBx7WgZuevZ5r7r6Sre9t44k7nmbR7FcLHV6d5UnGucLpB5wpaQ1wP3CSpLvJPEqsq4brS39GswOasuGtTfxs4PWMHjwBgGP6H8UXTz6mwNHVXZ5knCsQMxtlZp3MrAswDHjazL5D5lFiXTUc9oVDmfGv2zmgTXNefXYZO//zMd8dcza/eeY6wiCKLgGeZJwrPuOBUyStBE4Jj10ebN6wlY8/+rjs8eolbxcwmvrBk4xzRcDM5prZN8L0v81soJl1C/fvFzq+umD96g1cfPRP+HjHJ5x7zTdpd3Abnn9kPtd9+8ZCh1aneZJxztULEy++rewQ2UX/ex5T/zGpLNGsWry60OHVWY0KHYBzztWEX80cxQsPzWfAuV8BoOn+TZn6j0nMf/wVPteza4Gjq7t8T8Y5Vy/st1/jsgST0nT/pvQ/p2+BIqofPMk455xLTK1PMpIGSVohaZUk7+PJOeeKSK1OMpIaAr8HTgOOAs6VdFRho3LOOZdSq5MM0BtYZWZvmtnHRFdNDy5wTM4554LanmQOAd6JPV4bypxzzhWB2t6EOV1fELbPQtJIYGR4uF3Sigzraw+8l6fYqqtYYqlSHJqQQCS14z05rCYDiVu0aNF7kt7KMLs2vHc1rVhiKZY4IIFtu7YnmbXAobHHnYB15Rcys8nA5MpWJmmhmZXkL7yqK5ZYiiUOKJ5YiiWO8swsYzfMxRJzscQBxRNLscQBycRS2w+XvQx0k9RV0n5EnQyWFjgm55xzQa3ekzGzXZIuB/4KNATuNLNlBQ7LOedcUKuTDICZzQRm5ml1lR5Sq0HFEkuxxAHFE0uxxJGLYom5WOKA4omlWOKABGKR2T7nyZ1zzrm8qO3nZJxzzhWxepdkJLWVNFvSynDfJsNyayQtlbRY0sJc6+cjDkmHSnpG0nJJyyT9KDZvrKR3Q3yLJZ1ehRgq7JJHkUlh/hJJX8y2bp7jOD88/xJJL0o6NjYv7eeUYCwnStoae99HZ1s333LYltPGVdE2JGlUWH6FpFNrIJYbJL0RPuNHJLUO5V0kfRSL8Y+5rDc2P+dtuarf9arGku/vezXfk/z9/plZvboBvwauCdPXABMyLLcGaF/V+vmIAzgI+GKYbgH8AzgqPB4LXF2N96Eh8E/gs8B+wKupdceWOR2YRXQ9Uh9gfrZ18xxHX6BNmD4tFUdFn1OCsZwIPF6VuoXYliuKK9M2RNRF06tAE6BrqN8w4Vi+BjQK0xNS9YEuwGuF2JazeU15jiVv3/fqxFHR96oq70m925Mh6nZmWpieBgyp4fpZr8fM1pvZK2F6G7Cc/PVokE2XPIOB6RaZB7SWdFCWdfMWh5m9aGabw8N5RNdDJaE6r6sQXRxlsy1WJa7BwP1mttPMVgOrwnoSi8XMnjSzXWG5XD/jpLblqnzXqxxLnr/v1XlPKpLze1Ifk8yBZrYeoh9xoGOG5Qx4UtIiRT0G5Fo/X3EA0WED4Dhgfqz48rCbe2e2u/Ix2XTJk2mZfHbnk+u6RhD9+0rJ9DklGcvxkl6VNEtS9xzr5lM221BlcaXbhqryWvIRS8pF7P0Zd5X0d0nPSjqhiuutyrZcle96dWIpk4fve3XjyNvvX61vwpyOpKeAz6SZ9YscVtPPzNZJ6gjMlvSGmT1XgDiQdADwEPBjM/sgFN8K/JJoY/gl8BuiL2fWq01TVr6pYaZlsurOJ49xRAtKA4iSTHzkqWp/TjnG8gpwmJltD8fF/wJ0y7Ju7gFVfxuqKK5M21DaOgnHEi0g/QLYBdwTitYDnc3s35J6AX+R1D32PchqvRUsk+/PrTqxRDPz832vbhx5+17VySRjZidnmidpQ2rXNOwabsywjnXhfqOkR4h2P58DsqqfrzgkNSba4O4xs4dj694QW+Z24PFMz5VBNl3yZFpmvyzq5jMOJB0DTAFOM7N/p8or+JwSiSX+42ZmMyX9QVL7bF9HrvKwDWWMq4JtKG2dJGMJ6xgOfAMYaOGgv5ntBHaG6UWS/gkcAcQbeSS1LWf9Xc9TLPn8vlcrjnz8/pWp7KRNXbsBN7D3iatfp1mmOdAiNv0iMCjb+nmMQ8B04Ldp5h0Um76K6Bh6Ls/fCHiT6MRu6sRg93LLfJ29TwwuyLZunuPoTHReoG+2n1OCsXyGT68v6w28Hd6fvL0ned6GMsaVaRsCurP3if83qfzEf3VjGQS8DnQoV6dD6rmJTmK/C7StiW05m9eU5+9V3r7v1Ywjr79/iX0BivUGtAPmACvDfdtQfjAwM7Yxvxpuy4BfVFY/oTi+QrT7ugRYHG6nh3l3AUvDvNL4RphDDKcTtWD5Z+o1Aj8AfhDb6H8f5i8FSiqqW43PpLI4pgCbY+/Bwso+pwRjuTw816tEJ6j7VlS30NtyRXFVtA0RHQL7J7CCaO8x6VhWEZ0fSH3Gfwzl3469368AZ9TUtpzpNSX1vSLP3/dqxJHX3z+/4t8551xi6mPrMuecczXEk4xzzrnEeJJxzjmXGE8yzjnnEuNJxjnnXGIKlmRCr6JXh+nrJVV0odcQSUfVXHR7PXcTSU+F3kiH1vBzv1jDz3d26AH2mXLlXSSdV0G9gyU9mEA835N0S77Xm8Xz9syml9s09X4g6YI05V0kvZbDenaH7e3gHOqcIOn1XJ7HuZpQFHsyZjbazJ6qYJEhRD3DFsJxQGMz62lmD8RnSGqYxBOm1mtmffO1riyNAH5oZgPKlXcB0iYZSY3MbJ2ZnVXFEItRT6JrDPYhKWMvGWb2RzObnofn/yhsb1n3GGBmfyNDzLVFLfrjmep2//oc690j6X1Jdem7UqkaTTKSfqFofIOngM/Hyqem3nhJ48M/siWSbpTUFzgTuCH8uztc0sWSXlbUSeFDkvaPrWeSojFH3ox/mJJ+pmh8hFcljQ9lh0t6QlEncH+TdGS5eDsCdwM9Y8+9RtJoSc8DZ0s6N6z3NUkTYnW3S5oQ1v2UpN6S5oa4zkzz3pyoaCyJe4kujELS9nD/gPYe62OqpG9LaqhoHI6Xw/t1SaZ1lXuufWJWNC7KV4A/SrqhXJXxwAnhPbgq7GH8WdJjRJ3olf1TD9N/k/RKuPWNxTRX0oOKxg25R5LCvNND2fPh89unywxJHcJn/XK49UuzTMOwzSwN78cVobyXos4VF0n6q0JPsyGeCZIWSPqHor2B/YDrgaHh9Q4NPyqTJT0JTJd0mKQ54TnmSOoc1hf/kewVtrWXgMtiMXYPz7c41O9W/nWkeV05bUt1QZH/8QSYaGajK1/sU2Z2PtGFlPVL0lclx64U7UX0g7c/0JLoCt+rw7ypwFlAW6IrjFMXibaOz49fdRqb/hVwRWy5PxMlz6OIurqGaAySF4H9w+PU1chzgG5h+svA02niPpHY+CFE4yz8LHY189tEXV80Ap4GhoR5RrhSGngEeBJoDBwLLM7wPB8CXWNl28P9N4FpYXo/oiujmwEjgf8J5U2I+nPqmm5dsXVWFPNcYldCV/AefI+o36PU+9iFMOZH+HybhulufHp1/onAVqL+kRoALxEltabh9XQNy92Xeq7wPLeE6XuBr4TpzsDyNHFeStTvU2pckrbhPX+R0F0JMBS4M/Z6fxO7Ovqp8s8bHo8FFgHNwuPHgOFh+iLgL7HlUtv0EqB/mL4h9v78Djg/9lk2S/M6tpd7nNW2RBZjrxTbjahngRXAU+Gz3+s3IUyPJ+pyZglwI9H4Qu8Dq4muij8cuBh4megq9Yf49Ls+FZgUtoE32ft35GdEv0mvAuND2eHAE+Hz/htwZJqYyz7n2ONp4XNZA3yLaNyVpWFdjWPLTo3HUB9uNdlB5gnAI2b2HwBJ6TL6B8AOYIqk/0fmTuB6SPoV0Bo4APhrbN5fzGwP8LqkA0PZycCfUs9tZu8r6um0L/Dn8Icaoh/qbKQOm30JmGtmm8Jrugf4KlHPvB8TbWAQbWw7zewTSUuJfgzSWWDR+B3lzQImSWpC1MfTc2b2kaSvAcfo0z22VkQ/7B9XsK6KYs7FbDN7P015Y+AWST2B3USdGcZf39rwvIuJ3oftwJuxWO8jSp7lnQwcFfusWkpqYdG4G/Fl/mhhXJLwOfcAehD1JAvRYE7rY3VSnRAuIvPnAlBqZh+F6eOJfkgg6u7j1/EFJbUi+oP0bGyZ08L0S8AvJHUCHjazlRU8Z0pVtqWip6hX5WFEh6QbEXUbs6jcMm2J/mQdaWYmqbWZbQm/H4+b2YNhuS1mdnuY/hXRod/fhdUcRPSH5kiiPYkHJZ1GtDf0ZTP7T3gegMlE3a6slPRl4A/ASVm8nMOBAUR/bl8Cvm1mP1PUueTXyf37VWfUdC/MFfZhY2a7JPUGBhJtfJeT/gOeSvTv+1VJ3yP6l5yyMzat2H35524AbDGznlnGHvdhufWn84mFvy7AHj7tSXaPMh/X/zBdoZntkDQXOJXon/h9see/wsziSRZJJ2ZaVyUx5yLT+q8CNhD9y25A9KchJf7Z7Cba/rKNpwFwfOyHPp10n7OAZWZ2fIY6qZhS8WSS6fWS4TnTbutmdq+k+UQ/PH+V9H0ze7qCdUPVtqXaoC798ZwVS/wN2ftPQZcs11En1eQ5meeAb0pqJqkFcEb5BcKH3MrMZgI/JjoBC7CNaDjSlBbAekXdYp+fxXM/CVykT8/dtLWoy/bVks4OZVJs7PgszQf6S2qv6AT7ucCzldSpqvuBC4m+mKkv0F+BS8P7gKQjJDVPIOby739FWgHrw5f6u0RfuIq8AXxW0SBNECXRdJ4k+tMBRC3AMizzg9QPb/h3ugLoIOn4UNZYnw40lkllr/dFoj9BEG1/z8dnmtkWYKukr8SWScX9WaI9t0lE/6qPqSSWuq7SP55EvV0/RLTn8USGRacCl5vZ0cB1RIdhU3L+4xm7fSGbF0Es8bPvn4La/Eeg2mosyVg0rOgDRMdQHyI63lleC+BxSUuIfviuCuX3A/+laHS8w4FriX4sZxP9SFX23E8QfaEXhsM0V4dZ5wMjJKV6Gx2c42taD4wCniH0Emtmj+ayjhw8SXRY6ymLhlOFqHfi14FXFJ14v41KNugqxrwE2BVOZF9VybJ/AIZLmkd0qKyiPQDCnskPgScUNabYQHTuprwrgZJwsvx1ot5ky5tCdL5pSfhMzwvv1VnAhFC2mOjfakWeITo0l6nZ+pXAhWE7/S7wozTLXAj8Ppz4j+99DQVeC9vhkURdu9dXdfGPpyvHe2F2BSfpAItGmkx1Pb7SzCYWOq5CkbTdzA6oQr0uROcpeuQ/qmQoGgnzAuAtosYkr5vZjZKmEh0aewF4lGjPRMCNZjZNUevC24n2IM4CvkZ0Iv8tokNULczse6n1xM7dlL23kq4Jz/0x0XAE/y2pK9EolAcRnV+838z2aqosaSxR44wbMzyOP0f5eXvFUx94knEFF/aOhhO1tvo7cHHqWHl9JGkd0YiDp1uW18pIOoFoL/LfZnZiguHVe+UTR451p+JJxjnnXCaKroUaSbSXk/W1MqElZ1+ixjq5Dpdea3mScc45l5ii6FbGOedc3eRJxjnnXGI8yTjnnEuMJxnnnHOJ8STjnHMuMf8ffBzrqT0RKh0AAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], + "source": [ + "# hillslope_pars = []\n", + "# mesh_pars = []\n", + "# subcatch_all_ids = 1+np.arange(len(subcatchments))\n", + "# for subcatch_id in subcatch_all_ids:\n", + "# hillslope_pars.append(hillslopes.parameterizeSubcatchment(\n", + "# filenames, huc, subcatch_id,\n", + "# target_crs=target_crs,\n", + "# hillslope_keep_fraction=hillslope_keep_fraction,\n", + "# hillslope_bin_dx=hillslope_bin_dx))\n", + " \n", + "# for i in range(len(hillslope_pars)): \n", + "# mesh_pars.append(meshing.parameterizeMesh(hillslope_pars[i], mesh_dx,\n", + "# toeslope_min_slope=toeslope_min_slope,\n", + "# hillslope_min_slope=hillslope_min_slope,\n", + "# min_area_ratio=min_area_ratio))" + ] + }, + { + "cell_type": "markdown", + "id": "d89ac989", + "metadata": {}, + "source": [ + "## Plot all hillslopes" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "789b2ed3", + "metadata": {}, + "outputs": [], + "source": [ + "# fig = plt.figure(figsize=(20,30),dpi=80)\n", + "# nx, ny = 6,8\n", + "# sep=0.02\n", + "\n", + "# axs = []\n", + "# for i in range(nx):\n", + "# for j in range(ny):\n", + "# sub_id = i*ny+j+1\n", + "# if sub_id > len(subcatchments):\n", + "# continue\n", + " \n", + "# gs = gridspec.GridSpec(4,1,bottom=j/ny+sep, left=i/nx+sep, \n", + "# top=(j+1)/ny - sep, right=(i+1)/nx - sep)\n", + "# ax1 = fig.add_subplot(gs[2,0])\n", + "# ax2 = fig.add_subplot(gs[3,0])\n", + "# axs = [ax1,ax2]\n", + "# h_par = hillslope_pars[sub_id-1]\n", + "# m_par = mesh_pars[sub_id-1] \n", + "# plot.plot(h_par, m_par, fig=fig, axs=axs)\n", + " \n", + "# ax0 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[0,0])\n", + "# ax0.set_title(f'subcatchment {sub_id}')\n", + "# workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", + "# hillslope_pars[sub_id-1]['bins'], ax=ax0, cmap='prism')\n", + "# subcatch = hillslope_pars[sub_id-1]['subcatchment']\n", + "# subcatch_crs = hillslope_pars[sub_id-1]['subcatchment_target_crs'] \n", + "# workflow.plot.shply(subcatch, subcatch_crs, ax=ax0, color='k')\n", + " \n", + "# ax1 = workflow.plot.get_ax(native_crs, fig, axgrid=gs[1,0])\n", + "# vmin = min(hillslope_pars[sub_id-1]['land_cover']) \n", + "# vmax = max(hillslope_pars[sub_id-1]['land_cover'])\n", + "# cmap = plt.get_cmap(('viridis'),vmax-vmin+1)\n", + "# lc = workflow.plot.raster(hillslope_pars[sub_id-1]['raster_profile'], \n", + "# hillslope_pars[sub_id-1]['land_cover_raster'], \n", + "# ax=ax1, vmin=vmin-0.5, vmax=vmax+0.5, cmap=cmap)\n", + "# workflow.plot.shply(subcatch, subcatch_crs, ax=ax1, color='k')\n", + "# position=fig.add_axes([i/nx+sep+0.13, j/ny+sep+0.045, 0.006,0.04])\n", + "\n", + "# fig.colorbar(lc,ticks=np.arange(vmin,vmax+1),cax=position)\n", + "\n", + "# plt.tight_layout()\n", + "# plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d60fb0f2", + "metadata": {}, + "source": [ + "# Generate mesh" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "4916162d", + "metadata": {}, + "outputs": [], + "source": [ + "layer_info = meshing.layeringStructure(organic_cells=30, organic_cell_dz=0.02, \n", + " increase2depth=9.4, increase_cells=20, largest_dz=2.0,\n", + " bottom_depth=46)\n", + "layer_types, layer_data, layer_ncells = layer_info" + ] + }, + { + "cell_type": "markdown", + "id": "366f43ba", + "metadata": {}, + "source": [ + "## Column spinup mesh" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "d75f2a06", + "metadata": {}, + "outputs": [], + "source": [ + "# if os.path.isfile(os.path.join(mesh_dir,'column.exo')):\n", + "# os.remove(os.path.join(mesh_dir,'column.exo'))\n", + "# colum_mesh = meshing.createColumnMesh(layer_info, \n", + "# os.path.join(mesh_dir,'column.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "973ad6c6", + "metadata": {}, + "source": [ + "## 2D for a given subcatchment" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "4396c703", + "metadata": {}, + "outputs": [], + "source": [ + "# m2 = meshing.createHillslopeMesh2D(mesh_demo_pars)\n", + "# m3 = meshing.createHillslopeMesh3D(m2, mesh_demo_pars, layer_info,\n", + "# os.path.join(mesh_dir,f'sag_hillslope{subcatch_demo_id}.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "889672f6", + "metadata": {}, + "source": [ + "## 3D for a given subcatchment" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4bf13c05", + "metadata": {}, + "outputs": [], + "source": [ + "subcatch_demo = hillslope_demo_pars['subcatchment']\n", + "subcatch_demo_smooth = hillslope_demo_pars['subcatchment_smooth']\n", + "subcatch_crs_demo = hillslope_demo_pars['subcatchment_target_crs']\n", + "\n", + "nodem, m2, lc = meshing.createSubcatchmentMesh2D(filenames, subcatch_demo_smooth,\n", + " subcatch_crs_demo, mesh_demo_pars,\n", + " refine_max_area = refine_max_area, plot=True)\n", + "if nodem > 0:\n", + " _, m2, lc = meshing.createSubcatchmentMesh2D(filenames, subcatch_demo,\n", + " subcatch_crs_demo, mesh_demo_pars,\n", + " refine_max_area = refine_max_area, plot=True)\n", + "\n", + "m3 = meshing.createSubcatchmentMesh3D(m2, lc, layer_info,\n", + " os.path.join(mesh_dir, \n", + " f'sag_subcatchment{subcatch_demo_id}.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "d121163b", + "metadata": {}, + "source": [ + "## 2D for all subcatchments" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "457de366", + "metadata": {}, + "outputs": [], + "source": [ + "# subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", + "# for subcatch_id in subcatch_all_ids:\n", + "# index = subcatch_id - 1\n", + "# m2 = meshing.createHillslopeMesh2D(mesh_pars[index])\n", + "# m3 = meshing.createHillslopeMesh3D(m2, mesh_pars[index], meshing.layeringStructure(),\n", + "# os.path.join(mesh_dir,f'sag_hillslope{subcatch_id}.exo'))" + ] + }, + { + "cell_type": "markdown", + "id": "5e846eff", + "metadata": {}, + "source": [ + "## 3D for all subcatchments" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d32ea0e5", + "metadata": {}, + "outputs": [], "source": [ + "# give_up_id = []\n", + "# must_smooth_id = []\n", + "# no_smooth_id = []\n", + "\n", "# subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", "# for subcatch_id in subcatch_all_ids:\n", "# index = subcatch_id - 1\n", + "# subcatch = hillslope_pars[index]['subcatchment']\n", "# subcatch_smooth = hillslope_pars[index]['subcatchment_smooth']\n", - "# m2, lc = meshing.createSubcatchmentMesh2D(filenames, subcatch_smooth, subcatch_crs,\n", - "# mesh_pars[index], plot=False)\n", - "# m3 = meshing.createSubcatchmentMesh3D(m2, lc, layer_info, \n", - "# os.path.join(mesh_dir, f'sag_subcatchment{subcatch_id}.exo'))" + "# subcatch_crs = hillslope_pars[index]['subcatchment_target_crs']\n", + " \n", + "# if type(subcatch) == shapely.geometry.multipolygon.MultiPolygon:\n", + "# if subcatch_smooth is None:\n", + "# give_up_id.append(subcatch_id)\n", + " \n", + "# else:\n", + "# must_smooth_id.append(subcatch_id)\n", + "# _, m2, lc = meshing.createSubcatchmentMesh2D(filenames, subcatch_smooth, subcatch_crs,\n", + "# mesh_pars[index], plot=False)\n", + "# m3 = meshing.createSubcatchmentMesh3D(m2, lc, layer_info, \n", + "# os.path.join(mesh_dir, f'sag_subcatchment{subcatch_id}.exo'))\n", + " \n", + "# else:\n", + "# nodem, m2, lc = meshing.createSubcatchmentMesh2D(filenames, subcatch_smooth, \n", + "# subcatch_crs, mesh_pars[index],\n", + "# plot=False)\n", + "# if nodem > 0:\n", + "# no_smooth_id.append(subcatch_id)\n", + "# _, m2, lc = meshing.createSubcatchmentMesh2D(filenames, subcatch, subcatch_crs,\n", + "# mesh_pars[index], plot=False)\n", + " \n", + " \n", + "# m3 = meshing.createSubcatchmentMesh3D(m2, lc, layer_info, \n", + "# os.path.join(mesh_dir, f'sag_subcatchment{subcatch_id}.exo'))\n", + " \n", + "# print(give_up_id)\n", + "# print(must_smooth_id)" ] }, { @@ -7583,11 +988,11 @@ "metadata": {}, "outputs": [], "source": [ - "start, end = datetime.date(1980,1,1), datetime.date(2020,12,31)\n", - "hillslopes.downloadDaymet(hillslope_demo_pars, daymet_raw_dir, \n", - " os.path.join(daymet_dir, f'huc_{huc}_subcatchment{subcatch_demo_id}_'\n", - " +str(start.year)+'_'+str(end.year)+'.h5'),\n", - " start, end)" + "# start, end = datetime.date(1980,1,1), datetime.date(2020,12,31)\n", + "# hillslopes.downloadDaymet(hillslope_demo_pars, daymet_raw_dir, \n", + "# os.path.join(daymet_dir, f'huc_{huc}_subcatchment{subcatch_demo_id}_'\n", + "# +str(start.year)+'_'+str(end.year)+'.h5'),\n", + "# start, end)" ] }, { @@ -7605,7 +1010,7 @@ "metadata": {}, "outputs": [], "source": [ - "# start, end = datetime.date(1980,1,1), datetime.date(2020,12,31)\n", + "# start, end = datetime.date(2011,1,1), datetime.date(2020,12,31)\n", "# subcatch_all_ids = np.arange(1, len(subcatchments)+1)\n", "# for subcatch_id in subcatch_all_ids:\n", "# index = subcatch_id - 1\n", @@ -7644,9 +1049,9 @@ "title_sidebar": "Contents", "toc_cell": false, "toc_position": { - "height": "calc(100% - 180px)", - "left": "10px", - "top": "150px", + "height": "586px", + "left": "455px", + "top": "691.125px", "width": "288px" }, "toc_section_display": true, diff --git a/new_scripts/meshing.py b/new_scripts/meshing.py index 1d8bd2f..3ed68b2 100644 --- a/new_scripts/meshing.py +++ b/new_scripts/meshing.py @@ -181,28 +181,53 @@ def createColumnMesh(layer_info, filename): m3.write_exodus(filename) +# Smooth DEM data +def smoothDEM(dem): + dem1 = dem.copy() + nodata = 0 + for i in range(len(dem1)): + if len(list(set(dem1[i]))) == 1 and list(set(dem1[i]))[0] == -9999: + nodata += 1 + + else: + if dem1[i][0] == -9999: + index = (dem1[i]!=-9999).argmax() + dem1[i][:index] = dem1[i][index]+0.5 + + if dem1[i][-1] == -9999: + index = (dem1[i][::-1]!=-9999).argmax() + dem1[i][-index:] = dem1[i][-index-1]-0.5 + + if -9999 in dem1[i]: + index1 = np.where(dem1[i] == -9999)[0][0] + index2 = np.where(dem1[i] == -9999)[0][-1] + d = (dem1[i][index2+1] - dem1[i][index1-1])/(index2-index1+3) + for j in range(index1, index2+1): + dem1[i][j] = dem1[i][index1-1]+(j-index1+1)*d + + return nodata, dem1 + # Take mesh parameters and create a 2D subcatchment surface mesh -def createSubcatchmentMesh2D(filenames, subcatch_smooth, subcatch_crs, mesh_pars, - refine_max_area = 200, plot=False): +def createSubcatchmentMesh2D(filenames, subcatch, subcatch_crs, mesh_pars, + refine_max_area = 200, tol = 1, plot=False): # 1. triangulate the subcatchment - verts, tris, areas, dist = workflow.triangulate([subcatch_smooth,], list(), refine_max_area = refine_max_area) + verts, tris, areas, dist = workflow.triangulate([subcatch,], list(), tol = tol, + refine_max_area = refine_max_area) centroids = np.array([verts[t].mean(0) for t in tris]) # 2. elevate the triangulation - dem_profile, dem = workflow.get_raster_on_shape(filenames['dem'], subcatch_smooth,subcatch_crs, - mask=False) - index = (dem!=-9999).argmax(axis=1) - for i in range(dem.shape[0]): - for j in range(dem.shape[1]): - if dem[i][j] == -9999: - dem[i][j] = dem[i][index[i]] + dem_profile, dem0 = workflow.get_raster_on_shape(filenames['dem'], subcatch, + subcatch_crs, mask=False) + + nodem, dem = smoothDEM(dem0) + dem_crs = workflow.crs.from_rasterio(dem_profile['crs']) verts3 = workflow.elevate(verts, subcatch_crs, dem, dem_profile) # 3. get a land cover raster - lc_profile, lc_raster = workflow.get_raster_on_shape(filenames['land_cover'], - subcatch_smooth, subcatch_crs, - mask=False) + lc_profile, lc_raster = workflow.get_raster_on_shape(filenames['land_cover'],subcatch, + subcatch_crs,mask=False) + lc = workflow.values_from_raster(centroids, subcatch_crs, lc_raster, lc_profile) lc = lc.astype(int) @@ -211,9 +236,9 @@ def createSubcatchmentMesh2D(filenames, subcatch_smooth, subcatch_crs, mesh_pars # 5. riparian vs hillslope # 5.1 load raster of flowpath length - fpl_profile, fpl_raster = workflow.get_raster_on_shape(filenames['flowpath_length'], - subcatch_smooth, subcatch_crs, - mask=False) + fpl_profile, fpl_raster = workflow.get_raster_on_shape(filenames['flowpath_length'],subcatch, + subcatch_crs,mask=False) + fpl = workflow.values_from_raster(centroids, subcatch_crs, fpl_raster, fpl_profile) riparian = np.where(fpl > mesh_pars['riparian_width'], 1, 0) @@ -244,7 +269,7 @@ def createSubcatchmentMesh2D(filenames, subcatch_smooth, subcatch_crs, mesh_pars cb = fig.colorbar(mp, orientation="vertical", cax=cax) t = cax.set_title('elevation [m]') - return m2, lc + return nodem, m2, lc