diff --git a/20231110_Prism_Multisurface/templates/examine.py b/20231110_Prism_Multisurface/templates/examine.py new file mode 100644 index 0000000..5a7140f --- /dev/null +++ b/20231110_Prism_Multisurface/templates/examine.py @@ -0,0 +1,8 @@ +import numpy as np +from spectral import envi + +from isofit.core.common import envi_header + +path = '/Users/bgreenbe/.isofit/examples/20231110_Prism_Multisurface/output/prm20231110t071521_multi_surface_state' +ds = envi.open(envi_header(path)) +im = ds.load() diff --git a/20231110_Prism_Multisurface/templates/multi_surface_model.json b/20231110_Prism_Multisurface/templates/multi_surface_model.json index a90cd9e..2332d9f 100644 --- a/20231110_Prism_Multisurface/templates/multi_surface_model.json +++ b/20231110_Prism_Multisurface/templates/multi_surface_model.json @@ -8,7 +8,7 @@ { "input_spectrum_files": [ - "{data}/reflectance/filtered_veg" + "{data}/reflectance/surface_model_ucsb" ], "n_components": 2, "windows": [ @@ -22,12 +22,12 @@ {"interval":[2070,2470], "regularizer":1e-3, "correlation":"decorrelated"}, {"interval":[2470,2500], "regularizer":1e-6, "correlation":"EM","isolated": 1, "name": "noise" } ], - "surface_type": "land" + "surface_category": "land" }, { "input_spectrum_files": [ - "{data}/reflectance/glint_free_emit_lib" + "{data}/reflectance/ocean_spectra_rev2" ], "n_components": 2, "windows": [ @@ -41,7 +41,7 @@ {"interval":[2070,2470], "regularizer":1e-3, "correlation":"decorrelated"}, {"interval":[2470,2600], "regularizer":1e-3, "correlation":"EM","isolated": 1, "name": "noise" } ], - "surface_type": "water" + "surface_category": "water" } ] } diff --git a/20231110_Prism_Multisurface/templates/prm20231110t071521_multi_surface_isofit.json b/20231110_Prism_Multisurface/templates/prm20231110t071521_multi_surface_isofit.json index dd964be..f027155 100644 --- a/20231110_Prism_Multisurface/templates/prm20231110t071521_multi_surface_isofit.json +++ b/20231110_Prism_Multisurface/templates/prm20231110t071521_multi_surface_isofit.json @@ -81,12 +81,12 @@ "glint_model_surface": { "surface_category": "glint_model_surface", "surface_file": "{examples}/20231110_Prism_Multisurface/remote/multi_surface_test_surface_water.mat", - "surface_int": 0 + "surface_int": 1 }, "multicomponent_surface": { "surface_category": "multicomponent_surface", "surface_file": "{examples}/20231110_Prism_Multisurface/remote/multi_surface_test_surface_land.mat", - "surface_int": 1 + "surface_int": 0 } }, "multi_surface_flag": true, diff --git a/isofit-tutorials/Makefile b/isofit-tutorials/Makefile new file mode 100644 index 0000000..668cd51 --- /dev/null +++ b/isofit-tutorials/Makefile @@ -0,0 +1,24 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +build_docs: + sphinx-apidoc -fMeT -o source ../isofit -t source/_templates + @echo "Auto-generation of documentation finished. " diff --git a/isofit-tutorials/build/doctrees/environment.pickle b/isofit-tutorials/build/doctrees/environment.pickle new file mode 100644 index 0000000..f27f2c0 Binary files /dev/null and b/isofit-tutorials/build/doctrees/environment.pickle differ diff --git a/isofit-tutorials/build/doctrees/how_to_run/about.doctree b/isofit-tutorials/build/doctrees/how_to_run/about.doctree new file mode 100644 index 0000000..ed637ef Binary files /dev/null and b/isofit-tutorials/build/doctrees/how_to_run/about.doctree differ diff --git a/isofit-tutorials/build/doctrees/how_to_run/apply_oe.doctree b/isofit-tutorials/build/doctrees/how_to_run/apply_oe.doctree new file mode 100644 index 0000000..f1d57fd Binary files /dev/null and b/isofit-tutorials/build/doctrees/how_to_run/apply_oe.doctree differ diff --git a/isofit-tutorials/build/doctrees/how_to_run/functions.doctree b/isofit-tutorials/build/doctrees/how_to_run/functions.doctree new file mode 100644 index 0000000..1e70f63 Binary files /dev/null and b/isofit-tutorials/build/doctrees/how_to_run/functions.doctree differ diff --git a/isofit-tutorials/build/doctrees/index.doctree b/isofit-tutorials/build/doctrees/index.doctree new file mode 100644 index 0000000..715d226 Binary files /dev/null and b/isofit-tutorials/build/doctrees/index.doctree differ diff --git a/isofit-tutorials/build/doctrees/information/code_of_conduct.doctree b/isofit-tutorials/build/doctrees/information/code_of_conduct.doctree new file mode 100644 index 0000000..98a6ec3 Binary files /dev/null and b/isofit-tutorials/build/doctrees/information/code_of_conduct.doctree differ diff --git a/isofit-tutorials/build/doctrees/information/contribute.doctree b/isofit-tutorials/build/doctrees/information/contribute.doctree new file mode 100644 index 0000000..1e03bda Binary files /dev/null and b/isofit-tutorials/build/doctrees/information/contribute.doctree differ diff --git a/isofit-tutorials/build/doctrees/information/project_support.doctree b/isofit-tutorials/build/doctrees/information/project_support.doctree new file mode 100644 index 0000000..9e7132b Binary files /dev/null and b/isofit-tutorials/build/doctrees/information/project_support.doctree differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run/apply_oe.ipynb b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run/apply_oe.ipynb new file mode 100644 index 0000000..24edbdd --- /dev/null +++ b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run/apply_oe.ipynb @@ -0,0 +1,754 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1be88697", + "metadata": {}, + "source": [ + "# Apply OE" + ] + }, + { + "cell_type": "markdown", + "id": "94f3598f", + "metadata": {}, + "source": [ + "#### What is Apply OE?" + ] + }, + { + "cell_type": "markdown", + "id": "c0421619", + "metadata": {}, + "source": [ + "Apply OE is the built-in end-to-end atmospheric correction pipeline, and is the easiest way to run Isofit. Apply OE is run via a command line interface (CLI) tool accessed with a terminal call:\n", + "\n", + " `isofit apply_oe --help`\n", + "\n", + " The function docstring is printed when this command is run within a terminal window, and acts as a guide for how to run the function.\n", + "\n", + " ```\n", + "isofit apply_oe --help\n", + "\n", + "Usage: isofit apply_oe [OPTIONS] INPUT_RADIANCE INPUT_LOC INPUT_OBS\n", + " WORKING_DIRECTORY SENSOR\n", + "\n", + " Applies OE over a flightline using a radiative transfer engine. This\n", + " executes ISOFIT in a generalized way, accounting for the types of variation\n", + " that might be considered typical.\n", + "\n", + " Observation (obs) and location (loc) files are used to determine appropriate\n", + " geometry lookup tables and provide a heuristic means of determining\n", + " atmospheric water ranges.\n", + "\n", + " Parameters\n", + " ----------\n", + " input_radiance : str\n", + " Radiance data cube. Expected to be ENVI format\n", + " input_loc : str\n", + " Location data cube of shape (Lon, Lat, Elevation). Expected to be ENVI format\n", + " input_obs : str\n", + " Observation data cube of shape:\n", + " (path length, to-sensor azimuth, to-sensor zenith,\n", + " to-sun azimuth, to-sun zenith, phase,\n", + " slope, aspect, cosine i, UTC time)\n", + " Expected to be ENVI format\n", + " working_directory : str\n", + " Directory to stage multiple outputs, will contain subdirectories\n", + " sensor : str\n", + " The sensor used for acquisition, will be used to set noise and datetime\n", + " settings\n", + " surface_path : str\n", + " Path to surface model or json dict of surface model configuration\n", + " copy_input_files : bool, default=False\n", + " Flag to choose to copy input_radiance, input_loc, and input_obs locally into\n", + " the working_directory\n", + " modtran_path : str, default=None\n", + " Location of MODTRAN utility. Alternately set with `MODTRAN_DIR` environment\n", + " variable\n", + " wavelength_path : str, default=None\n", + " Location to get wavelength information from, if not specified the radiance\n", + " header will be used\n", + " surface_category : str, default=\"multicomponent_surface\"\n", + " The type of ISOFIT surface priors to use. Default is multicomponent_surface\n", + " aerosol_climatology_path : str, default=None\n", + " Specific aerosol climatology information to use in MODTRAN\n", + " rdn_factors_path : str, default=None\n", + " Specify a radiometric correction factor, if desired\n", + " atmosphere_type : str, default=\"ATM_MIDLAT_SUMMER\"\n", + " Atmospheric profile to be used for MODTRAN simulations. Unused for other\n", + " radiative transfer models.\n", + " channelized_uncertainty_path : str, default=None\n", + " Path to a channelized uncertainty file\n", + " model_discrepancy_path : str, default=None\n", + " Modifies S_eps in the OE formalism as the Gamma additive term, as:\n", + " S_eps = Sy + Kb.dot(self.Sb).dot(Kb.T) + Gamma\n", + " lut_config_file : str, default=None\n", + " Path to a look up table configuration file, which will override defaults\n", + " choices\n", + " multiple_restarts : bool, default=False\n", + " Use multiple initial starting poitns for each OE ptimization run, using\n", + " the corners of the atmospheric variables as starting points. This gives\n", + " a more robust, albeit more expensive, solution.\n", + " logging_level : str, default=\"INFO\"\n", + " Logging level with which to run ISOFIT\n", + " log_file : str, default=None\n", + " File path to write ISOFIT logs to\n", + " n_cores : int, default=1\n", + " Number of cores to run ISOFIT with. Substantial parallelism is available, and\n", + " full runs will be very slow in serial. Suggested to max this out on the\n", + " available system\n", + " presolve : int, default=False\n", + " Flag to use a presolve mode to estimate the available atmospheric water range.\n", + " Runs a preliminary inversion over the image with a 1-D LUT of water vapor, and\n", + " uses the resulting range (slightly expanded) to bound determine the full LUT.\n", + " Advisable to only use with small cubes or in concert with the empirical_line\n", + " setting, or a significant speed penalty will be incurred\n", + " empirical_line : bool, default=False\n", + " Use an empirical line interpolation to run full inversions over only a subset\n", + " of pixels, determined using a SLIC superpixel segmentation, and use a KDTREE of\n", + " local solutions to interpolate radiance->reflectance. Generally a good option\n", + " if not trying to analyze the atmospheric state at fine scale resolution.\n", + " Mutually exclusive with analytical_line\n", + " analytical_line : bool, default=False\n", + " Use an analytical solution to the fixed atmospheric state to solve for each\n", + " pixel. Starts by running a full OE retrieval on each SLIC superpixel, then\n", + " interpolates the atmospheric state to each pixel, and closes with the\n", + " analytical solution.\n", + " Mutually exclusive with empirical_line\n", + " ray_temp_dir : str, default=\"/tmp/ray\"\n", + " Location of temporary directory for ray parallelization engine\n", + " emulator_base : str, default=None\n", + " Location of emulator base path. Point this at the model folder (or h5 file) of\n", + " sRTMnet to use the emulator instead of MODTRAN. An additional file with the\n", + " same basename and the extention _aux.npz must accompany\n", + " e.g. /path/to/emulator.h5 /path/to/emulator_aux.npz\n", + " segmentation_size : int, default=40\n", + " If empirical_line is enabled, sets the size of segments to construct\n", + " num_neighbors : list[int], default=[]\n", + " Forced number of neighbors for empirical line extrapolation - overides default\n", + " set from segmentation_size parameter\n", + " atm_sigma : list[int], default=[2]\n", + " A list of smoothing factors to use during the atmospheric interpolation, one\n", + " for each atmospheric parameter (or broadcast to all if only one is provided).\n", + " Only used with the analytical line.\n", + " pressure_elevation : bool, default=False\n", + " Flag to retrieve elevation\n", + " prebuilt_lut : str, default=None\n", + " Use this pre-constructed look up table for all retrievals. Must be an\n", + " ISOFIT-compatible RTE NetCDF\n", + " no_min_lut_spacing : bool, default=False\n", + " Don't allow the LUTConfig to remove a LUT dimension because of minimal spacing.\n", + " inversion_windows : list[float], default=None\n", + " Override the default inversion windows. Will supercede any sensor specific\n", + " defaults that are in place.\n", + " Must be in 2-item tuples\n", + " config_only : bool, default=False\n", + " Generates the configuration then exits before execution. If presolve is\n", + " enabled, that run will still occur.\n", + " interpolate_bad_rdn : bool, default=False\n", + " Flag to perform a per-pixel interpolation across no-data and NaN data bands.\n", + " Does not interpolate vectors that are entire no-data or NaN, only partial.\n", + " Currently only designed for wavelength interpolation on spectra.\n", + " Does NOT do any spatial interpolation\n", + " interpolate_inplace : bool, default=False\n", + " Flag to tell interpolation to work on the file in place, or generate a\n", + " new interpolated rdn file. The location of the new file will be in the\n", + " \"input\" directory within the working directory.\n", + "\n", + " References\n", + " ----------\n", + " D.R. Thompson, A. Braverman,P.G. Brodrick, A. Candela, N. Carbon, R.N. Clark,D. Connelly, R.O. Green, R.F.\n", + " Kokaly, L. Li, N. Mahowald, R.L. Miller, G.S. Okin, T.H.Painter, G.A. Swayze, M. Turmon, J. Susilouto, and\n", + " D.S. Wettergreen. Quantifying Uncertainty for Remote Spectroscopy of Surface Composition. Remote Sensing of\n", + " Environment, 2020. doi: https://doi.org/10.1016/j.rse.2020.111898.\n", + "\n", + " sRTMnet emulator:\n", + " P.G. Brodrick, D.R. Thompson, J.E. Fahlen, M.L. Eastwood, C.M. Sarture, S.R. Lundeen, W. Olson-Duvall,\n", + " N. Carmon, and R.O. Green. Generalized radiative transfer emulation for imaging spectroscopy reflectance\n", + " retrievals. Remote Sensing of Environment, 261:112476, 2021.doi: 10.1016/j.rse.2021.112476.\n", + "\n", + "Options:\n", + " -sp, --surface_path TEXT [required]\n", + " --copy_input_files\n", + " --modtran_path TEXT\n", + " --wavelength_path TEXT\n", + " --surface_category TEXT\n", + " --aerosol_climatology_path TEXT\n", + " --rdn_factors_path TEXT\n", + " --atmosphere_type TEXT\n", + " --channelized_uncertainty_path TEXT\n", + " --model_discrepancy_path TEXT\n", + " --lut_config_file TEXT\n", + " --multiple_restarts\n", + " --logging_level TEXT\n", + " --log_file TEXT\n", + " --n_cores INTEGER\n", + " --presolve\n", + " --empirical_line\n", + " --analytical_line\n", + " --ray_temp_dir TEXT\n", + " --emulator_base TEXT\n", + " --segmentation_size INTEGER\n", + " -nn, --num_neighbors INTEGER\n", + " -as, --atm_sigma FLOAT\n", + " --pressure_elevation\n", + " --prebuilt_lut TEXT\n", + " --no_min_lut_spacing\n", + " --inversion_windows FLOAT...\n", + " --config_only\n", + " --interpolate_bad_rdn\n", + " --interpolate_inplace\n", + " --debug-args Prints the arguments list without executing\n", + " the command\n", + " --profile TEXT\n", + " --help Show this message and exit.\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "id": "f1b4490f", + "metadata": {}, + "source": [ + "The Apply OE function can leverage a large number of input parameters, but most are optional. The important inputs are the non-optional arguments: \n", + "\n", + "`INPUT_RADIANCE` `INPUT_LOC` `INPUT_OBS` `WORKING_DIRECTORY` `SENSOR` and `--surface_path`.\n", + "\n", + "which must be entered in the specified order. Descriptions of each are found in the docstring printed above. It is important to note that the `INPUT_RADIANCE`, `INPUT_LOC`, and `INPUT_OBS` are ENVI raster data formats that must be at the same row-column dimensions. The `--surface_path` points Isofit torwards the constructed prior distribution file for surface reflectance. Optional arguments are denoted by the '--' in their name, e.g. `--modtran_path`, `--pressure_elevation`. The default radiative transfer engine (RTE) is currently set to Modtran. Most new users will use the sRTMnet emulator for which you must specify an `--emulator_path`." + ] + }, + { + "cell_type": "markdown", + "id": "8b199b77", + "metadata": {}, + "source": [ + "#### How do you run Apply OE?" + ] + }, + { + "cell_type": "markdown", + "id": "f6028b6c", + "metadata": {}, + "source": [ + "The script is run via the CLI. For example:" + ] + }, + { + "cell_type": "markdown", + "id": "b9867343", + "metadata": {}, + "source": [ + "```\n", + "isofit apply_oe \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010 \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010 \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010 \\\n", + " ~/.isofit/examples/image_cube/small \\\n", + " ang \\\n", + " --surface_path ~/.isofit/imagecube/small/data/surface.mat \\\n", + " --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \\\n", + " --n_cores 10 \\\n", + " --presolve \\\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "id": "31d41c48", + "metadata": {}, + "source": [ + "Here, \n", + "\n", + "```\n", + "~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010\n", + "~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010\n", + "~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010\n", + "```\n", + "\n", + "are the radiance, location, and observational geometry files respectively. The `\\` tells the CLI call to expect a multi-line input. The remaining two requried parameters are `ang`, the sensor designation (AVIRIS-NG), and the `--surface_path` pointing to the surface prior file at `~/.isofit/imagecube/small/data/surface.mat`.\n", + "\n", + "The remaining arguments set Apply OE to run with:\n", + "1) `--emulator_base` points isofit to the location of the sRTMnet emulator to use as the radiative transfer engine (RTE)\n", + "2) `--n_cores = 10` CPU cores\n", + "3) The `--presolve` algorithm to narrow down the water vapor retrievals, which leads to faster total processing time" + ] + }, + { + "cell_type": "markdown", + "id": "ac5b2463", + "metadata": {}, + "source": [ + "We can examine both the inputs and outputs of Apply OE with this run call:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b18118d1", + "metadata": {}, + "outputs": [], + "source": [ + "# Common imports\n", + "import os\n", + "from pathlib import Path\n", + "\n", + "from spectral import envi\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "\n", + "from isofit.core.common import envi_header" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5b8a685f", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the input files\n", + "rdn_path = Path('~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010')\n", + "loc_path = Path('~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010')\n", + "obs_path = Path('~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0f7ec5b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Band names in the location file:\n", + "Longitude (WGS-84)\n", + "Latitude (WGS-84)\n", + "Elevation (m)\n", + "\n", + "Band names in the observational geometry file:\n", + "Path length (m)\n", + "To-sensor azimuth (0 to 360 degrees cw from N)\n", + "To-sensor zenith (0 to 90 degrees from zenith)\n", + "To-sun azimuth (0 to 360 degrees cw from N)\n", + "To-sun zenith (0 to 90 degrees from zenith)\n", + "Solar phase\n", + "Slope\n", + "Aspect\n", + "Cosine(i)\n", + "UTC Time\n", + "Earth-sun distance (AU)\n" + ] + } + ], + "source": [ + "# Print the bands of the input files\n", + "print('Band names in the location file:')\n", + "[print(f\"{i}\") for i in loc.metadata['band names']]\n", + "\n", + "print()\n", + "print('Band names in the observational geometry file:')\n", + "temp = [print(f\"{i}\") for i in obs.metadata['band names']]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4ce97d24", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the input data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(13, 4))\n", + "plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))\n", + "plot = axs[1].imshow(loc_im[..., 0])\n", + "plot = axs[2].imshow(obs_im[..., 4])\n", + "\n", + "title = axs[0].set_title('Radiance (RGB)')\n", + "title = axs[1].set_title('Longitude (WGS-84)')\n", + "title = axs[2].set_title('Solar zenith angle (Deg)')" + ] + }, + { + "cell_type": "markdown", + "id": "e12b5307", + "metadata": {}, + "source": [ + "The input image doesn't look like much because this is just a 10x10 pixel example. However we see per-pixel spectral variation in the radiance RGB, and systematic variation in the location and geometric variables.\n", + "\n", + "Looking at the output data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65ce0e9f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of the _rfl file: (10, 10, 425)\n", + "Shape of the _state file: (10, 10, 427)\n", + "Shape of the _uncert file: (10, 10, 427)\n" + ] + } + ], + "source": [ + "# Load the output files\n", + "rfl_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_rfl')\n", + "state_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_state')\n", + "uncert_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_uncert')\n", + "\n", + "rfl = envi.open(envi_header(str(rfl_path.expanduser())))\n", + "state = envi.open(envi_header(str(state_path.expanduser())))\n", + "uncert = envi.open(envi_header(str(uncert_path.expanduser())))\n", + "\n", + "rfl_im = rfl.open_memmap(interleave='bip')\n", + "state_im = state.open_memmap(interleave='bip')\n", + "uncert_im = uncert.open_memmap(interleave='bip')\n", + "\n", + "print(f'Shape of the _rfl file: {rfl_im.shape}')\n", + "print(f'Shape of the _state file: {state_im.shape}')\n", + "print(f'Shape of the _uncert file: {uncert_im.shape}')" + ] + }, + { + "cell_type": "markdown", + "id": "7054b0ee", + "metadata": {}, + "source": [ + "The difference between the `_rfl` file and the `_state` file is that the `_rfl` file only contains the solutions for surface reflectance variables. Here, the AVIRIS-NG image contains 425 wavelength bands. As a result, the `_rfl` contains 425 bands. The `_state` and `_uncert` files contain the surface reflectance solutions and uncertainty calculated as the standard deviation of the posterior distributions for the 425 wavelength bands and for non-reflectance statevector elements; here, aerosol optical depth (AOD) and water vapor (H2O). " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a518609c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the output data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(8, 8))\n", + "axs = np.ravel(axs)\n", + "plot = axs[0].imshow(normalize(rfl_im[..., bands], 0, 0.3))\n", + "uncert = axs[1].imshow(uncert_im[..., 55])\n", + "aod = axs[2].imshow(state_im[..., -2])\n", + "h2o = axs[3].imshow(state_im[..., -1])\n", + "\n", + "plt.colorbar(uncert)\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "title = axs[0].set_title('Reflectance')\n", + "title = axs[1].set_title('Uncertainty (at 650 nm)')\n", + "title = axs[2].set_title('AOD')\n", + "title = axs[3].set_title('H2O')" + ] + }, + { + "cell_type": "markdown", + "id": "697e2986", + "metadata": {}, + "source": [ + "#### The Analytical Line" + ] + }, + { + "cell_type": "markdown", + "id": "58752472", + "metadata": {}, + "source": [ + "In the example above, we ran Isofit using the full optimal estimation (OE) on each pixel independently. Computationally, this amounts to iterating through each row-column pair to solve for the full state-vector (427 variables in the above case). However for large images, this demands long run-times, and ignores the principle that some state-vector elements, namely the atmospheric variables like AOD and H2O, should not vary from one pixel to the next, but rather should be spatially smooth, and only vary over multi-pixel length scales [Link to the relevent paper](https://www.sciencedirect.com/science/article/pii/S0034425723004534/).\n", + "\n", + "The analytical line and empirical line algorithms leverage the assumption of a spatially smooth atmosphere to decrease run times by a factor of 10. Currently, we suggest using the analytical line algorithm and not the empirical line algorithm." + ] + }, + { + "cell_type": "markdown", + "id": "ad1b9d10", + "metadata": {}, + "source": [ + "See the following CLI call to run Apply OE with the analytical line algorithm:\n", + "\n", + "```\n", + "isofit apply_oe \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k \\\n", + " ~/.isofit/imagecube/medium \\\n", + " ang \\\n", + " --surface_path ~/.isofit/imagecube/small/data/surface.mat \\\n", + " --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \\\n", + " --n_cores 10 \\\n", + " --presolve \\\n", + " --log_file ~/.isofit/imagecube/medium/log.txt \\\n", + " --analytical_line \\\n", + " --segmentation_size 50\n", + "```\n", + "\n", + "Most of the input parameters are identical to the per-pixel application above. However, we've added a `--log_file`, the `--analytical_line` flag, and a `--segmentation_size`. The `--log_file` points the program to write a text file to print logging statements during run time. The `--analytical_line` flag tells Isofit to use the analytical line algorithm. \n", + "\n", + "A simple overview for the anylitical line algorithm:\n", + "\n", + "1) All three input files are \"segmented\" into superpixel blocks using the SLIC algorithm. The `--segmentation_size` value sets the number of pixels that each superpixel contains.\n", + "\n", + "2) At the superpixel resolution, Isofit solves for the OE solutions, which provides both surface and atmospheric state variables. \n", + "\n", + "3) Atmospheric state variables are spatially interpolated to full image resolution. The spatial interpolation uses the Apply OE parameters `--num_neighbors` and `--atm_sigma`.\n", + "\n", + "4) With a fixed atmosphere, we leverage a closed form solution for surface state elements that allows for a solution convergence in a single iteration.\n", + "\n", + "We can visualize what the segmentation is doing by leveraging the `isofit reconstruct_subs` CLI command. \n", + "\n", + "Visualizing the input data:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5ce57697", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting the input data\n", + "rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')\n", + "loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')\n", + "obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')\n", + "\n", + "subs_rdn_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_rdn')\n", + "subs_loc_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_loc')\n", + "subs_obs_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_obs')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "subs_rdn = envi.open(envi_header(str(subs_rdn_path.expanduser())))\n", + "subs_loc = envi.open(envi_header(str(subs_loc_path.expanduser())))\n", + "subs_obs = envi.open(envi_header(str(subs_obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')\n", + "\n", + "subs_rdn_im = subs_rdn.open_memmap(interleave='bip')\n", + "subs_loc_im = subs_loc.open_memmap(interleave='bip')\n", + "subs_obs_im = subs_obs.open_memmap(interleave='bip')\n", + "\n", + "fig, axs = plt.subplots(2, 3, sharex=True, sharey=True, figsize=(5, 10))\n", + "axs = np.ravel(axs)\n", + "\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(loc[0:400, :, 0])\n", + "axs[2].imshow(obs[0:400, :, 4])\n", + "\n", + "axs[3].imshow(normalize(subs_rdn_im[0:400, :, bands], 0, 15))\n", + "axs[4].imshow(subs_loc[0:400, :, 0])\n", + "axs[5].imshow(subs_obs[0:400, :, 4])\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Longitude')\n", + "axs[2].set_title('Elevation')\n", + "\n", + "axs[0].set_ylabel('Full resolution')\n", + "axs[3].set_ylabel('Superpixel resolution')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7788d2ce", + "metadata": {}, + "source": [ + "We can examine the results from Apply OE after the OE solutions on the superpixels:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "abf4b8ee", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.12389879..1.5404001].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wl = np.array(rdn.metadata['wavelength']).astype(float)\n", + "\n", + "state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_recon_subs_state')\n", + "state = envi.open(envi_header(str(state_path.expanduser())))\n", + "state_im = state.open_memmap(interleave='bip')\n", + "\n", + "fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(normalize(state_im[0:400, :, bands], 0, 0.25))\n", + "aod = axs[2].imshow(state_im[0:400, :, -2])\n", + "h2o = axs[3].imshow(state_im[0:400, :, -1])\n", + "\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Reflectance')\n", + "axs[2].set_title('AOD')\n", + "axs[3].set_title('H2O')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "af4360b8", + "metadata": {}, + "source": [ + "Finally, we can examine the final results at the end of the anlaytical line algorithm:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50c92071", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.11736042..1.7135264].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rfl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_rfl')\n", + "atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')\n", + "\n", + "rfl = envi.open(envi_header(str(rfl_path.expanduser())))\n", + "atm = envi.open(envi_header(str(atm_path.expanduser())))\n", + "\n", + "rfl_im = rfl.open_memmap(interleave='bip')\n", + "atm_im = atm.open_memmap(interleave='bip')\n", + "\n", + "\n", + "fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(normalize(rfl_im[0:400, :, bands], 0, 0.25))\n", + "aod = axs[2].imshow(atm_im[0:400, :, -2])\n", + "h2o = axs[3].imshow(atm_im[0:400, :, -1])\n", + "\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Reflectance')\n", + "axs[2].set_title('AOD')\n", + "axs[3].set_title('H2O')\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run/functions.ipynb b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run/functions.ipynb new file mode 100644 index 0000000..167a6f0 --- /dev/null +++ b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run/functions.ipynb @@ -0,0 +1,733 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fe75c48b", + "metadata": {}, + "source": [ + "# Internal Functions" + ] + }, + { + "cell_type": "markdown", + "id": "f0f4eaf6", + "metadata": {}, + "source": [ + "When debugging issues or testing configurations, it may be advantagous to run Isofit in a more controlled manner than the end-to-end Apply OE pipeline. This notebook gives a quick introduction to the structure of Isofit and how it can be used more like a Python package.\n", + "\n", + "NOTE: Isofit is actively developed, so while we try to make sure that Apply OE is stable from a CLI standpoint, individual functions are subject to change." + ] + }, + { + "cell_type": "markdown", + "id": "eee6abd3", + "metadata": {}, + "source": [ + "We'll start with the medium example found at `~/.isofit/imagecube/medium`. First, run Apply OE on this example, or for more adept users, run Apply OE with the `--config_only` flag. The objective here, is to generate an Isofit config file at `~/.isofit/imagecube/small/config/ang20170323t202244_isofit.json`. This saves us the trouble of building the configuration file manually. We can edit the Apply OE generated configuration as needed." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "75064908", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "from pathlib import Path\n", + "from pprint import pprint\n", + "\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "from spectral import envi\n", + "\n", + "from isofit.core.common import envi_header\n", + "from isofit.core.isofit import Isofit\n", + "from isofit.configs import configs\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.radiative_transfer.radiative_transfer import RadiativeTransfer\n", + "from isofit.surface.surface import Surface\n", + "from isofit.core.instrument import Instrument\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.core.geometry import Geometry\n", + "from isofit.core.fileio import IO\n", + "from isofit.inversion.inverse_simple import (\n", + " invert_algebraic,\n", + " invert_analytical,\n", + " invert_simple,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "04d04288", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the input data\n", + "rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')\n", + "loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')\n", + "obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')\n", + "\n", + "wl = np.array(rdn.metadata['wavelength']).astype(float)" + ] + }, + { + "cell_type": "markdown", + "id": "fe59a430", + "metadata": {}, + "source": [ + "### ISOFIT Configs and Classes\n", + "\n", + "ISOFIT is built around object classes.\n", + "\n", + "For example, the `config` object contains the full Isofit config. This is constructed directly from the config `.json` file via the `configs.create_new_config` function. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2ac3ee92", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The config object:\n", + "\n", + "\n", + "Config attributes:\n", + "_input_type\n", + "input\n", + "_output_type\n", + "output\n", + "_forward_model_type\n", + "forward_model\n", + "_implementation_type\n", + "implementation\n", + "\n", + "Example:\n", + "Forward model type: \n", + "Forward model: \n", + "\n", + "Forward model:\n", + "{'_instrument_type': ,\n", + " '_model_discrepancy_file_type': ,\n", + " '_radiative_transfer_type': ,\n", + " '_surface_type': ,\n", + " 'instrument': ,\n", + " 'model_discrepancy_file': None,\n", + " 'radiative_transfer': ,\n", + " 'surface': }\n", + "\n", + "Surface model:\n", + "{'_emissivity_for_surface_T_init_type': ,\n", + " '_select_on_init_type': ,\n", + " '_selection_metric_type': ,\n", + " '_surface_T_prior_sigma_degK_type': ,\n", + " '_surface_category_type': ,\n", + " '_surface_file_type': ,\n", + " '_wavelength_file_type': ,\n", + " 'emissivity_for_surface_T_init': 0.98,\n", + " 'select_on_init': True,\n", + " 'selection_metric': 'Euclidean',\n", + " 'surface_T_prior_sigma_degK': 1.0,\n", + " 'surface_category': 'multicomponent_surface',\n", + " 'surface_file': '/Users/bgreenbe/.isofit/imagecube/medium/data/surface.mat',\n", + " 'wavelength_file': None}\n" + ] + } + ], + "source": [ + "# Initialize the config object\n", + "config_file = Path('~/.isofit/imagecube/medium/config/ang20170323t202244_isofit.json')\n", + "config = configs.create_new_config(str(config_file.expanduser()))\n", + "\n", + "print('The config object:')\n", + "print(config)\n", + "print()\n", + "\n", + "print('Config attributes:')\n", + "[print(key) for key in vars(config).keys()]\n", + "print()\n", + "\n", + "print('Example:')\n", + "print(f'Forward model type: {config._forward_model_type}')\n", + "print(f'Forward model: {config.forward_model}\\n')\n", + "\n", + "print('Forward model:')\n", + "pprint(vars(config.forward_model), width=100, compact=False)\n", + "print()\n", + "print('Surface model:')\n", + "pprint(vars(config.forward_model.surface), width=100, compact=False)" + ] + }, + { + "cell_type": "markdown", + "id": "b5957a17-e65a-41eb-93e8-0df0c9abf8b9", + "metadata": {}, + "source": [ + "The `ForwardModel` object contains the `Instrument`, `Radiative transfer` and `Surface` portions of the ISOFIT forward model. The three forward model components are object classes themselves, which contain the math and logic relevant to these features. For example, the `Instrument` portion holds functions for instrument uncertainty quantification and calibration, the `Radiative transfer` portion holds functions relevant for generating and sampling the radiative transfer lookup-tables (LUTs), and the `Surface` portion holds functions relevant to sampling surface priors and formulating surface-specific forward model elements.\n", + "\n", + "Note: if the LUT has not been generated at the expected location from the config, initializing the forward model class will immediately constructing the LUT at that location." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "daf7e8d6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The expected location of the LUT:\n", + "/Users/bgreenbe/.isofit/imagecube/medium/lut_full/lut.nc\n", + "\n", + "\n", + "\n", + "\n", + ">\n" + ] + } + ], + "source": [ + "print('The expected location of the LUT:')\n", + "print(config.forward_model.radiative_transfer.radiative_transfer_engines[0].lut_path)\n", + "print()\n", + "\n", + "# Initialized from the config:\n", + "fm = ForwardModel(config)\n", + "\n", + "# Print the three forward model components\n", + "print(fm.instrument)\n", + "print(fm.RT)\n", + "print(fm.surface)\n", + "\n", + "# Print an example method from RT\n", + "print(fm.RT.calc_rdn)" + ] + }, + { + "cell_type": "markdown", + "id": "ddb76898-3e1a-4f9f-8ef2-3e916f14255e", + "metadata": {}, + "source": [ + "and individual component classes can also be initialized from the `config` object:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "420af4de-8a64-4624-91e4-56320dd7808f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is\n" + ] + } + ], + "source": [ + "instrument = Instrument(config)\n", + "rt = RadiativeTransfer(config)\n", + "surface = Surface(config)" + ] + }, + { + "cell_type": "markdown", + "id": "4b46aef7-7150-4447-be06-df47456dac7c", + "metadata": {}, + "source": [ + "The optimal estimation inversion is handled by the Inversion class object." + ] + }, + { + "cell_type": "markdown", + "id": "3b7e324d-8ef6-4832-9b54-b09fc2458d04", + "metadata": {}, + "source": [ + "### OE Inversions" + ] + }, + { + "cell_type": "markdown", + "id": "2daca64c-2f56-4aea-97a5-bbafe760ecd5", + "metadata": {}, + "source": [ + "We will go into how to perform single pixel optimal estimation (OE) inversions from a set of input data and an ISOFIT config. To do this, we need to load in a radiance spectrum with paired observational geometry data. We'll pull this directly from the `rdn`, `obs`, and `loc` files we loaded above. \n", + "\n", + "OE inversions are run using the Inversion class:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "451f496a-a7dd-435a-b69a-660ff487ecc4", + "metadata": {}, + "outputs": [], + "source": [ + "iv = Inversion(config, fm)" + ] + }, + { + "cell_type": "markdown", + "id": "1ac96a7e-c0e1-4210-bc9a-7919158c8ca5", + "metadata": {}, + "source": [ + "Next, we'll select a pixel to run through the OE inversion." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "15ad55ab-481f-4cc9-8eac-d049bb46bbba", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.1813465].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Pick a pixel\n", + "row = 175\n", + "col = 50\n", + "\n", + "# Plot the input data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(8, 8))\n", + "plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))\n", + "plot = axs[1].imshow(loc_im[..., 0])\n", + "plot = axs[2].imshow(obs_im[..., 4])\n", + "\n", + "axs[0].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "axs[1].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "axs[2].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "\n", + "title = axs[0].set_title('Radiance (RGB)')\n", + "title = axs[1].set_title('Longitude (WGS-84)')\n", + "title = axs[2].set_title('Solar zenith angle (Deg)')" + ] + }, + { + "cell_type": "markdown", + "id": "a238060c-b133-4c0e-a4e7-52c41b435716", + "metadata": {}, + "source": [ + "Then we'll load in the measurement and observational data for that pixel. The geometry object holds all of the observational information for a given pixel." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "be82abde-7b34-4e5f-b456-be34a50d5dc3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "197.31315008280822\n", + "71.53144734704047\n", + "-0.3017277626279998\n" + ] + } + ], + "source": [ + "meas = rdn_im[row, col, :]\n", + "geom = Geometry(\n", + " obs=obs_im[row, col, :],\n", + " loc=loc_im[row, col, :],\n", + " esd=IO.load_esd(),\n", + " svf=1\n", + ")\n", + "\n", + "# e.g.\n", + "print(geom.solar_azimuth)\n", + "print(geom.observer_azimuth)\n", + "print(geom.cos_i)" + ] + }, + { + "cell_type": "markdown", + "id": "6adf64c4-b09c-4f83-ba3b-34bee40e616c", + "metadata": {}, + "source": [ + "and finally run the OE inversion via the inversions.invert function:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "dca42de9-475e-4cf7-a3cb-3e11c40d121e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of iterations to convergence: 9\n", + "Data type of 'oe': \n", + "Array shape: (9, 427)\n" + ] + } + ], + "source": [ + "oe = iv.invert(meas, geom)\n", + "\n", + "print(f\"Number of iterations to convergence: {len(oe)}\")\n", + "print(f\"Data type of 'oe': {type(oe)}\")\n", + "print(f\"Array shape: {oe.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "89d8779d-b82b-4077-ac35-ebd705327d95", + "metadata": {}, + "source": [ + "The `oe` variable is a numpy array where each row is a subsequent iteration of the OE procedure. It is often useful to examine how the solution changes during optimization, which can help debug potential issues with final statevector solutions.\n", + "\n", + "The plots below show the trajectory of the reflectance solution throughout the optimization. The earlier solutions are lighter colors while the later solutions are darker colors.\n", + "\n", + "The plots also show the prior mean selected for this specific pixel via the `surface.xa` function, which can be called directly using the initial guess of the reflectance solution and the pixel observation variables." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "0a20094c-daf1-422b-a326-b7329781b092", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a color map for the iterations\n", + "n = len(oe)\n", + "cmap_name = 'viridis_r'\n", + "cmap = plt.get_cmap(cmap_name)\n", + "colors = [cmap(i) for i in np.linspace(0, 1, n)]\n", + "\n", + "# Fit the prior mean\n", + "xa = fm.surface.xa(oe[0], geom)\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 4))\n", + "axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')\n", + "axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')\n", + "for i, sp in enumerate(oe):\n", + " axs[0].plot(wl, sp[:len(wl)], color=colors[i])\n", + " axs[1].plot(wl, sp[:len(wl)], color=colors[i])\n", + "\n", + "axs[0].plot(wl, oe[-1][:len(wl)], color='black', label='Final')\n", + "axs[1].plot(wl, oe[-1][:len(wl)], color='black')\n", + "\n", + "axs[0].set_ylabel('Reflectance')\n", + "axs[0].set_xlabel('Wavelength (nm)')\n", + "axs[1].set_ylabel('Reflectance')\n", + "axs[1].set_xlabel('Wavelength (nm)')\n", + "\n", + "axs[1].set_xlim([725, 1200])\n", + "axs[1].set_ylim([.1, .5])\n", + "\n", + "axs[0].set_title('Full spectrum')\n", + "axs[1].set_title('Highlighting 725 - 1200 nm')\n", + "\n", + "axs[0].legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "36d20b3b-f06f-4aba-a731-99284b089cb2", + "metadata": {}, + "source": [ + "We can also look at the trajectory of atmospheric statevector variables:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3f0bfd77-470b-4e5d-bce8-1289e17d3041", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, sharex=True, figsize=(10, 5))\n", + "iters = [i for i in range(len(oe))]\n", + "axs[0].set_title('AOT550')\n", + "axs[0].scatter(iters, oe[:, -2], edgecolor='black', facecolor='green', s=200)\n", + "axs[0].set_ylabel('AOT550')\n", + "\n", + "axs[1].set_title('H2O')\n", + "axs[1].scatter(iters, oe[:, -1], edgecolor='black', facecolor='green', s=200)\n", + "axs[1].set_ylabel('H2O')\n", + "\n", + "axs[0].set_xlabel('Iteration')\n", + "axs[1].set_xlabel('Iteration')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1f1cc68c-59aa-44d1-ae46-94291e97fc2a", + "metadata": {}, + "source": [ + "### Inversions with a constrained atmosphere\n", + "\n", + "Scene-scale processing generally leverages superpixel algorithms that simultaneously speed up processing and enforce a spatially smooth atmosphere. Here, we'll demonstrate the analytical line algorithm. The analytical line algorithm assumes there exists a closed form state-vector solution under the assumptions of 1) a fixed atmosphere, and 2) that the measurement can be modeled as a linear combination of state-vector elements. We can call the anlaytical line solution for a given pixel directly, albeit with slightly more set-up.\n", + "\n", + "First, we'll set up a wrapper function to call the analytical line inversion. In practice, the analytical inversion is sensitive to the initial guess (x0 below). We generally use the \"priorless\" solution for the state-vector elemnents for a given atmosphere via the `invert_algebraic` and `iv.fm.surface.fit_params` functions." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "21b0f415-f11f-4aa8-9a27-0381f4e1c40c", + "metadata": {}, + "outputs": [], + "source": [ + "def invert_aoe(iv, meas, geom, sub_state, x_RT, n=1):\n", + "\n", + " # This script sets up the initial guess for the inversion\n", + " x_surface, _, x_instrument = iv.fm.unpack(iv.fm.init.copy())\n", + " rfl_est, coeffs = invert_algebraic(\n", + " iv.fm.surface,\n", + " iv.fm.RT,\n", + " iv.fm.instrument,\n", + " x_surface,\n", + " x_RT,\n", + " x_instrument,\n", + " meas,\n", + " geom,\n", + " )\n", + "\n", + " rfl_est = iv.fm.surface.fit_params(rfl_est, geom)\n", + "\n", + " x0 = np.concatenate(\n", + " [\n", + " rfl_est,\n", + " x_RT,\n", + " x_instrument,\n", + " ]\n", + " )\n", + "\n", + " # This script is responsible for performing the inversion\n", + " states, unc, EXIT_CODE = invert_analytical(\n", + " iv.fm,\n", + " iv.winidx,\n", + " meas,\n", + " geom,\n", + " np.copy(x0),\n", + " sub_state,\n", + " n,\n", + " None,\n", + " None,\n", + " )\n", + "\n", + " return states[-1], unc, x0" + ] + }, + { + "cell_type": "markdown", + "id": "01255d4b-036b-4b34-a958-1d7b7d19de1a", + "metadata": {}, + "source": [ + "Next, we will pull the superpixel state solution and spatially smooth atmosphere for the selected pixel. \n", + "\n", + "Note: This assumes that these files already exist at the expected location." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "2a668a70-b4c0-4b9a-a286-253374dd3eae", + "metadata": {}, + "outputs": [], + "source": [ + "sub_state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_subs_state')\n", + "lbl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_lbl')\n", + "atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')\n", + "\n", + "sub_state = envi.open(envi_header(str(sub_state_path.expanduser())))\n", + "lbl = envi.open(envi_header(str(lbl_path.expanduser())))\n", + "atm = envi.open(envi_header(str(atm_path.expanduser())))\n", + "\n", + "sub_state_im = sub_state.open_memmap(interleave='bip')\n", + "lbl_im = lbl.open_memmap(interleave='bip')\n", + "atm_im = atm.open_memmap(interleave='bip')\n", + "\n", + "idx = int(lbl[row, col, 0])\n", + "sub_state = sub_state_im[idx, 0, :]\n", + "x_RT = atm_im[row, col, :]" + ] + }, + { + "cell_type": "markdown", + "id": "fbd02d3f-26ee-4953-a489-bc154f24a79d", + "metadata": {}, + "source": [ + "We can then call the wrapper function. Solutions are generally acceptible after one iteration, but `n` can be definted to explictely set the number of iterations to perform. " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e0a8370a-44af-491e-b2ff-6b11308940c1", + "metadata": {}, + "outputs": [], + "source": [ + "aoe, aoe_unc, x0 = invert_aoe(\n", + " iv, meas, geom, sub_state, x_RT, n=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "ee7eefc7-183b-4321-9abb-e90389c455e3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a color map for the iterations\n", + "n = len(oe)\n", + "cmap_name = 'viridis_r'\n", + "cmap = plt.get_cmap(cmap_name)\n", + "colors = [cmap(i) for i in np.linspace(0, 1, n)]\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", + "\n", + "axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')\n", + "axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')\n", + "\n", + "axs[0].plot(wl, aoe[:len(wl)], color='purple', lw=2, label='AOE')\n", + "axs[1].plot(wl, aoe[:len(wl)], color='purple', lw=2)\n", + "\n", + "axs[0].plot(wl, oe[-1][:len(wl)], color='green', label='OE')\n", + "axs[1].plot(wl, oe[-1][:len(wl)], color='green')\n", + "\n", + "axs[0].set_ylabel('Reflectance')\n", + "axs[0].set_xlabel('Wavelength (nm)')\n", + "axs[1].set_ylabel('Reflectance')\n", + "axs[1].set_xlabel('Wavelength (nm)')\n", + "\n", + "axs[1].set_xlim([725, 1200])\n", + "axs[1].set_ylim([.1, .5])\n", + "axs[0].set_ylim([-.1, .5])\n", + "\n", + "axs[0].set_title('Full spectrum')\n", + "axs[1].set_title('Highlighting 725 - 1200 nm')\n", + "\n", + "axs[0].legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "adfffc32-8ef7-47c6-818f-d03acae7c50e", + "metadata": {}, + "outputs": [], + "source": [ + "### Algebraic inversions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0e5bf2f-cf60-409e-8c48-1573cf572c08", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_12_0.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_12_0.png new file mode 100644 index 0000000..86438b5 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_12_0.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_16_0.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_16_0.png new file mode 100644 index 0000000..694d311 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_16_0.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_20_1.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_20_1.png new file mode 100644 index 0000000..c61669d Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_20_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_21_1.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_21_1.png new file mode 100644 index 0000000..c61669d Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_21_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_22_1.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_22_1.png new file mode 100644 index 0000000..ab28dc8 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_22_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_24_1.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_24_1.png new file mode 100644 index 0000000..022a61a Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_24_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_26_1.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_26_1.png new file mode 100644 index 0000000..022a61a Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_apply_oe_26_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_16_1.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_16_1.png new file mode 100644 index 0000000..0d04584 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_16_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_22_0.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_22_0.png new file mode 100644 index 0000000..2285444 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_22_0.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_24_0.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_24_0.png new file mode 100644 index 0000000..a2fdfe5 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_24_0.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_31_0.png b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_31_0.png new file mode 100644 index 0000000..7196713 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/how_to_run_functions_31_0.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples/neon.ipynb b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples/neon.ipynb new file mode 100644 index 0000000..516534f --- /dev/null +++ b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples/neon.ipynb @@ -0,0 +1,1610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "35412b86-171d-473c-8575-470b8fbed89d", + "metadata": {}, + "source": [ + "# NEON\n", + "\n", + "Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f81e3c4a-0bef-4cbe-a494-75c8e0d908ca", + "metadata": {}, + "source": [ + "## Full image example\n", + "\n", + "This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.\n", + "\n", + "Prerequisites:\n", + "- Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the 'data' folder which includes the 'subsets' directory.\n", + "- Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed8d9de0-a74a-4e6c-83b2-54f7bc32f593", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "from pathlib import Path\n", + "from types import SimpleNamespace\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "from spectral.io import envi\n", + "\n", + "import isofit\n", + "from isofit.utils.apply_oe import apply_oe \n", + "from isofit.utils.surface_model import surface_model\n", + "from isofit import ray\n", + "ray.shutdown()\n" + ] + }, + { + "cell_type": "markdown", + "id": "164060bf-3cad-4d58-811f-838158d7d967", + "metadata": {}, + "source": [ + "### Setup\n", + "\n", + "ISOFIT needs at minimum three pieces as input:\n", + "\n", + " 1. Radiance measurements (rdn)\n", + " 2. Observation values (obs)\n", + " 3. Location information (loc)\n", + "\n", + "This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can 'fake' the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:\n", + "\n", + "```\n", + "Radiance\n", + "├── 173647\n", + "│ ├── NIS01_20210403_173647_obs_ort\n", + "│ ├── NIS01_20210403_173647_obs_ort.hdr\n", + "│ ├── NIS01_20210403_173647_rdn_ort\n", + "│ └── NIS01_20210403_173647_rdn_ort.hdr\n", + "└── 174150\n", + " ├── NIS01_20210403_174150_obs_ort\n", + " ├── NIS01_20210403_174150_obs_ort.hdr\n", + " ├── NIS01_20210403_174150_rdn_ort\n", + " └── NIS01_20210403_174150_rdn_ort.hdr\n", + "```\n", + "\n", + "These files have corresponding in situ data as well, and below we've encoded the locations of each, which we can use to help subset data files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7b88339c-ac36-4aab-98b7-2a1dd07ab8a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data subset directory at: /Users/bgreenbe/.isofit/neon_subset\n", + "Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json\n", + "sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5\n", + "6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs\n" + ] + } + ], + "source": [ + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "\n", + "# Path to the input NEON data\n", + "subset_dir = str(Path('~/.isofit/neon_subset').expanduser())\n", + "print(f'Data subset directory at: {subset_dir}')\n", + "\n", + "# Path to write isofit output\n", + "output = str(Path('~/.isofit/neon_subset/output').expanduser())\n", + "if os.path.isdir(output) is False:\n", + " os.mkdir(output)\n", + "\n", + "if os.path.isdir(subset_dir) is False:\n", + " os.mkdir(subset_dir)\n", + "\n", + "surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())\n", + "print(f'Surface model at: {surface_model_path}')\n", + "neon_id = '173647'\n", + "\n", + "\n", + "# Optionally set some environment variables as needed\n", + "#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'\n", + "#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'\n", + "\n", + "print(f'sRTMnet emulator path (required): {os.environ[\"EMULATOR_PATH\"]}')\n", + "print(f'6s path (required): {os.environ[\"SIXS_DIR\"]}')\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "727dcd06-2a38-4020-8a15-b6707b8ed453", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a5656147-509e-41f4-9cac-c9b81117c5b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Which NEON date to process - change this to process a different date\n", + "neon_id = list(report.keys())[0]\n", + "\n", + "# Select the locations from the neon id -- roi == Regions of Interest\n", + "roi = report[neon_id]" + ] + }, + { + "cell_type": "markdown", + "id": "e9ec9046-3c9d-47bf-914c-68e67424065f", + "metadata": {}, + "source": [ + "#### Loc file generation\n", + "\n", + "NEON doesn't distribute (?) a loc file, so let's fake one for now. We'll do this for the full file and for the subset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5b51ea6-f2ba-4348-9ec9-4a3eadd6c1c0", + "metadata": {}, + "outputs": [], + "source": [ + "def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):\n", + " \"\"\"\n", + " Retrieves the metadata from an envi header\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']\n", + " Removes keys from the metadata dictionary\n", + " \"\"\"\n", + " rdn_ds = envi.open(file)\n", + " metadata = rdn_ds.metadata.copy()\n", + " for key in remove:\n", + " if key in metadata:\n", + " del metadata[key]\n", + " else:\n", + " print(f'Key {key!r} not found in the metadata, skipping')\n", + "\n", + " return metadata\n", + "\n", + "def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake LOC file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " lon: float\n", + " Longitude value for location\n", + " lat: float\n", + " Latitude value for location\n", + " elv: float\n", + " Elevation in kilometers\n", + " output: str, default=None\n", + " Path to write the LOC file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `loc`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " Logger.error('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 3\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " loc = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " loc[..., 0] = lon\n", + " loc[..., 1] = lat\n", + " loc[..., 2] = elv\n", + "\n", + " del ds, loc\n", + "\n", + "def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake OBS file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN file containing metadata\n", + " param0: int, float, default=0\n", + " Parameter 0\n", + " sea: int, float, default=0\n", + " Solar Azimuth\n", + " sez: int, float, default=0\n", + " Sensor Zenith\n", + " soa: int, float, default=0\n", + " Solar Azimuth\n", + " soz: int, float, default=0\n", + " Solar Zenith\n", + " phase: int, float, default=0\n", + " Phase\n", + " slope: int, float, default=0\n", + " Slope\n", + " aspect: int, float, default=0\n", + " Aspect\n", + " cosi: int, float, default=0\n", + " COS(i)\n", + " param9: int, float, default=0\n", + " Parameter 9\n", + " param10: int, float, default=0\n", + " Parameter 10\n", + " output: str, default=None\n", + " Path to write the OBS file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `obs`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " print('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " rdn_ds = envi.open(rdn)\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 11\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " obs = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " obs[..., 0] = param0\n", + " obs[..., 1] = sea\n", + " obs[..., 2] = sez\n", + " obs[..., 3] = soa\n", + " obs[..., 4] = soz\n", + " obs[..., 5] = phase\n", + " obs[..., 6] = slope\n", + " obs[..., 7] = aspect\n", + " obs[..., 8] = cosi\n", + " obs[..., 9] = param9\n", + " obs[..., 10] = param10\n", + "\n", + " del ds, obs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bac7ba6b-1c0e-41b7-97e0-d9e137a9e217", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key 'band names' not found in the metadata, skipping\n" + ] + } + ], + "source": [ + "fakeLOC(\n", + " rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),\n", + " lon = -105.237000,\n", + " lat = 40.125000,\n", + " elv = 1689.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "83bf8ace-3e19-4674-86df-d2f46e220a32", + "metadata": {}, + "source": [ + "#### Apply OE\n", + "\n", + "The next part walks through running the ISOFIT utility script `isofit/utils/apply_oe.py`. This is the first step of executing ISOFIT and will generate a default configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d0ec94f8-b1e7-4e4d-9b8f-450134ca5a83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n" + ] + } + ], + "source": [ + "output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "surface_model(**{\n", + " 'config_path': surface_model_path,\n", + " 'output_path': output_surface_file,\n", + " 'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3cbe6f39-6d6f-4182-abfb-30e95ce49ede", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns\n", + "WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...\n", + "2025-07-08 15:20:10,698\tINFO worker.py:1917 -- Started a local Ray instance.\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn\n", + "2025-07-08 15:20:11,728\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: completing\n", + "2025-07-08 15:20:11,781\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc\n", + "2025-07-08 15:20:11,825\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2 0.84 1.49 2.13 2.77 3.42 4.06 4.7 5.35 5.99]\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.\n", + "INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess\n", + "INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "2025-07-08 15:20:11,882\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:20:19.280425-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete\u001b[32m [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11\u001b[32m [repeated 7x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17160)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete. 34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded. Aerosol State Vector:\n", + "{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}\n", + "Aerosol LUT Grid:\n", + "{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}\n", + "Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt\n", + "INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT\n", + "INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "2025-07-08 15:20:53,541\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:20:59 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)\n", + "INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:03 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)\n", + "INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:08 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)\n", + "INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:13 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)\n", + "INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:17 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)\n", + "INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:21 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)\n", + "INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:27 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)\n", + "INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:31 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)\n", + "INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:35 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)\n", + "INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:21:43 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\", file_line:1171, created_time:\"2025-07-08T15:21:46.660474-07:00\", http2_error:2, grpc_status:14}\n", + "I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:21:46.660733-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:21:47 ||| \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (32,0).\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:21:52 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (27,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:21:58 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (55,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:03 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (61,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:08 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (99,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:13 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (105,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:18 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (166,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:23 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (193,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:28 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (210,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:33 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (230,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:39 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (269,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:44 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (275,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:49 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (303,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:55 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (320,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:00 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (376,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:05 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (383,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:10 ||| \u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (412,0).\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete. 91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core\n", + "INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference\n", + "INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:16 ||| \u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (419,0).\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n", + "2025-07-08 15:23:17,031\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores\n", + "INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete. 1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core\n", + "2025-07-08 15:23:18,445\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete. 51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core\n", + "INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.\n", + "\u001b[36m(Worker pid=17657)\u001b[0m INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:24:10.613957-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n" + ] + } + ], + "source": [ + "kwargs = {\n", + " 'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance\n", + " 'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location\n", + " 'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations\n", + " 'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory\n", + " 'sensor': 'neon', \n", + " \"surface_path\": output_surface_file, # Surface priors - often changes\n", + " 'emulator_base': os.environ['EMULATOR_PATH'],\n", + " 'n_cores': 4,\n", + " \"wavelength_path\": None,\n", + " \"surface_category\": \"multicomponent_surface\",\n", + " \"rdn_factors_path\": None, # RCC update used 'on the fly'\n", + " \"channelized_uncertainty_path\": None, # Channelized uncertainty - if you have an instrument model\n", + " \"model_discrepancy_path\": None, # Model discrepancy term - handle things like unknown radiative transfer model effects\n", + " \"lut_config_file\": None,\n", + " \"logging_level\": \"INFO\",\n", + " \"log_file\": None,\n", + " \"presolve\": True, # Attempts to solve for the right wv range\n", + " \"analytical_line\": True, # mathematical representation of OE given that the atmsophere is known\n", + " \"ray_temp_dir\": \"/tmp/ray\",\n", + " \"segmentation_size\": 10,\n", + " \"num_neighbors\": [5],\n", + " \"atm_sigma\": [0.5],\n", + " \"pressure_elevation\": False,\n", + "}\n", + "\n", + "apply_oe(**kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9d31291a-c036-4288-9114-cd772dda6748", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "for _key, key in enumerate(report.keys()):\n", + " if _key < 1:\n", + "\n", + " rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))\n", + " rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()\n", + " wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])\n", + "\n", + " miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5\n", + " maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5\n", + " minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5\n", + " maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5\n", + "\n", + " plt.figure()\n", + " plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))\n", + " plt.title(f'NIS01_20210403_{key}')\n", + " for k,i in report[key].items():\n", + " plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)\n", + "\n", + " for k,i in report[key].items():\n", + " plt.figure()\n", + " in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())\n", + " in_situ = np.genfromtxt(in_situ_path, skip_header=3)\n", + " plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')\n", + " mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))\n", + " plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')\n", + " plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "85419744-2391-48f0-b6c2-239390d4b994", + "metadata": {}, + "source": [ + "## Per-Pixel Retrievals\n", + "\n", + "This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).\n", + "\n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f60f1ae9-754b-4c25-bc51-70b792debed7", + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5efac6d4-c9f5-4292-a8e1-739939056ac1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n" + ] + } + ], + "source": [ + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')\n", + "config.input.loc_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "467786f7-35a6-4472-92c5-1fa753da9e3d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line\n" + ] + } + ], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fdbd8001-530b-497f-a2c8-fdda0a2206d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(13, 428)\n", + "[0.10742364 0.60519719]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def closest_wl(mv):\n", + " return np.argmin(np.abs(io.meas_wl-mv))\n", + "\n", + "wl_nan = io.meas_wl.copy()\n", + "wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan\n", + "wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan\n", + "\n", + "fig = plt.figure(figsize=(14,5))\n", + "print(states.shape)\n", + "offset = 0\n", + "for n in range(0,states.shape[0],4):\n", + " lab = f'Step {n}'\n", + " if n == 0:\n", + " lab = 'Algebraic inversion at initial guess'\n", + " \n", + " plt.plot(wl_nan, states[n,:-2] + offset, label=lab)\n", + " offset += 0.04\n", + "plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')\n", + "plt.legend()\n", + "\n", + "print(states[-1,-2:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8fcb0f-cd8e-47b9-9146-2e1335afcfd2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples/neon/neon.ipynb b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples/neon/neon.ipynb new file mode 100644 index 0000000..339460d --- /dev/null +++ b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples/neon/neon.ipynb @@ -0,0 +1,1608 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "35412b86-171d-473c-8575-470b8fbed89d", + "metadata": {}, + "source": [ + "# NEON\n", + "\n", + "Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f81e3c4a-0bef-4cbe-a494-75c8e0d908ca", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.\n", + "\n", + "Prerequisites:\n", + "- Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the 'data' folder which includes the 'subsets' directory.\n", + "- Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed8d9de0-a74a-4e6c-83b2-54f7bc32f593", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "from pathlib import Path\n", + "from types import SimpleNamespace\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "from spectral.io import envi\n", + "\n", + "import isofit\n", + "from isofit.utils.apply_oe import apply_oe \n", + "from isofit.utils.surface_model import surface_model\n", + "from isofit import ray\n", + "ray.shutdown()\n" + ] + }, + { + "cell_type": "markdown", + "id": "164060bf-3cad-4d58-811f-838158d7d967", + "metadata": {}, + "source": [ + "ISOFIT needs at minimum three pieces as input:\n", + "\n", + " 1. Radiance measurements (rdn)\n", + " 2. Observation values (obs)\n", + " 3. Location information (loc)\n", + "\n", + "This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can 'fake' the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:\n", + "\n", + "```\n", + "Radiance\n", + "├── 173647\n", + "│ ├── NIS01_20210403_173647_obs_ort\n", + "│ ├── NIS01_20210403_173647_obs_ort.hdr\n", + "│ ├── NIS01_20210403_173647_rdn_ort\n", + "│ └── NIS01_20210403_173647_rdn_ort.hdr\n", + "└── 174150\n", + " ├── NIS01_20210403_174150_obs_ort\n", + " ├── NIS01_20210403_174150_obs_ort.hdr\n", + " ├── NIS01_20210403_174150_rdn_ort\n", + " └── NIS01_20210403_174150_rdn_ort.hdr\n", + "```\n", + "\n", + "These files have corresponding in situ data as well, and below we've encoded the locations of each, which we can use to help subset data files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7b88339c-ac36-4aab-98b7-2a1dd07ab8a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data subset directory at: /Users/bgreenbe/.isofit/neon_subset\n", + "Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json\n", + "sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5\n", + "6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs\n" + ] + } + ], + "source": [ + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "\n", + "# Path to the input NEON data\n", + "subset_dir = str(Path('~/.isofit/neon_subset').expanduser())\n", + "print(f'Data subset directory at: {subset_dir}')\n", + "\n", + "# Path to write isofit output\n", + "output = str(Path('~/.isofit/neon_subset/output').expanduser())\n", + "if os.path.isdir(output) is False:\n", + " os.mkdir(output)\n", + "\n", + "if os.path.isdir(subset_dir) is False:\n", + " os.mkdir(subset_dir)\n", + "\n", + "surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())\n", + "print(f'Surface model at: {surface_model_path}')\n", + "neon_id = '173647'\n", + "\n", + "\n", + "# Optionally set some environment variables as needed\n", + "#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'\n", + "#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'\n", + "\n", + "print(f'sRTMnet emulator path (required): {os.environ[\"EMULATOR_PATH\"]}')\n", + "print(f'6s path (required): {os.environ[\"SIXS_DIR\"]}')\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "727dcd06-2a38-4020-8a15-b6707b8ed453", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a5656147-509e-41f4-9cac-c9b81117c5b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Which NEON date to process - change this to process a different date\n", + "neon_id = list(report.keys())[0]\n", + "\n", + "# Select the locations from the neon id -- roi == Regions of Interest\n", + "roi = report[neon_id]" + ] + }, + { + "cell_type": "markdown", + "id": "e9ec9046-3c9d-47bf-914c-68e67424065f", + "metadata": {}, + "source": [ + "#### Loc file generation\n", + "\n", + "NEON doesn't distribute (?) a loc file, so let's fake one for now. We'll do this for the full file and for the subset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5b51ea6-f2ba-4348-9ec9-4a3eadd6c1c0", + "metadata": {}, + "outputs": [], + "source": [ + "def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):\n", + " \"\"\"\n", + " Retrieves the metadata from an envi header\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']\n", + " Removes keys from the metadata dictionary\n", + " \"\"\"\n", + " rdn_ds = envi.open(file)\n", + " metadata = rdn_ds.metadata.copy()\n", + " for key in remove:\n", + " if key in metadata:\n", + " del metadata[key]\n", + " else:\n", + " print(f'Key {key!r} not found in the metadata, skipping')\n", + "\n", + " return metadata\n", + "\n", + "def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake LOC file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " lon: float\n", + " Longitude value for location\n", + " lat: float\n", + " Latitude value for location\n", + " elv: float\n", + " Elevation in kilometers\n", + " output: str, default=None\n", + " Path to write the LOC file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `loc`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " Logger.error('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 3\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " loc = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " loc[..., 0] = lon\n", + " loc[..., 1] = lat\n", + " loc[..., 2] = elv\n", + "\n", + " del ds, loc\n", + "\n", + "def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake OBS file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN file containing metadata\n", + " param0: int, float, default=0\n", + " Parameter 0\n", + " sea: int, float, default=0\n", + " Solar Azimuth\n", + " sez: int, float, default=0\n", + " Sensor Zenith\n", + " soa: int, float, default=0\n", + " Solar Azimuth\n", + " soz: int, float, default=0\n", + " Solar Zenith\n", + " phase: int, float, default=0\n", + " Phase\n", + " slope: int, float, default=0\n", + " Slope\n", + " aspect: int, float, default=0\n", + " Aspect\n", + " cosi: int, float, default=0\n", + " COS(i)\n", + " param9: int, float, default=0\n", + " Parameter 9\n", + " param10: int, float, default=0\n", + " Parameter 10\n", + " output: str, default=None\n", + " Path to write the OBS file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `obs`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " print('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " rdn_ds = envi.open(rdn)\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 11\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " obs = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " obs[..., 0] = param0\n", + " obs[..., 1] = sea\n", + " obs[..., 2] = sez\n", + " obs[..., 3] = soa\n", + " obs[..., 4] = soz\n", + " obs[..., 5] = phase\n", + " obs[..., 6] = slope\n", + " obs[..., 7] = aspect\n", + " obs[..., 8] = cosi\n", + " obs[..., 9] = param9\n", + " obs[..., 10] = param10\n", + "\n", + " del ds, obs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bac7ba6b-1c0e-41b7-97e0-d9e137a9e217", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key 'band names' not found in the metadata, skipping\n" + ] + } + ], + "source": [ + "fakeLOC(\n", + " rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),\n", + " lon = -105.237000,\n", + " lat = 40.125000,\n", + " elv = 1689.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "83bf8ace-3e19-4674-86df-d2f46e220a32", + "metadata": {}, + "source": [ + "## Apply OE\n", + "\n", + "The next part walks through running the ISOFIT utility script `isofit/utils/apply_oe.py`. This is the first step of executing ISOFIT and will generate a default configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d0ec94f8-b1e7-4e4d-9b8f-450134ca5a83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n" + ] + } + ], + "source": [ + "output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "surface_model(**{\n", + " 'config_path': surface_model_path,\n", + " 'output_path': output_surface_file,\n", + " 'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3cbe6f39-6d6f-4182-abfb-30e95ce49ede", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns\n", + "WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...\n", + "2025-07-08 15:20:10,698\tINFO worker.py:1917 -- Started a local Ray instance.\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn\n", + "2025-07-08 15:20:11,728\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: completing\n", + "2025-07-08 15:20:11,781\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc\n", + "2025-07-08 15:20:11,825\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2 0.84 1.49 2.13 2.77 3.42 4.06 4.7 5.35 5.99]\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.\n", + "INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess\n", + "INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "2025-07-08 15:20:11,882\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:20:19.280425-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete\u001b[32m [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11\u001b[32m [repeated 7x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17160)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete. 34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded. Aerosol State Vector:\n", + "{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}\n", + "Aerosol LUT Grid:\n", + "{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}\n", + "Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt\n", + "INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT\n", + "INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "2025-07-08 15:20:53,541\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:20:59 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)\n", + "INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:03 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)\n", + "INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:08 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)\n", + "INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:13 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)\n", + "INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:17 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)\n", + "INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:21 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)\n", + "INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:27 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)\n", + "INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:31 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)\n", + "INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:35 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)\n", + "INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:21:43 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\", file_line:1171, created_time:\"2025-07-08T15:21:46.660474-07:00\", http2_error:2, grpc_status:14}\n", + "I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:21:46.660733-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:21:47 ||| \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (32,0).\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:21:52 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (27,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:21:58 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (55,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:03 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (61,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:08 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (99,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:13 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (105,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:18 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (166,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:23 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (193,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:28 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (210,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:33 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (230,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:39 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (269,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:44 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (275,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:49 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (303,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:55 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (320,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:00 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (376,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:05 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (383,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:10 ||| \u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (412,0).\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete. 91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core\n", + "INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference\n", + "INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:16 ||| \u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (419,0).\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n", + "2025-07-08 15:23:17,031\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores\n", + "INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete. 1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core\n", + "2025-07-08 15:23:18,445\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete. 51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core\n", + "INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.\n", + "\u001b[36m(Worker pid=17657)\u001b[0m INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:24:10.613957-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n" + ] + } + ], + "source": [ + "kwargs = {\n", + " 'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance\n", + " 'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location\n", + " 'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations\n", + " 'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory\n", + " 'sensor': 'neon', \n", + " \"surface_path\": output_surface_file, # Surface priors - often changes\n", + " 'emulator_base': os.environ['EMULATOR_PATH'],\n", + " 'n_cores': 4,\n", + " \"wavelength_path\": None,\n", + " \"surface_category\": \"multicomponent_surface\",\n", + " \"rdn_factors_path\": None, # RCC update used 'on the fly'\n", + " \"channelized_uncertainty_path\": None, # Channelized uncertainty - if you have an instrument model\n", + " \"model_discrepancy_path\": None, # Model discrepancy term - handle things like unknown radiative transfer model effects\n", + " \"lut_config_file\": None,\n", + " \"logging_level\": \"INFO\",\n", + " \"log_file\": None,\n", + " \"presolve\": True, # Attempts to solve for the right wv range\n", + " \"analytical_line\": True, # mathematical representation of OE given that the atmsophere is known\n", + " \"ray_temp_dir\": \"/tmp/ray\",\n", + " \"segmentation_size\": 10,\n", + " \"num_neighbors\": [5],\n", + " \"atm_sigma\": [0.5],\n", + " \"pressure_elevation\": False,\n", + "}\n", + "\n", + "apply_oe(**kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9d31291a-c036-4288-9114-cd772dda6748", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAelZJREFUeJzt3XlcFOUDBvBnuRUBD+RKUdBU1LygFBUhS0wztewnmWephZoXHaZWlpVaeWVe5ZGW5VFqaZJ5pWmieWCZJyqKKYh4cCiCwPv7Y9hxFxZYYHd2Fp7v57MfYPbd2Xd3Znce3mNGI4QQICIiIqpAbCxdASIiIiJTY8AhIiKiCocBh4iIiCocBhwiIiKqcBhwiIiIqMJhwCEiIqIKhwGHiIiIKhwGHCIiIqpw7CxdAUvIy8vD1atX4eLiAo1GY+nqEBERkRGEEEhPT4ePjw9sbIpvo6mUAefq1auoW7eupatBREREZXD58mXUqVOn2DKVMuC4uLgAkN4gV1dXC9eGiIiIjJGWloa6devKx/HiVMqAo+2WcnV1ZcAhIiKyMsYML+EgYyIiIqpwGHCIiIiowmHAISIiogqHAYeIiIgqHAYcIiIiqnAYcIiIiKjCYcAhIiKiCocBh4iIiCocBhwiIiKqcBhwiIiIqMJhwCEiIqIKhwGHiIiIKhwGHIWkpqYiKioKo0ePtnRViIiIKjyNEEJYuhJKS0tLg5ubG1JTUxW7mnhycjI8PT0BALm5ubCxYbYkIiIqjdIcv3mUVUiVKlXk3+/du2fBmhAREVV8DDgK0Q04mZmZFqwJERFRxceAoxA7OzvY2dkBYMAhIiIyNwYcBWlbcRhwiIiIzIsBR0EMOERERMpgwFEQAw4REZEyGHAUpA04nEVFRERkXgw4CmILDhERkTIYcBTEgENERKQMBhwFMeAQEREpgwFHQQw4REREymDAURADDhERkTIYcBTEgENERKQMBhwFOTk5AWDAISIiMjcGHAWxBYeIiEgZDDgKYsAhIiJSBgOOghhwiIiIlMGAoyAGHCIiImUw4CiIAYeIiEgZDDgKYsAhIiJShiIBZ+HChfDz84OTkxMCAwOxd+/eYsvv2bMHgYGBcHJygr+/PxYvXlyozO3btzFq1Ch4e3vDyckJAQEBiI6ONtdLMAkGHCIiImWYPeCsXbsW48aNw+TJkxEbG4uQkBB069YNCQkJBsvHx8eje/fuCAkJQWxsLCZNmoQxY8Zg/fr1cpns7Gx06dIFFy9exI8//ogzZ85gyZIleOihh8z9csqFAYfI9EaPHo2IiAgIISxdFSJSEY0w87dC27Zt0aZNGyxatEheFhAQgN69e2P69OmFyk+YMAGbNm3CqVOn5GWRkZH4+++/ERMTAwBYvHgxPvvsM5w+fRr29valrlNaWhrc3NyQmpoKV1fXMryqstm6dSu6deuGVq1aITY2VrHnJarINBoNAOD48eNo3ry5hWtDROZUmuO3WVtwsrOzceTIEYSHh+stDw8Px/79+w0+JiYmplD5rl274vDhw7h//z4AYNOmTQgODsaoUaPg6emJ5s2bY9q0acjNzTW4zqysLKSlpendLIEtOETmw88VkeVcuXIFHTt2xA8//GDpqsjMGnBSUlKQm5sLT09PveWenp5ISkoy+JikpCSD5XNycpCSkgIAuHDhAn788Ufk5uYiOjoa77zzDmbNmoWPP/7Y4DqnT58ONzc3+Va3bl0TvLrSY8AhMi3dBmjtP0BEpLzhw4fjzz//RN++fS1dFZkig4y1TchaQohCy0oqr7s8Ly8PHh4e+OqrrxAYGIgXXngBkydP1usG0zVx4kSkpqbKt8uXL5fn5ZSZNuDcu3fPIs9PVNEw4BCpw+nTpy1dhULszLlyd3d32NraFmqtSU5OLtRKo+Xl5WWwvJ2dHWrVqgUA8Pb2hr29PWxtbeUyAQEBSEpKQnZ2NhwcHPQe7+joCEdHR1O8pHJhCw6RaTHgEKlDcnKypatQiFlbcBwcHBAYGIjt27frLd++fTvat29v8DHBwcGFym/btg1BQUHygOIOHTrg3LlzyMvLk8ucPXsW3t7ehcKNmjDgEJkWAw6ROty5c8fSVSjE7F1UUVFRWLp0KZYvX45Tp05h/PjxSEhIQGRkJACp+2jQoEFy+cjISFy6dAlRUVE4deoUli9fjmXLluGNN96Qy4wYMQI3btzA2LFjcfbsWWzZsgXTpk3DqFGjzP1yykUbcHJycpCTk2Ph2hBVLNnZ2ZauAhGpiFm7qAAgIiICN27cwNSpU5GYmIjmzZsjOjoa9erVAwAkJibqnRPHz88P0dHRGD9+PBYsWAAfHx/MmzcPffr0kcvUrVsX27Ztw/jx49GiRQs89NBDGDt2LCZMmGDul1Mu2oADSK04Li4uFqwNkfVjCw6Ruuge5yzN7OfBUSNLnQdHCAEbG6nR7Nq1a/Dw8FDsuYkqouzsbHl83XfffYcXX3zRwjUiqpy0k4Dq16+P+Ph4sz2Pas6DQ/o0Gg2cnJwAcBwOkSmwBYfI8u7evSv/rqZ/3BlwFMaAQ2Q6DDhElnft2jX592rVqlmwJvoYcBTGmVREpsOAQ2R5ugFHTaNeGHAUxoBDZB4MOESWwYBDABhwiExJ98uU08SJLEP3JH8MOJUYAw6R6bCLisjydC9gzYBTiTHgEJkOAw6R5anxLMYAA47iGHCITIcBh8jydKeJswWnEmPAITIdBhwiy9NtwWHAqcQYcIhMh4OMiSxPrwXHjGcxLi0GHIUx4BCZB1twiCxDrwXnyhUL1kQfA47CGHCITIctOESWp9eCY8F6FMSAozAGHCLT4RgcIsvTa8GxYD0KYsBRmDbg3Lt3z8I1IbJ+DDhElqfbgqMmDDgKYwsOkekw4BBZHltwCAADDpEpMeAQWR7H4BAABhwiU2LAIbI8tuAQAAYcInPhLCoiy2DAIQAMOESmxGniRJYlhGAXFUkYcIhMhwGHyLKys7ORm5sr/82AU4kx4BCZDgMOkWUZnCKukutRMeAozMnJCQADDpEpMOAQWZbu+BsgvwWHAadyYgsOkekw4BBZVsEWHAEAOl1WlsSAozAGHCLTYcAhsiyDLTgMOJWTNuDcvHkTAwcORF5enoVrRFQxMOAQKY8tOCTTBhwAWLVqFc6cOWPB2hBZN7bgEFkWW3BIphtwgMI7BxEZjwGHyLIMtuCopGeCAUdhBQNOenq6hWpCZP10A05WVpYFa0JUOWn/SdcLE2zBqZzs7e3RsGFD+W8GHKKyYwsOkWVpW3Cc7ewAsIuqUtNoNDhw4ACaNm0KgAGHqDx0A05OTg4H7RMpTNuC42xrC4BdVJVerVq10KhRIwAMOETlIQqcUIxXFCdSVmJiIgCgtqMjAJ7ojwC4uLgAYMAhMiV2UxEp68SJEwCAZvnHNLbgEFxdXQEw4BCVR8EWHAYcImVpA07zatUAsAWH8KAFJy0tzcI1IbJeDDhElpORkYGLFy8CAJo5OwOohAFn4cKF8PPzg5OTEwIDA7F3795iy+/ZsweBgYFwcnKCv78/Fi9erHf/ihUroNFoCt3u3btnzpdhUuyiIiq/ggGHU8WJlHPq1CkAgKenJ9zt7R/cUVkCztq1azFu3DhMnjwZsbGxCAkJQbdu3ZCQkGCwfHx8PLp3746QkBDExsZi0qRJGDNmDNavX69XztXVFYmJiXo37ZW6rQEDDlH5FQw42v8micj85PE3zZrJU8Mr1Ric2bNnY+jQoRg2bBgCAgIwd+5c1K1bF4sWLTJYfvHixfD19cXcuXMREBCAYcOG4eWXX8bMmTP1ymk0Gnh5eendrAkDDlH5FQw4x44ds0xFiCqhc+fOAQAaN24MTf5nsdJ0UWVnZ+PIkSMIDw/XWx4eHo79+/cbfExMTEyh8l27dsXhw4f1poBmZGSgXr16qFOnDnr06IHY2Ngi65GVlYW0tDS9m6Ux4BCVHwMOkeXcvHkTAFC7du3KF3BSUlKQm5sLT09PveWenp5ISkoy+JikpCSD5XNycpCSkgIAaNKkCVasWIFNmzZh9erVcHJyQocOHRAXF2dwndOnT4ebm5t8q1u3rgleXfkw4BCZHgMOkXJu3boFAKhRowY0+d1SlSbgaGk0Gr2/hRCFlpVUXnd5u3btMGDAALRs2RIhISFYt24dGjVqhC+++MLg+iZOnIjU1FT5dvny5fK8HJNgwCEqv4ItOCdPnuRMKiITO3/+PFatWlXoTOHaFpyaNWvqt+CoZAyOnTlX7u7uDltb20KtNcnJyYVaabS8vLwMlrezs0OtWrUMPsbGxgaPPvpokS04jo6OcMw/y6JaMOAQlZ824NSoUQN5eXlITU1FXFycNOiRiExCe/1EIQQGDhwoL9drwalsXVQODg4IDAzE9u3b9ZZv374d7du3N/iY4ODgQuW3bduGoKAg2OtOQ9MhhMCxY8fg7e1tmoorgCf6Iyo/bcCxsbGRJxpou7LJhJYuBZ57DrCiU3GQ6e3Zs0fvb0NdVAAqR8ABgKioKCxduhTLly/HqVOnMH78eCQkJCAyMhKA1H00aNAguXxkZCQuXbqEqKgonDp1CsuXL8eyZcvwxhtvyGU++OAD/Pbbb7hw4QKOHTuGoUOH4tixY/I6rYG2BScrK4vXzyEqI93u65o1awJ40GxOJjR8OLBxI7BkiaVrQhZkm39BTS3dgAMVtuCYtYsKACIiInDjxg1MnToViYmJaN68OaKjo1GvXj0A0oW6dM+J4+fnh+joaIwfPx4LFiyAj48P5s2bhz59+shlbt++jVdeeQVJSUlwc3ND69at8ccff+Cxxx4z98sxGW3AAYAnn3wSW7duRZUqVSxYIyLrw4CjsNu3LV0DsiA7uweRIS8vTy/g3NUdZFwZxuBojRw5EiNHjjR434oVKwotCw0NxdGjR4tc35w5czBnzhxTVc8idHeUP/74A1u3bsWzzz5rwRoRWR/dgKMdo8eAQ2Q6ulcI0D1upaeny4OOa9SogauVdRYVGVYt/+JkAHDgwAEL1oTI+rEFRwHFzH6liik1NdXgcm3Pi5OTE6pUqVL5BhlT8b7//ns0atQIgHSCQyIqHXZREZmXthsKAO7cuQMAWLBgAVq0aAEAqOHmBrRuDc3ZswAYcCjfM888g59//hkACp2pmYhKZijg3Lhxw5JVIqpQbuuMu9LO+n3ttdfkZTVyc4Fjx6Bt21PTGBwGHAtr1KgRatSogczMTPzzzz+Wrg6RVWELDpF5GQo4umrkn2NOr/OSLTgESOfvaNmyJYAHl54nIuMw4BCZl24XlTbg6F7c2tZGP0awi4r0aM8Sef78eQvXhMi6MOAQmVdJLTjn8+/X66JiwCGtBg0aAHhw6XkiMo7utagMBZz79+/j+PHjha5ZRWXEWVSVTsGAk5eXh+vXr8vLtNeI5BgcMkjbgsOAQ1Q2ui04d+7cQVZWFoQQ6N69O1q0aIHffvvNwjUksk66XVQZGRm4desWcnNzAQDe3t74um9fAGzBoSIw4BCVjW4XlZubm/zf5OHDh9GvXz/s2LEDALB7925LVZHIqhVswdG23lSvXh1Xr17Fk/kXtlVjwFHkTMZUPG0XVUpKCm7fvo3q1atbtkJEVkI34NjY2KBGjRq4efMmevbsqddVlZGRYakqElk13YCTmZmJq1evAgBq164tLcy/CLYaAw5bcFTAxcUFHh4eADjQmKg0dAMOAPj4+AB4MA7H29sbgHTNOzIBjsGpdHS7qAAgPj4eAORjFvIv36C3Z3AMDul6+OGHAQBn888GSUQlKxhwnnzySfm+evXqYf78+QAg/9dJRKVzu8AFVrX/hMstOAWwBYcKCQgIAMBz4RCVRsGA8/TTT8v3dezYUW7RYcAhKpuCnx1twJFbcLSfwfz7GXCokKZNmwIATp48aeGaEFmPgtO/O3XqJP/erFkzOeAkJiZyqnhZ8X2rtLKysuSA4+zsDAC4cOECAJ0WHAYcKgkDDlHZaVtwHBwc8OmnnyIkJASvvvqqfMbV+/fv8xpVZaWS8RSkPO0Vw52dneHn5wcAOHHiBIAH49u0eB4cKpI24MTFxfGim0RGKthFBQBvvvkm/vjjD9SsWRMODg5wd3cHwIHGZaZ7sOIg40rj4sWL+OGHHwAA9evXh4uLCwBpJhUgtZACYAsOlaxOnTqoVq0acnJyeD4cIiMZCjgFaf/T5DicMso/qRtVbDdv3sRnn32G77//HgDQtm1bTJ48GYAUcAoOKpYDTj4GHCqSRqORW3EOHTpk4doQWQdjAg4HGpcTA06Fd+/ePTRv3hxvvfUWBgwYgKtXryI5OVm+v379+ujYsaP8tyeA2n/+Kf1RoAVHd5mlMeCoSLdu3QAACxcutHBNiKyDMQFHewqGXbt2KVKnCicn58HvNjxkVETHjx+Xu3CFEPjll1/07q9fvz46d+4s/90EACZNMrgujsEhg0aMGAFHR0ccPHgQMTExlq4OkUXs3r0bjRo1KvQla4gxAWfQoEEAgB9++AEpKSmmqWRlkp394HdbW8vVg8zmn3/+0ft748aNen/XqFEDrVq1kv/OBh6EXY7BIWN4enqiX79+AIClS5dauDZEyrt//z4ef/xxxMXF4aOPPjLJOoOCgtCmTRtkZWXhu+++w40bNzBu3DicOXPGJOuv8LKyHvyukgMXmZY24Gingu/cuVPv/tDQUNja2iI0NBQA8CpQqDWPAYdKNHToUADAunXrcOfOHQvXhkhZ3377rfx7vXr1SixvTAuORqNB//79AQBbt27FoEGD8Pnnn6N3797lq2xloduCo3DXQ2pqqnxxRzIfbcAZPnw4AMgzedu2bYt///1XviD0Tz/9hK0ABgFswaHS69ChAxo0aICMjAwsWbLE0tUhUtSxY8fk36tVq1ZieWMCDgB06dIFALBnzx5ER0cDAE6fPs2T/xlDtwVHwQHHubm5CA4ORqNGjfQunEqmtW/fPuzevRsA8OKLL6Jq1aryfS1bttSbLVW9enV0RX6YSU+XgoyhgMMxOGSIRqNBVFQUAODtt9/Gv//+a+EaESlH90BmTPgwNuA0b94cXl5e8jk8tOLi4spQy4ohISEBX3zxBS5fvozZs2cXHSIs1ILz22+/4dSpU7h9+zaOHDmi2PNWJkeOHEFISAgAwNbWFo888ggCAwPl+wuezE/PhQtA/rEKYAsOGSkyMhLdunVDVlYW3n77bUtXh8ishBDIyZ+pY66Ao9Fo9C7EqTVw4ED5bK2VzRNPPIExY8bA19cXr7/+etHfNRZqwdEdh8iLEJvH7Nmz5d8//fRTODk5oW3btvIyn/wzgRdp7lz5V04TJ6PY2Njg888/h62tLbZs2YK//vrL0lUiMptZs2bBwcEB+/fvN1vAAYDJkycjIiICL7/8Mvr27QsA+OuvvxAWFlZhZlfl5uaiZ8+eGDZsWIllC55QdP/+/YYLWqAFJz09HZs3b5b/5oBw07t8+TLWrVsHADh8+LDcc6AbcLyPHy95RQU+p2zBoRI9/PDD8sDIr776ysK1ITKfN998E0IIjBo1Su96UaYOOE2aNMGaNWuwbNkyzJgxA8HBwQCA+Ph4BAYG4rfffivjK1CPkydPYvPmzVi2bFmxrR6GuqN0uyb0WCDg7Nq1S27VA6TxUmQa//33H55//nn4+voiJycHYWFhetu+Xbt28u8+f/wBrFmjvw8UxDE4VBYDBgwAAERHRyNPJTsMkSll6XR/5OXllboFp6z8/Pywf/9+nDhxAnXr1kVCQgL69Olj9V0hV65ckX//6aefiiz3999/F1pWt25dw4Ut0EWlDZvac6+wBad8cnJysH79eqxbtw5PPfUU1q9fL9/30bvvAlOnAgcPAjk5qHP7NtoAqAmg0b//Av366XVFFYVjcKhUOnXqhGrVqiExMRGxsbGWrg6RyR3XaQJPS0vDrVu35L9N3YJjSNOmTXHmzBmEhYXhzp07GDFihFGPU8sFcXNzc7F48WJ5mq/ueCJtwMnNzUVugWCiO1tNq8j32wItONqAM3bsWADS67p792651imEwJo1a7Bjx45y18/avPnmm3j++ecREREhXw0ckE5L0uHgQWDKFKBdO8DeHnjkEcQAiAfgoi24ZUvRK8//zMoBx8YG0DkpoCUx4KiYo6MjwsPDAcCos7oSqd3hw4excuVKueXm8OHD8n0XL17UO8gqEXAAoEqVKli+fDkA4Pfff8f58+fRv39/tGrVCq1bt8Zzzz2HP/74A5988glee+01hIeHw8fHB9u2bcOf2uvxGOHatWsmP7fVzJkzMWLECDz99NMApHEVWjExMTh37hxCQ0Ph6+uLEydOyOP5DJ0pvchWYt0WHAUCTlZWFi5cuAAAeOaZZ+Dh4QFAupRNwZBz9OhR9OnTB6dOncK5c+eKbel+++230a9fPzz99NNISEhARkYGZs6ciVdffVWvJdFUfvjhBwwePBgfffQRsovr4jE1IZCzezdOxsZCCIF9+/Zhbn4LTPXq1fHyyy/L79WSJUuAAmcxBgAHAK66C7QX2jT0mcw/T5EccDQawNfXVK+mfEQllJqaKgCI1NRUS1elRMuXLxcARFBQkKWrQlRuTZo0EQBEzZo1xd9//y2eeuopAalVu9CtX79+Ja5v69atAoBo1apVuevWqlUrAUDUrl27yDoZui1durTEdZ85c0ZUqVJFhIWFlbueWrm5uaJatWpyPe7cuSMGDx6sVzcPD49C9X399dfl37/++mv59wkTJhh+om+/1Z7tRIioKJPVvyh3796V65SWliZ+/PFH4eTkJACI3bt365UNDw/Xe20BAQFi4sSJ4uzZsyIvL08sX75c/Pvvv+LMmTPFbsNPPvlEb71btmwRgwYNEqdPn9ZbfubMGZGRkWGwzq+++qrw9/cXLVu2FGFhYXrr79u3r8jJyTH9m2VA8qJFokP+84aGhoq+ffsKAGLAgAGGH/DSSw+2b1G3oUOlsllZhe8bMEAIQFzNf04bGxuzvr7SHL8ZcFQuKSlJ/pBcvXrV0tUhKhdDBxeNRiPs7e0LLX/hhRdKXN+vv/4qAIjWrVuXu26TJk2Sn7tatWpi5syZYvXq1aJnz57C1dVVPsgWvPn7+4tvv/1WNGnSROzbt8/guqOiouTyJ06cEEIIcf36dZGamiquXLkizpw5U+r6/vDDD3r12Ldvn+jcubMAUGxw1N4iIyP16vbWW28ZfqKlSx8czMaNK3U9SysjI0OuozZMtG3bVgAQP/30k17Z4OBgg6+tW7duYuPGjfLfK1euLPa9qFatmrh27ZrIysoSS5cuFRqNRg67r732mvjyyy/F7NmzBQDh5OQkWrRoIRo2bCiefvppMWXKFNGmTRuD63300UeFra2tACCGDx9e7pBz/vx5ER8fX2j53bt3xV9//SXi4+PFgFq1DNZl3bp1hlf66qslBxwPDyG+/FKItLTC9/XqJQQgEhlw1MGaAo4QQjz22GMCgFiyZImlq0JUZnl5ecLOzk4AEJ6engKAqFWrlvj555/FiBEjCn0hR0RElLjO6OhoAUC0adOm3PU7ePCgACAcHR0LtRRoZWRkiIsXL4rjx4+LqVOnCgcHB706P//88+LkyZNi2LBhIjo6Wn7dDz/8sFzmrbfeEs8884wAIKpXry6qVq0qbG1t5QNQdna2uHXrlvj111/FM888I8aMGSPGjx+vF4JOnDghHnroIb3nHjBggHBxcREAxK+//ip8fX2FRqMRISEhhd7bTp06yeFB26Lz5ptvGn5jFi58cDAbM6bc73NJ0tPT5XreuXNHCPGgpWblypV6ZZ944gm5bPv27YW/v78AIKpWraoXKiMjI4W2JUW7DwIQPj4+onnz5iWGQWNuzs7OYsWKFWLVqlXigw8+EBs3bhR5eXli3bp1wsbGRgAQjRo1EpGRkSIpKanU70tKSopwcXERTk5OYvPmzWLevHkicvhwET1qlKjj41OoPmMK/J2QkGB4xWFhJQec4m6dO+sFHI1GU+rXVhqqCzgLFiwQ9evXF46OjqJNmzbijz/+KLb87t27RZs2bYSjo6Pw8/MTixYtKrLs6tWrBQDRq1cvo+tjbQHno48+EgBEgwYNRFpamqWrQ1Qm9+7dk79sr127Ji5cuCD/R7tq1apCX9B9+/YtcZ1btmwRAERgYKBJ6rhu3Tpx6NAho8uvWLFC74CpbQ3Q/j516lTx7rvvGnWA1Gg0IigoSNSoUcPg/VWqVBF9+vQRPXv2lJc1aNBAr+VJezt//ry4ffu2uHbtmhBCiPHjx4uOHTuKXbt2idmzZ8vBQQgh3njjDQFAvPHGG4Zf5Ny5Dw5mo0aV6/01Rlpamvw67t69K4QQcjfLvHnz9MpqW04+/vhjkZubK3Jzc4W7u7sAoNe6o90m3333ndi9e7fYs2ePuH//vsjOzja474WHh4v09HSxcvly8eaTT4rqVaoIAKJ58+bip59+Eo8++qgY8L//iQkTJohXXnlFfPDBB+LUqVNFvqY1a9aI6tWr6223jRs3itzcXKPfl7lz5xodtjwAkV5gWV6B90720EPlCzghIUIAIknnucxJVQFnzZo1wt7eXixZskScPHlSjB07Vjg7O4tLly4ZLH/hwgVRtWpVMXbsWHHy5EmxZMkSYW9vL3788cdCZS9evCgeeughERISUqEDzq1bt4Svr68AIKIU6AMnMoeUlBT5C/D+/ft69126dKnQl/T//ve/Etdp6oBTFgkJCWLRokUlHnTGjRsnGjduLP/drVs3g6Go4O2VV14RTZs2LbS8R48e4tSpU2Lbtm2F7rt3757R9X/zzTcFII3NMeiTTx4czEaMMNG7VjTt9zMAkZmZKYQQYvjw4XJg1OXn5ycAiP3798vL/ve//xX5Xp49e7bQ82VlZQmv/LFKPlWriv85Ooor774rRF6eEJ9/LgQg4gDxeuvWUivahQtC9OkjvR8zZxr9uq5fvy6WP/+88NWpT+fOnQt3Od29K8TNm0IsWiREfkDNy8sTzZo1K/J1dQXEKZ2/u+dvL9v8lqMa2u335Zf6z5WbK0StWuULOO3bCwGIa5Ux4Dz22GNyX69WkyZNxNtvv22w/FtvvSWaNGmit+zVV18V7dq101uWk5MjOnToIJYuXSoGDx5coQOOEEL89NNPAoB46KGHRF5enqWrQ1Rq8fHxApDGMBhS8Ev7+eefL3Gdv/zyiwDUMQi/atWqct1PnTolhg4dKr/eVatWCSGk9+Dhhx8W4eHhIicnR4wePVoMGTJE3L9/X/zxxx/i888/F9u3bxetW7cWAMT3338vhBDi/v37Yvv27WLEiBGiatWq4p133pG/B3Jzc8WMGTPEe++9J2xsbETLli1LVe8JEyYU/8/Txx8/OJi9+mqZ3x9j3b59u1BQ07YyFQxh2taukydPysuKCpvVq1cXuadOCbFtmzSWJDVViO++E+Ltt8UhQHwJiBzdA/cHHwjh5GSwO0a+ubgIoQ2T69dLY1X69BFi0iTpOQrKDwIT3Nzk/aWas7PYtWuXdP+JE+JulSpiJiBiAXEPEHm1a4tt+WOrqmg04gud1+QPiEGAuJVfnxGA0ABiT/7fewHR2M1N7NSt86BBQmiHO+QHuHLd2rYVAhDJOvUy5zFKNQEnKytL2Nraig0bNugtHzNmjOjUqZPBx4SEhIgxBfp5N2zYIOzs7ER2dra87L333hO9e/cWQogSA869e/dEamqqfLt8+bLVBZzMzEzh7OwsAIgjR45YujpEpXLy5El5RmDt2rUNlqlZs6beAalPnz4lrnfz5s0CkAZzWpp2Fpb2P9jMzEwxf/588ffff5d6Xenp6eLgwYMG7yvu4BEfHy9SUlJK9Vxvv/220LYwGTR16oOD2bBhpVp3Wdy6dUt+H7OysoQQQnz44YcCgBimff7cXJH77bfyYODEv/4S4t9/hRBCnDl50mDAeaNVq/IfzIu6nT8vhLu7/rKWLaXlWrm5evfH7dolz3byc3YWmX/+Ke6OHSt669TZFRDNAOGU//dYQGQCwjf/vsQC9cgBxHVj6mtrK0RMjGlee2CgEPnPq613abreSqs0Aces58FJSUlBbm4uPD099ZZ7enoiKSnJ4GOSkpIMls/JyZGvF/Pnn39i2bJl0hx+I0yfPh1ubm7yrcgzdqqYk5MTunTpAgDYtGmThWtDZLyMjAw0bdoUL7/8MgCgWrVqBsvFxMRgxIgR8kUfhRAlrltbpjznwTGVJUuWoF27dvK5cZycnDBq1Ci0aNGi1OuqVq0aHnvsMYP3Ffda69evj1q1apXqubTrK/L91j1JoALnwdE9l422btWrVwcA3L59W7rjyy+RNnCgXOfqjz0GNG8O9OmDh7/4Ag8ZWO+7Bk5uWIinJ3DlCqC7zR5/HNC5KCX69QOeegrIP9M8AKBBA6Dg9cz+/lta3q4d8PnnQHy83t0NO3fGVgAPAYi/cwctQkPhu2ABftIpkwbgBIB7ABwBvAXACcDh/OUFL4VpC8AdAGxsgPz3TNap04Pfc3OB/EuVyAydnM+Yiz3nX1JDd6805rOrBEVO9FfwAymEKPZDaqi8dnl6ejoGDBiAJUuWwN3d3ajnnzhxIlJTU+Wb7smwrEmPHj0AANu2bbNwTYiM98MPP+j97eLiYrBco0aNsHDhQtSvXx9AMSee06GmgBMUFISYmBi0b9/e0lUpFbUFHN162NhIhyg3NzcAQGpqqnTHjh24nV/GKf8GANiwAZpFi9A5/08PAFsAxEHnxHW619z67jvpMgRnzgB//gkcOQL4+ACxscC9e9LyX34Bxo8Hzp8Hbt8Gvv8e+PVX4NtvAWOuE3jwIDBuHNCwYaG7qgFYkP97XE4OUnJy4Augo06ZpwD8D8BWAD75y2oDqOPjA3zxBfDee4Wf095e/3UCwDPPFF/Pn38uvKxAY4NB+fuH5T+BhZk14Li7u8PW1rZQa01ycnKhVhotLy8vg+Xt7OxQq1YtnD9/HhcvXsQzzzwDOzs72NnZ4ZtvvsGmTZtgZ2eH8+fPF1qno6MjXF1d9W7WKCwsDIB09tfMzEzLVobICLm5uYVaWotqwdEq8YCrQ00Bx1qV+H7rXPRSiWtR6dZDM24ckJMDt/x/6lIvX5ZaIjZswK38MjUMrOOJ/ONLIwDdAcjRIiAA+OMPYN06Kay8+CIwdizQqBHQvj3wUH7bj40N4OgoLa9aVVrm7w/kBy3Z8OHApk1Sa0mzZsBvvwEfflj8C3zqKelx+XoB+ByAPYBBAOJ8fLDjzBlMDgjANgC/AljXqxfCNBrAz0+6dMbx48CBA8BrrwHvvy8FsvzLWgAA7t8HWrZ88Pfjj0vP6+BguE5dukhnH9YGSACoUkX/LNZF0d0/8qmlBcfOnCt3cHBAYGAgtm/fjmeffVZevn37dvTq1cvgY4KDg7F582a9Zdu2bUNQUBDs7e3RpEkTvevXAMA777yD9PR0fP7551bZ/WQsf39/eHt7IzExEX/99RdCQ0MtXSWiImVmZuK5554rdFmAolpwtMoScKjsVNeCo3NZA838+cD8+aie//ft06eB/CuL385fVqNKFal14qOPgMWLgV9+Qf8vv8TVmBjpUjfu7lKomTkTmDdPCiz/+5/pKvzMM/L1mAAA4eFSOPrqKykwPP44kJQk1QEAhgyRQtrWrcDly0C1ahgzaxaG16iBKgsWAFFRQKNG+Cg2FkhIAB5+WHrcv/8CXl5S60zz5g+eT6ORupdmzZJaiw4cAObPB2roRL+VK4G6dYG4OODll4GdOx/c5+cn1QUAXF2B9euBUaOA1asBYy4touIuKrMGHACIiorCwIEDERQUhODgYHz11VdISEhAZGQkAKn76MqVK/jmm28AAJGRkZg/fz6ioqIwfPhwxMTEYNmyZVi9ejUAqV+7ue7GxYP+2YLLKxqNRoOQkBCsW7cOy5cvR6dOnfifK6lSbm4uXnjhBWzduhVVq1bVu4aQKVtwCj6GSk81AUcI4OpVCJ2uEu1W1bab6LQvyC041Vu3Btaulf6YNQuYNQt2ACbmt3gDAAYOlG5KefNN6abrv/+kgBEWJoWSkycBW1uppQRAFUA/eDk6Pgg3gH6oMcTWFoiJkbaRjQ2QliaFl0aNpHADSK00rVrpBxwfH6m81nPPAc8+K9XRmM+gigOO2cfgREREYO7cuZg6dSpatWqFP/74A9HR0ahXrx4AIDExUe8KuH5+foiOjsbu3bvRqlUrfPjhh5g3bx769Olj7qpahZCQEADAN998gw4dOljteCKqmPLy8jB//nwEBARg06ZNcHJyQnR0NIYMGSKXYReViQkhtRTk5kq3e/dK9XDtOBejAo45u6imTwfq1IEYNerBsjZtAI0Gbu+/D8BwwKmh21KhZnXqSK052n21WjU53JiUNqy4ugIXLjxondEq2E1laMKPto7GfK5UHHDM3oIDACNHjsTIkSMN3rdixYpCy0JDQ3H06FGj129oHRXVCy+8gJ9//hm7d+9GTEwMevXqhSNHjlTuL3iymBs3biAlJQX+/v6wt7fHu+++i2nTpsn3L1iwAKGhoXoz/8zRRVVh9v9796QuCCGk8Q9XrwLXrgHnzkkDXmvUkGb5xMdL3Qf37kn36449tLGR/ts/flz6j93JSXpstWpARgbQq5fU3XH+PGBvD03+bK0iB3Ur1YLzyScApHnGQP423bcPuHULblWqAO+/j3sAsiDNKLqdX85qAo5a9OkjhUkt3dlVZVHZAw6Zjru7O7Zv344LFy6gRYsWiI2NxR9//MHxOGQWx44dw8aNG/HYY4+ha9eu+Pzzz7FgwQI8++yzuHPnDpYsWYK8vDx4eHigd+/e+Cp/VknNmjXxyiuv4KWXXgIAvanLRrfgZGYCERHSVNXWrQ2WVX3AyckB7t4FEhOBmzel/6ivXpW6KtLSpNBx7Zp0X0oKcPZs+Z8zLw/45x/p90uXHizPyJB+6s6WuX8fmvxp7eKff6RgpQ1Phw4Be/cCuv9Amjrg3L4ttTT884/0fgDQPoONjY3UwlGlClx1Qlbqs8/CY+NG3HJzA1JT5SEKZKTAQCn85uQAGzYU7kor6P33pVtR7t8HwIBDJuTv74+BAwdi8eLFCAsLw4wZMzBhwgRLV4vMZPfu3bhz5w6efvppk60zLS0No0ePRrVq1TB37lzY29vL9yUmJmLz5s146623HkzN1TFb57wgtra2SE5OlsPN8OHD5d+1atasKf9udAvOyZNS8/m6dUWOBbBIwMnLk1o1rlwBNm+WxlZcuiQ1/WdmSmHm0iWpBebuXeMGapYkIECaxSMEUKsWcOMG0LixNI3XxQVo21bqprp+XZrR888/wMWL0sGnaVMgPV1qtbl/Xwo6CQlSqw4eHJjE/v36YzEMMWUX1e7d0oDcgQOB5cvlxXotOPlsbW3h4uKC9PR0pI4aBQ9PT9y6fh1Yv54tOGWhHc9j6Nw3BU2ZIs0wCw83fH/+oHA1/ovBgGPFRo8ejaVLlyInJwdvv/02evTogWbNmlm6WmRiV65cQXh4OO7fvw9PT0906tQJkyZNQqv8L6eUlBTs27cPvXr1MvpAv337drz++uvyjMSEhAS0b98eN2/exKlTp7B161bk6hzMqlevjtu3b8PV1RWd8pu07969i1dffRXPPvssXnjhBWzYsAFVq1bFRx99VOj5StOCI48Jyf+PvjhmCThZWVL3zdmz0i0uTpolExcnBZe7d+X/Wkuldm0pbFSvLgWVJk2kgaS1akljHdzdpcGgjo6AnZ3UotGypdTFVNqxGl27llwmOxu4cQOasDDg7FkY9T93WVtwhJDeN2dn6e/MTGk8CqAXbgBA5Ae4gtvUzc0N6enpuO3qCixahNv9+wMAW3CUoPPPTyE6s9602IJD5da0aVP8+++/6NmzJ86ePYvJkydj9erVqGKOgWtkMkII7NixA3v37sXgwYMBAO+//z6eeeYZ9O3bF4B07qfTp0/j4sWLWLBgAe7nH1CvXbuGH374AT/88AP8/f3h7u6OxMREXL58GQsXLsSIESP0nis+Ph716tWDjY0Nrl+/jgEDBiAmJgbp6el65X755Rf88ssvestat26NRx99FNOmTYOtrS2OHz+ONm3awFl7kNKxcuVK1K9fH507d4aHh0eh+8vSgqN3KE1JkQJAASb5Is3LA/bvB7ZtA3bskKbaGnMgt7WVTt7WqpUURGxtpTDi4SFNRc7Lkw7o7dtLgcXRsfx1NSUHB8DbG5pBg4B33jFvwBk5UprCfeKEFPJef91wuc2bIVq2BHx9CwWc6tWr47///pNbFG/lT81mC44Cigs4+efKYRcVmVzjxo2xevVqBAYG4ueff0abNm2wb9++Up+uncxv7dq1WL58OQ4fPoybN28CAD788EM4OTnh3r17WLVqFSIiIuDh4YHr168X+pJ4+umn8fDDD+Ps2bP49ddfceHCBVy4cEG+f8qUKXj11VflFpDZs2fj9ddfR5cuXbB582ZMmzZN7yzYgwcPxowZM3DhwgXMmjULaWlpaNKkCapXr47+/fujSZMmes+vncFnSLVq1TBr1qwi7y/TGBzdVpJz5wwGnIKPKVZurtR99NBDUovJvn3SmWw3bZLGxehydZWm1zZqJJWvVUtqeQkOlgb6OjlJP+2s/ytUfr8jIqRztSQmFl3YUBeV9jIEc+YUPetm8WLp50cfSSenW7RI//7HHgO2bAHc3SHyZ9UW3Kba/eZOfpcfA46CSuq6BAMOmUmbNm2wdu1ajB07FqdPn4a7uztCQ0OxYcMGvf+ck5OTcfDgQXTt2hUORZ3RkkwqLy8P//33H+bOnYs5c+YYLHOvwLTe5ORkAECDBg3g6+uL06dPw9/fHz/99BPs8g+o//33H3799Ve88sor8uOuX7+OHTt2IDw8HMePH8cbb7wBQOqO8vDwQJpOl8/o0aMxd+5c2NjYwMvLy3SXF9CGkvv3pYGMO3YAjzyCmjpn3q62YYN0vo7sbOk8He7uUndMq1ZA+/YPDri6Z0jV1j0vT7rlvw8ldlFlZ0tjUWbMAKKjpQG9DRtKXSa6M49cXYEePaTrBvXuLU3pVevAZROT329nZynohYUBe/YYLmyoBWfcOOln//7Ao48W/2Q3bgAdOjz4OzpaOrHcG2/IAbaobVo1/4zC2nMqaa9LxS4qBei2+CYkSJ+fkBDp93wMOGQ2ffv2RdOmTREcHIyMjAzs2bMHPXv2xPfffw9fX1/s2rUL/fr1Q3JyMh5++GH8+uuvaNCggaWrXeENHDgQ33//vfy3k5MT6tSpg2nTpiE8PBzLly9HnTp10KNHD1y7dg2ZmZm4du0afH194e/vX+R669Spg+HDh+Phhx/Gzz//jJSUFKxatQobN25EeHg4vv76awgh4OTkBI1GI4ebxx9/HDt37izfmJUrV6RTw584IX3xXbokhYGLF6WZNwbOw6LbnqhZs6bodfv6QpN/ElC9L8mrV6Uzq371lfS8e/cCjRvrHwzj4qSBq8ePS/U5cUK6vlDB+pw79+D3Dh2kM8sOHKi+LiSFFDoPzk8/SdvS0My14rqojBgzhYLX0evWTbrpPUWeXr20CgYctuAoSPfyRtqTBnbrBnz5pbyYAYfMqnnz5jhx4gR+/fVXvPHGG/jzzz/RvHlzREREYPny5fIXR1xcHEaMGIH169djy5Yt6NGjh9z8e/36ddSoUQO5ubl45513EBQUhIiICEu+LIvJyMjAypUrce7cOQwbNqzUA7j/+usvOdy4uLhg8eLFePHFF/XKjB8/Xv5de5HJgIAAo58jLCwMYWFh2LJlC1atWoWtW7dCCIH9+/cDkK5w3bhxY0RFRaFt27Z49913jQs32oG2R49K/6UdOybNaDpxQprSbAw3N2m8xX//SQen/Fk72Z06AfXrS4Hi5k1pdk9GhtS6kpAAzZQpAKA/JiR/urnsxx+ByZMfBJz0dGkcTFHXaPPyki5M2K6dNN7GwUGagdSuXaVpqSmKPOZJG16qV5da0zZskM5qq8uUs6gKXs06X0ktOImJidi3b5/czcuAo4C2bYGPP5YGxmsV6J5VY8CBqIRSU1MFAJGammrpqpjN8ePHRVBQkIB0nBAAxEsvvSSOHz8uHBwc9JZHRkaK9PR08dprrwmNRiO8vb2Fu7u7fP/06dPF66+/LrZs2SIuXLggDh8+LHJzcy39Ek3uxo0b4tdffxVZWVkiOTlZtGnTRn4PmjdvLnJycoxeV15enujcubMAIAb37Svy1q0TomVLIYKChIiNNXndMzIy5O36999/C3t7ewFAnDt3zvADcnKEWL9eiPnzhRgyRIjOnYXo3l2IRo2E8PYWwsFBCKkhuvDNxkaI5s2FeOYZIQYPFmLaNCGmTxdi+XIhTp8WIi5OiJSUQk/ZuXNnUbt2bZGenm64TqdOCeHgIFbnv+ePF/X82tuYMeK7/P30iYL3+fgI8fbbQmzaJMSFC0Lcu2e6N7uC+fTTTwUAMWjQoMJ3FnxfQ0P178/Le3Df9u3Ssh07hPjxx+LXAwhx7ZrB+pw7d04AENWqVdNb/tJLL+l9b2lvFfl7XNWmTdPbnlk62+T27dtme9rSHL8ZcCqwa9euCW9vbwFATJkyRV4+depUvS8IjUYj6tevb/DLo6ibl5eXGD9+vLh7967YuXOnePfdd826U5vb1q1bRc2aNQUAERAQIIKDgwUAYWtrK7/m119/XXz//ffi0qVLBteRm5srZs+eLUJCQuTHODk6igs2Nvpf7M2ameU1PPHEEwKAiIiIEABE7dq1RV5enhC5uUIcOSLE3btC/PyzEH37CuHqWnx40N78/ITo3VuIzz4TYsUKIQ4dEuLGjTLVLzc3V2RmZhZf6PhxsSb/vQszon6r8ss+CUih7KefhMjIKFP9KqvPPvtMABADBw4sfGfB9zwkRP/++/cf3LdtmxScteH4wIGi1/PJJ0XWJy4uTgAQLi4uestHjRpV6HvI1tZW2sdJed9+W2TAuXXrltmetjTHb3ZRVWAeHh6IjY3FuXPn9AaRvvPOO+jQoQO2bt2Kr7/+GikpKbh48SLq1auHhQsXIi4uDm+//TZycnKQkz/QMyAgAKdOnQIA2NvbIykpCXPmzMGyZcvk8R2bNm3C5s2bcfToUfTo0QO2trbKv2gj3Lp1CydOnMDGjRuxfft2VK9eHXv37pXv175OANi3bx/27duHN998U54l1LFjR+zduxc3b96Ek5MTqlatCiEEXhowAN/kXxRWa2JWFvwKVsDYLh5d9+5JAz8PHJDOp3LzpjQDKD1dOtHbnTvoevcudkKarQUAwY0bQ/PMM9LsFEMcHIAGDaRupF69pAG5NWtKM4bc3aXmaCNmTxjLxsYGTk5OxRdq3hyanj2BTZsgHB2BadOKnlIMPOjG8vSUrjLNAaelVqqLm2q7qO7dk2aS6XZZ/fyzdEJC7XlR4uOlrg1D69UOTDZAW4+iuqh0Va9eXb1nsa7oCpwugl1UKlFZWnCM8fvvv4u6deuK1157Ta/r4N69eyI3N1csXrxY/PrrryIvL0+sWLFCLFu2TGRmZooNGzaIGjVqFNnCM3/+fAu+qsKys7PFwoULRb9+/YSzs7PBOvv7+4uEhAS5eycsLEwIIbU8fPLJJ3IXkI2NjTh8+LBwdXUVjz76qMjLyxPfrVolAAg7QHw4frz4EBBvAeKeoZaH7t0fVCwvT4izZ4XIypL+/vtvqatn2DAhvLyEqF5diDp1hNBoSmzN+KfgNjBUztlZiKgoIfbvFyItzQJbomQ//PCDACA6deokvT9vvFHka/62SxcBQHTp0sXS1bZas2bNEgBE//79C99Z8D1v107q+tO20GRk6N8/ceKD31eulNaRna1fpmvXYutz5swZAUC4ubnpLZ8yZUqhz2yDBg1M9C5QqW3dqrdd7+tslxtlbOU1BruoSsCAYxpXr14VK1euFJs3bxbr169X5Itn//79IiIiQpw9e7bQfcnJyXIXyJUrV8TZs2dFbm6umD9/vvDz89Orn7Ozs2jevLmYM2eOaNKkidBoNOLH/HEDR48eFS+88II4ffp0oecouB4A4udJk0St/FD0oRHdKqJXL6k5f9y4B8tcXITw8Cj+cba2QoSHS11GvXsL8cEHQhw8KMRXXwnRpYvI0+lOAyBu6z7200+lsTFWsM//+OOPAoDo2LGjtOD+fSG+/FKI2rWFqFVLCoRCCHH3rvjmm28EABEeHm65Clu52bNnCwDixRdfLHynv7/+PvjYY/rjcVJT9e9v0+bB74sXSwF16VL9MiNGFFufU6dOCQCiRo0aesu1Y4V0b0FBQSZ8J6hU9u7V2645OtslxcAYPFNhFxUpwtvbG4MGDQIgzcDw8fHB1fwTpl24cAHJyckGz2pbVqmpqejduzeSk5OxY8cO9OnTB5s3b8Zzzz0HJycnzJkzBzY2NvD398dZAxctrF27Nl555RW0bdsWPXr0kJu2R44cicuXL8vT5lu3bo3VBbqatEJDQxEfH6+3rFf+1bPbAHirqMr37CmdI+Tdd6WmfN0LHgJSV5PuuSacnYGOHaVrxgQHA0FB0pWhDTXHP/YYMHw4NACe69MHGzZswFOPPAK3LVus8nwuhbpM7OyAV14Bhg/XFpB+VqlSZHcGGa/QNHFd0dH6M2cKXllc91xFgHTxTK3MTGla+LBh+mUCA4utT1Hb1FAXFWdQWVCB7aHGLioGHDIJGxsbbNmyBWvXrsX69esRFxeHxYsX47333jPq8YcOHcKWLVvw77//wsvLC3PmzNG7+CMAfPTRR/JJ8G7cuCFf0HHBggVymby8PIPhZuzYsfj4448NXmbAwcHB6HMChYaEYEX+1ZUbeXvjbP5ZX30AbAKgd/pEf3/p+jsLFwLPPisdLAry8QFGjJDOLeHuLp05t0ED6SBehoP2okWLEBQUJF2ywUrHoxQ5JsTA+8GAU36FponratxY/2/dMtqLjurSObM2MjOBv/4qvM4SQklpAk5Jl/0gM2LAocqkVatWaNWqFRo0aIDhw4djypQpCA4ORpcuXYp93IYNG/C///1P7wv23r17+PLLL/UGKm/YsAEAMH36dJw5cwYpKSnw9fXF2bNncejQIURGRmLkyJH4999/0aRJE2RmZqJHjx6oX78+Pv3007KfvTktTToHTNeu6HXxItoCCAHwdmIiHgZQBcAuAA/pPubbb4EBA/TX07279B9tRgbw9NPSIF8T8/DwwMSJE02+XiWVZtArA075lWqQsW7AEaJwC46uu3cNX8OomEtu6NbDmICTbeBCj6SQYgKOWjDgkMkNHToUO3fuxJo1axAdHV1swImLi8OLL76IvLw8hIeHo02bNvjkk0+wbNkybNmyBY0bN8Zzzz2H7t2748KFC7Czs8OoUaOK/c/N19dX/v18/un4C54VtUhCSF/i165Jf0+aBKxcKd9dA8ABneLnILXayFdXCgiQvsCff97w+ksIe8SAo7QyzaICDLfg6MrMLHytrshI6RT/xShqmxpqfdVel4oswEDg1GILDlVYGo0GrVu3xpo1axAXF4cpU6Zg8ODB8Pf3x6VLl9CtWzfk5OSgU6dO2L59O7KysvDEE09gy5YtsLOzQ4sWLfDqq68iKSkJSUlJ2LNnD/78808AQHBwcKmapYsNNkIAa9dK42IeflhqTr9xo1SvtaaTk3Sm3y++AP77Tzp1eXFX3qUSlSXgUNmV+H5//jkwdar02ShNC05mJqB7YdVmzQpfZNOA0rTgMOBYEAMOVVbai3xu2bIFW7ZswaJFi5CcnIzJkyfL55mJi4sDIJ1XZ+HChfKFJPv164cnnngCR48eRUREBNLS0rBu3ToAKLG7y6CbN6XQcemSdA2jkSOl7iHd5m3d6xMV58svgYgIaUDw119LA4Fr15YOAGQSpWpRKPAYKr0S3+8xY6RLN4SG6gec3NziW3AWLnwwMByQLqVhhJKuRaWrT58+Rq2TzKBKlUKLNMifRsWAQxVZrVq19P6+fv06YmNj5Wszffzxx4iPj8e9e/cwZMgQNGrUSK+8h4cHnnrqKQwdOlTvKtxt27Yt/onv3JE+eKdPA4cPS+MARowoXK5g333VqlJ3lL+/9CU+Y4b02I8/lq6ZpA0yWm5uUssPmRy7qJRl1PutDRtFzaJycwNSUws/bsmSB78bOejdmC4qd3d3LFiwAL179zZqnWQGBj5zDDhUKWhbcHS1bdsWQghERERg0qRJRq2n4BW19S5EmZkptc4sXw6cOiWdOfXAAZSoRg3gzTel6a/t2kljZuzs9D+w/fsbVT8yPe1/7gZn9RTAgFN+xU4T19IO9i/YRaUNPLa20sD5os6aDUghyAjGdFE1aNAAffv2NWp9ZEYvvyx9/+bTbjEGHKrQCrbgAMD9+/dRvXp1vRaZkvj5PbjQgbO9Pep8/TVw+TJw8qQUZko6CNraAi+8IJ0yftAg6fwyBQc+kqqwBUdZxU4T19K24OiW+fdf4P596Xd7e6Bfv+IDjpFj54wJONV0x/aQ5QwYwIBDlY+hFhwA+Oabb+Dt7V30A3NypK6lf/4BjhyB/6+/ync1vn8fmilTCj+maVOgRQsgLEzq5791SwoyISFWd5I7YsBRWpm7qO7f1w84jo7FP5GBMRuGGBNwynzKBzKtAtcbVNunkAGHzKJgwBk0aBDefvtt/S4mALh6Fbh4UTrXzNmzwKxZ0qykfPV1itYGpBDTooXUtdSmDeDnZ5bzyZDlcBaVsox6vw11UQH6AaekC6kaeaoGYwKOWi/kW+kU0Rquls8lAw6ZhZOTE5ycnHDv3j0AwIwZM+Dt5SUN/t2zB9i+HTh4UJpaXZCjo9T60qIFqjRvLvXzAnDs2bPwJQ6owmELjrJK1YJTXMApqQXHiDFVuvUouE11z2xu9HmtyLyKaMFhwKGKKy9POmW7TnO2e5cu0iDgu3cNP6ZOHemyBf36Aa++qtecXeP113Hr1i307NnT3DUnFeA0cWWVuYsKeDCLys4OMDDuTudJgJdeMqo+RU0T168OA44qFGjBYcChiiU9Hfj+e6mLKSUF2LkTOHYMyM2F7leh/YkT0i+2tkDr1kCvXlIrTWCgdAKxoi4kCek6Vfv27cPAgQPN/nLI8tiCo6xSd1HZ2DxojdGebsHeXvpcDxsmHfQOHJC+B7SOHCn3LCr96rCLShXYgkMVRmqqdLbfuDipq2n/fiA2tsimZ71znP76K1CvHlC/fuHBhiXMiGjQoIHRF8Mk68eAo6xSd1HpBpzMTOmnvb30D4r2vDd370oD/bVKEUiM2aZswVEJtuCQVcrJkWYyHT4snf133z5pMHBxOnaUpg0GBQHNmkHoBpmnnjJrdaniMOq8LPkYcMrPqPMO6XZR6b7X2i7ngpcnqVJFKqfdhqU4NQMDjhVhCw5ZhdRUaRbTtm3AL79ILTNZWYXLeXlJF5Rs3lzqXgoJkc7+S2QiRp2XJR8DTvmVqYtKq6iAo9FILTgZGdLfJg44Pj4+Rq+PzEg7yDyf2j6FDDiVVV4e8PffwG+/AVu3Sq00BQ8oVatKJ8jr2FEKNUFBQMOGRp9bpl27djhw4IDe1b2JSsJp4soqdReV7udft4uqoKpVHwQcE3VRrV27Ft9++y3ee+89o9dHZlTEpBG1fC4ZcCqT69el1pktW6RAk5ysf7+zsxRonn1WCjXNmpXrythr167Fp59+irFjx5az4lSZcAyOsko9i0q3nPYAZ6iFRncMTilacIqbRdW3b19eokFNmjbV+5NdVKSc27el1pldu4Djx4FDh/SneTo7A48/DnTtCnTvbvKuJl9fX8yfP9+k66SKj9PElVXqLqocnekDJbXgaJm4i4pUwtVV+sc5/0LEDDhkHkIAJ05IM5t275bOQ3PwYOFyTZoAnTsDffoAHTqUfHIuIoWxBUdZpW7B0f0nqagxOIBZZ1GRiri7y7+qLeAoMhR94cKF8PPzg5OTEwIDA7F3795iy+/ZsweBgYFwcnKCv78/Fi9erHf/hg0bEBQUhOrVq8PZ2RmtWrXCt99+a86XoC5CSJc42LoVeOst6eR4rVoBjzwinSRv9eoH4cbDA+jdG/j6a+DcOemq2wsWSCGH4YZUiAFHWaUKODk5+suLCzi6l25gC06loLaAY/YWnLVr12LcuHFYuHAhOnTogC+//BLdunXDyZMnDQ4+jY+PR/fu3TF8+HCsWrUKf/75J0aOHInatWujT58+AKTrHE2ePBlNmjSBg4MDfvnlF7z00kvw8PBA165dzf2SlJOeLs1mSk2Vupe0V9GOi5MuKFmQvT0QHCx9sQQHA4MHS9dqIrIiDDjKMmpaflEtMMUFHN1/oBhwKoVKF3Bmz56NoUOHYtiwYQCAuXPn4rfffsOiRYswffr0QuUXL14MX19fzJ07FwAQEBCAw4cPY+bMmXLACQsL03vM2LFjsXLlSuzbt896A87Nm9L1mVavli42efKkdJbQonYUW1vg4YeBxo2lwcD16klnB/b0VLbeRCbGgKMso6blF3XeGQYc0qG2LWbWgJOdnY0jR47g7bff1lseHh6O/fv3G3xMTEwMwsPD9ZZ17doVy5Ytw/379/UuuAZIH4Zdu3bhzJkz+OSTTwyuMysrC1k653RJS0sry8sxrXPngKNHpRPpnTghdSnduFG4XJ06QM2aUkvMI49IoaZlSynYlHT1XiIrVJYT/VHZlaqLqqDiZlHpztIsxRgcY65FReqmls+lWQNOSkoKcnNz4VmgVcHT0xNJSUkGH5OUlGSwfE5ODlJSUuDt7Q0ASE1NxUMPPYSsrCzY2tpi4cKF6NKli8F1Tp8+HR988IEJXpER5swBli4F1q+XBtnVrSst/+cf4LvvpPuBQidI0tO/PzBuHPDQQ0D+6yWqLHiiP2WVahZVQcXNovrrrwe/swWnUqh0XVRA4R1VCFHszmuofMHlLi4uOHbsGDIyMrBz505ERUXB39+/UPcVAEycOBFRUVHy32lpaairDR6mdOYMoH2egADjH/foo8B77wFPPik16/KDTZUYp4krq1wtOP/8I/00FHDs7PSvNm4kBhzrVakCjru7O2xtbQu11iQnJxdqpdHy8vIyWN7Ozg61atWSl9nY2KBhw4YAgFatWuHUqVOYPn26wYDj6OgIRyVmDGmvrFsSV1fghx+kFp4OHcxbJyIrwzE4yipXwLl+XfppKOC0bi1NjpCexOj6cJtar0oVcBwcHBAYGIjt27fj2WeflZdv374dvXr1MviY4OBgbN68WW/Ztm3bEBQUVGj8jS4hhN44G4t45BHpHBEHDkhdVH/9BaSlAQ0aSGNoXnxROplejRqWrSeRijHgKKtcXVRahr6bv/8emDQJmDChVPXhNrVelSrgAEBUVBQGDhyIoKAgBAcH46uvvkJCQgIiIyMBSN1HV65cwTfffAMAiIyMxPz58xEVFYXhw4cjJiYGy5Ytw+rVq+V1Tp8+HUFBQWjQoAGys7MRHR2Nb775BosWLTL3yymZjQ3Qvr10I6JSY8BRllGDuksa8Gso4DRsCKxbV+r6cJtar0oXcCIiInDjxg1MnToViYmJaN68OaKjo1GvXj0AQGJiIhISEuTyfn5+iI6Oxvjx47FgwQL4+Phg3rx58hRxALhz5w5GjhyJ//77D1WqVEGTJk2watUqREREmPvlEJGZMeAoq1zTxLVKMcamJJxFZb3U9ilUZJDxyJEjMXLkSIP3rVixotCy0NBQHD16tMj1ffTRR/joo49MVT0iUhFeTVxZZuuiKiOGVuunls8lIzIRqQpnUSnLqPdboyl+7CADDkF9XVQMOESkKtquCZ4HRxlGB8pJk4q+T/cCnOXEbWq9GHCIiIrBMTjKMvr9Lm6cTXq6yerDbWq9GHCIiIrBgKMso9/v4rqh2IJTueVvKwYcIqJiMOAoq0wBp0oV/fu0Zyw2AW5TK5Q/CJ0Bh4ioGJxFpSyjxzzpdlE5Oz+40Kb0YJPVh9PErVD+tlJbJOUeRESqwhYcZZVpDI4Q+q047KKq3AqEUbX848GAQ0SqwmniyjL6/XZ3f/B7wbIMOJUbu6iIiErGFhxlGf1+P/XUg98LltUNP+XEbWqFCnRRMeAQERlg1LWR8vFgWH5GBxzdbgjtmJs1a4DnngNef91k9eE2tUIqDTiKXKqBiMhYRl0bKR8PhuVXli5BuUsqIkK6mRC3qRViFxURUcnYRaWsMgWcrCwz1YazqKySSltwuAcRkapwmriyStMlKLt/30y1YWi1SgVacNSCAYeIVIUtOMoqTZegErhNrRCniRMRlYzTxJVVpi4qM2LAsULsoiIiKhlbcJRVqoDz6afSz1mzzFYfblMrpNJBxpxFRUSqwoCjrFIFnDffBAYOBLy8zFYfblMrxBYcIqKSMeAoq9RdVGYMNwBnUVklBhwiopIZffFHMOCYAsfgULmptIuKAYeIVIXTxJVVpmniZsSAY4V4NXEiopKxi0pZnCZO5ZbfgqOllrDMgENEqsJp4spiFxWVG8fgEBGVrDQHNh4My48Bh8pNu83kP9WxLzHgEJGq6B7YSvqi5MGw/NQWcDiLygrlbzMGHCKiYjDgKEttAYfb1Aox4BARlYwBR1kMOFRuDDhERCUrS8ChsmPAoXIrEHDUggGHiFRFd+xFSVOXeTAsv9KcWFEJ3KZWqMC+o5awzIBDRKpSmhYcQ4+h0mELDpUbu6iIiErGMTjKUlvA0bYkcZtaEQYcIqKSMeAoS20BR1sPThO3Igw4REQlY8BRlloDDrepFeGJ/oiISsZZVMpiwKFy69ULAKBxdASgnn1JkYCzcOFC+Pn5wcnJCYGBgdi7d2+x5ffs2YPAwEA4OTnB398fixcv1rt/yZIlCAkJQY0aNVCjRg08+eST+Ouvv8z5EohIIWzBURYDDpXbzJnAkiXQBARYuiZ6zB5w1q5di3HjxmHy5MmIjY1FSEgIunXrhoSEBIPl4+Pj0b17d4SEhCA2NhaTJk3CmDFjsH79ernM7t270a9fP/z++++IiYmBr68vwsPDceXKFXO/HCIyMwYcZXGaOJVb1arAsGGAvT0A9YRlswec2bNnY+jQoRg2bBgCAgIwd+5c1K1bF4sWLTJYfvHixfD19cXcuXMREBCAYcOG4eWXX8bMmTPlMt999x1GjhyJVq1aoUmTJliyZAny8vKwc+dOc78cIjIz3cGlnCZufmzBIVNR275k1oCTnZ2NI0eOIDw8XG95eHg49u/fb/AxMTExhcp37doVhw8fxv379w0+5u7du7h//z5q1qxp8P6srCykpaXp3YhInXQPbDzRn/mp7aDEi21aL7XtS2bdg1JSUpCbmwtPT0+95Z6enkhKSjL4mKSkJIPlc3JykJKSYvAxb7/9Nh566CE8+eSTBu+fPn063Nzc5FvdunXL8GqISAnsolKW2g5K3KbWS237kiIRueCOKoQoduc1VN7QcgD49NNPsXr1amzYsAFOTk4G1zdx4kSkpqbKt8uXL5f2JRCRQhhwlKW2gxK3qfVS275kZ86Vu7u7w9bWtlBrTXJycqFWGi0vLy+D5e3s7FCrVi295TNnzsS0adOwY8cOtGjRosh6ODo6wjF/+hoRqRuniStLbQclBhzrpbZ9yawtOA4ODggMDMT27dv1lm/fvh3t27c3+Jjg4OBC5bdt24agoCDY54/QBoDPPvsMH374IbZu3YqgoCDTV56ILIItOMpS20GJ29R6qW2bmb2LKioqCkuXLsXy5ctx6tQpjB8/HgkJCYiMjAQgdR8NGjRILh8ZGYlLly4hKioKp06dwvLly7Fs2TK88cYbcplPP/0U77zzDpYvX4769esjKSkJSUlJyMjIMPfLISIzY8BRlnYwLwMOmYpa9iWzdlEBQEREBG7cuIGpU6ciMTERzZs3R3R0NOrVqwcASExM1Dsnjp+fH6KjozF+/HgsWLAAPj4+mDdvHvr06SOXWbhwIbKzs/H888/rPdeUKVPw/vvvm/slEZEZ8WriytK+d2o5Dw5nUVkvtbUGmj3gAMDIkSMxcuRIg/etWLGi0LLQ0FAcPXq0yPVdvHjRRDUjIjVjC475qe2gxG1qvdS2LzEiE5HqGHt2XR4My09tByVuU+ultn2JAYeIVMfYL0oeDMtPbQclblPrpbZ9iQGHiFSntAGHyk5tByUGHOultn2JAYeIVIctOMpR23vHbWq91LbNGHCISHUYcJRTlllr5sRZVNZPDfsRwIBDRCpU2qZuBpyy0w0SapgqztBqvdhFRURUArbgKEdtLTjcptaLAYeIqAQMOMphwCFTYcAhIioBA45yGHDIVBhwiIhKUNoT/VHZMeCQqTDgEBGVgC04ylFbwNGGWm5T66O2bcaAQ0Sqw4CjHLUFHG0dOE3ceqlhPwIYcIhIhThNXDmcJk6mwi4qIqISsAVHOWptweE2tT4MOEREJWDAUQ4DDpkKAw4RUQkYcJTDgEOmwoBDRFQCXk1cOQw4ZCoMOEREJdAOfGULjvmpLeDwYpvWS22fQ+5BRKQ62i9KY2f1qO2L1ZqoLeAwtFo/NexHAAMOEakQx+AoR7elRA0HJm5T68UuKiKiEjDgKEf3veN5cKg8GHCIiErAgKMcdlGRqTDgEBGVgLOolMOAQ6bCgENEVAK24FiGGg5MnEVlvRhwiIhKwICjLDUdmLhNrZfathkDDhGpDi+2qSwGHDIlNexHAAMOEamQtnuipFk9PBiaBgMOmYKa9iOAAYeIVIhdVMoyNlAqgdvUejHgEBGVgAFHWWo6MHGbWi817UcAAw4RqRCniStLTQcmzqKyXmrajwAGHCJSIbbgKEtNByZuU+ulpv0IYMAhIhViwFGWmg5M3KbWS23bjAGHiFSH08SVxYBDpqSG/QhQKOAsXLgQfn5+cHJyQmBgIPbu3Vts+T179iAwMBBOTk7w9/fH4sWL9e4/ceIE+vTpg/r160Oj0WDu3LlmrD0RKY0tOMpiwCFTUNN+BCgQcNauXYtx48Zh8uTJiI2NRUhICLp164aEhASD5ePj49G9e3eEhIQgNjYWkyZNwpgxY7B+/Xq5zN27d+Hv748ZM2bAy8vL3C+BiBTGgKMsThMnU6h0AWf27NkYOnQohg0bhoCAAMydOxd169bFokWLDJZfvHgxfH19MXfuXAQEBGDYsGF4+eWXMXPmTLnMo48+is8++wwvvPACHB0dzf0SiEhhPNGfstR0YOIsKuulpv0IMHPAyc7OxpEjRxAeHq63PDw8HPv37zf4mJiYmELlu3btisOHD+P+/ftmqysRqQeniStLTQcmhlbrpab9CADszLnylJQU5ObmwtPTU2+5p6cnkpKSDD4mKSnJYPmcnBykpKTA29u71PXIyspCVlaW/HdaWlqp10FEymEXlbLUdGDiNrVeatqPAIUGGRfcUYUQxe68hsobWm6s6dOnw83NTb7VrVu3TOshImUw4ChLTQcmblPrpbZtZtaA4+7uDltb20KtNcnJyYVaabS8vLwMlrezs0OtWrXKVI+JEyciNTVVvl2+fLlM6yEiZXCauLIYcMiU1LAfAWYOOA4ODggMDMT27dv1lm/fvh3t27c3+Jjg4OBC5bdt24agoCDY29uXqR6Ojo5wdXXVuxGRerEFR1kMOGQKatqPAAW6qKKiorB06VIsX74cp06dwvjx45GQkIDIyEgAUuvKoEGD5PKRkZG4dOkSoqKicOrUKSxfvhzLli3DG2+8IZfJzs7GsWPHcOzYMWRnZ+PKlSs4duwYzp07Z+6XQ0QKYMBRlnbGkhoOTNpZVNym1kdtAcesg4wBICIiAjdu3MDUqVORmJiI5s2bIzo6GvXq1QMAJCYm6p0Tx8/PD9HR0Rg/fjwWLFgAHx8fzJs3D3369JHLXL16Fa1bt5b/njlzJmbOnInQ0FDs3r3b3C+JiMyMAUdZ2vdPTefB4TRx61PpAg4AjBw5EiNHjjR434oVKwotCw0NxdGjR4tcX/369VXzBhKR6ZX2PDhUPmo6MDG0Wi817UcAr0VFRCrEFhxlqenAxG1qvdS0HwEMOESkQgw4ylLTgYnb1HqpbZsx4BCR6nCauLIYcMiU1LAfAQw4RKRCbMFRFgMOmYKa9iOAAYeIVIgBR1lqOjDxYpvWS037EcCAQ0QqxIttKsvYWWtKYGi1Xgw4REQlYAuOstR0YOI2tV5q2o8ABhwiUiEGHGWp6cDEbWq91LQfAQw4RKRCpT3RHw+G5aOmAxO3qfVS2zZjwCEi1eE0cWUx4JApqWE/AhhwiEiF2EWlLDUFHM6isl5q2o8ABhwiUiEGHGWp6cDEbWq91LQfAQw4RKRCnCauLE4TJ1NgwCEiKgFbcJSlpgMTt6n1UtN+BDDgEJEKMeAoS00HJm5T66Wm/QhgwCEiFWLAUZaaDkzcptZLbduMAYeIVIfTxJWlpoDDWVTWTw37EcCAQ0QqxBP9KUtNAYfb1HqpaT8CGHCISIXYRaUsNR2YuE2tl5r2I4ABh4hUiNPElcVp4mQKDDhERCVgC46y1HRg4ja1XmrajwAGHCJSIQYcZanpwMRtar3UtB8BDDhEpEIMOMpS04FJ203GbWp91LbNGHCISHU4TVxZago42jpwmrj1UsN+BDDgEJEKsQVHWWoMONym1kdN+xHAgENEKsTz4ChLTQcmblPrpab9CGDAISIV4jRxZanpwMSAY73UtB8BDDhEpELsolIWz4NDpsCAQ0RUAgYcZanpwMRtar3UtB8BDDhEpEIMOMpS04GJF9u0Xmr7HHIPIiLV4TRxZakp4DC0Wj817EcAAw4RqRBbcJTFgEOmoKb9CGDAISIV4iwqZanpwMSAY73UtB8BDDhEpEJswVGWmg5M3KbWS037EaBQwFm4cCH8/Pzg5OSEwMBA7N27t9jye/bsQWBgIJycnODv74/FixcXKrN+/Xo0bdoUjo6OaNq0KTZu3Giu6hORwniiP2VxmjiZQqULOGvXrsW4ceMwefJkxMbGIiQkBN26dUNCQoLB8vHx8ejevTtCQkIQGxuLSZMmYcyYMVi/fr1cJiYmBhERERg4cCD+/vtvDBw4EH379sXBgwfN/XKISAFswVGWmg5MnEVlvdS0HwEKBJzZs2dj6NChGDZsGAICAjB37lzUrVsXixYtMlh+8eLF8PX1xdy5cxEQEIBhw4bh5ZdfxsyZM+Uyc+fORZcuXTBx4kQ0adIEEydOxBNPPIG5c+ea++UQkQIYcJSlpgMTt6n1Uts2M2vAyc7OxpEjRxAeHq63PDw8HPv37zf4mJiYmELlu3btisOHD+P+/fvFlilqnVlZWUhLS9O7EZF6cZq4shhwyJTUsB8BZg44KSkpyM3Nhaenp95yT09PJCUlGXxMUlKSwfI5OTlISUkptkxR65w+fTrc3NzkW926dcv6kohIAWzBURYDDpmCmvYjQKFBxgV3VCFEsTuvofIFl5dmnRMnTkRqaqp8u3z5cqnqT0TK4jRxZanpwMSAY73UtB8BgJ05V+7u7g5bW9tCLSvJycmFWmC0vLy8DJa3s7NDrVq1ii1T1DodHR3h6OhY1pdBRApjC46y1HRg4ja1XmrajwAzt+A4ODggMDAQ27dv11u+fft2tG/f3uBjgoODC5Xftm0bgoKCYG9vX2yZotZJRNaFAUdZapomzllU1kttAcesLTgAEBUVhYEDByIoKAjBwcH46quvkJCQgMjISABS99GVK1fwzTffAAAiIyMxf/58REVFYfjw4YiJicGyZcuwevVqeZ1jx45Fp06d8Mknn6BXr174+eefsWPHDuzbt8/cL4eIFMCAoyw1HZi4Ta2XmvYjQIGAExERgRs3bmDq1KlITExE8+bNER0djXr16gEAEhMT9c6J4+fnh+joaIwfPx4LFiyAj48P5s2bhz59+shl2rdvjzVr1uCdd97Bu+++iwYNGmDt2rVo27atuV8OESmgtC0KPBiWj5oOTAw41ktt28zsAQcARo4ciZEjRxq8b8WKFYWWhYaG4ujRo8Wu8/nnn8fzzz9viuoRkcqwBUdZDDhkSmrYjwCFAo61ys3Nlc+9Q2Qp9vb2sLW1tXQ1FMWAoywGHDIFNe1HAAOOQUIIJCUl4fbt25auChEAoHr16vDy8qo0X/qcJq4sNR2YGHCsl5r2I4ABxyBtuPHw8EDVqlX5QSOLEULg7t27SE5OBgB4e3tbuEbKYAuOstR0YNKOu+I2tT5q2o8ABpxCcnNz5XCjPe8OkSVVqVIFgHSuJw8Pj0rRXcWAoyw1HZi0deA0ceujpv0IUOhMxtZEO+amatWqFq4J0QPa/bGyjAljwFGWms6Dw21qvRhwrAQ/XKQmlW1/5MU2laWmAxMDjvVS2zZjwCEi1TG2RYEHQ9NgwCFTUNN+BDDgUBnUr18fc+fOtdjzh4WFYdy4cSZb35AhQ9C7d2+TrY/Kj11UylLTgYnb1PqpYT8CGHAqFFMcqO/cuYMJEybA398fTk5OqF27NsLCwvDLL7/IZQ4dOoRXXnlF/luj0eCnn34q1/MCwO7du6HRaORblSpV0KxZM3z11VflXndZhYWF6dWp4K1+/foWq1tFxmniymLAIVNQ034EcBYVFRAZGYm//voL8+fPR9OmTXHjxg3s378fN27ckMvUrl3brHU4c+YMXF1dkZmZic2bN2PEiBFo0KABnnjiCbM+ryEbNmxAdnY2AODy5ct47LHHsGPHDjRr1gwASj2j6f79+/JFY6lobMFRlpoOTLzYpvVS034EsAWnQgsLC8OYMWPw1ltvoWbNmvDy8sL7779f7GM2b96MSZMmoXv37qhfvz4CAwMxevRoDB48WC6j20WlbcF49tln9Vo0DLUmjRs3DmFhYSXW28PDA15eXvDz88OYMWNQv379Yi/dsWrVKgQFBcHFxQVeXl548cUX5fPGaJ04cQJPP/00XF1d4eLigpCQEJw/f97g+o4cOQIPDw98/PHH8vvm5eUlB7tatWrJy2bOnIlGjRqhatWq8Pf3x7vvvqs30+n9999Hq1atsHz5cvj7+8PR0RFCCISFheG1117Da6+9hurVq6NWrVp45513VPPFYGkMOMpS04GJ29R6qWk/AtiCYxwhgLt3LfPcVasC5figr1y5ElFRUTh48CBiYmIwZMgQdOjQAV26dDFY3svLC9HR0Xjuuefg4uJS4voPHToEDw8PfP3113jqqadMeo4WIQR+++03XL58udgLqWZnZ+PDDz9E48aNkZycjPHjx2PIkCGIjo4GAFy5cgWdOnVCWFgYdu3aBVdXV/z555/IyckptK7du3ejd+/emD59OkaMGFFiHV1cXLBixQr4+Pjg+PHjGD58OFxcXPDWW2/JZc6dO4d169Zh/fr1eu/PypUrMXToUBw8eBCHDx/GK6+8gnr16mH48OGleZsqJAYcZXGaOJkCA441unsXqFbNMs+dkQE4O5f54S1atMCUKVMAAA8//DDmz5+PnTt3FhlwvvrqK/Tv3x+1atVCy5Yt0bFjRzz//PPo0KGDwfLaVg3tpQRMoU6dOgCArKws5OXlYerUqejUqVOR5V9++WX5d39/f8ybNw+PPfYYMjIyUK1aNSxYsABubm5Ys2aN3D3UqFGjQuv5+eefMXDgQHz55Zfo16+fUXV955135N/r16+P119/HWvXrtULONnZ2fj2228Lde3VrVsXc+bMgUajQePGjXH8+HHMmTOHAQecJq40NR2YGHCsl9q2GbuoKrgWLVro/e3t7V2o+0ZXp06dcOHCBezcuRN9+vTBiRMnEBISgg8//NDcVZXt3bsXx44dw7Fjx7B06VJMmzYNixYtKrJ8bGwsevXqhXr16sHFxUXuBktISAAAHDt2DCEhIcWOfTl48CD69OmDlStXGh1uAODHH39Ex44d4eXlhWrVquHdd9+Vn1erXr16BscttWvXTu8LITg4GHFxccjNzTX6+SsqtuAoiwGHTEFN+xHAgGOcqlWllhRL3Mp5RuWCB3WNRlNiM7S9vT1CQkLw9ttvY9u2bZg6dSo+/PBDebCtMWxsbArt5MaehdfPzw8NGzZEs2bN8NJLL2HgwIH4+OOPDZa9c+cOwsPDUa1aNaxatQqHDh3Cxo0bAUCur/ZSB8Vp0KABmjRpguXLlxv9Og8cOIAXXngB3bp1wy+//ILY2FhMnjy50OOdy9ECV1lxFpWy1HRgYsCxfmrYjwB2URlHoylXN5G1a9q0KXJycnDv3j04ODgUut/e3r5Qq0Pt2rXx77//6i07duxYmWYQ2draIjMz0+B9p0+fRkpKCmbMmIG6desCAA4fPqxXpkWLFli5cmWxM5jc3d2xYcMGhIWFISIiAuvWrSuxrn/++Sfq1auHyZMny8suXbpk9Os6cOBAob8ffvjhSnGtqZLwRH/KUlPA4Swq66Wm/QhgCw4VEBYWhi+//BJHjhzBxYsXER0djUmTJuHxxx+Hq6urwcfUr18fO3fuRFJSEm7dugUA6Ny5Mw4fPoxvvvkGcXFxmDJlSqHAU5Tk5GQkJSXh0qVL+OGHH/Dtt9+iV69eBsv6+vrCwcEBX3zxBS5cuIBNmzYV6k577bXXkJaWhhdeeAGHDx9GXFwcvv32W5w5c0avnIeHB3bt2oXTp0+jX79+Bgch62rYsCESEhKwZs0anD9/HvPmzZNbj4xx+fJlREVF4cyZM1i9ejW++OILjB071ujHV2TsolKWmg5M3KbWS037EcCAQwV07doVK1euRHh4OAICAjB69Gh07doV69atK/Ixs2bNwvbt21G3bl20bt1aXs+7776Lt956C48++ijS09MxaNAgo+rQuHFjeHt7o2HDhpgwYQJeffVVfPHFFwbL1q5dGytWrMAPP/yApk2bYsaMGZg5c6ZemVq1amHXrl3IyMhAaGgoAgMDsWTJEoMtNF5eXti1axeOHz+O/v37FzseplevXhg/fjxee+01tGrVCvv378e7775r1GsEgEGDBiEzMxOPPfYYRo0ahdGjR+udQLEyY8BRlpoOTNym1ktN+xEAQFRCqampAoBITU0tdF9mZqY4efKkyMzMtEDNqLIIDQ0VY8eONbp8ZdsvJ06cKACU+B7Z2dkJAOLy5cvKVKyCGjJkiAAgZsyYYemqCBsbGwFAXL161dJVoVL66quvBADRs2dPsz1HccfvgtiCQ0Sqw2niylLTf96CLThWS23bjAGHiFSHXVTKYsAhU1DTfgRwFhWRRezevdvSVVA1ThNXlloOTLrPz1lU1svS+5EW9yAiUh224ChLjQGH29T6qGU/0mLAISLV0X5R8jw4ylDLgYkBx7qpZT/SYsAhItXRdk9wkLEy1HJgYsCxbmrZj7QYcIhIdYz5ouTB0HTUcmDiNrVuatmPtBhwiEh1OE1cWcZeGsPcGHCsm9q2GQMOEakOW3CUpZb/vHUDFrep9VHLfqTFgEOK2r17NzQaDW7fvm2S9V28eBEajQbHjh0zyfpIHUobcKh81HJg4jTxisHS+5EW96AKZMiQIdBoNNBoNLCzs4Ovry9GjBghXwDTGOUJDGFhYfLz29jYwNPTE//73/9KdYVtU9KGqeJuK1assEjdqHhswVGWGgMOt6n1Uct+pMWAU8E89dRTSExMxMWLF7F06VJs3rwZI0eOVOz5hw8fjsTERFy5cgU///wzLl++jAEDBij2/Lrat2+PxMRE+da3b1/5/dHeIiIiSrXO+/fvm6m2pIsBR1lqOTBxm1o3texHWgw4FYyjoyO8vLxQp04dhIeHIyIiAtu2bdMr8/XXXyMgIABOTk5o0qQJFi5cKN/n5+cHAGjdujU0Gg3CwsJK9fxVq1aFl5cXvL290a5dO4waNQpHjx4tsvyNGzfQr18/1KlTB1WrVsUjjzyC1atX65XJy8vDJ598goYNG8LR0RG+vr74+OOPDa4vLy8Pw4cPR6NGjZCYmAgvLy/5VqVKFfn98fLywuXLl9GzZ0+4u7vDzc0NoaGhheqq0WiwePFi9OrVC87Ozvjoo4/klqEtW7agZcuWcHJyQtu2bXH8+PFSvVdUNAYcZanlwMRtat3Ush9p8VINRhBC4O7duxZ57qpVq5b5g37hwgVs3boV9vb28rIlS5ZgypQpmD9/Plq3bo3Y2FgMHz4czs7OGDx4MP766y889thj2LFjB5o1awYHB4cy1/3mzZv44Ycf0LZt2yLL3Lt3D4GBgZgwYQJcXV2xZcsWDBw4EP7+/vLjJk6ciCVLlmDOnDno2LEjEhMTcfr06ULrys7Oxosvvojz589j37598PDwKLZ+6enpGDx4MObNmwcAmDVrFrp37464uDi4uLjI5aZMmYLp06djzpw5sLW1RXx8PADgzTffxOeffw4vLy9MmjQJPXv2xNmzZ/XebyobY2b18GBoOmo5MHGbWje17Ecyo65PXkY3b94UAwYMEK6ursLV1VUMGDBA3Lp1q9jH5OXliSlTpghvb2/h5OQkQkNDxb///qtX5ssvvxShoaHCxcVFAChxnQUVd7n1zMxMcfLkSZGZmSkvy8jIEAAscsvIyDD6dQ0ePFjY2toKZ2dn4eTkJK9j9uzZcpm6deuK77//Xu9xH374oQgODhZCCBEfHy8AiNjY2FK9p0IIERoaKuzt7YWzs7OoWrWqACAaNWok4uPj5TK///57iduse/fu4vXXXxdCCJGWliYcHR3FkiVLDJbV1nfv3r3iySefFB06dBC3b982WHbw4MGiV69eRT5vTk6OcHFxEZs3b5aXARDjxo3TK6d9DWvWrJGX3bhxQ1SpUkWsXbu2yPWXh6H9siL79NNPBQAxaNCgIsvcu3dP3seL2uZknPHjxwsAYsKECRatx+3bt+VtWln29Ypk9erVAoDo3Lmz2Z6juON3QWbtonrxxRdx7NgxbN26FVu3bsWxY8cwcODAYh/z6aefYvbs2Zg/fz4OHToELy8vdOnSBenp6XKZu3fv4qmnnsKkSZPMWX2r9Pjjj+PYsWM4ePAgRo8eja5du2L06NEAgOvXr+Py5csYOnQoqlWrJt8++ugjnD9/3iTP379/fxw7dgx///039u3bh4YNGyI8PFxv++nKzc3Fxx9/jBYtWqBWrVqoVq0atm3bhoSEBADAqVOnkJWVhSeeeKLY5+3Xrx8yMjKwbds2uLm5GVXX5ORkREZGolGjRnBzc4ObmxsyMjLk59YKCgoy+Pjg4GD595o1a6Jx48Y4deqUUc9NxWMXlbLU8p+34Cwqq6aW/UjLbF1Up06dwtatW3HgwAG5q2HJkiUIDg7GmTNn0Lhx40KPEUJg7ty5mDx5Mp577jkAwMqVK+Hp6Ynvv/8er776KgBg3LhxAJS7InPVqlWRkZGhyHMZeu7ScHZ2RsOGDQEA8+bNw+OPP44PPvgAH374odzcv2TJkkLdRra2tiapr5ubm/z8DRs2xLJly+Dt7Y21a9di2LBhhcrPmjULc+bMwdy5c/HII4/A2dkZ48aNQ3Z2NgCgSpUqRj1v9+7dsWrVKhw4cACdO3c26jFDhgzB9evXMXfuXNSrVw+Ojo4IDg6Wn1vL2dnZqPUBPNCaCqeJK0stByaG1orB0vuRltkCTkxMDNzc3PQOpO3atYObmxv2799vMODEx8cjKSkJ4eHh8jJHR0eEhoZi//79csApraysLGRlZcl/p6WllerxGo2mVAc5NZkyZQq6deuGESNGwMfHBw899BAuXLiA/v37GyyvHXOTm5trkufXBqfMzEyD9+/duxe9evWSZ1rl5eUhLi4OAQEBAICHH34YVapUwc6dOw0GJK0RI0agefPm6NmzJ7Zs2YLQ0NAS67Z3714sXLgQ3bt3BwBcvnwZKSkpRr+2AwcOwNfXFwBw69YtnD17Fk2aNDH68VQ07cHt0KFD8j80BeXk5BQqT2Wjff927txZ5PuthHv37sm/c5taH+02i4uLw7hx4+Dh4WHRnhazBZykpCSDgzw9PDyQlJRU5GMAwNPTU2+5p6dnuc6lMn36dHzwwQdlfrw1CwsLQ7NmzTBt2jTMnz8f77//PsaMGQNXV1d069YNWVlZOHz4MG7duoWoqCh4eHigSpUq2Lp1K+rUqQMnJye4ublh48aNmDhxosHBvbru3r0rb8dr167ho48+gpOTk15o1dWwYUOsX78e+/fvR40aNTB79mwkJSXJAcfJyQkTJkzAW2+9BQcHB3To0AHXr1/HiRMnMHToUL11jR49Grm5uejRowd+/fVXdOzYsdi6NmzYEN9++y2CgoKQlpaGN9980+gWIwCYOnUqatWqBU9PT0yePBnu7u7o3bu30Y+nolWvXh0AcObMGZw5c6bYsk5OTuUaDE8P3u+jR48WO+tRKc7OzuyiskLa/ejKlSv4/PPP0bhxY+sKOO+//36JYeHQoUMADCdwIUSJybzg/cY8pjgTJ05EVFSU/HdaWhrq1q1b5vVZm6ioKLz00kuYMGEChg0bhqpVq+Kzzz7DW2+9BWdnZzzyyCPyf212dnaYN28epk6divfeew8hISHYvXs3UlNTSzzQAFL315IlSwAANWrUQIsWLRAdHW2wxQ4A3n33XcTHx6Nr166oWrUqXnnlFfTu3Rupqal6Zezs7PDee+/h6tWr8Pb2RmRkpMH1jRs3Dnl5eejevTu2bt2K9u3bF1nX5cuX45VXXkHr1q3h6+uLadOm4Y033ijxNWrNmDEDY8eORVxcHFq2bIlNmzbxQGsiERERuH37Nm7cuFFi2Y4dO8LR0VGBWlVcI0aMgK2tbZFj5ZT2+OOPM+BYoc6dO2PBggW4cuUKAMDd3d2i9dGIUnaWpaSklNiMX79+fXz//feIiooqdEr+6tWrY86cOXjppZcKPe7ChQto0KABjh49itatW8vLe/XqherVq2PlypV65Xfv3o3HH38ct27dkpOjMdLS0uDm5obU1FS4urrq3Xfv3j3Ex8fDz88PTk5ORq+TKo+y7nflwf2SiKj443dBpW7BcXd3NyqVBQcHIzU1VT6vCgAcPHgQqampRf5X7efnBy8vL2zfvl0OONnZ2dizZw8++eST0laViIiIKimztQEGBATgqaeewvDhw3HgwAEcOHAAw4cPR48ePfS6K5o0aYKNGzcCkLqmxo0bh2nTpmHjxo34999/MWTIEFStWhUvvvii/JikpCQcO3YM586dAwAcP34cx44dw82bN831coiIiMiKmPVMxt999x3GjBkjDzDt2bMn5s+fr1fmzJkzeuMt3nrrLWRmZmLkyJG4desW2rZti23btumdWXbx4sV644A6deoEQLoEwZAhQ8z4ioikgdtqmQZJRESGlXoMTkXAMThkbbhfEhGVbgwOh6kTERFRhcOAU4TiLvJHpDTuj0REpcOriRfg4OAAGxsbXL16FbVr14aDgwPPqEkWI4RAdnY2rl+/DhsbG55nh4jISAw4BdjY2MDPzw+JiYm4evWqpatDBEC6Jpmvry9PfkZEZCQGHAMcHBzg6+uLnJwck12TiaisbG1tYWdnx5ZEIqJSYMApgkajgb29Pezt7S1dFSIiIioltncTERFRhcOAQ0RERBUOAw4RERFVOJVyDI725M1paWkWrgkREREZS3vcNuYiDJUy4KSnpwMA6tata+GaEBERUWmlp6fDzc2t2DKV8lpUeXl5uHr1KlxcXCrU1Nu0tDTUrVsXly9fLvEaHaQ8bh/14zZSN24fdVNi+wghkJ6eDh8fnxLPC1YpW3BsbGxQp04dS1fDbFxdXfnhVzFuH/XjNlI3bh91M/f2KanlRouDjImIiKjCYcAhIiKiCocBpwJxdHTElClT4OjoaOmqkAHcPurHbaRu3D7qprbtUykHGRMREVHFxhYcIiIiqnAYcIiIiKjCYcAhIiKiCocBh4iIiCocBhyVe//996HRaPRuXl5e8v1CCLz//vvw8fFBlSpVEBYWhhMnTuitIysrC6NHj4a7uzucnZ3Rs2dP/Pfff0q/lArhjz/+wDPPPAMfHx9oNBr89NNPevebanvcunULAwcOhJubG9zc3DBw4EDcvn3bzK+uYihpGw0ZMqTQZ6pdu3Z6ZbiNzGP69Ol49NFH4eLiAg8PD/Tu3RtnzpzRK8PPkGUZs42s5TPEgGMFmjVrhsTERPl2/Phx+b5PP/0Us2fPxvz583Ho0CF4eXmhS5cu8vW2AGDcuHHYuHEj1qxZg3379iEjIwM9evRAbm6uJV6OVbtz5w5atmyJ+fPnG7zfVNvjxRdfxLFjx7B161Zs3boVx44dw8CBA83++iqCkrYRADz11FN6n6no6Gi9+7mNzGPPnj0YNWoUDhw4gO3btyMnJwfh4eG4c+eOXIafIcsyZhsBVvIZEqRqU6ZMES1btjR4X15envDy8hIzZsyQl927d0+4ubmJxYsXCyGEuH37trC3txdr1qyRy1y5ckXY2NiIrVu3mrXuFR0AsXHjRvlvU22PkydPCgDiwIEDcpmYmBgBQJw+fdrMr6piKbiNhBBi8ODBolevXkU+httIOcnJyQKA2LNnjxCCnyE1KriNhLCezxBbcKxAXFwcfHx84OfnhxdeeAEXLlwAAMTHxyMpKQnh4eFyWUdHR4SGhmL//v0AgCNHjuD+/ft6ZXx8fNC8eXO5DJmGqbZHTEwM3Nzc0LZtW7lMu3bt4Obmxm1mIrt374aHhwcaNWqE4cOHIzk5Wb6P20g5qampAICaNWsC4GdIjQpuIy1r+Awx4Khc27Zt8c033+C3337DkiVLkJSUhPbt2+PGjRtISkoCAHh6euo9xtPTU74vKSkJDg4OqFGjRpFlyDRMtT2SkpLg4eFRaP0eHh7cZibQrVs3fPfdd9i1axdmzZqFQ4cOoXPnzsjKygLAbaQUIQSioqLQsWNHNG/eHAA/Q2pjaBsB1vMZqpRXE7cm3bp1k39/5JFHEBwcjAYNGmDlypXyoC6NRqP3GCFEoWUFGVOGysYU28NQeW4z04iIiJB/b968OYKCglCvXj1s2bIFzz33XJGP4zYyrddeew3//PMP9u3bV+g+fobUoahtZC2fIbbgWBlnZ2c88sgjiIuLk2dTFUy7ycnJ8n9AXl5eyM7Oxq1bt4osQ6Zhqu3h5eWFa9euFVr/9evXuc3MwNvbG/Xq1UNcXBwAbiMljB49Gps2bcLvv/+OOnXqyMv5GVKPoraRIWr9DDHgWJmsrCycOnUK3t7e8PPzg5eXF7Zv3y7fn52djT179qB9+/YAgMDAQNjb2+uVSUxMxL///iuXIdMw1fYIDg5Gamoq/vrrL7nMwYMHkZqaym1mBjdu3MDly5fh7e0NgNvInIQQeO2117Bhwwbs2rULfn5+evfzM2R5JW0jQ1T7GTLJUGUym9dff13s3r1bXLhwQRw4cED06NFDuLi4iIsXLwohhJgxY4Zwc3MTGzZsEMePHxf9+vUT3t7eIi0tTV5HZGSkqFOnjtixY4c4evSo6Ny5s2jZsqXIycmx1MuyWunp6SI2NlbExsYKAGL27NkiNjZWXLp0SQhhuu3x1FNPiRYtWoiYmBgRExMjHnnkEdGjRw/FX681Km4bpaeni9dff13s379fxMfHi99//10EBweLhx56iNtIASNGjBBubm5i9+7dIjExUb7dvXtXLsPPkGWVtI2s6TPEgKNyERERwtvbW9jb2wsfHx/x3HPPiRMnTsj35+XliSlTpggvLy/h6OgoOnXqJI4fP663jszMTPHaa6+JmjVriipVqogePXqIhIQEpV9KhfD7778LAIVugwcPFkKYbnvcuHFD9O/fX7i4uAgXFxfRv39/cevWLYVepXUrbhvdvXtXhIeHi9q1awt7e3vh6+srBg8eXOj95zYyD0PbBYD4+uuv5TL8DFlWSdvImj5DmvwXRERERFRhcAwOERERVTgMOERERFThMOAQERFRhcOAQ0RERBUOAw4RERFVOAw4REREVOEw4BAREVGFw4BDREREFQ4DDhEREVU4DDhERERU4TDgEBERUYXDgENEREQVzv8B9J2NxhaoXB0AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "for _key, key in enumerate(report.keys()):\n", + " if _key < 1:\n", + "\n", + " rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))\n", + " rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()\n", + " wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])\n", + "\n", + " miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5\n", + " maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5\n", + " minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5\n", + " maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5\n", + "\n", + " plt.figure()\n", + " plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))\n", + " plt.title(f'NIS01_20210403_{key}')\n", + " for k,i in report[key].items():\n", + " plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)\n", + "\n", + " for k,i in report[key].items():\n", + " plt.figure()\n", + " in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())\n", + " in_situ = np.genfromtxt(in_situ_path, skip_header=3)\n", + " plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')\n", + " mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))\n", + " plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')\n", + " plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "85419744-2391-48f0-b6c2-239390d4b994", + "metadata": {}, + "source": [ + "## Per-Pixel Retrievals\n", + "\n", + "This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).\n", + "\n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f60f1ae9-754b-4c25-bc51-70b792debed7", + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5efac6d4-c9f5-4292-a8e1-739939056ac1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n" + ] + } + ], + "source": [ + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')\n", + "config.input.loc_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "467786f7-35a6-4472-92c5-1fa753da9e3d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line\n" + ] + } + ], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fdbd8001-530b-497f-a2c8-fdda0a2206d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(13, 428)\n", + "[0.10742364 0.60519719]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def closest_wl(mv):\n", + " return np.argmin(np.abs(io.meas_wl-mv))\n", + "\n", + "wl_nan = io.meas_wl.copy()\n", + "wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan\n", + "wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan\n", + "\n", + "fig = plt.figure(figsize=(14,5))\n", + "print(states.shape)\n", + "offset = 0\n", + "for n in range(0,states.shape[0],4):\n", + " lab = f'Step {n}'\n", + " if n == 0:\n", + " lab = 'Algebraic inversion at initial guess'\n", + " \n", + " plt.plot(wl_nan, states[n,:-2] + offset, label=lab)\n", + " offset += 0.04\n", + "plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')\n", + "plt.legend()\n", + "\n", + "print(states[-1,-2:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8fcb0f-cd8e-47b9-9146-2e1335afcfd2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples/neon/neon_single_pixel.ipynb b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples/neon/neon_single_pixel.ipynb new file mode 100644 index 0000000..069c37b --- /dev/null +++ b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples/neon/neon_single_pixel.ipynb @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup\n", + "\n", + "This notebook is an excercise in running ISOFIT in pixel mode (dynamically from python), in order to get into some configuation details.\n", + "\n", + "Prerequisites:\n", + "- Run the neon.ipynb notebook succesfully - we'll use some of the outputs created from that intiial sample run" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running Per-Pixel Retrievals\n", + "\n", + "That gave us a baseline run, but its not clear what might be improved. Let's load up some individual retrievals so we can understand the performance a bit better. \n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Loading config file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Loading from wavelength_file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Prebuilt LUT provided\n", + "WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_upwelling\n", + "WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_downwelling\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Resampling LUT to instrument spectral response.\n" + ] + } + ], + "source": [ + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "output = os.path.join(home,'outputs')\n", + "output_surface_file = os.path.join(output, 'surface.mat')\n", + "neon_id = '173647' #one of 173647, 174150\n", + "roi = report[neon_id]\n", + "indata = os.path.join(home, 'data') \n", + "\n", + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = output_surface_file\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_obs_ort')\n", + "config.input.loc_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the basic setup, we can run some retrievals." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, Ls, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(12, 428)\n", + "[0.11728845 0.61252989]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_0.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_0.png new file mode 100644 index 0000000..2584a6b Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_0.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_1.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_1.png new file mode 100644 index 0000000..793f869 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_2.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_2.png new file mode 100644 index 0000000..14e5d88 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_2.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_3.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_3.png new file mode 100644 index 0000000..602e14e Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_3.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_4.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_4.png new file mode 100644 index 0000000..b7e6282 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_4.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_5.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_5.png new file mode 100644 index 0000000..16c8e5c Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_13_5.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_18_1.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_18_1.png new file mode 100644 index 0000000..47d639e Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_18_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_0.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_0.png new file mode 100644 index 0000000..2584a6b Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_0.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_1.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_1.png new file mode 100644 index 0000000..793f869 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_2.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_2.png new file mode 100644 index 0000000..14e5d88 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_2.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_3.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_3.png new file mode 100644 index 0000000..602e14e Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_3.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_4.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_4.png new file mode 100644 index 0000000..b7e6282 Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_4.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_5.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_5.png new file mode 100644 index 0000000..16c8e5c Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_13_5.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_18_1.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_18_1.png new file mode 100644 index 0000000..47d639e Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_18_1.png differ diff --git a/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_single_pixel_7_1.png b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_single_pixel_7_1.png new file mode 100644 index 0000000..975fe7b Binary files /dev/null and b/isofit-tutorials/build/doctrees/nbsphinx/sensor_examples_neon_neon_single_pixel_7_1.png differ diff --git a/isofit-tutorials/build/doctrees/sensor_examples/neon.doctree b/isofit-tutorials/build/doctrees/sensor_examples/neon.doctree new file mode 100644 index 0000000..772f9a2 Binary files /dev/null and b/isofit-tutorials/build/doctrees/sensor_examples/neon.doctree differ diff --git a/isofit-tutorials/build/doctrees/sensor_examples/neon/neon.doctree b/isofit-tutorials/build/doctrees/sensor_examples/neon/neon.doctree new file mode 100644 index 0000000..2144918 Binary files /dev/null and b/isofit-tutorials/build/doctrees/sensor_examples/neon/neon.doctree differ diff --git a/isofit-tutorials/build/doctrees/sensor_examples/neon/neon_single_pixel.doctree b/isofit-tutorials/build/doctrees/sensor_examples/neon/neon_single_pixel.doctree new file mode 100644 index 0000000..2a5031c Binary files /dev/null and b/isofit-tutorials/build/doctrees/sensor_examples/neon/neon_single_pixel.doctree differ diff --git a/isofit-tutorials/build/html/.buildinfo b/isofit-tutorials/build/html/.buildinfo new file mode 100644 index 0000000..a676042 --- /dev/null +++ b/isofit-tutorials/build/html/.buildinfo @@ -0,0 +1,4 @@ +# Sphinx build info version 1 +# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. +config: dc804ba1fda085ce10bb7de08174ea85 +tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/isofit-tutorials/build/html/_images/how_to_run_apply_oe_12_0.png b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_12_0.png new file mode 100644 index 0000000..86438b5 Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_12_0.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_apply_oe_16_0.png b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_16_0.png new file mode 100644 index 0000000..694d311 Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_16_0.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_apply_oe_20_1.png b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_20_1.png new file mode 100644 index 0000000..c61669d Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_20_1.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_apply_oe_21_1.png b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_21_1.png new file mode 100644 index 0000000..c61669d Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_21_1.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_apply_oe_22_1.png b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_22_1.png new file mode 100644 index 0000000..ab28dc8 Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_22_1.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_apply_oe_24_1.png b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_24_1.png new file mode 100644 index 0000000..022a61a Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_24_1.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_apply_oe_26_1.png b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_26_1.png new file mode 100644 index 0000000..022a61a Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_apply_oe_26_1.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_functions_16_1.png b/isofit-tutorials/build/html/_images/how_to_run_functions_16_1.png new file mode 100644 index 0000000..0d04584 Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_functions_16_1.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_functions_22_0.png b/isofit-tutorials/build/html/_images/how_to_run_functions_22_0.png new file mode 100644 index 0000000..2285444 Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_functions_22_0.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_functions_24_0.png b/isofit-tutorials/build/html/_images/how_to_run_functions_24_0.png new file mode 100644 index 0000000..a2fdfe5 Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_functions_24_0.png differ diff --git a/isofit-tutorials/build/html/_images/how_to_run_functions_31_0.png b/isofit-tutorials/build/html/_images/how_to_run_functions_31_0.png new file mode 100644 index 0000000..7196713 Binary files /dev/null and b/isofit-tutorials/build/html/_images/how_to_run_functions_31_0.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_13_0.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_0.png new file mode 100644 index 0000000..2584a6b Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_0.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_13_1.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_1.png new file mode 100644 index 0000000..793f869 Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_1.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_13_2.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_2.png new file mode 100644 index 0000000..14e5d88 Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_2.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_13_3.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_3.png new file mode 100644 index 0000000..602e14e Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_3.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_13_4.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_4.png new file mode 100644 index 0000000..b7e6282 Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_4.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_13_5.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_5.png new file mode 100644 index 0000000..16c8e5c Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_13_5.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_18_1.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_18_1.png new file mode 100644 index 0000000..47d639e Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_18_1.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_0.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_0.png new file mode 100644 index 0000000..2584a6b Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_0.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_1.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_1.png new file mode 100644 index 0000000..793f869 Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_1.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_2.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_2.png new file mode 100644 index 0000000..14e5d88 Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_2.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_3.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_3.png new file mode 100644 index 0000000..602e14e Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_3.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_4.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_4.png new file mode 100644 index 0000000..b7e6282 Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_4.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_5.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_5.png new file mode 100644 index 0000000..16c8e5c Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_13_5.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_18_1.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_18_1.png new file mode 100644 index 0000000..47d639e Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_18_1.png differ diff --git a/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_single_pixel_7_1.png b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_single_pixel_7_1.png new file mode 100644 index 0000000..975fe7b Binary files /dev/null and b/isofit-tutorials/build/html/_images/sensor_examples_neon_neon_single_pixel_7_1.png differ diff --git a/isofit-tutorials/build/html/_sources/how_to_run/about.rst.txt b/isofit-tutorials/build/html/_sources/how_to_run/about.rst.txt new file mode 100644 index 0000000..e470d9c --- /dev/null +++ b/isofit-tutorials/build/html/_sources/how_to_run/about.rst.txt @@ -0,0 +1,22 @@ +===== +About +===== + +ISOFIT contains a set of routines and utilities for fitting surface, atmosphere and instrument models to imaging +spectrometer data. It is written primarily in Python, with JSON format configuration files and some dependencies on +widely-available numerical and scientific libraries such as scipy, numpy, and scikit-learn. It is designed for maximum +flexibility, so that users can swap in and evaluate model components based on different radiative transfer models (RTMs) +and various statistical descriptions of surface, instrument, and atmosphere. It can run on individual radiance spectra +in text format, or imaging spectrometer data cubes. + +Feature overview +---------------- + +* utilities for fitting surface, atmosphere and instrument models to imaging spectrometer data +* a selection of radiative transfer models (RTMs) incl. MODTRAN, LibRadTran, and 6S +* sRTMnet emulator for MODTRAN 6 by coupling a neural network with a surrogate RTM (6S v2.1) +* various statistical descriptions of surface, instrument, and atmosphere +* application to both individual radiance spectra and imaging spectrometer data cubes +* custom instrument models to handle new sensors +* observation uncertanities to account for model discrepancy errors +* prior distribution based on background knowledge of the state vector diff --git a/isofit-tutorials/build/html/_sources/how_to_run/apply_oe.ipynb.txt b/isofit-tutorials/build/html/_sources/how_to_run/apply_oe.ipynb.txt new file mode 100644 index 0000000..24edbdd --- /dev/null +++ b/isofit-tutorials/build/html/_sources/how_to_run/apply_oe.ipynb.txt @@ -0,0 +1,754 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1be88697", + "metadata": {}, + "source": [ + "# Apply OE" + ] + }, + { + "cell_type": "markdown", + "id": "94f3598f", + "metadata": {}, + "source": [ + "#### What is Apply OE?" + ] + }, + { + "cell_type": "markdown", + "id": "c0421619", + "metadata": {}, + "source": [ + "Apply OE is the built-in end-to-end atmospheric correction pipeline, and is the easiest way to run Isofit. Apply OE is run via a command line interface (CLI) tool accessed with a terminal call:\n", + "\n", + " `isofit apply_oe --help`\n", + "\n", + " The function docstring is printed when this command is run within a terminal window, and acts as a guide for how to run the function.\n", + "\n", + " ```\n", + "isofit apply_oe --help\n", + "\n", + "Usage: isofit apply_oe [OPTIONS] INPUT_RADIANCE INPUT_LOC INPUT_OBS\n", + " WORKING_DIRECTORY SENSOR\n", + "\n", + " Applies OE over a flightline using a radiative transfer engine. This\n", + " executes ISOFIT in a generalized way, accounting for the types of variation\n", + " that might be considered typical.\n", + "\n", + " Observation (obs) and location (loc) files are used to determine appropriate\n", + " geometry lookup tables and provide a heuristic means of determining\n", + " atmospheric water ranges.\n", + "\n", + " Parameters\n", + " ----------\n", + " input_radiance : str\n", + " Radiance data cube. Expected to be ENVI format\n", + " input_loc : str\n", + " Location data cube of shape (Lon, Lat, Elevation). Expected to be ENVI format\n", + " input_obs : str\n", + " Observation data cube of shape:\n", + " (path length, to-sensor azimuth, to-sensor zenith,\n", + " to-sun azimuth, to-sun zenith, phase,\n", + " slope, aspect, cosine i, UTC time)\n", + " Expected to be ENVI format\n", + " working_directory : str\n", + " Directory to stage multiple outputs, will contain subdirectories\n", + " sensor : str\n", + " The sensor used for acquisition, will be used to set noise and datetime\n", + " settings\n", + " surface_path : str\n", + " Path to surface model or json dict of surface model configuration\n", + " copy_input_files : bool, default=False\n", + " Flag to choose to copy input_radiance, input_loc, and input_obs locally into\n", + " the working_directory\n", + " modtran_path : str, default=None\n", + " Location of MODTRAN utility. Alternately set with `MODTRAN_DIR` environment\n", + " variable\n", + " wavelength_path : str, default=None\n", + " Location to get wavelength information from, if not specified the radiance\n", + " header will be used\n", + " surface_category : str, default=\"multicomponent_surface\"\n", + " The type of ISOFIT surface priors to use. Default is multicomponent_surface\n", + " aerosol_climatology_path : str, default=None\n", + " Specific aerosol climatology information to use in MODTRAN\n", + " rdn_factors_path : str, default=None\n", + " Specify a radiometric correction factor, if desired\n", + " atmosphere_type : str, default=\"ATM_MIDLAT_SUMMER\"\n", + " Atmospheric profile to be used for MODTRAN simulations. Unused for other\n", + " radiative transfer models.\n", + " channelized_uncertainty_path : str, default=None\n", + " Path to a channelized uncertainty file\n", + " model_discrepancy_path : str, default=None\n", + " Modifies S_eps in the OE formalism as the Gamma additive term, as:\n", + " S_eps = Sy + Kb.dot(self.Sb).dot(Kb.T) + Gamma\n", + " lut_config_file : str, default=None\n", + " Path to a look up table configuration file, which will override defaults\n", + " choices\n", + " multiple_restarts : bool, default=False\n", + " Use multiple initial starting poitns for each OE ptimization run, using\n", + " the corners of the atmospheric variables as starting points. This gives\n", + " a more robust, albeit more expensive, solution.\n", + " logging_level : str, default=\"INFO\"\n", + " Logging level with which to run ISOFIT\n", + " log_file : str, default=None\n", + " File path to write ISOFIT logs to\n", + " n_cores : int, default=1\n", + " Number of cores to run ISOFIT with. Substantial parallelism is available, and\n", + " full runs will be very slow in serial. Suggested to max this out on the\n", + " available system\n", + " presolve : int, default=False\n", + " Flag to use a presolve mode to estimate the available atmospheric water range.\n", + " Runs a preliminary inversion over the image with a 1-D LUT of water vapor, and\n", + " uses the resulting range (slightly expanded) to bound determine the full LUT.\n", + " Advisable to only use with small cubes or in concert with the empirical_line\n", + " setting, or a significant speed penalty will be incurred\n", + " empirical_line : bool, default=False\n", + " Use an empirical line interpolation to run full inversions over only a subset\n", + " of pixels, determined using a SLIC superpixel segmentation, and use a KDTREE of\n", + " local solutions to interpolate radiance->reflectance. Generally a good option\n", + " if not trying to analyze the atmospheric state at fine scale resolution.\n", + " Mutually exclusive with analytical_line\n", + " analytical_line : bool, default=False\n", + " Use an analytical solution to the fixed atmospheric state to solve for each\n", + " pixel. Starts by running a full OE retrieval on each SLIC superpixel, then\n", + " interpolates the atmospheric state to each pixel, and closes with the\n", + " analytical solution.\n", + " Mutually exclusive with empirical_line\n", + " ray_temp_dir : str, default=\"/tmp/ray\"\n", + " Location of temporary directory for ray parallelization engine\n", + " emulator_base : str, default=None\n", + " Location of emulator base path. Point this at the model folder (or h5 file) of\n", + " sRTMnet to use the emulator instead of MODTRAN. An additional file with the\n", + " same basename and the extention _aux.npz must accompany\n", + " e.g. /path/to/emulator.h5 /path/to/emulator_aux.npz\n", + " segmentation_size : int, default=40\n", + " If empirical_line is enabled, sets the size of segments to construct\n", + " num_neighbors : list[int], default=[]\n", + " Forced number of neighbors for empirical line extrapolation - overides default\n", + " set from segmentation_size parameter\n", + " atm_sigma : list[int], default=[2]\n", + " A list of smoothing factors to use during the atmospheric interpolation, one\n", + " for each atmospheric parameter (or broadcast to all if only one is provided).\n", + " Only used with the analytical line.\n", + " pressure_elevation : bool, default=False\n", + " Flag to retrieve elevation\n", + " prebuilt_lut : str, default=None\n", + " Use this pre-constructed look up table for all retrievals. Must be an\n", + " ISOFIT-compatible RTE NetCDF\n", + " no_min_lut_spacing : bool, default=False\n", + " Don't allow the LUTConfig to remove a LUT dimension because of minimal spacing.\n", + " inversion_windows : list[float], default=None\n", + " Override the default inversion windows. Will supercede any sensor specific\n", + " defaults that are in place.\n", + " Must be in 2-item tuples\n", + " config_only : bool, default=False\n", + " Generates the configuration then exits before execution. If presolve is\n", + " enabled, that run will still occur.\n", + " interpolate_bad_rdn : bool, default=False\n", + " Flag to perform a per-pixel interpolation across no-data and NaN data bands.\n", + " Does not interpolate vectors that are entire no-data or NaN, only partial.\n", + " Currently only designed for wavelength interpolation on spectra.\n", + " Does NOT do any spatial interpolation\n", + " interpolate_inplace : bool, default=False\n", + " Flag to tell interpolation to work on the file in place, or generate a\n", + " new interpolated rdn file. The location of the new file will be in the\n", + " \"input\" directory within the working directory.\n", + "\n", + " References\n", + " ----------\n", + " D.R. Thompson, A. Braverman,P.G. Brodrick, A. Candela, N. Carbon, R.N. Clark,D. Connelly, R.O. Green, R.F.\n", + " Kokaly, L. Li, N. Mahowald, R.L. Miller, G.S. Okin, T.H.Painter, G.A. Swayze, M. Turmon, J. Susilouto, and\n", + " D.S. Wettergreen. Quantifying Uncertainty for Remote Spectroscopy of Surface Composition. Remote Sensing of\n", + " Environment, 2020. doi: https://doi.org/10.1016/j.rse.2020.111898.\n", + "\n", + " sRTMnet emulator:\n", + " P.G. Brodrick, D.R. Thompson, J.E. Fahlen, M.L. Eastwood, C.M. Sarture, S.R. Lundeen, W. Olson-Duvall,\n", + " N. Carmon, and R.O. Green. Generalized radiative transfer emulation for imaging spectroscopy reflectance\n", + " retrievals. Remote Sensing of Environment, 261:112476, 2021.doi: 10.1016/j.rse.2021.112476.\n", + "\n", + "Options:\n", + " -sp, --surface_path TEXT [required]\n", + " --copy_input_files\n", + " --modtran_path TEXT\n", + " --wavelength_path TEXT\n", + " --surface_category TEXT\n", + " --aerosol_climatology_path TEXT\n", + " --rdn_factors_path TEXT\n", + " --atmosphere_type TEXT\n", + " --channelized_uncertainty_path TEXT\n", + " --model_discrepancy_path TEXT\n", + " --lut_config_file TEXT\n", + " --multiple_restarts\n", + " --logging_level TEXT\n", + " --log_file TEXT\n", + " --n_cores INTEGER\n", + " --presolve\n", + " --empirical_line\n", + " --analytical_line\n", + " --ray_temp_dir TEXT\n", + " --emulator_base TEXT\n", + " --segmentation_size INTEGER\n", + " -nn, --num_neighbors INTEGER\n", + " -as, --atm_sigma FLOAT\n", + " --pressure_elevation\n", + " --prebuilt_lut TEXT\n", + " --no_min_lut_spacing\n", + " --inversion_windows FLOAT...\n", + " --config_only\n", + " --interpolate_bad_rdn\n", + " --interpolate_inplace\n", + " --debug-args Prints the arguments list without executing\n", + " the command\n", + " --profile TEXT\n", + " --help Show this message and exit.\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "id": "f1b4490f", + "metadata": {}, + "source": [ + "The Apply OE function can leverage a large number of input parameters, but most are optional. The important inputs are the non-optional arguments: \n", + "\n", + "`INPUT_RADIANCE` `INPUT_LOC` `INPUT_OBS` `WORKING_DIRECTORY` `SENSOR` and `--surface_path`.\n", + "\n", + "which must be entered in the specified order. Descriptions of each are found in the docstring printed above. It is important to note that the `INPUT_RADIANCE`, `INPUT_LOC`, and `INPUT_OBS` are ENVI raster data formats that must be at the same row-column dimensions. The `--surface_path` points Isofit torwards the constructed prior distribution file for surface reflectance. Optional arguments are denoted by the '--' in their name, e.g. `--modtran_path`, `--pressure_elevation`. The default radiative transfer engine (RTE) is currently set to Modtran. Most new users will use the sRTMnet emulator for which you must specify an `--emulator_path`." + ] + }, + { + "cell_type": "markdown", + "id": "8b199b77", + "metadata": {}, + "source": [ + "#### How do you run Apply OE?" + ] + }, + { + "cell_type": "markdown", + "id": "f6028b6c", + "metadata": {}, + "source": [ + "The script is run via the CLI. For example:" + ] + }, + { + "cell_type": "markdown", + "id": "b9867343", + "metadata": {}, + "source": [ + "```\n", + "isofit apply_oe \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010 \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010 \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010 \\\n", + " ~/.isofit/examples/image_cube/small \\\n", + " ang \\\n", + " --surface_path ~/.isofit/imagecube/small/data/surface.mat \\\n", + " --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \\\n", + " --n_cores 10 \\\n", + " --presolve \\\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "id": "31d41c48", + "metadata": {}, + "source": [ + "Here, \n", + "\n", + "```\n", + "~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010\n", + "~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010\n", + "~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010\n", + "```\n", + "\n", + "are the radiance, location, and observational geometry files respectively. The `\\` tells the CLI call to expect a multi-line input. The remaining two requried parameters are `ang`, the sensor designation (AVIRIS-NG), and the `--surface_path` pointing to the surface prior file at `~/.isofit/imagecube/small/data/surface.mat`.\n", + "\n", + "The remaining arguments set Apply OE to run with:\n", + "1) `--emulator_base` points isofit to the location of the sRTMnet emulator to use as the radiative transfer engine (RTE)\n", + "2) `--n_cores = 10` CPU cores\n", + "3) The `--presolve` algorithm to narrow down the water vapor retrievals, which leads to faster total processing time" + ] + }, + { + "cell_type": "markdown", + "id": "ac5b2463", + "metadata": {}, + "source": [ + "We can examine both the inputs and outputs of Apply OE with this run call:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b18118d1", + "metadata": {}, + "outputs": [], + "source": [ + "# Common imports\n", + "import os\n", + "from pathlib import Path\n", + "\n", + "from spectral import envi\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "\n", + "from isofit.core.common import envi_header" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5b8a685f", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the input files\n", + "rdn_path = Path('~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010')\n", + "loc_path = Path('~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010')\n", + "obs_path = Path('~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0f7ec5b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Band names in the location file:\n", + "Longitude (WGS-84)\n", + "Latitude (WGS-84)\n", + "Elevation (m)\n", + "\n", + "Band names in the observational geometry file:\n", + "Path length (m)\n", + "To-sensor azimuth (0 to 360 degrees cw from N)\n", + "To-sensor zenith (0 to 90 degrees from zenith)\n", + "To-sun azimuth (0 to 360 degrees cw from N)\n", + "To-sun zenith (0 to 90 degrees from zenith)\n", + "Solar phase\n", + "Slope\n", + "Aspect\n", + "Cosine(i)\n", + "UTC Time\n", + "Earth-sun distance (AU)\n" + ] + } + ], + "source": [ + "# Print the bands of the input files\n", + "print('Band names in the location file:')\n", + "[print(f\"{i}\") for i in loc.metadata['band names']]\n", + "\n", + "print()\n", + "print('Band names in the observational geometry file:')\n", + "temp = [print(f\"{i}\") for i in obs.metadata['band names']]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4ce97d24", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the input data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(13, 4))\n", + "plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))\n", + "plot = axs[1].imshow(loc_im[..., 0])\n", + "plot = axs[2].imshow(obs_im[..., 4])\n", + "\n", + "title = axs[0].set_title('Radiance (RGB)')\n", + "title = axs[1].set_title('Longitude (WGS-84)')\n", + "title = axs[2].set_title('Solar zenith angle (Deg)')" + ] + }, + { + "cell_type": "markdown", + "id": "e12b5307", + "metadata": {}, + "source": [ + "The input image doesn't look like much because this is just a 10x10 pixel example. However we see per-pixel spectral variation in the radiance RGB, and systematic variation in the location and geometric variables.\n", + "\n", + "Looking at the output data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65ce0e9f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of the _rfl file: (10, 10, 425)\n", + "Shape of the _state file: (10, 10, 427)\n", + "Shape of the _uncert file: (10, 10, 427)\n" + ] + } + ], + "source": [ + "# Load the output files\n", + "rfl_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_rfl')\n", + "state_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_state')\n", + "uncert_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_uncert')\n", + "\n", + "rfl = envi.open(envi_header(str(rfl_path.expanduser())))\n", + "state = envi.open(envi_header(str(state_path.expanduser())))\n", + "uncert = envi.open(envi_header(str(uncert_path.expanduser())))\n", + "\n", + "rfl_im = rfl.open_memmap(interleave='bip')\n", + "state_im = state.open_memmap(interleave='bip')\n", + "uncert_im = uncert.open_memmap(interleave='bip')\n", + "\n", + "print(f'Shape of the _rfl file: {rfl_im.shape}')\n", + "print(f'Shape of the _state file: {state_im.shape}')\n", + "print(f'Shape of the _uncert file: {uncert_im.shape}')" + ] + }, + { + "cell_type": "markdown", + "id": "7054b0ee", + "metadata": {}, + "source": [ + "The difference between the `_rfl` file and the `_state` file is that the `_rfl` file only contains the solutions for surface reflectance variables. Here, the AVIRIS-NG image contains 425 wavelength bands. As a result, the `_rfl` contains 425 bands. The `_state` and `_uncert` files contain the surface reflectance solutions and uncertainty calculated as the standard deviation of the posterior distributions for the 425 wavelength bands and for non-reflectance statevector elements; here, aerosol optical depth (AOD) and water vapor (H2O). " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a518609c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the output data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(8, 8))\n", + "axs = np.ravel(axs)\n", + "plot = axs[0].imshow(normalize(rfl_im[..., bands], 0, 0.3))\n", + "uncert = axs[1].imshow(uncert_im[..., 55])\n", + "aod = axs[2].imshow(state_im[..., -2])\n", + "h2o = axs[3].imshow(state_im[..., -1])\n", + "\n", + "plt.colorbar(uncert)\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "title = axs[0].set_title('Reflectance')\n", + "title = axs[1].set_title('Uncertainty (at 650 nm)')\n", + "title = axs[2].set_title('AOD')\n", + "title = axs[3].set_title('H2O')" + ] + }, + { + "cell_type": "markdown", + "id": "697e2986", + "metadata": {}, + "source": [ + "#### The Analytical Line" + ] + }, + { + "cell_type": "markdown", + "id": "58752472", + "metadata": {}, + "source": [ + "In the example above, we ran Isofit using the full optimal estimation (OE) on each pixel independently. Computationally, this amounts to iterating through each row-column pair to solve for the full state-vector (427 variables in the above case). However for large images, this demands long run-times, and ignores the principle that some state-vector elements, namely the atmospheric variables like AOD and H2O, should not vary from one pixel to the next, but rather should be spatially smooth, and only vary over multi-pixel length scales [Link to the relevent paper](https://www.sciencedirect.com/science/article/pii/S0034425723004534/).\n", + "\n", + "The analytical line and empirical line algorithms leverage the assumption of a spatially smooth atmosphere to decrease run times by a factor of 10. Currently, we suggest using the analytical line algorithm and not the empirical line algorithm." + ] + }, + { + "cell_type": "markdown", + "id": "ad1b9d10", + "metadata": {}, + "source": [ + "See the following CLI call to run Apply OE with the analytical line algorithm:\n", + "\n", + "```\n", + "isofit apply_oe \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k \\\n", + " ~/.isofit/imagecube/medium \\\n", + " ang \\\n", + " --surface_path ~/.isofit/imagecube/small/data/surface.mat \\\n", + " --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \\\n", + " --n_cores 10 \\\n", + " --presolve \\\n", + " --log_file ~/.isofit/imagecube/medium/log.txt \\\n", + " --analytical_line \\\n", + " --segmentation_size 50\n", + "```\n", + "\n", + "Most of the input parameters are identical to the per-pixel application above. However, we've added a `--log_file`, the `--analytical_line` flag, and a `--segmentation_size`. The `--log_file` points the program to write a text file to print logging statements during run time. The `--analytical_line` flag tells Isofit to use the analytical line algorithm. \n", + "\n", + "A simple overview for the anylitical line algorithm:\n", + "\n", + "1) All three input files are \"segmented\" into superpixel blocks using the SLIC algorithm. The `--segmentation_size` value sets the number of pixels that each superpixel contains.\n", + "\n", + "2) At the superpixel resolution, Isofit solves for the OE solutions, which provides both surface and atmospheric state variables. \n", + "\n", + "3) Atmospheric state variables are spatially interpolated to full image resolution. The spatial interpolation uses the Apply OE parameters `--num_neighbors` and `--atm_sigma`.\n", + "\n", + "4) With a fixed atmosphere, we leverage a closed form solution for surface state elements that allows for a solution convergence in a single iteration.\n", + "\n", + "We can visualize what the segmentation is doing by leveraging the `isofit reconstruct_subs` CLI command. \n", + "\n", + "Visualizing the input data:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5ce57697", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting the input data\n", + "rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')\n", + "loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')\n", + "obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')\n", + "\n", + "subs_rdn_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_rdn')\n", + "subs_loc_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_loc')\n", + "subs_obs_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_obs')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "subs_rdn = envi.open(envi_header(str(subs_rdn_path.expanduser())))\n", + "subs_loc = envi.open(envi_header(str(subs_loc_path.expanduser())))\n", + "subs_obs = envi.open(envi_header(str(subs_obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')\n", + "\n", + "subs_rdn_im = subs_rdn.open_memmap(interleave='bip')\n", + "subs_loc_im = subs_loc.open_memmap(interleave='bip')\n", + "subs_obs_im = subs_obs.open_memmap(interleave='bip')\n", + "\n", + "fig, axs = plt.subplots(2, 3, sharex=True, sharey=True, figsize=(5, 10))\n", + "axs = np.ravel(axs)\n", + "\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(loc[0:400, :, 0])\n", + "axs[2].imshow(obs[0:400, :, 4])\n", + "\n", + "axs[3].imshow(normalize(subs_rdn_im[0:400, :, bands], 0, 15))\n", + "axs[4].imshow(subs_loc[0:400, :, 0])\n", + "axs[5].imshow(subs_obs[0:400, :, 4])\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Longitude')\n", + "axs[2].set_title('Elevation')\n", + "\n", + "axs[0].set_ylabel('Full resolution')\n", + "axs[3].set_ylabel('Superpixel resolution')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7788d2ce", + "metadata": {}, + "source": [ + "We can examine the results from Apply OE after the OE solutions on the superpixels:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "abf4b8ee", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.12389879..1.5404001].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wl = np.array(rdn.metadata['wavelength']).astype(float)\n", + "\n", + "state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_recon_subs_state')\n", + "state = envi.open(envi_header(str(state_path.expanduser())))\n", + "state_im = state.open_memmap(interleave='bip')\n", + "\n", + "fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(normalize(state_im[0:400, :, bands], 0, 0.25))\n", + "aod = axs[2].imshow(state_im[0:400, :, -2])\n", + "h2o = axs[3].imshow(state_im[0:400, :, -1])\n", + "\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Reflectance')\n", + "axs[2].set_title('AOD')\n", + "axs[3].set_title('H2O')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "af4360b8", + "metadata": {}, + "source": [ + "Finally, we can examine the final results at the end of the anlaytical line algorithm:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50c92071", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.11736042..1.7135264].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rfl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_rfl')\n", + "atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')\n", + "\n", + "rfl = envi.open(envi_header(str(rfl_path.expanduser())))\n", + "atm = envi.open(envi_header(str(atm_path.expanduser())))\n", + "\n", + "rfl_im = rfl.open_memmap(interleave='bip')\n", + "atm_im = atm.open_memmap(interleave='bip')\n", + "\n", + "\n", + "fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(normalize(rfl_im[0:400, :, bands], 0, 0.25))\n", + "aod = axs[2].imshow(atm_im[0:400, :, -2])\n", + "h2o = axs[3].imshow(atm_im[0:400, :, -1])\n", + "\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Reflectance')\n", + "axs[2].set_title('AOD')\n", + "axs[3].set_title('H2O')\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/html/_sources/how_to_run/functions.ipynb.txt b/isofit-tutorials/build/html/_sources/how_to_run/functions.ipynb.txt new file mode 100644 index 0000000..167a6f0 --- /dev/null +++ b/isofit-tutorials/build/html/_sources/how_to_run/functions.ipynb.txt @@ -0,0 +1,733 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fe75c48b", + "metadata": {}, + "source": [ + "# Internal Functions" + ] + }, + { + "cell_type": "markdown", + "id": "f0f4eaf6", + "metadata": {}, + "source": [ + "When debugging issues or testing configurations, it may be advantagous to run Isofit in a more controlled manner than the end-to-end Apply OE pipeline. This notebook gives a quick introduction to the structure of Isofit and how it can be used more like a Python package.\n", + "\n", + "NOTE: Isofit is actively developed, so while we try to make sure that Apply OE is stable from a CLI standpoint, individual functions are subject to change." + ] + }, + { + "cell_type": "markdown", + "id": "eee6abd3", + "metadata": {}, + "source": [ + "We'll start with the medium example found at `~/.isofit/imagecube/medium`. First, run Apply OE on this example, or for more adept users, run Apply OE with the `--config_only` flag. The objective here, is to generate an Isofit config file at `~/.isofit/imagecube/small/config/ang20170323t202244_isofit.json`. This saves us the trouble of building the configuration file manually. We can edit the Apply OE generated configuration as needed." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "75064908", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "from pathlib import Path\n", + "from pprint import pprint\n", + "\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "from spectral import envi\n", + "\n", + "from isofit.core.common import envi_header\n", + "from isofit.core.isofit import Isofit\n", + "from isofit.configs import configs\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.radiative_transfer.radiative_transfer import RadiativeTransfer\n", + "from isofit.surface.surface import Surface\n", + "from isofit.core.instrument import Instrument\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.core.geometry import Geometry\n", + "from isofit.core.fileio import IO\n", + "from isofit.inversion.inverse_simple import (\n", + " invert_algebraic,\n", + " invert_analytical,\n", + " invert_simple,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "04d04288", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the input data\n", + "rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')\n", + "loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')\n", + "obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')\n", + "\n", + "wl = np.array(rdn.metadata['wavelength']).astype(float)" + ] + }, + { + "cell_type": "markdown", + "id": "fe59a430", + "metadata": {}, + "source": [ + "### ISOFIT Configs and Classes\n", + "\n", + "ISOFIT is built around object classes.\n", + "\n", + "For example, the `config` object contains the full Isofit config. This is constructed directly from the config `.json` file via the `configs.create_new_config` function. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2ac3ee92", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The config object:\n", + "\n", + "\n", + "Config attributes:\n", + "_input_type\n", + "input\n", + "_output_type\n", + "output\n", + "_forward_model_type\n", + "forward_model\n", + "_implementation_type\n", + "implementation\n", + "\n", + "Example:\n", + "Forward model type: \n", + "Forward model: \n", + "\n", + "Forward model:\n", + "{'_instrument_type': ,\n", + " '_model_discrepancy_file_type': ,\n", + " '_radiative_transfer_type': ,\n", + " '_surface_type': ,\n", + " 'instrument': ,\n", + " 'model_discrepancy_file': None,\n", + " 'radiative_transfer': ,\n", + " 'surface': }\n", + "\n", + "Surface model:\n", + "{'_emissivity_for_surface_T_init_type': ,\n", + " '_select_on_init_type': ,\n", + " '_selection_metric_type': ,\n", + " '_surface_T_prior_sigma_degK_type': ,\n", + " '_surface_category_type': ,\n", + " '_surface_file_type': ,\n", + " '_wavelength_file_type': ,\n", + " 'emissivity_for_surface_T_init': 0.98,\n", + " 'select_on_init': True,\n", + " 'selection_metric': 'Euclidean',\n", + " 'surface_T_prior_sigma_degK': 1.0,\n", + " 'surface_category': 'multicomponent_surface',\n", + " 'surface_file': '/Users/bgreenbe/.isofit/imagecube/medium/data/surface.mat',\n", + " 'wavelength_file': None}\n" + ] + } + ], + "source": [ + "# Initialize the config object\n", + "config_file = Path('~/.isofit/imagecube/medium/config/ang20170323t202244_isofit.json')\n", + "config = configs.create_new_config(str(config_file.expanduser()))\n", + "\n", + "print('The config object:')\n", + "print(config)\n", + "print()\n", + "\n", + "print('Config attributes:')\n", + "[print(key) for key in vars(config).keys()]\n", + "print()\n", + "\n", + "print('Example:')\n", + "print(f'Forward model type: {config._forward_model_type}')\n", + "print(f'Forward model: {config.forward_model}\\n')\n", + "\n", + "print('Forward model:')\n", + "pprint(vars(config.forward_model), width=100, compact=False)\n", + "print()\n", + "print('Surface model:')\n", + "pprint(vars(config.forward_model.surface), width=100, compact=False)" + ] + }, + { + "cell_type": "markdown", + "id": "b5957a17-e65a-41eb-93e8-0df0c9abf8b9", + "metadata": {}, + "source": [ + "The `ForwardModel` object contains the `Instrument`, `Radiative transfer` and `Surface` portions of the ISOFIT forward model. The three forward model components are object classes themselves, which contain the math and logic relevant to these features. For example, the `Instrument` portion holds functions for instrument uncertainty quantification and calibration, the `Radiative transfer` portion holds functions relevant for generating and sampling the radiative transfer lookup-tables (LUTs), and the `Surface` portion holds functions relevant to sampling surface priors and formulating surface-specific forward model elements.\n", + "\n", + "Note: if the LUT has not been generated at the expected location from the config, initializing the forward model class will immediately constructing the LUT at that location." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "daf7e8d6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The expected location of the LUT:\n", + "/Users/bgreenbe/.isofit/imagecube/medium/lut_full/lut.nc\n", + "\n", + "\n", + "\n", + "\n", + ">\n" + ] + } + ], + "source": [ + "print('The expected location of the LUT:')\n", + "print(config.forward_model.radiative_transfer.radiative_transfer_engines[0].lut_path)\n", + "print()\n", + "\n", + "# Initialized from the config:\n", + "fm = ForwardModel(config)\n", + "\n", + "# Print the three forward model components\n", + "print(fm.instrument)\n", + "print(fm.RT)\n", + "print(fm.surface)\n", + "\n", + "# Print an example method from RT\n", + "print(fm.RT.calc_rdn)" + ] + }, + { + "cell_type": "markdown", + "id": "ddb76898-3e1a-4f9f-8ef2-3e916f14255e", + "metadata": {}, + "source": [ + "and individual component classes can also be initialized from the `config` object:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "420af4de-8a64-4624-91e4-56320dd7808f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is\n" + ] + } + ], + "source": [ + "instrument = Instrument(config)\n", + "rt = RadiativeTransfer(config)\n", + "surface = Surface(config)" + ] + }, + { + "cell_type": "markdown", + "id": "4b46aef7-7150-4447-be06-df47456dac7c", + "metadata": {}, + "source": [ + "The optimal estimation inversion is handled by the Inversion class object." + ] + }, + { + "cell_type": "markdown", + "id": "3b7e324d-8ef6-4832-9b54-b09fc2458d04", + "metadata": {}, + "source": [ + "### OE Inversions" + ] + }, + { + "cell_type": "markdown", + "id": "2daca64c-2f56-4aea-97a5-bbafe760ecd5", + "metadata": {}, + "source": [ + "We will go into how to perform single pixel optimal estimation (OE) inversions from a set of input data and an ISOFIT config. To do this, we need to load in a radiance spectrum with paired observational geometry data. We'll pull this directly from the `rdn`, `obs`, and `loc` files we loaded above. \n", + "\n", + "OE inversions are run using the Inversion class:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "451f496a-a7dd-435a-b69a-660ff487ecc4", + "metadata": {}, + "outputs": [], + "source": [ + "iv = Inversion(config, fm)" + ] + }, + { + "cell_type": "markdown", + "id": "1ac96a7e-c0e1-4210-bc9a-7919158c8ca5", + "metadata": {}, + "source": [ + "Next, we'll select a pixel to run through the OE inversion." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "15ad55ab-481f-4cc9-8eac-d049bb46bbba", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.1813465].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Pick a pixel\n", + "row = 175\n", + "col = 50\n", + "\n", + "# Plot the input data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(8, 8))\n", + "plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))\n", + "plot = axs[1].imshow(loc_im[..., 0])\n", + "plot = axs[2].imshow(obs_im[..., 4])\n", + "\n", + "axs[0].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "axs[1].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "axs[2].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "\n", + "title = axs[0].set_title('Radiance (RGB)')\n", + "title = axs[1].set_title('Longitude (WGS-84)')\n", + "title = axs[2].set_title('Solar zenith angle (Deg)')" + ] + }, + { + "cell_type": "markdown", + "id": "a238060c-b133-4c0e-a4e7-52c41b435716", + "metadata": {}, + "source": [ + "Then we'll load in the measurement and observational data for that pixel. The geometry object holds all of the observational information for a given pixel." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "be82abde-7b34-4e5f-b456-be34a50d5dc3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "197.31315008280822\n", + "71.53144734704047\n", + "-0.3017277626279998\n" + ] + } + ], + "source": [ + "meas = rdn_im[row, col, :]\n", + "geom = Geometry(\n", + " obs=obs_im[row, col, :],\n", + " loc=loc_im[row, col, :],\n", + " esd=IO.load_esd(),\n", + " svf=1\n", + ")\n", + "\n", + "# e.g.\n", + "print(geom.solar_azimuth)\n", + "print(geom.observer_azimuth)\n", + "print(geom.cos_i)" + ] + }, + { + "cell_type": "markdown", + "id": "6adf64c4-b09c-4f83-ba3b-34bee40e616c", + "metadata": {}, + "source": [ + "and finally run the OE inversion via the inversions.invert function:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "dca42de9-475e-4cf7-a3cb-3e11c40d121e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of iterations to convergence: 9\n", + "Data type of 'oe': \n", + "Array shape: (9, 427)\n" + ] + } + ], + "source": [ + "oe = iv.invert(meas, geom)\n", + "\n", + "print(f\"Number of iterations to convergence: {len(oe)}\")\n", + "print(f\"Data type of 'oe': {type(oe)}\")\n", + "print(f\"Array shape: {oe.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "89d8779d-b82b-4077-ac35-ebd705327d95", + "metadata": {}, + "source": [ + "The `oe` variable is a numpy array where each row is a subsequent iteration of the OE procedure. It is often useful to examine how the solution changes during optimization, which can help debug potential issues with final statevector solutions.\n", + "\n", + "The plots below show the trajectory of the reflectance solution throughout the optimization. The earlier solutions are lighter colors while the later solutions are darker colors.\n", + "\n", + "The plots also show the prior mean selected for this specific pixel via the `surface.xa` function, which can be called directly using the initial guess of the reflectance solution and the pixel observation variables." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "0a20094c-daf1-422b-a326-b7329781b092", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a color map for the iterations\n", + "n = len(oe)\n", + "cmap_name = 'viridis_r'\n", + "cmap = plt.get_cmap(cmap_name)\n", + "colors = [cmap(i) for i in np.linspace(0, 1, n)]\n", + "\n", + "# Fit the prior mean\n", + "xa = fm.surface.xa(oe[0], geom)\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 4))\n", + "axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')\n", + "axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')\n", + "for i, sp in enumerate(oe):\n", + " axs[0].plot(wl, sp[:len(wl)], color=colors[i])\n", + " axs[1].plot(wl, sp[:len(wl)], color=colors[i])\n", + "\n", + "axs[0].plot(wl, oe[-1][:len(wl)], color='black', label='Final')\n", + "axs[1].plot(wl, oe[-1][:len(wl)], color='black')\n", + "\n", + "axs[0].set_ylabel('Reflectance')\n", + "axs[0].set_xlabel('Wavelength (nm)')\n", + "axs[1].set_ylabel('Reflectance')\n", + "axs[1].set_xlabel('Wavelength (nm)')\n", + "\n", + "axs[1].set_xlim([725, 1200])\n", + "axs[1].set_ylim([.1, .5])\n", + "\n", + "axs[0].set_title('Full spectrum')\n", + "axs[1].set_title('Highlighting 725 - 1200 nm')\n", + "\n", + "axs[0].legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "36d20b3b-f06f-4aba-a731-99284b089cb2", + "metadata": {}, + "source": [ + "We can also look at the trajectory of atmospheric statevector variables:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3f0bfd77-470b-4e5d-bce8-1289e17d3041", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, sharex=True, figsize=(10, 5))\n", + "iters = [i for i in range(len(oe))]\n", + "axs[0].set_title('AOT550')\n", + "axs[0].scatter(iters, oe[:, -2], edgecolor='black', facecolor='green', s=200)\n", + "axs[0].set_ylabel('AOT550')\n", + "\n", + "axs[1].set_title('H2O')\n", + "axs[1].scatter(iters, oe[:, -1], edgecolor='black', facecolor='green', s=200)\n", + "axs[1].set_ylabel('H2O')\n", + "\n", + "axs[0].set_xlabel('Iteration')\n", + "axs[1].set_xlabel('Iteration')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1f1cc68c-59aa-44d1-ae46-94291e97fc2a", + "metadata": {}, + "source": [ + "### Inversions with a constrained atmosphere\n", + "\n", + "Scene-scale processing generally leverages superpixel algorithms that simultaneously speed up processing and enforce a spatially smooth atmosphere. Here, we'll demonstrate the analytical line algorithm. The analytical line algorithm assumes there exists a closed form state-vector solution under the assumptions of 1) a fixed atmosphere, and 2) that the measurement can be modeled as a linear combination of state-vector elements. We can call the anlaytical line solution for a given pixel directly, albeit with slightly more set-up.\n", + "\n", + "First, we'll set up a wrapper function to call the analytical line inversion. In practice, the analytical inversion is sensitive to the initial guess (x0 below). We generally use the \"priorless\" solution for the state-vector elemnents for a given atmosphere via the `invert_algebraic` and `iv.fm.surface.fit_params` functions." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "21b0f415-f11f-4aa8-9a27-0381f4e1c40c", + "metadata": {}, + "outputs": [], + "source": [ + "def invert_aoe(iv, meas, geom, sub_state, x_RT, n=1):\n", + "\n", + " # This script sets up the initial guess for the inversion\n", + " x_surface, _, x_instrument = iv.fm.unpack(iv.fm.init.copy())\n", + " rfl_est, coeffs = invert_algebraic(\n", + " iv.fm.surface,\n", + " iv.fm.RT,\n", + " iv.fm.instrument,\n", + " x_surface,\n", + " x_RT,\n", + " x_instrument,\n", + " meas,\n", + " geom,\n", + " )\n", + "\n", + " rfl_est = iv.fm.surface.fit_params(rfl_est, geom)\n", + "\n", + " x0 = np.concatenate(\n", + " [\n", + " rfl_est,\n", + " x_RT,\n", + " x_instrument,\n", + " ]\n", + " )\n", + "\n", + " # This script is responsible for performing the inversion\n", + " states, unc, EXIT_CODE = invert_analytical(\n", + " iv.fm,\n", + " iv.winidx,\n", + " meas,\n", + " geom,\n", + " np.copy(x0),\n", + " sub_state,\n", + " n,\n", + " None,\n", + " None,\n", + " )\n", + "\n", + " return states[-1], unc, x0" + ] + }, + { + "cell_type": "markdown", + "id": "01255d4b-036b-4b34-a958-1d7b7d19de1a", + "metadata": {}, + "source": [ + "Next, we will pull the superpixel state solution and spatially smooth atmosphere for the selected pixel. \n", + "\n", + "Note: This assumes that these files already exist at the expected location." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "2a668a70-b4c0-4b9a-a286-253374dd3eae", + "metadata": {}, + "outputs": [], + "source": [ + "sub_state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_subs_state')\n", + "lbl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_lbl')\n", + "atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')\n", + "\n", + "sub_state = envi.open(envi_header(str(sub_state_path.expanduser())))\n", + "lbl = envi.open(envi_header(str(lbl_path.expanduser())))\n", + "atm = envi.open(envi_header(str(atm_path.expanduser())))\n", + "\n", + "sub_state_im = sub_state.open_memmap(interleave='bip')\n", + "lbl_im = lbl.open_memmap(interleave='bip')\n", + "atm_im = atm.open_memmap(interleave='bip')\n", + "\n", + "idx = int(lbl[row, col, 0])\n", + "sub_state = sub_state_im[idx, 0, :]\n", + "x_RT = atm_im[row, col, :]" + ] + }, + { + "cell_type": "markdown", + "id": "fbd02d3f-26ee-4953-a489-bc154f24a79d", + "metadata": {}, + "source": [ + "We can then call the wrapper function. Solutions are generally acceptible after one iteration, but `n` can be definted to explictely set the number of iterations to perform. " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e0a8370a-44af-491e-b2ff-6b11308940c1", + "metadata": {}, + "outputs": [], + "source": [ + "aoe, aoe_unc, x0 = invert_aoe(\n", + " iv, meas, geom, sub_state, x_RT, n=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "ee7eefc7-183b-4321-9abb-e90389c455e3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a color map for the iterations\n", + "n = len(oe)\n", + "cmap_name = 'viridis_r'\n", + "cmap = plt.get_cmap(cmap_name)\n", + "colors = [cmap(i) for i in np.linspace(0, 1, n)]\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", + "\n", + "axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')\n", + "axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')\n", + "\n", + "axs[0].plot(wl, aoe[:len(wl)], color='purple', lw=2, label='AOE')\n", + "axs[1].plot(wl, aoe[:len(wl)], color='purple', lw=2)\n", + "\n", + "axs[0].plot(wl, oe[-1][:len(wl)], color='green', label='OE')\n", + "axs[1].plot(wl, oe[-1][:len(wl)], color='green')\n", + "\n", + "axs[0].set_ylabel('Reflectance')\n", + "axs[0].set_xlabel('Wavelength (nm)')\n", + "axs[1].set_ylabel('Reflectance')\n", + "axs[1].set_xlabel('Wavelength (nm)')\n", + "\n", + "axs[1].set_xlim([725, 1200])\n", + "axs[1].set_ylim([.1, .5])\n", + "axs[0].set_ylim([-.1, .5])\n", + "\n", + "axs[0].set_title('Full spectrum')\n", + "axs[1].set_title('Highlighting 725 - 1200 nm')\n", + "\n", + "axs[0].legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "adfffc32-8ef7-47c6-818f-d03acae7c50e", + "metadata": {}, + "outputs": [], + "source": [ + "### Algebraic inversions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0e5bf2f-cf60-409e-8c48-1573cf572c08", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/html/_sources/index.rst.txt b/isofit-tutorials/build/html/_sources/index.rst.txt new file mode 100644 index 0000000..947094a --- /dev/null +++ b/isofit-tutorials/build/html/_sources/index.rst.txt @@ -0,0 +1,39 @@ +ISOFIT tutorials +================ + +This contains examples, tutorials and notebooks for the ISOFIt software. +Included here are: + +* A demonstration of how ISOFIT is run via the Apply Optimal Estimation (Apply OE) pipeline +* Examples for how ISOFIT can be run through function calls akin to a Python library +* Sensor-specific examples (NEON, EMIT, etc.) +* Information for how to contribute additional examples. + + +This is a companion to the `primary ISOFIT documentation `_ +and `source code `_. + + +Table of contents: +================== + +.. toctree:: + :Caption: Running Isofit + :maxdepth: 1 + + how_to_run/apply_oe.ipynb + how_to_run/functions.ipynb + +.. toctree:: + :caption: Sensor examples + :maxdepth: 1 + + sensor_examples/neon + +.. toctree:: + :Caption: Information + :maxdepth: 2 + + information/contribute.rst + information/code_of_conduct.rst + information/project_support.rst diff --git a/isofit-tutorials/build/html/_sources/information/code_of_conduct.rst.txt b/isofit-tutorials/build/html/_sources/information/code_of_conduct.rst.txt new file mode 100644 index 0000000..b9bb238 --- /dev/null +++ b/isofit-tutorials/build/html/_sources/information/code_of_conduct.rst.txt @@ -0,0 +1,70 @@ +Code of Conduct +=============== + +**Our Pledge** + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a positive experience for everyone. + +**Our Standards** + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming language +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members +* Scientific integrity and honesty, respecting the scientific method +* Crediting other's work where appropriate +* Striving towards, and sharing, new scientific knowledge to benefit humanity + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others’ private information, such as a physical or electronic address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a professional setting +* Misrepresenting or manufacturing experimental data or test results +* Failing to duly recognize the contributions of others in one's work + +**Our Responsibilities** + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +**Scope** + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +**Enforcement** + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at david.r.thompson@jpl.nasa.gov. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project’s leadership. + +**Attribution** + +This Code of Conduct is adapted from the Contributor Covenant, version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html diff --git a/isofit-tutorials/build/html/_sources/information/contribute.rst.txt b/isofit-tutorials/build/html/_sources/information/contribute.rst.txt new file mode 100644 index 0000000..a9a6373 --- /dev/null +++ b/isofit-tutorials/build/html/_sources/information/contribute.rst.txt @@ -0,0 +1,22 @@ +Contributing +============ + +We hope that these tutorials can be a community repository of software examples for +atmospheric and surface corrections using the ISOFIT software. If new functionality is added to the codebase, +it can be accompanied by notebook-style code examples. + +Examples of potential contributions include: + +* Tutorials for existing and new ISOFIT functionality +* Examples of ISOFIT running on various supported instruments + +Please feel free to draft notebooks, contact the maintainers, and open pull requests. +If you have have discovered an issue or desire a missing feature, please create a `new +issue `_. + +The primary ISOFIT documentation `describes in detail `_ how to begin contributing. + +We use `nbsphinx `_ to display jupyter notebook examples on the readthedocs page. Contributed examples can be written, and hosted simply as an .ipynb file. +Notebook codes are executed locally and jupyter cell outputs are saved as image hashes, which are then viewable on the static html page. + +The current notebook directory structure is subject to change as more examples are added. Place your example in the source folder under the most appropriate directory. We can always iterate through the PR process. diff --git a/isofit-tutorials/build/html/_sources/information/project_support.rst.txt b/isofit-tutorials/build/html/_sources/information/project_support.rst.txt new file mode 100644 index 0000000..bc8bb26 --- /dev/null +++ b/isofit-tutorials/build/html/_sources/information/project_support.rst.txt @@ -0,0 +1,21 @@ +Project Support +============ + +The ISOFIT codebase was made possible with support from various sources. +The initial algorithm and code was developed by the NASA Earth Science +Division data analysis program “Utilization of Airborne Visible/Infrared +Imaging Spectrometer Next Generation Data from an Airborne Campaign in +India," program NNH16ZDA001N-AVRSNG, managed by Woody Turner. + +Later research and maturation was provided by the Jet Propulsion Laboratory and +California Institute of Technology President and Director’s Fund, and the +Jet Propulsion Laboratory Research and Technology Development Program. +The project is currently supported by the Open Source Tools, Frameworks, +and Libraries Program (NNH20ZDA001N), managed by Dr. Steven Crawford. + +Neural network radiative transfer is supported by the NASA Center +Innovation Fund managed in conjunction with the Jet Propulsion Laboratory +Office of the Chief Scientist and Technologist. + +The initial research took place at the Jet Propulsion Laboratory, California Institute of Technology, +4800 Oak Grove Dr., Pasadena, CA 91109 USA. diff --git a/isofit-tutorials/build/html/_sources/sensor_examples/neon.ipynb.txt b/isofit-tutorials/build/html/_sources/sensor_examples/neon.ipynb.txt new file mode 100644 index 0000000..516534f --- /dev/null +++ b/isofit-tutorials/build/html/_sources/sensor_examples/neon.ipynb.txt @@ -0,0 +1,1610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "35412b86-171d-473c-8575-470b8fbed89d", + "metadata": {}, + "source": [ + "# NEON\n", + "\n", + "Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f81e3c4a-0bef-4cbe-a494-75c8e0d908ca", + "metadata": {}, + "source": [ + "## Full image example\n", + "\n", + "This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.\n", + "\n", + "Prerequisites:\n", + "- Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the 'data' folder which includes the 'subsets' directory.\n", + "- Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed8d9de0-a74a-4e6c-83b2-54f7bc32f593", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "from pathlib import Path\n", + "from types import SimpleNamespace\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "from spectral.io import envi\n", + "\n", + "import isofit\n", + "from isofit.utils.apply_oe import apply_oe \n", + "from isofit.utils.surface_model import surface_model\n", + "from isofit import ray\n", + "ray.shutdown()\n" + ] + }, + { + "cell_type": "markdown", + "id": "164060bf-3cad-4d58-811f-838158d7d967", + "metadata": {}, + "source": [ + "### Setup\n", + "\n", + "ISOFIT needs at minimum three pieces as input:\n", + "\n", + " 1. Radiance measurements (rdn)\n", + " 2. Observation values (obs)\n", + " 3. Location information (loc)\n", + "\n", + "This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can 'fake' the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:\n", + "\n", + "```\n", + "Radiance\n", + "├── 173647\n", + "│ ├── NIS01_20210403_173647_obs_ort\n", + "│ ├── NIS01_20210403_173647_obs_ort.hdr\n", + "│ ├── NIS01_20210403_173647_rdn_ort\n", + "│ └── NIS01_20210403_173647_rdn_ort.hdr\n", + "└── 174150\n", + " ├── NIS01_20210403_174150_obs_ort\n", + " ├── NIS01_20210403_174150_obs_ort.hdr\n", + " ├── NIS01_20210403_174150_rdn_ort\n", + " └── NIS01_20210403_174150_rdn_ort.hdr\n", + "```\n", + "\n", + "These files have corresponding in situ data as well, and below we've encoded the locations of each, which we can use to help subset data files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7b88339c-ac36-4aab-98b7-2a1dd07ab8a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data subset directory at: /Users/bgreenbe/.isofit/neon_subset\n", + "Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json\n", + "sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5\n", + "6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs\n" + ] + } + ], + "source": [ + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "\n", + "# Path to the input NEON data\n", + "subset_dir = str(Path('~/.isofit/neon_subset').expanduser())\n", + "print(f'Data subset directory at: {subset_dir}')\n", + "\n", + "# Path to write isofit output\n", + "output = str(Path('~/.isofit/neon_subset/output').expanduser())\n", + "if os.path.isdir(output) is False:\n", + " os.mkdir(output)\n", + "\n", + "if os.path.isdir(subset_dir) is False:\n", + " os.mkdir(subset_dir)\n", + "\n", + "surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())\n", + "print(f'Surface model at: {surface_model_path}')\n", + "neon_id = '173647'\n", + "\n", + "\n", + "# Optionally set some environment variables as needed\n", + "#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'\n", + "#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'\n", + "\n", + "print(f'sRTMnet emulator path (required): {os.environ[\"EMULATOR_PATH\"]}')\n", + "print(f'6s path (required): {os.environ[\"SIXS_DIR\"]}')\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "727dcd06-2a38-4020-8a15-b6707b8ed453", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a5656147-509e-41f4-9cac-c9b81117c5b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Which NEON date to process - change this to process a different date\n", + "neon_id = list(report.keys())[0]\n", + "\n", + "# Select the locations from the neon id -- roi == Regions of Interest\n", + "roi = report[neon_id]" + ] + }, + { + "cell_type": "markdown", + "id": "e9ec9046-3c9d-47bf-914c-68e67424065f", + "metadata": {}, + "source": [ + "#### Loc file generation\n", + "\n", + "NEON doesn't distribute (?) a loc file, so let's fake one for now. We'll do this for the full file and for the subset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5b51ea6-f2ba-4348-9ec9-4a3eadd6c1c0", + "metadata": {}, + "outputs": [], + "source": [ + "def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):\n", + " \"\"\"\n", + " Retrieves the metadata from an envi header\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']\n", + " Removes keys from the metadata dictionary\n", + " \"\"\"\n", + " rdn_ds = envi.open(file)\n", + " metadata = rdn_ds.metadata.copy()\n", + " for key in remove:\n", + " if key in metadata:\n", + " del metadata[key]\n", + " else:\n", + " print(f'Key {key!r} not found in the metadata, skipping')\n", + "\n", + " return metadata\n", + "\n", + "def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake LOC file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " lon: float\n", + " Longitude value for location\n", + " lat: float\n", + " Latitude value for location\n", + " elv: float\n", + " Elevation in kilometers\n", + " output: str, default=None\n", + " Path to write the LOC file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `loc`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " Logger.error('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 3\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " loc = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " loc[..., 0] = lon\n", + " loc[..., 1] = lat\n", + " loc[..., 2] = elv\n", + "\n", + " del ds, loc\n", + "\n", + "def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake OBS file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN file containing metadata\n", + " param0: int, float, default=0\n", + " Parameter 0\n", + " sea: int, float, default=0\n", + " Solar Azimuth\n", + " sez: int, float, default=0\n", + " Sensor Zenith\n", + " soa: int, float, default=0\n", + " Solar Azimuth\n", + " soz: int, float, default=0\n", + " Solar Zenith\n", + " phase: int, float, default=0\n", + " Phase\n", + " slope: int, float, default=0\n", + " Slope\n", + " aspect: int, float, default=0\n", + " Aspect\n", + " cosi: int, float, default=0\n", + " COS(i)\n", + " param9: int, float, default=0\n", + " Parameter 9\n", + " param10: int, float, default=0\n", + " Parameter 10\n", + " output: str, default=None\n", + " Path to write the OBS file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `obs`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " print('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " rdn_ds = envi.open(rdn)\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 11\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " obs = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " obs[..., 0] = param0\n", + " obs[..., 1] = sea\n", + " obs[..., 2] = sez\n", + " obs[..., 3] = soa\n", + " obs[..., 4] = soz\n", + " obs[..., 5] = phase\n", + " obs[..., 6] = slope\n", + " obs[..., 7] = aspect\n", + " obs[..., 8] = cosi\n", + " obs[..., 9] = param9\n", + " obs[..., 10] = param10\n", + "\n", + " del ds, obs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bac7ba6b-1c0e-41b7-97e0-d9e137a9e217", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key 'band names' not found in the metadata, skipping\n" + ] + } + ], + "source": [ + "fakeLOC(\n", + " rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),\n", + " lon = -105.237000,\n", + " lat = 40.125000,\n", + " elv = 1689.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "83bf8ace-3e19-4674-86df-d2f46e220a32", + "metadata": {}, + "source": [ + "#### Apply OE\n", + "\n", + "The next part walks through running the ISOFIT utility script `isofit/utils/apply_oe.py`. This is the first step of executing ISOFIT and will generate a default configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d0ec94f8-b1e7-4e4d-9b8f-450134ca5a83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n" + ] + } + ], + "source": [ + "output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "surface_model(**{\n", + " 'config_path': surface_model_path,\n", + " 'output_path': output_surface_file,\n", + " 'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3cbe6f39-6d6f-4182-abfb-30e95ce49ede", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns\n", + "WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...\n", + "2025-07-08 15:20:10,698\tINFO worker.py:1917 -- Started a local Ray instance.\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn\n", + "2025-07-08 15:20:11,728\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: completing\n", + "2025-07-08 15:20:11,781\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc\n", + "2025-07-08 15:20:11,825\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2 0.84 1.49 2.13 2.77 3.42 4.06 4.7 5.35 5.99]\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.\n", + "INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess\n", + "INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "2025-07-08 15:20:11,882\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:20:19.280425-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete\u001b[32m [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11\u001b[32m [repeated 7x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17160)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete. 34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded. Aerosol State Vector:\n", + "{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}\n", + "Aerosol LUT Grid:\n", + "{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}\n", + "Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt\n", + "INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT\n", + "INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "2025-07-08 15:20:53,541\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:20:59 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)\n", + "INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:03 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)\n", + "INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:08 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)\n", + "INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:13 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)\n", + "INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:17 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)\n", + "INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:21 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)\n", + "INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:27 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)\n", + "INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:31 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)\n", + "INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:35 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)\n", + "INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:21:43 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\", file_line:1171, created_time:\"2025-07-08T15:21:46.660474-07:00\", http2_error:2, grpc_status:14}\n", + "I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:21:46.660733-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:21:47 ||| \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (32,0).\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:21:52 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (27,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:21:58 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (55,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:03 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (61,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:08 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (99,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:13 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (105,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:18 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (166,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:23 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (193,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:28 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (210,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:33 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (230,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:39 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (269,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:44 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (275,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:49 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (303,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:55 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (320,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:00 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (376,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:05 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (383,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:10 ||| \u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (412,0).\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete. 91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core\n", + "INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference\n", + "INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:16 ||| \u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (419,0).\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n", + "2025-07-08 15:23:17,031\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores\n", + "INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete. 1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core\n", + "2025-07-08 15:23:18,445\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete. 51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core\n", + "INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.\n", + "\u001b[36m(Worker pid=17657)\u001b[0m INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:24:10.613957-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n" + ] + } + ], + "source": [ + "kwargs = {\n", + " 'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance\n", + " 'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location\n", + " 'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations\n", + " 'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory\n", + " 'sensor': 'neon', \n", + " \"surface_path\": output_surface_file, # Surface priors - often changes\n", + " 'emulator_base': os.environ['EMULATOR_PATH'],\n", + " 'n_cores': 4,\n", + " \"wavelength_path\": None,\n", + " \"surface_category\": \"multicomponent_surface\",\n", + " \"rdn_factors_path\": None, # RCC update used 'on the fly'\n", + " \"channelized_uncertainty_path\": None, # Channelized uncertainty - if you have an instrument model\n", + " \"model_discrepancy_path\": None, # Model discrepancy term - handle things like unknown radiative transfer model effects\n", + " \"lut_config_file\": None,\n", + " \"logging_level\": \"INFO\",\n", + " \"log_file\": None,\n", + " \"presolve\": True, # Attempts to solve for the right wv range\n", + " \"analytical_line\": True, # mathematical representation of OE given that the atmsophere is known\n", + " \"ray_temp_dir\": \"/tmp/ray\",\n", + " \"segmentation_size\": 10,\n", + " \"num_neighbors\": [5],\n", + " \"atm_sigma\": [0.5],\n", + " \"pressure_elevation\": False,\n", + "}\n", + "\n", + "apply_oe(**kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9d31291a-c036-4288-9114-cd772dda6748", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhx9JREFUeJzt3XlYVNUfx/H3gCxKirugoqK57+GG+5IolZppmgtqufzMJcnSXHOpXFNxSS03tMWw1DQ1FXMXXAOztHJNM0hxAVEBhfv74zIjwyYDw8wd+b6eZx5g5s6dM3MPnA/nnnuOTlEUBSGEEEIIDbOzdgGEEEIIIZ5GAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNC+ftQtgLklJSfz7778ULFgQnU5n7eIIIYQQIgsUReHevXuULl0aO7uM+1GemcDy77//4uHhYe1iCCGEECIbrl27RtmyZTN8/JkJLAULFgTUN1yoUCErl0YIIYQQWRETE4OHh4ehHc9ItgLL0qVLmTt3LhEREdSsWZOAgABatGjx1OcdOXKEVq1aUatWLcLDw40e27hxI5MnT+bixYtUqlSJTz75hK5du2a5TPrTQIUKFZLAIoQQQtiYpw3nMHnQbVBQEP7+/kycOJGwsDBatGiBr68vV69ezfR50dHR9OvXj3bt2qV5LDQ0lJ49e+Ln58fp06fx8/OjR48eHDt2zNTiCSGEEOIZpDN1tebGjRvzwgsvsGzZMsN91atX59VXX2XmzJkZPu+NN96gcuXK2Nvb88MPPxj1sPTs2ZOYmBh++uknw30dO3akSJEirF+/PkvliomJwdXVlejoaOlhEUIIIWxEVttvk3pYEhISOHXqFD4+Pkb3+/j4EBISkuHz1qxZw8WLF5kyZUq6j4eGhqbZZ4cOHTLdpxBCCCHyDpPGsERFRZGYmEipUqWM7i9VqhSRkZHpPuf8+fOMGzeOQ4cOkS9f+i8XGRlp0j4B4uPjiY+PN/wcExPz1PInJiby6NGjp24nRHbZ29uTL18+ubReCCHMLFuDblP/MVYUJd0/0ImJifTu3Ztp06ZRpUoVs+xTb+bMmUybNi3LZY6NjeWff/7BxDNgQpisQIECuLu74+joaO2iCCHEM8OkwFK8eHHs7e3T9HzcuHEjTQ8JwL179zh58iRhYWGMGDECUCd4UxSFfPnysXv3btq2bYubm1uW96k3fvx4Ro8ebfhZf1lUehITE/nnn38oUKAAJUqUkP9+Ra5QFIWEhARu3rzJ5cuXqVy5cqaTIAkhhMg6kwKLo6MjXl5eBAcHG11yHBwcTJcuXdJsX6hQIc6cOWN039KlS9m7dy/ff/89np6eAHh7exMcHMy7775r2G737t00bdo0w7I4OTnh5OSUpXI/evQIRVEoUaIE+fPnz9JzhMiO/Pnz4+DgwN9//01CQgLOzs7WLpIQQjwTTD4lNHr0aPz8/GjQoAHe3t588cUXXL16laFDhwJqz8f169dZt24ddnZ21KpVy+j5JUuWxNnZ2ej+UaNG0bJlS2bPnk2XLl3YsmULe/bs4fDhwzl8e8akZ0VYgvSqCCGE+ZkcWHr27MmtW7eYPn06ERER1KpVix07dlC+fHkAIiIinjonS2pNmzbl22+/ZdKkSUyePJlKlSoRFBRE48aNTS2eEEIIIZ5BJs/DolWZXccdFxfH5cuX8fT0lC56keukvgkhRNblyjws4tlUoUIFAgICrF0Ms7py5Qo6nS7NEhBCCCFskwQWDRswYACvvvpqjvZx//59PvjgAypWrIizszMlSpSgdevWbNu2zbDNiRMnGDJkiOFnnU7HDz/8kKPXBdi/fz86nc5wK1asGG3btuXIkSM53rep9AEmvdvRo0f5448/0Ol0aZaDaNy4MU5OTjx48MBwX0JCAgUKFOCLL76w9NsQQog865lZrVmkb+jQoRw/fpwlS5ZQo0YNbt26RUhICLdu3TJsU6JEiVwtw59//kmhQoW4efMmH3/8MS+//DJ//fUXJUuWzNXXTc+ePXuoWbOm0X3FihXDwcEBd3d39u3bZxg7FRsbS1hYGKVKlSIkJIQXX3wRgGPHjvHw4UPatGlj8fLbqq+//pqiRYvi6+tr7aIIIWxU3uxhURS4f986txwMGWrdujXvvPMOY8eOpWjRori5uTF16tRMn/Pjjz8yYcIEXnrpJSpUqICXlxcjR46kf//+hm1SnhKqUKECAF27dkWn0xl+Tq+3x9/fn9atWz+13CVLlsTNzY3atWszadIkoqOjjXoyDhw4QKNGjXBycsLd3Z1x48bx+PFjw+M7d+6kefPmFC5cmGLFivHKK69w8eJFo9c4fvw49evXx9nZmQYNGhAWFpZuWYoVK4abm5vRzcHBAVA/3/379xu2PXToEFWqVKFz585G9+/fv58yZcpQuXLlp753AZcvX6Zv37689NJL1i6KEMKG5c3A8uABPPecdW4pTi1kx9q1a3FxceHYsWPMmTOH6dOnExwcnOH2bm5u7Nixg3v37mVp/ydOnADU9Z8iIiIMP5vDgwcPWLNmDYAhJFy/fp2XXnqJhg0bcvr0aZYtW8aqVav4+OOPDc+7f/8+o0eP5sSJE/z888/Y2dnRtWtXkpKSDI+/8sorVK1alVOnTjF16lTef/99k8vXpk0bDh8+bAhL+/bto3Xr1rRq1Yp9+/YZttu3b5/0rpjg33//NWn7Xbt20bhxY3777bdcKpEQwhbJKSEbU6dOHcMikpUrV2bJkiX8/PPPtG/fPt3tv/jiC/r06UOxYsWoW7cuzZs3p3v37jRr1izd7fWnhwoXLoybm5tZyly2bFlADSyKouDl5UW7du0AdSJBDw8PlixZgk6no1q1avz777988MEHfPjhh9jZ2dGtWzej/a1atYqSJUty9uxZatWqxddff01iYiKrV6+mQIEC1KxZk3/++Ye33347TVmaNm2aZp6U6Oho7O3tad26Nffv3+fEiRN4e3uzf/9+xowZQ8uWLfHz8+PBgwfky5ePo0ePsmTJErN8NnmBqet3dezYEYAuXbqk6UkTQuRdeTOwFCgAsbHWe+0cqFOnjtHP7u7u3LhxI8PtW7ZsyaVLlzh69ChHjhxh7969LFy4kGnTpjF58uQclSWrDh06hIuLC2FhYXzwwQcEBgYaeljOnTuHt7e30aR+zZo1M6z9VK5cOS5evMjkyZM5evQoUVFRhp6Vq1evUqtWLc6dO0fdunUpkOKz9fb2TrcsQUFBVK9e3eg+e3t7QA2AZcuWZf/+/dSsWZOwsDBatWpFyZIl8fT05MiRIzg5OfHw4UPatm1r1s/oWZbdBUcjIiLMXBIhhC3Lm4FFpwMXF2uXIlv0Db2eTqczNOCZPadFixa0aNGCcePG8fHHHzN9+nQ++OCDLC/QZ2dnl2bhyKw2RJ6enhQuXJgqVaoQFxdH165d+e2333Byckp3kUv96+jv79SpEx4eHqxYsYLSpUuTlJRErVq1SEhIMNo+Kzw8PHj++eczfLx169bs27ePOnXqULlyZcPAYP1pIScnJ8qXL28Y2yOeLuV4JFPIyupCiJTy5hiWPK5GjRo8fvyYuLi4dB93cHAgMTHR6L4SJUqk+Y83O3Oc+Pn5kZSUxNKlSw1lCQkJMQodISEhFCxYkDJlynDr1i3OnTvHpEmTaNeuHdWrV+fOnTtp3s/p06d5+PCh4b6jR4+aXDZQx7GEhIQQHBxsNKC4VatW7N+/n/3790vviomyG1iy+zwhxLNJAsszrnXr1nz++eecOnWKK1eusGPHDiZMmECbNm0ynFGwQoUK/Pzzz0RGRhrCQdu2bTl58iTr1q3j/PnzTJkyJVuDIu3s7PD392fWrFk8ePCAYcOGce3aNUaOHMkff/zBli1bmDJlCqNHj8bOzo4iRYpQrFgxvvjiCy5cuMDevXuNVukG6N27N3Z2dgwcOJCzZ8+yY8cOPv3003Rf/9atW0RGRhrdUga3Nm3acP/+fVavXk2rVq0M97dq1YqTJ09y9OhRGXBrIgkeQghzkMDyjOvQoQNr167Fx8eH6tWrM3LkSDp06MCGDRsyfM68efMIDg7Gw8OD+vXrG/YzefJkxo4dS8OGDbl37x79+vXLVpneeustHj16xJIlSyhTpgw7duzg+PHj1K1bl6FDhzJw4EAmTZoEqAHn22+/5dSpU9SqVYt3332XuXPnGu3vueee48cff+Ts2bPUr1+fiRMnMnv27HRf+8UXX8Td3d3olnKSPE9PT8qXL8+9e/eMAkuZMmUoV64ccXFxElhMJKd2hBDmIGsJCWFmUt+MffPNN/Tp0wfI2nijlGOanpE/T0KITMhaQkIITUh5SkgCiBAiuySwCCFyVcpTQhJYhBDZJYFFCJGrpIdFCGEOEliEELnK1EG3qeflEUIIkMAihMhlpvawZHUyQyFE3iKBRQiRqySwCCHMQQKLECJXSWARQpiDBBYhRK6SwCKEMAcJLEKTBgwYwKuvvmrtYggzMHXQrZOTUy6VRAhhyySwaNiAAQPQ6XTodDry5ctHuXLlePvtt9Ms/peZK1euoNPpsrVQYevWrQ2v7+joSKVKlRg/fjzx8fEm7yunUn4WKW8dO3YE4I033sDX19foOT/99BM6nY7Jkycb3f/RRx9RunRpi5U9rzO1hyX1iuRCCAGQz9oFEJnr2LEja9as4fHjx5w9e5a33nqLu3fvsn79eou8/uDBg5k+fToJCQmcOHGCN998E4CZM2da5PVT0n8WKen/G2/Tpg3vv/8+jx8/Jl8+tVrv378fDw8P9u3bZ/Sc/fv3y3pAFmTqxHFySkgIkR7pYdE4Jycn3NzcKFu2LD4+PvTs2ZPdu3cbbbNmzRqqV6+Os7Mz1apVY+nSpYbHPD09Aahfvz46nY7WrVub9PoFChTAzc2NcuXK0a1bN9q3b2/0+vHx8bzzzjuULFkSZ2dnmjdvzokTJwyPJyYmMnDgQDw9PcmfPz9Vq1Zl4cKFRq+RmJjI6NGjKVy4MMWKFWPs2LHpNmz6zyLlrUiRIoAaWGJjYzl58qRh+/379zNu3DhOnDjBgwcPAEhISCA0NFQCiwXJGBYhhDnkyR4WRVEMDZilFShQINsTY126dImdO3cadZmvWLGCKVOmsGTJEurXr09YWBiDBw/GxcWF/v37c/z4cRo1asSePXuoWbNmjhqD06dPc+TIESpUqGC4b+zYsWzcuJG1a9dSvnx55syZQ4cOHbhw4QJFixYlKSmJsmXLsmHDBooXL05ISAhDhgzB3d2dHj16AOrq0KtXr2bVqlXUqFGDefPmsXnzZtq2bZvlslWpUoXSpUuzb98+mjRpwr179/jll1/Ytm0bS5Ys4ciRI7Rv356jR4/y8OFDCSwWJIFFCGEWyjMiOjpaAZTo6Og0jz18+FA5e/as8vDhQ0VRFCU2NlYBrHKLjY3N8nvq37+/Ym9vr7i4uCjOzs6GfcyfP9+wjYeHh/LNN98YPe+jjz5SvL29FUVRlMuXLyuAEhYWZvJn2qpVK8XBwUFxcXFRHB0dFUCxs7NTvv/+e8Pn6ODgoHz99deG5yQkJCilS5dW5syZk+F+hw0bpnTr1s3ws7u7uzJr1izDz48ePVLKli2rdOnSJd3PIuVt+vTphm169+6t+Pj4KIqiKNu3b1dq1KihKIqiDB06VJkwYYKiKIoybdo0xcPDw+TPwhSp61teN3ToUJPqf8uWLQ3bP3782AIlFEJYU2btd0p5sofFlrRp04Zly5bx4MEDVq5cyV9//cXIkSMBuHnzJteuXWPgwIEMHjzY8JzHjx/j6upqltfv06cPEydOJCYmhtmzZ1OoUCG6desGwMWLF3n06BHNmjUzbO/g4ECjRo04d+6c4b7ly5ezcuVK/v77bx4+fEhCQgL16tUDIDo6moiICLy9vQ3b58uXjwYNGqT5b1z/WaRUtGhRo8f9/f159OgR+/fvN5z+atWqFYsXLwbU00Sm9NyInMtJD0t8fDwFChTIlXIJIWxLngwsBQoUIDY21mqvbQoXFxeef/55ABYtWkSbNm2YNm0aH330EUlJSYB6Wqhx48ZGz7O3tzdLeV1dXQ2v/9VXX1GzZk1WrVrFwIEDDY1P6lNciqIY7tuwYQPvvvsu8+bNw9vbm4IFCzJ37lyOHTtmcllSfhbpadOmDffv3+fEiRPs27ePMWPGAGpg6devH7dv3yY0NJT+/fub/Noi+ySwCCHMIU8GFp1Oh4uLi7WLkS1TpkzB19eXt99+m9KlS1OmTBkuXbpEnz590t1e/8c/MTExx6/t4ODAhAkTGD9+PL169eL555/H0dGRw4cP07t3b0C9IuTkyZP4+/sDcOjQIZo2bcqwYcMM+7l48aLhe1dXV9zd3Tl69CgtW7YE1Abu1KlTvPDCCyaVr1KlSnh4eLB161bCw8Np1aoVAO7u7lSoUIF58+YRFxcn41cszNTAkjJsW+MSeiGENslVQjamdevW1KxZkxkzZgAwdepUZs6cycKFC/nrr784c+YMa9asYf78+QCULFmS/Pnzs3PnTv777z+io6MB2Lx5M9WqVTP59Xv37o1Op2Pp0qW4uLjw9ttvM2bMGHbu3MnZs2cZPHgwDx48YODAgQA8//zznDx5kl27dvHXX38xefJko6uIAEaNGsWsWbPYvHkzf/zxB8OGDePu3btpXjs+Pp7IyEijW1RUlNE2bdq0YenSpTz//POUKlXKcL/+tFDFihUpV66cye9bZJ+pgSUlCSwiyx48ADP8Yya0SwKLDRo9ejQrVqzg2rVrDBo0iJUrVxIYGEjt2rVp1aoVgYGBhsuZ8+XLx6JFi/j8888pXbo0Xbp0AdSxI3/++afJr+3o6MiIESOYM2cOsbGxzJo1i27duuHn58cLL7zAhQsX2LVrl+Fy46FDh/Laa6/Rs2dPGjduzK1bt4x6WwDee+89+vXrx4ABAwynjbp27ZrmtXfu3Im7u7vRrXnz5kbbtGnThnv37qW5fLtVq1bcu3dPeleswNSZblOGGgksIkO//w5Ll4KvL5QoAS4u4OEBAwbA/v3WLp3IBTrF1H95NComJgZXV1eio6MpVKiQ0WNxcXFcvnwZT09PnJ2drVRCkVdIfTPWpUsXtm7dCsCdO3coXLhwptu/8sorbN++HYBff/2V2rVr53YRha1ISoJt22D2bAgJyXzb114Db2+4dQtu34bISDh/Hnx8YMoUSP6nSlhfZu13StnqYVm6dKnhj7GXlxeHDh3KcNvDhw/TrFkzihUrRv78+alWrRoLFiww2iYwMDDdadfj4uKyUzwhhIaYekpIelhEGvHxsHo11KwJXbqoYcXODlq1gvHj4auvYNcuCAqCPn3UxzZtgjFjYNYs+OIL2LoVzp2DhQuhQgX46SdrvythIpMH3QYFBeHv78/SpUtp1qwZn3/+Ob6+vpw9ezbdsQEuLi6MGDGCOnXq4OLiwuHDh/nf//6Hi4sLQ4YMMWxXqFChNKco5L9TIWxfTgJLQkJCrpRJ2IizZ+Gtt+DECbV3BcDVFd5+G955B9zd0z6nRw/44AOYPx+uX1fve+45qFEDnJxg+XL491/o3h1CQ6FOHcu9H5EjJgeW+fPnM3DgQAYNGgRAQEAAu3btYtmyZemuL1O/fn3q169v+LlChQps2rSJQ4cOGQUWnU6Hm5tbdt6DEELDZNCtyJbjx+Hll0E/sL5MGXj3XRg8GDI5bQBA7dqQat0xg3Hj1P0GB6vf79hh3nKLXGPSKaGEhAROnTqFj4+P0f0+Pj6EPO18YrKwsDBCQkIMl5zqxcbGUr58ecqWLcsrr7xCWFhYpvuJj48nJibG6CaE0B4ZdCtMNn++Ov4kKgq8vODAAbh0Cd577+lh5WkcHGDZMrC3V08LhYaap8wi15kUWKKiokhMTDS6XBSgVKlSREZGZvrcsmXL4uTkRIMGDRg+fLihhwagWrVqBAYGsnXrVtavX4+zszPNmjXj/PnzGe5v5syZuLq6Gm4eHh6mvBUhhIXIGBZhkm3b1GCSlAQvvQQ//wwtW4I515iqVEm9mgjUAbjCJmRr0G1mM5tm5NChQ5w8eZLly5cTEBDA+vXrDY81adKEvn37UrduXVq0aMGGDRuoUqWKYTr19IwfP57o6GjD7dq1a08t9zNyQZTQOKlnxiSwWEBSEty8qQ4qvXEDbLUOLlkCnTur3w8fDtu3q2NWcsOkSWpvS3AwZGPmbWF5Jo1hKV68OPb29ml6U27cuJGm1yU1/bwgtWvX5r///mPq1Kn06tUr3W3t7Oxo2LBhpj0sTk5OODk5Zanc+pkzExISyJ8/f5aeI0R26VcCT7mqdl6W8pSQBJZsio+HX3+FP/5QB4xev65+1X8fEQEpT73VqAEzZz5p/G3BP/+oV/UoitqzMmdO7r5ehQrqFUWBgfDpp/Ddd7n7eiLHTAosjo6OeHl5ERwcbDSxV3BwsGFCsqxQFCXTP0SKohAeHm62+Rfy5ctHgQIFuHnzJg4ODtjZyXx5wvwUReHBgwfcuHGDwoULm209J1uX8kofGXSbjocP4b//1HlC/vvP+PvISLh6VQ0rWbliqlAhiIlRr67p0gXmzYPRo3P/PZjDhx9CXBw0b66eFnpKr71ZvP++Glg2bYKLF9VTRUKzTL5KaPTo0fj5+dGgQQO8vb354osvuHr1KkOHDgXUUzXXr19n3bp1AHz22WeUK1fOMA384cOH+fTTTw0rDgNMmzaNJk2aULlyZWJiYli0aBHh4eF89tln5niP6HQ63N3duXz5Mn///bdZ9ilERgoXLixXvKUgg25Rew3+/Rd++cX4dvOm2nuSFUWLQt266myupUurtzJlnnzv5qaO87hzRw0pgYHqWJB//lF7K/JpeOm4uXOfXNXz6aeWCSugzuvy0kvqlULz54OZ2hyRO0yuwT179uTWrVtMnz6diIgIatWqxY4dOyhfvjwAERERXL161bB9UlIS48eP5/Lly+TLl49KlSoxa9Ys/ve//xm2uXv3LkOGDCEyMhJXV1fq16/PwYMHadSokRneosrR0ZHKlSvLvA4iVzk4OEjPSip58pSQosCFC+qA0b174eBBtcckI05OUKqUGjpKlTL+3t0d6tcHT8+sNeRFiqiTrFWvrs5HsmABHDmiTlevxVPi9+7B5Mnq96+9BqlWns9177+vBpbAQDXY2ejCuHlBnpiaXwhhPWXLluV68gRe//77L+7pTfaVQrt27di7dy8Afn5+rF279qmD+jXhwQPYuVMdKBocDKkvBLCzU8eWvPCCeqtfH8qVg8KF1YGlufEev/wS+vVTv2/fXm2YtdbTsnatesVOsWLqgGFLn7JXFPVU0OXL8P330K2bZV9fZLn91ljNFUI8a3LSw/Lll1/SuHFjhg8fnitly7GkJDh0CNatUwdt3rv35DFHR3UukXbtoE0bNaQUKGDZ8vn5qaeSXnlFDVFdu8KWLZYPBRk5flydsRZg5EjrlEunU0PKp59KYNE4CSxCiFxlamBJ7ZdffgHUwbvz5s1DURR69+5NhQoVzFVE0/31l9p78eWXkHJcXIUK6mBXX19o0cLyASU9L7+sNsbjxqmDWZctUy8ZtravvlKn2I+NVedZef9965VFH1i2bVMH/sqyMJokgUUIkauyO+i2Xbt2/Pzzz9y4cQOA77//ngkTJgBw4MABdu3aZd6CPk1cnNqLsmyZ8eyohQqp69f06wfNmmmn9yKl995Te3zeeQfGjoU33lBPwVjLokUwapT6fdu2aq+PNceONGqkDmC+fl3tierUyXplERnS4G+WEOJZkt1TQiVLlgTg5s2bAJw5c8awzZUrV8xYwqe4ckXtnfDwUENJaKg6rbuvL6xfr156vGKF2qOixbCiN3w41KqljrUJDrZeOdaseRJW3n8fdu9WFye0Jjs7dcAvwMaN1i2LyJCGf7uEEM8CU+dh0W+jn4xSH1j++OMPwza3bt0yZxHTSkpSB9B26gQVK8Ls2eq6Nh4e8PHH6qXCO3aoPRUau/ImISGBHj16pJ0p3M4OmjZVv08R/izqzp0np34++EC9KkcrV9Xpx65s3Wo8CZ/QDAksQohck5iYaBRSstPDoj8llDKw3L59m8TERHMWVRUTo062VqWK2oOybZt6FUn79rB5s7oA38SJ6iXHGrVy5Uq+++473tEPZk1JPxlnRoHlzp3cK1h8vHrq7PZt9Wqpjz+23HwrWdG8OZQsqX4G+/ZZuzQiHRJYhBC5JvX4FVMG3eoDS2xsLPfu3ePChQtG+7l7965ZygiovSeTJ6uXGb//vjrrqasr+Pur0+Hv3g2vvqq9S4JTePz4MRMnTiQgICDjjZIn8CS9ZU9+/FG9omj2bPMXTlFg0CDYs0cdq7JmjVk+y127dtG7d2/z1AV7+ydLGezcmfP9CbPT7m+fEMLmmTrgFp6EGldXVxwcHHj06BHHjh3j8ePHuLi4YGdnx71794iKiqJYTgeORkaqpyU+/1wd2wHqhGvvvgu9e9vUJGLLly9nxowZmW+kn3r+8mX1tFfKMTd+furXcePU3oYmTcx3umbiRPWqIHt7dRp8M0wKmpSURMeOHQHw8PBgtjmCVps2sHKleqm60BzpYRFC5Jrs9LDot7Gzs6NEiRIAHDx4EIBq1aoZ7svROJboaHW13kqV1JlgHzxQ50nZuBF++w0GD7apsALw+++/P30jDw+1ZyM+Xr0iJqWU4aV5c+jQwTwFO3JEXYgRYPly8PExy24PHDhg+F5/6buiKJw+fTr7pwtbtFC/hoWpl1sLTZHAIoTINTkJLDqdzhBOjh07BsDzzz9P8eLFAYiKijK9QAkJakCpVAk++UQNKo0bw08/wcmT6pUiGrvSJzExMUunPPRjfTKVL586VwxAUJDxY8mfq8HPP6tXSP3zT1aKmbG5c9WvAwaop4VyYNiwYdSrV4979+4Z1qsD2LNnD3Xq1KFevXrUq1ePRYsWZe8FPDzU04KJiXD0aI7KKsxPW7+ZQohnirkCy6lTpwAoV66c4TSQyYFl50510Ono0XDrljqeY9Mm9TLljh21NQA0hffff5+SJUsaQltGstTDAupCiQBjxsD9++pq0Xfvpj9ZWo0aaiP+/femFVrvzz/Vq25AvSooh5YtW8bp06dZu3YtW/X7TXbmzBl+/fVXgOwHFnjSyyKnhTRHAosQItfkZNCtTqczDLzVn/7x8PAw9LBk+ZTQ3bvqeBRfX3WG2lKl1HEKZ86oU9VrNKjoBQQE8OjRI/r27ZvhNnFxcZxPNZBW/9mlMWzYk+9//VVdVLFIkfSvHHr4UP06b56pxX7yPEVRLw/XD/h9in379nH58uU09z/QjzECvvnmG27fvk3hwoV56aWX0mz777//8lBfdlM1b65+PXw4e88XuUYCixAi12RndfSUoUbfw6JXtmxZ03pYQkKgXj11gjd7e7V35a+/YOBATV/xk54LFy4YfTZ//PEHrVu3Zv/+/fzxxx8kJSUZbZ/hgpE9e6qfCaifS2arSOsdP276Jc8xMerSBaD25mTB+fPnadu2LRUrViQ6Otrosf9SlDM0eaZhHx8fPvvsM5YsWUJUVBTBwcG4ubmRkJDA0RSndOLi4ggODk4T6tKl72E5elQ9NWSqmBg4dUqdUfjll9XBzJs2mb4fkYYEFiFErkn5XzGYfkoo9crOJvWwzJ+vrlHz99/q5G+HD6v/8dvQau7x8fFGP6dscHv06MGBAwd48cUXDafMWrZsyYIFC4CnfNYVK6pfU08uB096GFJKSjJ9bhL9ujxVq6a/z3SkfH+jRo0iJiaG6dOnM2PGDCIjI9Ns7+vrS4UKFRg+fDjFihXjxRdfpF27dgDMmDGD3bt3s2TJEjw8PPDx8aFKlSq8+eab3L9/P+NCVKumTgb44AGkuJT+qR48UNeRcnWFBg3UsTs7dqhXR3XrBn37Gi+OKUwmgUUIkWtiU11pYWpgqV+/vtFjHh4eWethmTNHXT8nMVH9DzcsTL1M1wZERUUZlh5I3UgvWbKETz/9lHbt2hmWKkhMTGTHjh0AtGnThhdffPHpL5JZaPv5Z+OfBw9Wv4aEZKn8Bl99pX59/fUsn3a7ffu24fu1a9fi6urKlClTmDhxYpoxPPny5aNbOisrDxgwADs7O/bs2UOHDh0YOXIkUVFRODg4ABAYGEijRo2MJiI0Ym8Pdeqo34eHZ6ncrFihnmpMNa4Gb291jSKAr7/WxqKTNkwCixAi1+Q0sHh5eRk9VqJECUMPS4ZXxcyf/2SA50cfwbp1NtOrkpSURMuWLalRowb//PMP11Nderx48WLGjBnD3r17je7flHzKQT8vCTzls85s7R5HR/XS7s6d1VNB3t7q/cmXDmfJhAnqlVc6nbp8QbITJ07QunVrfvvtt3SflrLXzMPDw+ixzZs3pyiiI3v27KFgwYJp9vHiiy8SFBRE5cqVqVq1KmXKlMHf35/Y2FgOHjyIu7s7Z8+epVmzZpw7dy798utPmWUlsHz1FQwZol4GXaSIOrg7JkadjDAkRL3K6qef1KvPvvxSXUBTZI/yjIiOjlYAJTo62tpFEUIk++677xTAcPvjjz+e+pyGDRsqgLJt2zZFURSj5yuKopw+fdrwc2BgoJKUlKR88sknyoQJE5SI6dMVRR3mqShTp+bqe8sN+/fvN7y3VatWKRs2bFAApWnTpkrTpk0VQHFxcTH6TPS3IkWKKI8fP1Z+++03BVCKFy+e8QuNG/fkc0p9S+30afX+/PkVJTb26W/i6lVFsbNTnzN7ttFDdnZ2CqBUrVo13adOmjRJAZRhw4Ypf/31l+Lm5pbmffr5+Sn//vvv08uRgYiICKVBgwYKoFSsWFGJi4tLu9GyZWr5O3bMfGd//aUozs7qtl27KsqDBxlvO2mSul3x4opy82a2y/8symr7LT0sQohck7qHJSuUp/TC1KlTh/HjxwPwzjvvsGnTJiZOnMiMGTPw+PBDegH3xoyBDz/MTpGt6iv9aRQgJCTEcKlymTJl2LRpE0uXLuXvv/8mJCSEFi1a0Fk/lTzQuXNn7O3tDYNtM/0c0+mZyFCtWuppjYcPYcOGp2+/bJk65qVFC3XgaQr6gcF//vlnuk/V97AUL16cypUrc/HiRdauXWu0TYUKFdKMbTKFm5sbP/30E+7u7ly6dInAwMC0G2W1h+Wjj9RxOi++qF76ndlCmB9+qF5WHxUFyfVXmMgi8ckCpIdFCO1ZsmSJ0X/H586de+pzvLy8FEDZvn27oiiKMmbMGAVQXnzxRcM2iYmJStWqVdPtaQAULy8vm/tbsHHjRsXR0THd9+Pv75/uc+7fv69Mnz5d+fLLL5WHDx8qiqIoZ8+eVQClaNGiGb/YwoVPelSKFFGUs2cVpWRJRRkzJv3tP/xQ3bZp08zfxP37ilK0qLrtpk1GD0VERBjej4uLS7pPf/311xVAWbhwoeG+q1evGn0Wn332WeZlyKKAgAAFUMqVK6fEx8cbPxgbqyg6nfo+IiLS38HNm4ri6Khuc+xY1l708GF1e51OUS5dytkbeIZID4sQwupyOoYF4KOPPuLLL7/km2++MWxjZ2fHuwMGGH62B64AIUOHUqJECU6dOkXv3r3TXOqrVZcvX6ZXr14kJCTQPJ0rakrrJ3tLpUCBAkyePJm+ffvinDzxW5Z6WFKOYXntNXX9pIgIdbByerp3V78eOwaPH2e83y++UFdjrljxyUKC6J/6ZNDs/fv30529N2UPi56HhwfVUszhUqpUqYxf3wRDhgzBzc2Nq1evGs2aC6jLMlSpon5/+nT6O/jqK3Xm5Pr1oWHDrL1os2Zqb4yiQKqeI/F0EliEELkm9eWj2QksTk5O9O3b13hOlp9/pt8nn9ADaA+sLl6c8tu24b1sGdu3b8fZ2Znt27cbLvHVunHjxpGQkECbNm3Yv38/1atXN3q8cOHCWd5XlgJLynWSChRQv2a2JEHNmuDgoF519e+/6W+TkPBkGv5x49IsnJj6Kp/0rtLRX/mVelHLt99+2/C9uQJL/vz5GZt8yuqTTz5Ju/6Q/rRQWFj6O1i1Sv06eLBpkw++9Zb6NTBQPXUmskwCixAi12Snh+WpLl6E7t3JHxtLUOPG7N6+nX7//adO0gU0bNjQMDX7hAkTMrwixRoUReHEiROsWLGCoKAgvvvuO0aOHMmGDRvQ6XTMnz8fe3t7tm7dSnBwMFOmTKFKlSp06tQpy6+RpcCS8gor/dpCmbGzU6foB7h6Nf1tVqxQw4y7O/Tvn+bhn1NdLr1o0aI088zoe1hSB5Z+/fqlKG4WyptF//vf/yhatChXrlwxLLBpoL+kPr1xLH//rV5JZW8PvXqZ9qKvvqrO1fL336bPbWNhu3btYuPGjdYuxhO5e2bKcmQMixDaM2TIEKPxB7/99ttTn1OvXj0FUHbu3Jn2wYQERWnYUB0H0KSJoqR3hYeiKElJScorr7yiAEqFChWUNm3aKG3atFG2bt2qJCYm5vRtZcupU6eUunXrZjjuZs6cOWZ5nb/++ksBlEKFCmW80cWLT8awZPWKlTZt1O2/+irtY2fOPNnf/PlpHr5165ai0+kUQOnatavhPX/44YeGbZKSkhRnZ2cFUC5fvpxmHydOnFB++umnrJXVBAMHDlQAZejQocYP7Nqlvp9KldI+adUq9TFv7+y96Ntvq8/v0yd7z7eAxMREw3G6ceNGrr6WjGERQlidOcawGJk7F06cgMKF1fksnJzS3YdOp2PFihUUK1aMK1eusG/fPvbt20fnzp2pWLEi48ePJywsLPMZT83k8OHDNGvWjEaNGnH69GkKFChAhw4d8Pb2plmzZvTs2ZN169YxJovT1z9NlnpYKlaE69fVK39Sr9KckXLl1K9//218f1ycOsOrfr8jRqR56p49e1AUhZo1azJt2jTD/RdSzCT74MED4uLigLQ9LAANGjQwmmfGXHr06AGoc9k8Tjk+p1Ej9VTPxYtply/Ys0f9mjyrrsn060Jt2wap1tvSipiYGMP3+uNibba1mIYQwqaYNbCcOwf6xm7xYihbNtP9uLm5sXfvXvbs2YObmxunT582XBY8a9YsZs2aBUDNmjWJj4+nVq1alC5dmgYNGtCnTx/s7e2xTzUOQ+/x48fMnz+fX375hf79+/PCCy9w9OhRHB0dKVGihOE01IEDB1i3bp1h8G+XLl1YtWpVug2yuWQpsMCTVZuzSh9Yrl0zvv+77+DSJXXStN271bEuqegnuvPx8aF27dqsWLGCwYMHcy/FVPX600GOjo48l9nEdmbWpk0bihYtyo0bNzh48CBt27ZVHyhcWL2k+8wZOHJEHZwMaj+SfuK+7AaWxo2hRAm4eVNdMqJNmxy/D3NLOSjaIZ1jag0SWIQQ5peQAJGR3DdXYFEUGDpU3e9LL0GfPlkqRp06daiTPM167969mTp1Ktu3b+ebb75h165dPHjwwDDXScr/9ocOHUpiYiIlSpSgTJky3Lx5k5iYGEqVKoWnpydhYWGGxfiCgoKeWo7+/fszdepUs46/yEiWA4up9AEnIsL4fv3MrSNHQqVK6T71TvLCiZ6engCGGWpTBpaUA24zXLgxFzg4ONC1a1dWrVrFhg0bngQWUK/qOXNGDRX6wPLbb2qPS/78T2YBNpW9vVqP166FiRNNX/bAAlIuPmn2upRNEliEEDnz+LE6bXtwsDpA8fff4fx5ePyY2FT/mWX7D9++fXDwoHoKaPly067KSCF//vx0796d7t27oygKly9fZs+ePTx8+JAjR47w+PFjQkNDDWv4REZGGq3nc/fuXcOkZ4UKFeK1115j06ZNxMTEULVqVXQ6HRcuXKBRo0a4uLjg6enJgAED8M5uw5YNudbY6ydrS3mVUHQ07Nqlfp98aiU9qUOovgclZQ+cfh2h3Ox9ykiPHj1YtWoVmzZtYsmSJeTTr+TdvLla344cebLxjz+qX9u0yfCUZJZ07qwGltBQ9fScfs0hjUjZwyKBRQhhu/79V13obds2NUhksArt/Wycn0+3h0V/uezgwU+uVskhnU5HxYoVGTJkCKCuDgzqbKznz5/nxo0bTJw4kRIlSjB69GiKFi3KmTNnuHPnDnXq1KFu3boUKFCAJUuWcPPmTcqXL49Op0NRFIv2EGQk13pY9IHl4kV4/nn1++rV1Uufn1IW/eeSuodFURRDA2nKJdzmoj8tdPPmTQ4cOGBY8ZlmzdSvv/yi1vGCBZ8scKgft5Ndr76q9rQkJqoLI6aaFdjaJLAIIWzXf/+pk2UFBakDX1NydVXP5zdrBjVqqI1XsWLEFi0KKS5dzdYpoX/+efJfvL+/Od5Jpuzs7KhatSpVq1ZNc6lr6vlRAFxcXHBJMa+JtcNKrp8SioxUe9Bat37y2NChmT41dVn0gSU2Npbz58/TrFkzCiUvUGmNwOLg4MBrr73GypUr+e67754ElvLl1VB24QJs366+Z/18MiZcap4uOzt1LNawYWqvjcYCixZPCclVQkKIzP3xh9qzUb48vP++GlZ0OvX8/cyZ6n+ft27Bxo0wejRKhw58c+gQf167xn39pGTJshVY1q1Tx7C0bJnhGAnxRK4FllKl1OOemAgdO6o9LUWLwpYt6viVTGR0SujevXtMmTKFmzdvcvHiRQBcXV3NW+4sev311wHYuHHjk6uFdLonp7o2bAD9XDJeXk9OkeVEhw7q18OHYcAATV0xpMUeFgksQoj0RUbCoEFqj8nKlWpPSaNGsHSp2liFhKgzmtavbzSr6ebNm+nTpw/VqlUjNtXlkNkKLN9+q35NMRW/yFiuBZZ8+dTQAupVQXZ26pilzp2fOqYoo1NCsbGxT8aLJLNGDwuop4WKFStGVFQUR1KOWUkOMuzcCT/9pN/YPC9asaJ6agjU8Sx162pm9ttnpodl6dKleHp64uzsjJeXF4cOHcpwW/0cBMWKFSN//vxUq1Yt3emyN27cSI0aNXBycqJGjRps3rw5O0UTQuTUw4dqz0nlyur044qiNkqHD6vd4W+/DW5uGT495d+Dhw8fAqAfmqiknv78aa5dU6/SsLNLszaNSF+uBRYw7lVo2zbL44ky6mFJSkrCLtWSANYKLA4ODnRI7vHYvXv3kwfq1n2yWvXXX6v36XtGzOH775/0UJ07B19+ab5958Az0cMSFBSEv78/EydOJCwsjBYtWuDr68vVDKZrdnFxYcSIERw8eJBz584xadIkJk2axBdffGHYJjQ0lJ49e+Ln58fp06fx8/OjR48eadaeEELkoqQk9fRL1aowYQLExqo9KkeOqN3++gGIT3EvnQG4hlk1Ulw6nBGjxk3/H22TJmCFq0dsUa4GlpRzt6S8/PcpUgcWFxcXw/epF6i01ikhUOeJgVSBRaeD//3vyc/Nm5v03p/K3h4WLQI/P/XnWbM00cvyTPSwzJ8/n4EDBzJo0CCqV69OQEAAHh4eLFu2LN3t69evT69evahZsyYVKlSgb9++dOjQwei/sICAANq3b8/48eOpVq0a48ePp127dgQEBGT7jQkhTPDrr+qYlP791V4NDw81vISGQtOmJu1Kf9mvnk6nI3/ySsLKiRPw+efqpG+lS8OYMWoPTgpGjZt+zEAuzHD6rLJYYElnAHJGUgcWnU5n1MuSkrV6WOBJYDl16pRhXhhADfArV6qDZHfsyHyhyOxasgQKFVLHjOkHmVuRzfewJCQkcOrUKcNB1fPx8SEkixPfhIWFERISQqtWrQz3hYaGptlnhw4dMt1nfHw8MTExRjchhIkePlT/GHt5wfHj6h/M2bPhzz/V//iy8Yc59Sq8Li4u2OkDy4IF6hUl16+rE5B9+ilMnmy0vVHjFhqq3tm8eTbeXN5ksVNCtWpl+WnpXaquDyyp/3ZbM7C4u7tTu3ZtFEVhX8qFCe3tYeBAddmB5PE3ZleokDpmDGDGjDRB3tJsvoclKiqKxMTENMt7lypVymhypfSULVsWJycnGjRowPDhwxmkPzCokzOZus+ZM2fi6upquHmYaW4GIfKMvXuhTh11vMrjx9Ctm3oOfexYdRbPbLh165bxf6aoAyx1yfsz/NlLOUnWJ5+ol4wmMzRuUVFqb4+dHTRsmK3y5EW5Glj0/1hWqWLSFVvpBRb9wNvU9cWap4QAwz/TmY3NzDX+/lCggDpeTD/Y3EpsvodFL/U8A1mZKOnQoUOcPHmS5cuXExAQwPr163O0z/HjxxMdHW24XUu9voUQIn23bsGbb6rzply4oIaHH35QB/+Zur5MKvreFXd3d0aMGEHDhg0ZM2YMutQzgv78szoRl37+kkmT0v5HmbweD3XqgAXXlrF1uRpYmjVTG9MjR0yabdiUwGLNHhaAli1bAqSZg8ciPDzggw/U7+fPt2ovixYDi0kTxxUvXhx7e/s0PR83btxI00OSmn4Nidq1a/Pff/8xdepUevXqBaiLlJm6TycnJ5xyMi2yEHmNoqhXILz/vrromk4Hw4erPRzJk3bl1I/J05Y3aNCAxYsXG+5ftGiRWgQ3N3VOl6pV1Qf+/hsqVFAvj922DTp1etK4Ja/xQ5MmZilbXpGrgQWyPPg6pcxOCWmth6VFixYA/Prrr9y5c4ciRYpYtgBvv62eEjp5Eg4cMJ6gz4Js/pSQo6MjXl5eBAcHG90fHBxMUxMG5imKQnyK2S+9vb3T7HP37t0m7VMIkYnff1f/8PXvr4aVWrXUeVQWLzZLWHnw4AFTpkxh9uzZALz55ptGjxsa0c2bYfr0Jw8UK6aGJoCPPgJFSRtYLLgOz7PA2jPtpiezHhb9woh61u5hcXNzo0qVKiiKYjwfSzpiYmL45JNPWLNmTbpXx2VLiRLQu7f6farxXZaScqkE/c+aoJjo22+/VRwcHJRVq1YpZ8+eVfz9/RUXFxflypUriqIoyrhx4xQ/Pz/D9kuWLFG2bt2q/PXXX8pff/2lrF69WilUqJAyceJEwzZHjhxR7O3tlVmzZinnzp1TZs2apeTLl085evRolssVHR2tAEp0dLSpb0mIZ9e9e4oydqyi5MunKKAoBQooyuzZihIfb9aXGTNmjII6REXx8PBQHj16ZPR4xYoVFUAJCQlJ++T//lMUZ2e1fAcOPNlWX+a//jJrWZ91//33n+FYaIWvr68CKGvWrDHc16tXL0M5U94ePnxovYImGzRokAIoY8eOzXCb69evK9WrVzeUu2bNmsrt27fNU4ArVxTFzk6t/3/++eT+FSsUxc1NUUqVUpRt2xTlk08UZfNm87xmCg8ePDA6Jn/88YfZXyOlrLbf2arRn332mVK+fHnF0dFReeGFF5QDBw4YHuvfv7/SqlUrw8+LFi1SatasqRQoUEApVKiQUr9+fWXp0qVKYmKi0T6/++47pWrVqoqDg4NSrVo1ZePGjSaVSQKLECkkJSnKpk2K4uGh/tEDRXn1VfUPodleIkk5d+6ccuPGDcXFxUUBlOeee07Ztm1bmm0rVaqkAMqRI0fS39ngwWoZe/VSPD09FUAJBUUpUUJ9LyLLbty4YWhokjTy2XXs2FEBlMDAQMN9gwcPTjewaMG6desUQGnSpEm6jz969Ehp3ry5AigODg6Kk5OTAigtW7Y0X+Dq2FH9nfjkE/V34ODBJ7/LqW/796vPMdPx/ueff4yOyblz58yy34zkamDRIgksQiS7eFFRXn75yR+zChUU5ccfzf4yY8eONfqjVq9evQwbyKcGllOn1LI6OCie5co9CSyvvmr2cj/rbt68aTgmqf8xtJYOHToogLJ27VrDfaNHj9ZsYLly5YoCKPny5VNiY2PTPP75558rgFKwYEHl/Pnzyq+//qoUKlRIAZQWLVooH3/8sTJ//nxlxIgRSokSJZTKlSsrd+7cMa0QK1aovxMeHsa/z+ndevdWlHnzFOW55xRl4cIcv/9ff/3V6JicPXs2x/vMjAQWIfKax4/V0z360ysODooycaKi3L9v9pcKDw83+oP23HPPpX+6J9nzzz+vAMrhw4cz3mmjRooCSoUiRRRAOQqKMmeO2cv+rIuKijIcl8ePH1u7OIqiKIqPj48CKOvWrTPc9+GHH2o2sCiKopRLDs47d+5M81jbtm0VQJk1a5bhvn379hl6WtK7+fv7m1aA+/fVfzZSh5PwcEW5dk1RBgxQg0p6Aeaff3L03vfv36/JwCKLHwrxLLh4EVq1Ui+JjItTpw7/9Vf4+GN1XgczmzdvHgDVqlUzLL3hncng2CxduTJ0qLpN8mA/HcBLL5mjuHlKyoGtmX7eFqQvR3qDbrXK19cXgK+++sro/qioKA4cOAA8WeEZoHXr1oSHh9OnTx9ee+01OnXqRL9+/Zg1axYAixcvTnNxSaYKFIBvvnnys729Oi9R3brqTNFr1qizUae3rlfNmpCDy7Jv375t9LNW6pF24mwOSQ+LyLP27lUUV1f1P6uCBRVl9epcHfeRmJiolChRQgGU/fpz509RpUoVBVAOHjyY8Ub37ytKkSJKueT/6o5XrWqmEuctt2/fNvxnnJCQYO3iKIqiKC+++KICKF999ZXhvuXLlxv9F+/j46OEh4dbsZTGjh8/rgCKs7Oz0emcVatWGU6BZpWfn59hvEv//v2VuLi4rBdk2jRFKV5cUdavT//xLVsU5fnnFWX6dEXZs0dR7O3VvwX29ory++9Zf50UVq5caXRsfvvtt2ztJ6ukh0WIvODrr9WVY6Oj1TV/zpxRJ4XLxUtbw8PDuXnzJgULFsy0VyWlLPWwFCgAixYZZsPVvf12DkuaN9lKD8tzqSYDHDt2LHXr1rVouTLToEEDateuTVxcHN+k6OnYtGkTAN26dcvyvlasWEGnTp149OgRa9euZdWqVVkvyIcfqlMRvPFG+o937gznz6uXQLdrB5s3q/cnJkKq3qGsSn2puVbqkQQWIWzRw4fqH6i+feHRI+jRQ509tnz5XH/p7777DoC2bdvi6Oho3p337avOQwHZmqBM2E5gSX1KyDl5vSmt0Ol0hiVkVq5cCajzruhP67z22mtZ3peTkxNbt25lypQpgLqIcGJioplLnKxTpyfT+uuX3TCRVk8JSWARwpYkJan/NVWtqo5PAXXm2vXrIZf/4N+/f58PPvjAcE7elD/Ypsy+qiTPYK3FCdBsga0GFi3OXN6nTx8cHR0JCwvjl19+Ydu2bSQkJFC1alWqm7Batd6YMWMoWrQoFy9eZPz48blQ4mQvvwz6z7NcOZOfLoFFCJEzUVHg66uuonztmrruyPr1MHdu7ix3j7pC+7Zt2/jggw+oXr06c+bMAeC9996jb9++Wd6PSYElncZNZJ2tBJbUp4S01sMCUKxYMUMwX7VqFStWrADUwbbZqZ8uLi4sXLgQgLlz5/L111+br7ApPfccdO2qfh8RoZ5WMoEEFiFE9igKBAerKxbv3q2upDxjBvz5Z8bntc3g7t27NG3alE6dOjFnzhyuXbtG+fLl2bx5M59++il2JoQkCSyWYyuBxRZ6WADDaaGlS5eyf/9+7O3tGTJkSLb317dvXz5MDhDDhw/n8uXLZilnGl99BV5e6vcffaSu15VFWg0sJi1+KITIZUlJcOiQ2nOya5c6cC42FvSD4CpVUldWrlUrV17+2rVrhISE8Pvvv/Ptt99y/vx5ihQpQvfu3alXrx4DBgygQDYuk5bAYjla/NxsObC0adMGT09PQ7Do1q0bHh4eOdrn5MmTCQ4OJjQ0lJdffpmQkBDzr6Fkb68uoPjqq7Bli/p3o169LD1VAosQImPx8bB6NcyZA1eupH3cwUFdxXXaNDDTH7bExEQOHz7M4cOHOXnyJCdOnOD69etG2xQvXpw9e/Zo6uoNkXVaaWhs9ZQQgJ2dHVOmTOHdd9+ladOmLFiwIMf7zJcvH9999x1NmjTh3LlzzJkzhxkzZpihtOlo314NLNOmqXM1tWkDqKd7Mxo0L4FFCJHWw4ewciXMng36sODqCq+9pl75U6SIerlvpUpGE8A9evSIfv36cf78eVauXEm9p/znpCgKv/76K5cvX+bEiRPcvHmT7du38++//xptZ29vT7169ahfvz716tXDz8+PQmZYzVl6WCzHVk4JpQ4sWu1hAejfvz/9+/c36z7LlCnD4sWL6dq1K8uWLWP8+PG5M5leq1ZPvn/pJYiK4vjvv9OyZUumTJmS7uBfCSxCiCcSE+HLL9VLk//5R72vbFkYNw7eeksdp5KOu3fvoigKY8eO5dvkSxebNWtGaGgoderUSbP9v//+S1BQEF9++SVhYWFpHi9SpAg+Pj40atSIhg0b8sILL+Di4mK+95lMAovl2Epgsbe3J3/+/Dx8+BDQbg9LburcuTNVqlThr7/+YuXKlbz77rvmf5FataBfP3VW3Lg4OHmSoe++S3x8PBMmTEgTWB49esS9e/cAKFCgAA8ePNBMPZLAIoQlKQr89JM6hf5vv6n3lS0LEyeqE75l8F+moih8//33DBw40PDHRO/Bgwf06tWLTZs2kT9/fn799Vf+/vtvtm3bxu7du0lKSgLUBqFGjRrUr1+fUqVK0bBhQ3x9fS3yn60EFsuxlcAC6jgWfWAx+5w+NsDOzo4xY8YwePBg5s+fz4gRI3BwcDD/CwUGqpNLbtkCoaGGvwnpuXXrFqAeqyJFikhgESJPOnECxo6F/fvVnwsXhgkTYOTITOdQefz4Ma+//jo//PCD4T47OzsCAwPp0KEDderU4ezZs1SrVi3d5zdt2pQePXrQt29fihUrZr73YwIJLJZja4Hlxo0bODk55dnj3bdvXyZNmsQ///zDV199xZtvvmn+F9HpwMdHDSwff0xSJnOzXL16FYDSpUuTL58aEbRSj+SyZiFy24UL0LMnNGqkhhUnJxgzBi5dUr8+pSt89+7d/PDDDzg4ODBhwgRCQ0M5deoUfn5+lCxZkv3799O2bVtA7WavW7cuvr6+fPzxx/z1118cOXKEUaNGWS2sCMuypcCiH8ei5fEruc3Z2Zn33nsPgEmTJhEbG5s7L9S/vzqJ3P37JJ079+T+3r1h507Dj/qroTzLl0eXkABopx5JD4sQueXmTZg+HZYvV6fH1unUc8nTp5s0+6R+KvwhQ4bwySefpHm8WrVq/Pzzz8THxwPa/OMvPSyWY0uBRT/IVIt11pJGjhzJsmXLuHz5MkuXLmXs2LHmfxEXF3XSyU8+weiE0Pr16sruHTsCcCX5KsUKkZFcj4gAtFOPpIdFCHNLTFRDStWqsGSJGlZ8fdWJmwIDTQorCQkJhlNBKZeyT4+Tk5Nm//BLYLEcWwwseXHAbUrOzs588MEHAGzcuDH3XqhBAwCjwBIP8PvvEBMDpAgsly6hP1paqUcSWIQwp/Pn1csI335bneytXj3Yuxd27IB0ruJ5mpCQEO7evUvJkiVp3ry5+ctrIRJYLMeWAoucEnqic+fOABw/fpzIyMgsPefSpUucP38+6y/yyiswaRKP8z05uRKt/+bDD0FRDIHFEySwCPFMSkhQFyOsVQuOHIGCBWHRInWgbfJETdmxP3mAbrt27bC3tzdTYS1PAovl2FJgkR6WJ9zd3WmQ3AOyffv2p27/+++/U6dOHV544QUiIyMZMGAADRo0ICoqKuMn5csHH33E3RTzvdxN/vv0cOFClBEjuHz6NAAV8ueXwCLEM+f4cXXNjsmT1eDSoQOcPq1e/ZMvZ8PE9u3bB6jTgwuRFbYYWKSHRfXqq68C8Omnn/Lo0SOjx+Lj43n33XdZu3Yt8fHxvP7669y/f5/Y2FhKly7N2rVrOXXqFB/rV3HPQFJSEneiDf0q3K1WjUjAHXh96VL+Th63UuHhQwksQjxTZs8Gb291TpXixeGbb9R5Vjw9c7zrhw8fcvToUQBat26d4/1Zk/SwWI4WP7ennRKSHhbV8OHDKVGiBH/88QdLly41emz69OkEBAQwYMAAxowZw7kUV/qk/L1aunQpq1at4vHjx+m+xr1794zmYYn29WVV2bJEAxuBONRg4EGKU0KZzNtiSRJYhMiu8HB1ZtqkJPXSwHPnoFcv9WogM1i/fj0JCQmUKVOG559/3iz7tBYJLNahlf+MpYclawoXLsxHH30EwPz58w2h48KFC8yZM8ew3eLFiwFYvnw5xYsXR6fTsWDBAl577TUePXrEoEGDqFixIidOnEjzGnf0C6kmuxsXx71UA/rLAg6kCCxxceZ5gzkkgUUIU0VHw7x5UL+++nO9evD112oPi5ns3bvXcNWAv7+/zTfeElisQ+uBRQbdptW/f3+KFy/O1atX2bp1KwCLFi1K02PSuXNnhgwZwrFjxwgLC8Pf35+goCDmzJlDiRIluHbtGm3btuWdd94hOsUpoNTrBN29e5eI5Nlt9SokfzUEllSnp6xFAosQprh/X73a5/33n9yXPE+KuXz++ee0a9eOqKgoateuzahRo8y6f2uQwGJZpnzelpDRMW3VqhUlS5bkpZdeskaxNMnZ2ZkhQ4YA8NFHH3Hnzh3WrFkDwK5du1i0aBGrV69m8+bN6HQ6KlasaFhNPV++fIwZM4ZLly7Rpk0bYmNjWbx4MUuWLDHsP3VgiY6O5s8//zS6r0LyVwksQtiq+/fV6a2Tp66mfn24exfMeLpm1apVDB8+HIA333yTPXv25M7aIuKZZiuBpVatWkRGRjJixAhrFEuz/P39KVy4MOHh4RQtWpTY2Fhq1KhB+/btGTlyJG+++SZ2dhk338899xzBwcEMHToUMJ7bJfUpoTt37qQJLPoReIbAksF4GEuTwCJEVvzwAzz3HISEgIMDbN0Kv/wCrq5m2X18fDz/+9//GDRoEImJiQwYMIBVq1ZRsmRJs+zf2qSHxbJsJbBkdF9eV6JECaZNm2Z034IFC0z6rOzt7Zk+fTp2dnaEhYUZptxP3cNy4cIF7t69a3RfheSv0sMihK05cQK6dn3y8zffQKdOZtv9hQsXaNmyJV988QU6nY5PPvmEVatWPVN/yCWwWJYtBRaRvpEjRzJ37lwKFy6Mv78/Pj4+Ju+jRIkStGrVCoBt27YB8Msvvxhto78SMaUK06bBxInSwyKETdm7V120UG/tWuje3Sy7vn//PhMmTKBmzZocP36cokWL8tNPPzFhwoRMu3ttkQQWy5LAYvt0Oh3vv/8+t2/fZsGCBdneT9OmTQE4e/YsSUlJ/Pjjj8CTpT70qzOn5Nm/P3z8Mbrkv0NKYmK2X9+cnq2/ikKY0+HD0K6d+n2RInDlirp4oRkcP36c+vXrM3PmTBISEujYsSMnT56kQ4cOZtm/1khgsSwJLM+OnH5mlStXBtSelG7duhEREcFzzz3HgAEDjLbT98TY29tTpkwZo9eWU0JCaNmFC9CixZOfT56E8uVzvNvw8HAGDBhA06ZNOX/+PGXKlOGHH35gx44deJphsrlngVYaWVsmgUXo6QNLeHi4YSHVjh070qZNG6PLyQcMGICLiwtNmjQhX/IM3YZ6JKeEhNCoHTugRo0nP58/DxUr5miXN27cYNiwYbzwwgusXbuWxMREevbsya+//kqXLl2e+T/k2WlAn/XPJDdJYBF6VapUMfrZzc2NWbNmkT9/fsPl0AAdOnTg77//5ueffzbc90wElqVLl+Lp6YmzszNeXl4cOnQow203bdpE+/btKVGiBIUKFcLb25tdu3YZbRMYGIhOp0tzi9PI7HoiD5k7F15+GfRdoPv2ZfuyZUVRCAoKon379pQuXZply5ahKAo9evTg8OHDfPvttxQtWtSMhdcuOSVkWRJYhF6xYsWMFk49efIklSpVAjB8BXXxxWLFihn1uth8YAkKCsLf35+JEycSFhZGixYt8PX1TXfgDsDBgwdp3749O3bs4NSpU7Rp04ZOnToRFhZmtF2hQoWIiIgwusn6EsKivvoKxo5Vvy9WDCIjIRtr+CQkJLBw4UJq1arFG2+8wZ49e0hMTKRRo0bs3buXoKAgmjVrZt6ya5wEFsvS2mcnx9R6dDodiSkGzerHpwB88sknlC5dmokTJ2b4XNBOYDF5Kdn58+czcOBABg0aBEBAQAC7du1i2bJlzJw5M832AQEBRj/PmDGDLVu28OOPP1JfP7U56gfj5uZmanGEyD5FgZ074cgRdZ6V339X7+/cGTZvhmxcqRMcHMzIkSMNEzG5uLjw3nvv0a9fP6P/ZvIaCSzWIT0sAtSJ5GJjYw1rN+l5enpy/fr1DJ+ntcBi0l/khIQETp06leZ6cB8fH0JCQrK0j6SkJO7du5emKzw2Npby5ctTtmxZXnnllTQ9MKnFx8cTExNjdBMiyx4/hhEj4KWX4JNPnoSVDz6ATZtMDitJSUlMmjQJHx8f/vzzT0qWLMlnn33GtWvXmDZtWp4OK6bSSiNry+SUkEhp27Zt1K9fn3379pn0PMNlzfHxuVEsk5nUwxIVFUViYiKlSpUyur9UqVJERkZmaR/z5s3j/v379OjRw3BftWrVCAwMpHbt2sTExLBw4UKaNWvG6dOnDSOcU5s5c2aamQCFyJJr16BvXzh4UP25dWu4dQsGD4aRI03e3cOHD/Hz8zNMfz1s2DBmzJiBq5lmwX0WyKBby5LAIlJq1apVmgnjskKXPPZFK6s1m3xKCNJWOkVRslQR169fz9SpU9myZYvRlONNmjShSZMmhp+bNWvGCy+8wOLFi1m0aFG6+xo/fjyjR482/BwTE4OHh4epb0XkJY8fw7RpMGcOJCRAgQIQGAipllZP6dq1ayxfvhw3NzeqVKlCtWrVKJ/i8ua///6bHj16cPz4cRwdHVm5ciV+fn4WeDO2RU4JWZYEFmEOhh4WWwwsxYsXx97ePk1vyo0bN9L0uqQWFBTEwIED+e6773jxxRcz3dbOzo6GDRty/vz5DLdxcnKSJclF1igK/PQTTJ8Ox46p973wAnz5pfHly6nEx8fTuXNnwsPDje6fPHkyI0eOZMaMGaxcuZLY2FiKFi3K5s2badmyZS6+EdslgcWyJLAIczD0sDx8aOWSqEw6Ue/o6IiXlxfBwcFG9wcHBxum/03P+vXrGTBgAN988w0vv/zyU19HURTCw8Nxd3c3pXhCpLVvHzRtql6qfOwYFCyorgV08mSmYQVg2rRphIeHU6xYMbp27UqN5O0/+ugjSpYsSUBAALGxsXh7e3PixAkJK1kggcUyJLAIczAElkwG5lqSyZdBjB49mpUrV7J69WrOnTvHu+++y9WrVw3LWI8fP55+KaYvX79+Pf369WPevHk0adKEyMhIIiMjiY6ONmwzbdo0du3axaVLlwgPD2fgwIGEh4cb9imEyY4fh/btoW1bOHoU8ueHt9+GsDDo1Qsy+cP56aefotPpDFe9rVixgk2bNvH777/z5ptvGrarX78+O3fu5PDhw1TM4cRyzzpTGiqtNLK2TAKLMAed/uKYf/5Re6qtzOQxLD179uTWrVtMnz6diIgIatWqxY4dOwzn9SMiIozmZPn88895/Pgxw4cPZ/jw4Yb7+/fvT2BgIAB3795lyJAhREZG4urqSv369Tl48CCNUi46J0RW/PYbTJ6sXqYM4OAA//sfTJgAWeixi42NZax+LhagUaNGvPrqq4afFy1axPPPP0+tWrV4+eWXjSZkEhmTQbeWJYFFmEVyYFGmTMn0nzxLydag22HDhjFs2LB0H9OHEL39+/c/dX8LFizI0WqUQnDxIkydCl9/rf4nYGenLlQ4ZQpUqJClXWzfvp3u3bsb/rhWqlSJRYsWGf2Rfe6555gwYUIuvIFnmwQWy5LAIszBUI+sXA49WUtI2LbISLUHpVo1daZaRVGv+vntN1izJsth5cyZM3Tv3t2wHMSCBQu4cOECjRs3zsXC5x1ZbUBTPi6NW/ZJYBHmoLV6lK0eFiGsLjZWXfdn3jy4f1+9r2NHdRK4F14weXfDhg0jLi6OwoUL88EHH2TYgyhyRgKLZWitoZHAYpu0Vo8ksAjb8+OP6gBa/cj1Ro3U8JLNq3Ru3LjB4cOHAbWnpWzZsuYqqUiW1YZKK38YbZ3WgoEEFtuktcAip4SE7bhxA/r0Udf6uX4dPD3hu+/Uq4BycEmxfvXw+vXrS1jJJTKGxTq00tBIYLFNWgss0sMibMPGjerU+XfuqANqR49WJ4LLnz9Hu1UUhS1btgDw0ksvmaOkIh0yhsWytNbQaKUcwjRaq0fSwyK07bffoFMn6N5dDSv16qkTwM2dm6OwoigKX331FW3atDGsAdSpUyczFVqkJoHFsrTW0EgPi23SWj2SHhahTYoCn34KEyfCo0dPelVmzoR8Oau2ly9fZsiQIezZswcAe3t7ZsyYIVcEWYAEFsvQWkMjgcU2aa0eSWAR2nP/Prz5pjo+BdQelnnzIIOVu01x+fJlGjRowO3bt3F2dmb8+PH06dOHSpUq5XjfImMy6NaytNbQSGCxTVqrRxJYhLZcuQJdusCvv6qz1C5eDEOGmGWWxdDQUIYMGcLt27epV68eGzZsoLIZQpB4Ohl0a1laa2gksNgmrdUjCSxCO0JD1SuAoqKgVCn4/nto3twsu/7jjz9o1aoVjx49olixYmzZsoVy5cqZZd/i6WQMi2VpraGRwGKbtFaPZNCt0IY9e+DFF9WwUr8+nDhhtrACMH/+fB49ekTz5s355ZdfJKxYmAQWy9JaQyOBxTZprR5JYBHW9+OP8PLL8OAB+PjAoUPg4WGWXSclJbFq1SrWrVsHwKxZsySsWJEEFsvQWkMjgcU2aa0eSWAR1rVrF3TrBgkJ8OqrsHUruLiYZdenTp2iadOmDBo0iPj4eHx9fWnatKlZ9i1MI4NuLUtrDY0EFtuktXokgUVYz+HD0LWretly9+6wYQM4OeV4t3/++SdDhw6lYcOGHDt2jIIFCzJ//ny2bNkifzCtRAbdWpbWGhoJLLZJa/VIBt0K6wgPV08DPXwIvr7w9dfqVUE5cPfuXT788EMWL15suK93797MnTuX0qVL57DAIidkDItlae2zk8BimySwCPHvv+ppoJgYaNFCvRrI0THbu4uKiuLjjz9m1apVxMbGAuo0+2PGjKF169ZmKrTICQks1qGVhkYCi22SwCLytpgYaN8eLl1SB9Zu3QoFCmRrV/Hx8Xz//feMGzeOf/75B4CaNWsyd+5cfH19zVlqYSYSWCxDaw2NBBbbpLV6JIFFWE5iIvTqBWfPgru7eilz4cIm7yY+Pp6FCxcyd+5coqKiAKhatSoLFy7Ex8dH/ihqkAy6tSytNTQSWGyT1uqRBBZhOePGwY4d4OwMW7ZAlSom7+Kvv/6id+/enDp1CoCyZcsyZMgQ/P39KViwoLlLLMxEBt1altYaGgkstklr9UgCi7CMwEB1MUP99w0bmvT0kJAQpk2bxu7duwEoVqwY8+bNo0+fPuTL4WKIIvfJGBbL0lpDI4HFNmmtHslfepH7jhxR1wMCmDwZevY06ekHDx6kQ4cOxMXFodPp8PX1ZenSpZQvXz4XCitygwQWy9JaQyOBxTZprR7JPCwid/3995O5Vrp1g6lTTXp6REQEr732GnFxcfj6+nLhwgW2b98uYeUZJYHFPLTW0EhgsU1aq0fSwyJyz6NH8MYbcPMm1KsHa9eCXdYz8r179+jbty+3bt2iXr16bNy4kfz58+deeUWuyU4Pi8g+rTU0Elhsk9bqkfSwiNwzbRocPQqFCsGmTSZNuX/hwgW8vb3Zu3cvzs7OfPnllxJWbJgMurUsrTU0Elhsk9bqkQQWkTv27oUZM9TvV6wAT88sP3X37t00bNiQ33//HXd3d/bt20etWrVyqaDCEmQMi2VpraGRwGKbtFaPJLAI84uKgr59QVFg0CDo0SPLT12wYAG+vr7cvXuXJk2acPLkSZo0aZKLhRWWIIHFsrTW0EhgsU1aq0cSWIR5xceDnx9EREC1ahAQkOWnTp06ldGjR5OUlMRbb73F/v37ZQ2gPEYCi3lo7bOTwGKbJLCIZ5eiQP/+sHOnuuryt99medzK1KlTmTZtGgCzZs1i5cqVOJlh5WahDTLo1jq08nlKYLFNWgsscpWQMJ8lSyAoSF11+YcfoG7dpz5FURSmT59uCCtz587l/fffz+WCCkvT2h++Z53WPm8JLLZJa/VIAoswj5Mn4b331O/nzoWOHZ/6lISEBIYMGcLatWsBmDNnjoSVZ5SpPSzSsOWM1hoaPTmutkVr9UgCi8i5O3fUgbWPHsGrr8I77zz1KYqiMGLECNauXYudnR3z589n1KhRuV9WYVUSWCxDaw2NnhxX26K1epStMSxLly7F09MTZ2dnvLy8OHToUIbbbtq0ifbt21OiRAkKFSqEt7c3u3btSrPdxo0bqVGjBk5OTtSoUYPNmzdnp2jC0pKS1HErly9DhQqwejVk4Y/Snj17WLFiBTqdjs2bN0tYecaZulqzNGw5o6WGRgZS2y4t1SPIRmAJCgrC39+fiRMnEhYWRosWLfD19eXq1avpbn/w4EHat2/Pjh07OHXqFG3atKFTp06EhYUZtgkNDaVnz574+flx+vRp/Pz86NGjB8eOHcv+OxOWMXcu/PijOsh240YoUiRLT/vpp58AGDBgAJ07d87NEgoNkEG3lqWlhkYCi+3SUj2CbASW+fPnM3DgQAYNGkT16tUJCAjAw8ODZcuWpbt9QEAAY8eOpWHDhlSuXJkZM2ZQuXJlfvzxR6Nt2rdvz/jx46lWrRrjx4+nXbt2BJhwSaywgv37YcIE9ftFi+CFF7L0tPj4ePbv3w+Aj49P7pRNaIqpf/ikYcsZLTU0Elhsl5bqEZgYWBISEjh16lSaRsbHx4eQkJAs7SMpKYl79+5RtGhRw32hoaFp9tmhQ4dM9xkfH09MTIzRTVhQRIS6TlBSEvTrB4MHZ+lpS5cuxdnZ2dDD1qpVq9wspdAIGXRrWVpqaCSw2C4t1SMwMbBERUWRmJhIqVKljO4vVaoUkZGRWdrHvHnzuH//Pj1SzH4aGRlp8j5nzpyJq6ur4ebh4WHCOxE58vixGlb++w9q1YJly7I0bmXt2rUMHz7c8HOxYsVwd3fPzZIKjZHAYhlaamgksNguLdUjyOag29SVTlGULFXE9evXM3XqVIKCgihZsmSO9jl+/Hiio6MNt2vXrpnwDkSOTJwIBw9CwYLquJUCBZ76lIMHDzI4uRemSpUqlClThg8//DC3Syo0QgbdWpaWGhoJLLZLa8fLpMuaixcvjr29fZqejxs3bqTpIUktKCiIgQMH8t133/Hiiy8aPebm5mbyPp2cnGQmVGvYsgXmzFG/X70aqlR56lPOnTtH165defToET169GD9+vXY2ckky3mJDLq1LAkswpy0UI/AxB4WR0dHvLy8CA4ONro/ODiYpk2bZvi89evXM2DAAL755htefvnlNI97e3un2efu3bsz3aewgkuX1EuYAfz9oXv3pz4lKCiIhg0bcvv2bRo2bEhgYKCElTxIBt1alpY+PwkstktLwReyMXHc6NGj8fPzo0GDBnh7e/PFF19w9epVhg4dCqinaq5fv866desANaz069ePhQsX0qRJE0NPSv78+XF1dQVg1KhRtGzZktmzZ9OlSxe2bNnCnj17OHz4sLnep8ipuDg1oERHg7c3zJ6d6eZJSUl8+OGHfPLJJ4A6uDYoKIj8+fNborRCY2TQrXVooaGRwGK7tBZYTP5Xt2fPngQEBDB9+nTq1avHwYMH2bFjB+XLlwcgIiLCaE6Wzz//nMePHzN8+HDc3d0Nt5QThTVt2pRvv/2WNWvWUKdOHQIDAwkKCqJx48ZmeIsixxQF3n4bwsKgeHHYsAEcHTPZXOF///ufIayMGTOGn3/++amnDcWzTwKLZWipoZHAYru0VI8gm1PzDxs2jGHDhqX7WGBgoNHP+vk2nqZ79+50z8IpBmEFixdDYCDY2cH69VC2bKabf/bZZ6xcuRI7OztWr15Nf/1pJJFnyaBby9JSQyOBxXZpqR5BNq8SEnnIvn0werT6/dy5kGrAdGq7d+/m3XffBWD27NkSVgQgg24tTUsNjQQW26WlegQSWERmrlyB11+HxETo2xeSg0h64uLiGDRoEB06dODx48f06tWL9/SrN4s8TwbdWpaWGhoJLLZLS/UIZLVmkZEHD9SVl2/dAi8v+OKLDCeHu379Ol27duXEiRPodDoGDBjAkiVL5I+TMJBBt5alpYZGAovt0lI9AgksIj2KAm+9BadPQ4kSsHkzZHB1T0xMDK1ateLixYsULVqUoKCgNPPsCKEngcUytNTQSGCxXVqqRyCBRaRn7lwICoJ8+dSZbDNZ9mDUqFFcvHiRcuXKsW/fPipWrGjBggpbIYNuLUtLDY0EFtulpXoEMoZFpLZ7N4wfr36/aBG0aJHhphs3biQwMBCdTsdXX30lYUVkSAbdWpaWGhoJLLZLS/UIJLCIlC5fhl691BWYBw6E5MkA03PlyhXD2kDjxo2jRSbBRggZdGtZWmpoJLDYLi3VI5DAIvQePIDXXoPbt6FhQ1iyJN1BtoqisHHjRjp06MCdO3do2LAhU6dOtXx5hU2RQbeWpaWGRgKL7dJSPQIZwyJAHWQ7dCiEh6uDbDduBGfnNJvduXOHfv36sW3bNgBKlizJ999/j2Mms94KkZIEFsvQ0ucngcV2aS2wSA+LUHtTvvwS7O3VafdTDbK9fv06J06coGnTpmzbtg1HR0cmTpzImTNnKFeunJUKLWyJDLq1Di00NBJYbJfWAov0sOR1hw4Zz2TburXhocTERFavXs3QoUNJSkoCoGzZsvz444/Uq1fP8mUVNksG3VqWlhoaCSy2S0v1CKSHJW+LiFBnsn38GN54A/z9AXj48CGTJ0+mcOHCDBkyxBBWmjVrxrFjxySsCJPJoFvL0lJDo4UyiOzRUj0C6WHJu5KSYMAA+O8/qF0bVq4EnY5Lly7RrVs3wsPDAciXLx8jRoxg5syZOKczrkWIrJBBt5alpYZGjqnt0lI9AgksedfixeqcK87O6iRxLi789NNP9OnThzt37lC8eHGWLVtG165dsbe3t3ZpxTNCAotlaKmhkWNqu7RUj0BOCeVNZ87ABx+o38+bR1LVqkybNo2XX36ZO3fu0KhRI3755Re6d+8uYUWYhQy6tSwtNTRyTG2XluoRSA9L3pOYCP37Q3w8vPwyd954g76dOrFjxw4A3n77bRYsWICTk5OVCyqeJTLo1rK01NBIYLFdWqpHIIEl7/n8cwgLg8KFebB4MR19fTl+/DjOzs4sX76c/v37W7uE4hkkg24tS0sNjQQW26WlegRySihHFi9ezFtvvUVoaKi1i5I1N2/CxIkAJE6bRi9/f44fP07RokUJCQmRsCJyjQy6tSwtNTRyTG2XluoRSGDJkZ07d7JmzRr++OMPaxclayZPhrt3oW5dxly6xNatW3FycmLr1q3Ur1/f2qUTeYAEFsvQUkMjx9R2aakegQSWHHFxcQHg/v37Vi5JFly4oF66DPzQowcLFi4E4Msvv6RZs2bWLJnIA2TQrWVpqaGRY2q7tFSPQAJLjthUYJkyBRITudu+Pf9LDitjxozh9ddft3LBRF4gg24tS0vhQAKL7ZLA8gyxmcDy+++wfj0K8F6BAty4cYNq1arx8ccfW7tkIo+QQbfWoYWGRgKL7ZLA8gyxmcAyfz4oCjNq1mT1li0AfPbZZ7LKsrAYGXRrWVpqaLRQBpE9WqpHIIElR2wisNy4AV9/zZ/A1OTBwYsXL6Zt27bWLZfIkySwWIaWGho5prZLS/UIJLDkiE0Els8/h/h4PihcmMeJibzyyiuMGDHC2qUSeYwMurUsLTU0ckxtl5bqEUhgyZHnnnsO0HBgiY+HpUv5Fdhy9y52dnbMnTvX2qUSeZAMurUsLTU0Elhsl5bqEUhgyRF9D0tsbKyVS5KBH36AyEhm588PwOuvv061atWsWyaRJ8mgW8vSUkMjgcV2aakegQSWHNH8KaFVq7gEfBsXB8AH+gUPhbASGcNiGVpqaOSY2i4t1SOQwJIjmg4sV65AcDDzgCRFoUOHDjKbrbAauUrIsrTU0MgxtV1aqkcggSVHNB1Y1qzhP2C1nXqIx40bZ93yiDxNBt1alpYaGjmmtktL9QgksOSIZgNLYiKsXs0iIC4picaNG9OqVStrl0rkYTLo1rK01NBIYLFdWqpHkM3AsnTpUjw9PXF2dsbLy4tDhw5luG1ERAS9e/ematWq2NnZ4e/vn2abwMBAdDpdmltc8tgLrdJsYAkO5v4///BZcmUbN26c/LEQViWDbi1LSw2NBBbbpaV6BNkILEFBQfj7+zNx4kTCwsJo0aIFvr6+XL16Nd3t4+PjKVGiBBMnTqRu3boZ7rdQoUJEREQY3ZydnU0tnkWlDCxaOaAArFzJ90C0olCxYkU6d+5s7RIJAcgYFkvR0ucnx9R22XxgmT9/PgMHDmTQoEFUr16dgIAAPDw8WLZsWbrbV6hQgYULF9KvXz9cXV0z3K9Op8PNzc3opnX6wJKYmEhCQoKVS5Psxg3YupVVyT8OHDgQOzs58yesSwbdWocWGho5prbLpgNLQkICp06dwsfHx+h+Hx8fQkJCclSQ2NhYypcvT9myZXnllVcICwvLdPv4+HhiYmKMbpamDyygodNCX37Jn48ecQiws7NjwIAB1i6REDLo1sK01NDIMRXmYlJgiYqKIjExkVKlShndX6pUKSIjI7NdiGrVqhEYGMjWrVtZv349zs7ONGvWjPPnz2f4nJkzZ+Lq6mq4eXh4ZPv1sytfvnw4OTkBGpk8TlFgxQpD78rLL79M6dKlrVokIUAG3VqaBBZhDlqqR5DNQbepK56iKDmqjE2aNKFv377UrVuXFi1asGHDBqpUqcLixYszfM748eOJjo423K5du5bt188JTQ28PXSI+D//ZG3yjwMHDrRqcYTQk0G3lqWlhkYCi+3SUj0CyGfKxsWLF8fe3j5Nb8qNGzfS9LrkhJ2dHQ0bNsy0h8XJycnQu2FNLi4u3L59WxuBZcUKFgI3gDJlyvDSSy9Zu0RCGJExLJahpYZGjqnt0lI9AhN7WBwdHfHy8iI4ONjo/uDgYJo2bWq2QimKQnh4OO7u7mbbZ27RTA/L7dvc3rCBj5N/nDFjBg4ODlYtkhB6MujWsrTU0MgxtV1aqkdgYg8LwOjRo/Hz86NBgwZ4e3vzxRdfcPXqVYYOHQqop2quX7/OunXrDM8JDw8H1HEeN2/eJDw8HEdHR2rUqAHAtGnTaNKkCZUrVyYmJoZFixYRHh7OZ599Zoa3mLs0E1i+/JKvExK4B9SqVYu+fftatzxCpGDqoFuRM1pqaCSw2C4t1SPIRmDp2bMnt27dYvr06URERFCrVi127NhB+fLlAXWiuNRzsqRcw+bUqVN88803lC9fnitXrgBw9+5dhgwZQmRkJK6urtSvX5+DBw/SqFGjHLw1y9BEYEkebLsm+cfBgwfLpcxCU6SHxbK01NDIMbVdWqpHkI3AAjBs2DCGDRuW7mOBgYFp7nvam12wYAELFizITlGsThOBJTSUsN9/JwxwcHCgd+/e1iuLEOmQQbeWpaWGRgKL7dJSPQJZSyjHnnvuOcDKlzUvXszC5G+7d+9O8eLFrVcWITIhPSyWoaWGRo6p7dJSPQIJLDlWuHBhQD2tZRVXrxK5YQPrk38cNWqUdcohRCbklJBlaamhkWNqu7RUj0ACS45ZPbAsXsyUpCQSgKZNm9K4cWPrlEOITMigW8vSUjiQwGK7JLA8Y/SB5c6dO5Z/8ZgYflu2jJXJP86ePdvyZRAiC6SHxTq00NDIMbVdElieMUWKFAGs1MOyciVj7t8nCXita1eaN29u+TIIkQUy6NaytNTQSGCxXVqqRyCBJcesdkro3j32TZ/OTsDB3p7Zc+ZY9vWFyAbpYbEMLTU0ckxtl5bqEUhgyTGrnRIKCCAgOhqAQYMG8fzzz1v29YUwgazWbFlaamjkmNouLdUjkMCSY1Y5JXTrFpfmzOHH5B9Hvfuu5V5biGyQ1ZotS0sNjQQW26WlegQSWHLMKj0ss2ezNDYWBfBp356qVata7rWFyAYZdGtZWmpo5JjaLi3VI5DAkmP6Hpbo6GiSkpJy/wWvX+f+okWsSv5x5Dvv5P5rCpFDMujWsrTU0EhgsV1aqkcggSXHXF1dAfWAxsTE5P4LfvQRX8fHcxeoWLEivr6+uf+aQpiJ9LBYhpYaGjmmtktL9QgksOSYs7Mzzs7OgAXGsVy4gLJyJYuTfxw+fDj29va5+5pCmIEMurUsLTU0ckxtl5bqEUhgMQuLDbydMoXNiYn8BhQoUIC33nord19PCDORQbeWpaWGRgKL7dJSPQIJLGZhkYG3p0+z+Ztv6JH848CBAw2vK4TWyaBby9JSQyPH1HZpqR6BBBazyPXJ4xSFv4cO5U0gEejduzdzZKI4YUNk0K1laenzk8Biu7QWWPJZuwDPAv0podzqYXm8YQN9jh4lGmhSvz6BgYE4ODjkymsJkZukh8WytNDQyDG1XVoLLNLDYgb6HpZbt26Zf+cPHvDhkCEcAQo6OvLNxo0SVoTNkUG3lqWlhkaOqe3SUj0CCSxmUblyZQB+/fVXs+97bZ8+zEy+XPrzzz/H09PT7K8hRG6TQbeWpaWGRgKL7dJSPQIJLGbRuHFjAI4dO2bW/R7euJHBP/wAwIRXX6XXgAFm3b8QliKDbi1LSw2NHFPbpaV6BBJYzKJRo0YAnD9/ntu3b5tln/Hx8Qzo149HQPfixfno++/Nsl8hrEEG3VqWlhoaCSy2S0v1CCSwmEWxYsUMqyWfOHEix/u7cuUK3Zs35+KDB7gBq7dvx04miBPPAOlhsQytNTQgx9QWaa0eSWAxE/1poZwGluvXr9OsaVO2nTwJwNxOnSiY3IMjhK2SQbeWpaWGRo6p7dJSPQIJLGZTo0YNQD0tlF3Lly+ndu3a/BsRQTVgt5sbfb/91kwlFMJ6ZNCtZWmpoZHAYru0VI9A5mExm0qVKgFw8eLFbD3/6NGjDB8+nKSkJKoA24GKa9ZAgQLmK6QQViKDbi1LSw2NHFPbpaV6BBJYzCargSUiIoLff/+dGzduMHv2bG7duoW3tzcHDhwgKSmJ3s7OrIuLw/7tt6FjR0sUXQiLkUG3lqGlhkYCi+3SUj0CCSxmow8skZGR3L9/HxcXlzTbHDlyhBdffJG4uDij+79PvgKomosLi+7fx75GDZg3L/cLLYSFSA+LZWmpoZFjaru0VI9AAovZFClShCJFinDnzh0uXbpE7dq1jR6PjIzkjTfeIC4ujnLlyuHm5kaDBg1o3bo1v/32G0UPHWLIvn3kd3aG9eshf34rvRMhzE8G3VqWlj4/Oaa2SwLLM6xSpUqcPHmSOnXqsGbNGvr3749Op+PgwYOMGjWKf/75h6pVq3LixAkKFixoeN7rN2/Cvn3qD2vXQp06VnoHQuQOGXRrHVr4PCWw2C4JLM8wNzc3w/dvvvkmp0+fpnbt2gwcOBCA4sWLs23bNqOwwg8/wIgR6vcffQQ9eliwxEJYhpwSsiwtNTRyTG2XluoRyGXNZtWiRQujnwMCAgxhpVevXoSEhBgmmAPg6FHo1QsUBQYPhokTLVlcISxOBt1ahpYaGgkstktL9QgksJjVO++8w08//cSDBw8ICAjAzk79eHv06MFXX31lWCQRgAsXoFMniIuDl16CpUtBfqHFM0p6WCxLSw2NHFPbpaV6BNkMLEuXLsXT0xNnZ2e8vLw4dOhQhttGRETQu3dvqlatip2dHf7+/ulut3HjRmrUqIGTkxM1atRg8+bN2SmaVTk7O9OxY0fy58/PqFGjuHbtGufPn+fbb781hBcAHj6Erl0hKgq8vCAoCPLJ2Tnx7JJBt5alpYZGjqnt0toxMzmwBAUF4e/vz8SJEwkLC6NFixb4+vpy9erVdLePj4+nRIkSTJw4kbp166a7TWhoKD179sTPz4/Tp0/j5+dHjx49zL76saWVLl2a559/Pu1Bf+89+O03KFkSfvwRnnvOOgUUwkJk0K1lSWAR5qSFegTZCCzz589n4MCBDBo0iOrVqxMQEICHhwfLli1Ld/sKFSqwcOFC+vXrh6ura7rbBAQE0L59e8aPH0+1atUYP3487dq1IyAgwNTiad+mTaD/rL78EtzdrVseISxATglZlgQWYQ5aqkdgYmBJSEjg1KlT+Pj4GN3v4+NDSEhItgsRGhqaZp8dOnTI0T416eZNdXAtwNixkOo9C/Gsk0G3lqGlhkYCi+3SUj0CEy9rjoqKIjExkVKlShndX6pUKSIjI7NdiMjISJP3GR8fT3x8vOHnmJiYbL++xYwdC7dvq/OsfPyxtUsjhMVID4tlaamhkWNqu7RUjyCbg25TVzxFUXJcGU3d58yZM3F1dTXcPDw8cvT6ue7gQQgMVK8E+vxzcHCwdomEsBgZdGtZWmpo5JjaLi3VIzAxsBQvXhx7e/s0PR83btxI00NiCjc3N5P3OX78eKKjow23a9euZfv1c11CArz9tvr94MHQpIl1yyOEhcmgW8vSUkMjgcV2aakegYmBxdHRES8vL4KDg43uDw4OpmnTptkuhLe3d5p97t69O9N9Ojk5UahQIaObZs2bB2fPQokSMHOmtUsjhMXJKSHL0tLnJ8fUdmktsJg8+cfo0aPx8/OjQYMGeHt788UXX3D16lWGDh0KqD0f169fZ926dYbnhIeHAxAbG8vNmzcJDw/H0dGRGjVqADBq1ChatmzJ7Nmz6dKlC1u2bGHPnj0cPnzYDG/Ryi5ehOnT1e/nz4eiRa1bHiGsSAbdWpYWGhoJLLbL5gNLz549uXXrFtOnTyciIoJatWqxY8cOypcvD6gTxaWek6V+/fqG70+dOsU333xD+fLluXLlCgBNmzbl22+/ZdKkSUyePJlKlSoRFBRE48aNc/DWNEBRYPhwdTbbdu2gTx9rl0gIq5AeFsvSUkOjhTKI7NFSPYJsLn44bNgwhg0blu5jgYGBae7Lypvt3r073bt3z05xtGvDBti1CxwdZep9kafJoFvL0lJDI8fUdmmpHoGsJZR77t6FUaPU7ydOhCpVrFocIaxJBt1alpYaGgkstktL9QgksOQORVHDyn//QdWq8MEH1i6REFYlp4QsS0sNjRxT26WlegQSWHLHihWwbh3Y2anfOzlZu0RCaIIMurUMLTU0Elhsl5bqEUhgMb9Tp2DkSPX7Tz6BFi2sWx4hNEB6WCxLSw2NHFPbpaV6BBJYzOv2bejeXZ0ornNndSp+IYQMurUwLTU0ckxtl5bqEUhgMZ+kJPDzgytXoGJFWLtWPSUkhJBBtxampYZGAovt0lI9Agks5vPJJ7BjBzg7w/ffQ+HC1i6REJohp4QsS0sNjRxT26WlegQSWMxj3z6YMkX9ftkySDFRnhDiCRl0axlaamgksNguLdUjkMCSc/fvw6BB6qXMgwbBgAHWLpEQmiM9LJalpc9PjqntksDyrJk8GS5dAg8Pda0gIUQaMujWOrTQ0MgxtV0SWJ4loaEQEKB+//nnULCgVYsjhFbJoFvL0lJDI4HFdmmpHoEEluyLi4O33lJPBfXvD76+1i6REJolp4QsS0sNjRxT26WlegQSWLLvww/hjz/AzU1OBQmRRTLo1jK01NBIYLFdWqpHIIEle3btgk8/Vb9fvhyKFrVueYTQOOlhsSwtNTRyTG2XluoRSGAx3f790LWreipo8GDo0sXaJRJC82TQrWVpqaGRY2q7tFSPQAKLaXbvhpdfhocP1TErixZZu0RC2AQZdGtZWmpoJLDYLi3VI5DAknWrV0OHDvDgAXTsCJs2qbPaCiGyTE4JWYaWGho5prZLS/UIJLA8XXw8DB0KAweqP/fuDZs3S1gRwgSm/uGTxi1ntNTQSGCxXVqqRwD5rF0ATUtIgG7dYPt29ed33oEFC2RRQyFMJINuLUtLDY0cU9ulpXoEEliezslJ7U35/HN1NWb5pRPCZDLo1rK01NDIMbVdWqpHIIElc46O8O23cOYMvPCCtUsjhM2SQbeWpaVwIIHFdmktsMi5jadxcJCwIoSZyCkhy9JCQyPH1HZJYBFC5Dky6NaytNTQSGCxXVqqRyCBRQhhATLo1rK01NDIMbVdWqpHIIFFCGEBMujWsrTU0MgxtV1aqkcggUUIYQEy6NaytNTQSGCxXVqqRyCBRQhhQXJKyDK01NDIMbVdWqpHIIFFCGEBMujWsrTU0EhgsV1aqkcggUUIYQEy6NaytNTQyDG1XVo7ZhJYhBC5TgbdWpYEFmFOWqhHIIFFCGEBMujWsiSwCHPQUj0CCSxCCAuSU0KWoaWGRo6p7dJSPYJsBpalS5fi6emJs7MzXl5eHDp0KNPtDxw4gJeXF87OzlSsWJHly5cbPR4YGIhOp0tzi4uLy07xhBAaI4NuLUtLn58EFttl84ElKCgIf39/Jk6cSFhYGC1atMDX15erV6+mu/3ly5d56aWXaNGiBWFhYUyYMIF33nmHjRs3Gm1XqFAhIiIijG7Ozs7Ze1dCCE2RMSzWoYWGRo6p7dJaYDF5teb58+czcOBABg0aBEBAQAC7du1i2bJlzJw5M832y5cvp1y5cgQEBABQvXp1Tp48yaeffkq3bt0M2+l0Otzc3LL5NoQQWiZXCVmWlhoaOaa2S0v1CEzsYUlISODUqVP4+PgY3e/j40NISEi6zwkNDU2zfYcOHTh58iSPHj0y3BcbG0v58uUpW7Ysr7zyCmFhYZmWJT4+npiYGKObEEKbZNCtZWmpoZHAYru0VI/AxMASFRVFYmIipUqVMrq/VKlSREZGpvucyMjIdLd//PgxUVFRAFSrVo3AwEC2bt3K+vXrcXZ2plmzZpw/fz7DssycORNXV1fDzcPDw5S3IoSwAulhsQwtNTRyTG2XluoRZHPQbeqKpyhKppUxve1T3t+kSRP69u1L3bp1adGiBRs2bKBKlSosXrw4w32OHz+e6Ohow+3atWvZeStCCAuQQbeWpaWGRgKL7dJSPQITx7AUL14ce3v7NL0pN27cSNOLoufm5pbu9vny5aNYsWLpPsfOzo6GDRtm2sPi5OSEk5OTKcUXQliJDLq1LC01NHJMbZeW6hGY2MPi6OiIl5cXwcHBRvcHBwfTtGnTdJ/j7e2dZvvdu3fToEEDHBwc0n2OoiiEh4fj7u5uSvGEEBolg24tS0sNjRxT26WlegTZOCU0evRoVq5cyerVqzl37hzvvvsuV69eZejQoYB6qqZfv36G7YcOHcrff//N6NGjOXfuHKtXr2bVqlW8//77hm2mTZvGrl27uHTpEuHh4QwcOJDw8HDDPoUQtk0G3VqWlhoaCSy2S0v1CLJxWXPPnj25desW06dPJyIiglq1arFjxw7Kly8PQEREhNGcLJ6enuzYsYN3332Xzz77jNKlS7No0SKjS5rv3r3LkCFDiIyMxNXVlfr163Pw4EEaNWpkhrcohNAK6WGxDC01NHJMbZeW6hFkI7AADBs2jGHDhqX7WGBgYJr7WrVqxS+//JLh/hYsWMCCBQuyUxQhhA2QU0KWpaWGRo6p7dJSPQJZS0gIYQGmNlbSuOWMlhoaCSy2S0v1CCSwCCEsQHpYLEtLn58cU9slgUUIkefIoFvr0MLnKYHFdklgEULkWdLDYhlaamjkmNouLdUjkMAihLAAOSVkWVpqaOSY2i4t1SOQwCKEsAAZdGtZWmpoJLDYLi3VI5DAIoSwAOlhsSwtNTRyTG2XluoRSGARQliADLq1LC01NBJYbJeW6hFIYBFCWJD0sFiGlhoaOaa2S0v1CCSwCCEsQE4JWZbWGhqQY2qLtHbMJLAIIXKdDLq1LC0FFgmhtivlMdNCXZLAIoTIddLDYlkSWIQ5SGARQuRZMujWMiSwCHOQwCKEyHOkh8WytPT5yTG1XRJYhBB5jgQW69BCIyPH1HZJYBFC5Dky6NaytHhKSNgeCSxCiDxHelgsS4uBRY6p7ZHAIoTIs2TQrWVIYBHmIIFFCJHnSA+LZUlgEeYggUUIkedIYLEsCSzCHCSwCCHyHBl0a1kSWIQ5SGARQuQ50sNiWRJYhDlIYBFC5Fky6NYyJLAIc5DAIoTIc6SHxbIksAhzkMAihMhzJLBYlgQWYQ4SWIQQeY4MurUsLX1+EliEuUhgEULkOulhsQ4t/Fcsx9R2SQ+LECLPkkG3liGnhIQ5SGARQuQ50sNiWRJYhDlIYBFC5DkSWCxLAoswBwksQog8RwbdWpYEFmEOz0RgWbp0KZ6enjg7O+Pl5cWhQ4cy3f7AgQN4eXnh7OxMxYoVWb58eZptNm7cSI0aNXBycqJGjRps3rw5O0UTQmiQ9LBYlgQWYQ42H1iCgoLw9/dn4sSJhIWF0aJFC3x9fbl69Wq621++fJmXXnqJFi1aEBYWxoQJE3jnnXfYuHGjYZvQ0FB69uyJn58fp0+fxs/Pjx49enDs2LHsvzMhhObIoFvLkMAizMHmA8v8+fMZOHAggwYNonr16gQEBODh4cGyZcvS3X758uWUK1eOgIAAqlevzqBBg3jrrbf49NNPDdsEBATQvn17xo8fT7Vq1Rg/fjzt2rUjICAg229MCKEd0sNiWRJYhLlpoS6ZFFgSEhI4deoUPj4+Rvf7+PgQEhKS7nNCQ0PTbN+hQwdOnjzJo0ePMt0mo30CxMfHExMTY3QTQmiTBBbLksAizEVLdcmkwBIVFUViYiKlSpUyur9UqVJERkam+5zIyMh0t3/8+DFRUVGZbpPRPgFmzpyJq6ur4ebh4WHKWxFCWJAMurUsLTUyElhsm5bqUrYG3aaueIqiZFoZ09s+9f2m7nP8+PFER0cbbteuXcty+YUQlpXVxkoaN/PQUiMjx9S2aaku5TNl4+LFi2Nvb5+m5+PGjRtpekj03Nzc0t0+X758FCtWLNNtMtongJOTE05OTqYUXwihAZn9M6KFP4rPAi2FAwkstk1LgcWkHhZHR0e8vLwIDg42uj84OJimTZum+xxvb+802+/evZsGDRrg4OCQ6TYZ7VMIYVuyerWBNG7mpYVGRo6pbdNSYDGphwVg9OjR+Pn50aBBA7y9vfniiy+4evUqQ4cOBdRTNdevX2fdunUADB06lCVLljB69GgGDx5MaGgoq1atYv369YZ9jho1ipYtWzJ79my6dOnCli1b2LNnD4cPHzbT2xRCWJMEFsvSUiMjx9S2aakumRxYevbsya1bt5g+fToRERHUqlWLHTt2UL58eQAiIiKM5mTx9PRkx44dvPvuu3z22WeULl2aRYsW0a1bN8M2TZs25dtvv2XSpElMnjyZSpUqERQUROPGjc3wFoUQ1iaDbi1LS42MBBbbpqW6ZHJgARg2bBjDhg1L97HAwMA097Vq1Ypffvkl0312796d7t27Z6c4QgiNkx4Wy9JSIyPH1LZpqS5lK7AIIUR2jR49Gju79IfPhYWFWbg0zyZ9I3Pv3j38/f2tWpbffvsNkMBiq/THbdq0aRQqVAh/f38qVKhglbJIYBFC5DpnZ2ccHR1JSEhg8eLFT93e1dXVAqV6duk/v7i4OBYuXGjl0qjkmNqmwoUL8/DhQ9asWQPAG2+8IYFFCPHsKlCgAJs2bcp09mq94sWLy+nhHCpbtizr16/nzJkz1i4KACVLlqRTp07WLobIhqCgIHbu3Gn4uXTp0lYri07RwokpM4iJicHV1ZXo6GgKFSpk7eIIIYQQIguy2n5na6ZbIYQQQghLksAihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNy2ftApiLftHpmJgYK5dECCGEEFmlb7f17XhGnpnAcu/ePQA8PDysXBIhhBBCmOrevXu4urpm+LhOeVqksRFJSUn8+++/FCxYEJ1OZ+3imE1MTAweHh5cu3aNQoUKWbs4IhU5Ptomx0fb5PhonyWOkaIo3Lt3j9KlS2Nnl/FIlWemh8XOzo6yZctauxi5plChQvILrWFyfLRNjo+2yfHRvtw+Rpn1rOjJoFshhBBCaJ4EFiGEEEJongQWjXNycmLKlCk4OTlZuygiHXJ8tE2Oj7bJ8dE+LR2jZ2bQrRBCCCGeXdLDIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8BiYVOnTkWn0xnd3NzcDI8risLUqVMpXbo0+fPnp3Xr1vz+++9G+4iPj2fkyJEUL14cFxcXOnfuzD///GPpt/LMOHjwIJ06daJ06dLodDp++OEHo8fNdUzu3LmDn58frq6uuLq64ufnx927d3P53dm+px2fAQMGpPmdatKkidE2cnxyz8yZM2nYsCEFCxakZMmSvPrqq/z5559G28jvkPVk5fjYyu+QBBYrqFmzJhEREYbbmTNnDI/NmTOH+fPns2TJEk6cOIGbmxvt27c3rJUE4O/vz+bNm/n22285fPgwsbGxvPLKKyQmJlrj7di8+/fvU7duXZYsWZLu4+Y6Jr179yY8PJydO3eyc+dOwsPD8fPzy/X3Z+uednwAOnbsaPQ7tWPHDqPH5fjkngMHDjB8+HCOHj1KcHAwjx8/xsfHh/v37xu2kd8h68nK8QEb+R1ShEVNmTJFqVu3brqPJSUlKW5ubsqsWbMM98XFxSmurq7K8uXLFUVRlLt37yoODg7Kt99+a9jm+vXrip2dnbJz585cLXteACibN282/GyuY3L27FkFUI4ePWrYJjQ0VAGUP/74I5ff1bMj9fFRFEXp37+/0qVLlwyfI8fHsm7cuKEAyoEDBxRFkd8hrUl9fBTFdn6HpIfFCs6fP0/p0qXx9PTkjTfe4NKlSwBcvnyZyMhIfHx8DNs6OTnRqlUrQkJCADh16hSPHj0y2qZ06dLUqlXLsI0wH3Mdk9DQUFxdXWncuLFhmyZNmuDq6irHzQz2799PyZIlqVKlCoMHD+bGjRuGx+T4WFZ0dDQARYsWBeR3SGtSHx89W/gdksBiYY0bN2bdunXs2rWLFStWEBkZSdOmTbl16xaRkZEAlCpVyug5pUqVMjwWGRmJo6MjRYoUyXAbYT7mOiaRkZGULFkyzf5Lliwpxy2HfH19+frrr9m7dy/z5s3jxIkTtG3blvj4eECOjyUpisLo0aNp3rw5tWrVAuR3SEvSOz5gO79Dz8xqzbbC19fX8H3t2rXx9vamUqVKrF271jDISafTGT1HUZQ096WWlW1E9pnjmKS3vRy3nOvZs6fh+1q1atGgQQPKly/P9u3bee211zJ8nhwf8xsxYgS//vorhw8fTvOY/A5ZX0bHx1Z+h6SHxcpcXFyoXbs258+fN1wtlDqN3rhxw/DfiZubGwkJCdy5cyfDbYT5mOuYuLm58d9//6XZ/82bN+W4mZm7uzvly5fn/PnzgBwfSxk5ciRbt25l3759lC1b1nC//A5pQ0bHJz1a/R2SwGJl8fHxnDt3Dnd3dzw9PXFzcyM4ONjweEJCAgcOHKBp06YAeHl54eDgYLRNREQEv/32m2EbYT7mOibe3t5ER0dz/PhxwzbHjh0jOjpajpuZ3bp1i2vXruHu7g7I8cltiqIwYsQINm3axN69e/H09DR6XH6HrOtpxyc9mv0dMsvQXZFl7733nrJ//37l0qVLytGjR5VXXnlFKViwoHLlyhVFURRl1qxZiqurq7Jp0yblzJkzSq9evRR3d3clJibGsI+hQ4cqZcuWVfbs2aP88ssvStu2bZW6desqjx8/ttbbsmn37t1TwsLClLCwMAVQ5s+fr4SFhSl///23oijmOyYdO3ZU6tSpo4SGhiqhoaFK7dq1lVdeecXi79fWZHZ87t27p7z33ntKSEiIcvnyZWXfvn2Kt7e3UqZMGTk+FvL2228rrq6uyv79+5WIiAjD7cGDB4Zt5HfIep52fGzpd0gCi4X17NlTcXd3VxwcHJTSpUsrr732mvL7778bHk9KSlKmTJmiuLm5KU5OTkrLli2VM2fOGO3j4cOHyogRI5SiRYsq+fPnV1555RXl6tWrln4rz4x9+/YpQJpb//79FUUx3zG5deuW0qdPH6VgwYJKwYIFlT59+ih37tyx0Lu0XZkdnwcPHig+Pj5KiRIlFAcHB6VcuXJK//7903z2cnxyT3rHBlDWrFlj2EZ+h6znacfHln6HdMlvSAghhBBCs2QMixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNO//mpsDdofvaw4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "for _key, key in enumerate(report.keys()):\n", + " if _key < 1:\n", + "\n", + " rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))\n", + " rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()\n", + " wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])\n", + "\n", + " miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5\n", + " maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5\n", + " minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5\n", + " maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5\n", + "\n", + " plt.figure()\n", + " plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))\n", + " plt.title(f'NIS01_20210403_{key}')\n", + " for k,i in report[key].items():\n", + " plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)\n", + "\n", + " for k,i in report[key].items():\n", + " plt.figure()\n", + " in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())\n", + " in_situ = np.genfromtxt(in_situ_path, skip_header=3)\n", + " plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')\n", + " mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))\n", + " plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')\n", + " plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "85419744-2391-48f0-b6c2-239390d4b994", + "metadata": {}, + "source": [ + "## Per-Pixel Retrievals\n", + "\n", + "This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).\n", + "\n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f60f1ae9-754b-4c25-bc51-70b792debed7", + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5efac6d4-c9f5-4292-a8e1-739939056ac1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n" + ] + } + ], + "source": [ + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')\n", + "config.input.loc_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "467786f7-35a6-4472-92c5-1fa753da9e3d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line\n" + ] + } + ], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fdbd8001-530b-497f-a2c8-fdda0a2206d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(13, 428)\n", + "[0.10742364 0.60519719]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def closest_wl(mv):\n", + " return np.argmin(np.abs(io.meas_wl-mv))\n", + "\n", + "wl_nan = io.meas_wl.copy()\n", + "wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan\n", + "wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan\n", + "\n", + "fig = plt.figure(figsize=(14,5))\n", + "print(states.shape)\n", + "offset = 0\n", + "for n in range(0,states.shape[0],4):\n", + " lab = f'Step {n}'\n", + " if n == 0:\n", + " lab = 'Algebraic inversion at initial guess'\n", + " \n", + " plt.plot(wl_nan, states[n,:-2] + offset, label=lab)\n", + " offset += 0.04\n", + "plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')\n", + "plt.legend()\n", + "\n", + "print(states[-1,-2:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8fcb0f-cd8e-47b9-9146-2e1335afcfd2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/html/_sources/sensor_examples/neon/neon.ipynb.txt b/isofit-tutorials/build/html/_sources/sensor_examples/neon/neon.ipynb.txt new file mode 100644 index 0000000..339460d --- /dev/null +++ b/isofit-tutorials/build/html/_sources/sensor_examples/neon/neon.ipynb.txt @@ -0,0 +1,1608 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "35412b86-171d-473c-8575-470b8fbed89d", + "metadata": {}, + "source": [ + "# NEON\n", + "\n", + "Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f81e3c4a-0bef-4cbe-a494-75c8e0d908ca", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.\n", + "\n", + "Prerequisites:\n", + "- Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the 'data' folder which includes the 'subsets' directory.\n", + "- Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed8d9de0-a74a-4e6c-83b2-54f7bc32f593", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "from pathlib import Path\n", + "from types import SimpleNamespace\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "from spectral.io import envi\n", + "\n", + "import isofit\n", + "from isofit.utils.apply_oe import apply_oe \n", + "from isofit.utils.surface_model import surface_model\n", + "from isofit import ray\n", + "ray.shutdown()\n" + ] + }, + { + "cell_type": "markdown", + "id": "164060bf-3cad-4d58-811f-838158d7d967", + "metadata": {}, + "source": [ + "ISOFIT needs at minimum three pieces as input:\n", + "\n", + " 1. Radiance measurements (rdn)\n", + " 2. Observation values (obs)\n", + " 3. Location information (loc)\n", + "\n", + "This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can 'fake' the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:\n", + "\n", + "```\n", + "Radiance\n", + "├── 173647\n", + "│ ├── NIS01_20210403_173647_obs_ort\n", + "│ ├── NIS01_20210403_173647_obs_ort.hdr\n", + "│ ├── NIS01_20210403_173647_rdn_ort\n", + "│ └── NIS01_20210403_173647_rdn_ort.hdr\n", + "└── 174150\n", + " ├── NIS01_20210403_174150_obs_ort\n", + " ├── NIS01_20210403_174150_obs_ort.hdr\n", + " ├── NIS01_20210403_174150_rdn_ort\n", + " └── NIS01_20210403_174150_rdn_ort.hdr\n", + "```\n", + "\n", + "These files have corresponding in situ data as well, and below we've encoded the locations of each, which we can use to help subset data files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7b88339c-ac36-4aab-98b7-2a1dd07ab8a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data subset directory at: /Users/bgreenbe/.isofit/neon_subset\n", + "Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json\n", + "sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5\n", + "6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs\n" + ] + } + ], + "source": [ + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "\n", + "# Path to the input NEON data\n", + "subset_dir = str(Path('~/.isofit/neon_subset').expanduser())\n", + "print(f'Data subset directory at: {subset_dir}')\n", + "\n", + "# Path to write isofit output\n", + "output = str(Path('~/.isofit/neon_subset/output').expanduser())\n", + "if os.path.isdir(output) is False:\n", + " os.mkdir(output)\n", + "\n", + "if os.path.isdir(subset_dir) is False:\n", + " os.mkdir(subset_dir)\n", + "\n", + "surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())\n", + "print(f'Surface model at: {surface_model_path}')\n", + "neon_id = '173647'\n", + "\n", + "\n", + "# Optionally set some environment variables as needed\n", + "#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'\n", + "#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'\n", + "\n", + "print(f'sRTMnet emulator path (required): {os.environ[\"EMULATOR_PATH\"]}')\n", + "print(f'6s path (required): {os.environ[\"SIXS_DIR\"]}')\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "727dcd06-2a38-4020-8a15-b6707b8ed453", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a5656147-509e-41f4-9cac-c9b81117c5b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Which NEON date to process - change this to process a different date\n", + "neon_id = list(report.keys())[0]\n", + "\n", + "# Select the locations from the neon id -- roi == Regions of Interest\n", + "roi = report[neon_id]" + ] + }, + { + "cell_type": "markdown", + "id": "e9ec9046-3c9d-47bf-914c-68e67424065f", + "metadata": {}, + "source": [ + "#### Loc file generation\n", + "\n", + "NEON doesn't distribute (?) a loc file, so let's fake one for now. We'll do this for the full file and for the subset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5b51ea6-f2ba-4348-9ec9-4a3eadd6c1c0", + "metadata": {}, + "outputs": [], + "source": [ + "def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):\n", + " \"\"\"\n", + " Retrieves the metadata from an envi header\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']\n", + " Removes keys from the metadata dictionary\n", + " \"\"\"\n", + " rdn_ds = envi.open(file)\n", + " metadata = rdn_ds.metadata.copy()\n", + " for key in remove:\n", + " if key in metadata:\n", + " del metadata[key]\n", + " else:\n", + " print(f'Key {key!r} not found in the metadata, skipping')\n", + "\n", + " return metadata\n", + "\n", + "def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake LOC file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " lon: float\n", + " Longitude value for location\n", + " lat: float\n", + " Latitude value for location\n", + " elv: float\n", + " Elevation in kilometers\n", + " output: str, default=None\n", + " Path to write the LOC file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `loc`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " Logger.error('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 3\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " loc = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " loc[..., 0] = lon\n", + " loc[..., 1] = lat\n", + " loc[..., 2] = elv\n", + "\n", + " del ds, loc\n", + "\n", + "def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake OBS file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN file containing metadata\n", + " param0: int, float, default=0\n", + " Parameter 0\n", + " sea: int, float, default=0\n", + " Solar Azimuth\n", + " sez: int, float, default=0\n", + " Sensor Zenith\n", + " soa: int, float, default=0\n", + " Solar Azimuth\n", + " soz: int, float, default=0\n", + " Solar Zenith\n", + " phase: int, float, default=0\n", + " Phase\n", + " slope: int, float, default=0\n", + " Slope\n", + " aspect: int, float, default=0\n", + " Aspect\n", + " cosi: int, float, default=0\n", + " COS(i)\n", + " param9: int, float, default=0\n", + " Parameter 9\n", + " param10: int, float, default=0\n", + " Parameter 10\n", + " output: str, default=None\n", + " Path to write the OBS file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `obs`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " print('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " rdn_ds = envi.open(rdn)\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 11\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " obs = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " obs[..., 0] = param0\n", + " obs[..., 1] = sea\n", + " obs[..., 2] = sez\n", + " obs[..., 3] = soa\n", + " obs[..., 4] = soz\n", + " obs[..., 5] = phase\n", + " obs[..., 6] = slope\n", + " obs[..., 7] = aspect\n", + " obs[..., 8] = cosi\n", + " obs[..., 9] = param9\n", + " obs[..., 10] = param10\n", + "\n", + " del ds, obs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bac7ba6b-1c0e-41b7-97e0-d9e137a9e217", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key 'band names' not found in the metadata, skipping\n" + ] + } + ], + "source": [ + "fakeLOC(\n", + " rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),\n", + " lon = -105.237000,\n", + " lat = 40.125000,\n", + " elv = 1689.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "83bf8ace-3e19-4674-86df-d2f46e220a32", + "metadata": {}, + "source": [ + "## Apply OE\n", + "\n", + "The next part walks through running the ISOFIT utility script `isofit/utils/apply_oe.py`. This is the first step of executing ISOFIT and will generate a default configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d0ec94f8-b1e7-4e4d-9b8f-450134ca5a83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n" + ] + } + ], + "source": [ + "output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "surface_model(**{\n", + " 'config_path': surface_model_path,\n", + " 'output_path': output_surface_file,\n", + " 'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3cbe6f39-6d6f-4182-abfb-30e95ce49ede", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns\n", + "WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...\n", + "2025-07-08 15:20:10,698\tINFO worker.py:1917 -- Started a local Ray instance.\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn\n", + "2025-07-08 15:20:11,728\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: completing\n", + "2025-07-08 15:20:11,781\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc\n", + "2025-07-08 15:20:11,825\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2 0.84 1.49 2.13 2.77 3.42 4.06 4.7 5.35 5.99]\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.\n", + "INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess\n", + "INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "2025-07-08 15:20:11,882\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:20:19.280425-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete\u001b[32m [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11\u001b[32m [repeated 7x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17160)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete. 34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded. Aerosol State Vector:\n", + "{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}\n", + "Aerosol LUT Grid:\n", + "{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}\n", + "Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt\n", + "INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT\n", + "INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "2025-07-08 15:20:53,541\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:20:59 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)\n", + "INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:03 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)\n", + "INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:08 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)\n", + "INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:13 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)\n", + "INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:17 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)\n", + "INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:21 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)\n", + "INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:27 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)\n", + "INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:31 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)\n", + "INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:35 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)\n", + "INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:21:43 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\", file_line:1171, created_time:\"2025-07-08T15:21:46.660474-07:00\", http2_error:2, grpc_status:14}\n", + "I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:21:46.660733-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:21:47 ||| \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (32,0).\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:21:52 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (27,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:21:58 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (55,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:03 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (61,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:08 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (99,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:13 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (105,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:18 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (166,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:23 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (193,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:28 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (210,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:33 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (230,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:39 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (269,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:44 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (275,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:49 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (303,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:55 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (320,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:00 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (376,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:05 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (383,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:10 ||| \u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (412,0).\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete. 91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core\n", + "INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference\n", + "INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:16 ||| \u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (419,0).\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n", + "2025-07-08 15:23:17,031\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores\n", + "INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete. 1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core\n", + "2025-07-08 15:23:18,445\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete. 51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core\n", + "INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.\n", + "\u001b[36m(Worker pid=17657)\u001b[0m INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:24:10.613957-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n" + ] + } + ], + "source": [ + "kwargs = {\n", + " 'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance\n", + " 'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location\n", + " 'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations\n", + " 'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory\n", + " 'sensor': 'neon', \n", + " \"surface_path\": output_surface_file, # Surface priors - often changes\n", + " 'emulator_base': os.environ['EMULATOR_PATH'],\n", + " 'n_cores': 4,\n", + " \"wavelength_path\": None,\n", + " \"surface_category\": \"multicomponent_surface\",\n", + " \"rdn_factors_path\": None, # RCC update used 'on the fly'\n", + " \"channelized_uncertainty_path\": None, # Channelized uncertainty - if you have an instrument model\n", + " \"model_discrepancy_path\": None, # Model discrepancy term - handle things like unknown radiative transfer model effects\n", + " \"lut_config_file\": None,\n", + " \"logging_level\": \"INFO\",\n", + " \"log_file\": None,\n", + " \"presolve\": True, # Attempts to solve for the right wv range\n", + " \"analytical_line\": True, # mathematical representation of OE given that the atmsophere is known\n", + " \"ray_temp_dir\": \"/tmp/ray\",\n", + " \"segmentation_size\": 10,\n", + " \"num_neighbors\": [5],\n", + " \"atm_sigma\": [0.5],\n", + " \"pressure_elevation\": False,\n", + "}\n", + "\n", + "apply_oe(**kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9d31291a-c036-4288-9114-cd772dda6748", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "for _key, key in enumerate(report.keys()):\n", + " if _key < 1:\n", + "\n", + " rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))\n", + " rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()\n", + " wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])\n", + "\n", + " miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5\n", + " maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5\n", + " minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5\n", + " maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5\n", + "\n", + " plt.figure()\n", + " plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))\n", + " plt.title(f'NIS01_20210403_{key}')\n", + " for k,i in report[key].items():\n", + " plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)\n", + "\n", + " for k,i in report[key].items():\n", + " plt.figure()\n", + " in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())\n", + " in_situ = np.genfromtxt(in_situ_path, skip_header=3)\n", + " plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')\n", + " mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))\n", + " plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')\n", + " plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "85419744-2391-48f0-b6c2-239390d4b994", + "metadata": {}, + "source": [ + "## Per-Pixel Retrievals\n", + "\n", + "This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).\n", + "\n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f60f1ae9-754b-4c25-bc51-70b792debed7", + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5efac6d4-c9f5-4292-a8e1-739939056ac1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n" + ] + } + ], + "source": [ + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')\n", + "config.input.loc_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "467786f7-35a6-4472-92c5-1fa753da9e3d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line\n" + ] + } + ], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fdbd8001-530b-497f-a2c8-fdda0a2206d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(13, 428)\n", + "[0.10742364 0.60519719]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def closest_wl(mv):\n", + " return np.argmin(np.abs(io.meas_wl-mv))\n", + "\n", + "wl_nan = io.meas_wl.copy()\n", + "wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan\n", + "wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan\n", + "\n", + "fig = plt.figure(figsize=(14,5))\n", + "print(states.shape)\n", + "offset = 0\n", + "for n in range(0,states.shape[0],4):\n", + " lab = f'Step {n}'\n", + " if n == 0:\n", + " lab = 'Algebraic inversion at initial guess'\n", + " \n", + " plt.plot(wl_nan, states[n,:-2] + offset, label=lab)\n", + " offset += 0.04\n", + "plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')\n", + "plt.legend()\n", + "\n", + "print(states[-1,-2:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8fcb0f-cd8e-47b9-9146-2e1335afcfd2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/html/_sources/sensor_examples/neon/neon_single_pixel.ipynb.txt b/isofit-tutorials/build/html/_sources/sensor_examples/neon/neon_single_pixel.ipynb.txt new file mode 100644 index 0000000..069c37b --- /dev/null +++ b/isofit-tutorials/build/html/_sources/sensor_examples/neon/neon_single_pixel.ipynb.txt @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup\n", + "\n", + "This notebook is an excercise in running ISOFIT in pixel mode (dynamically from python), in order to get into some configuation details.\n", + "\n", + "Prerequisites:\n", + "- Run the neon.ipynb notebook succesfully - we'll use some of the outputs created from that intiial sample run" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running Per-Pixel Retrievals\n", + "\n", + "That gave us a baseline run, but its not clear what might be improved. Let's load up some individual retrievals so we can understand the performance a bit better. \n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Loading config file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Loading from wavelength_file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Prebuilt LUT provided\n", + "WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_upwelling\n", + "WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_downwelling\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Resampling LUT to instrument spectral response.\n" + ] + } + ], + "source": [ + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "output = os.path.join(home,'outputs')\n", + "output_surface_file = os.path.join(output, 'surface.mat')\n", + "neon_id = '173647' #one of 173647, 174150\n", + "roi = report[neon_id]\n", + "indata = os.path.join(home, 'data') \n", + "\n", + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = output_surface_file\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_obs_ort')\n", + "config.input.loc_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the basic setup, we can run some retrievals." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, Ls, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(12, 428)\n", + "[0.11728845 0.61252989]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAAGsCAYAAAC1slApAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hT5RfA8W9Wm3QPOmlLWzaUVfbeFgREQBQUAVFAcYCoiAMEFQcqIirgQFCGgoufIHvJ3nvTQilddO+VJvn9ERooZdM2UM7neXja3vvee89NS5ucvO85CpPJZEIIIYQQQgghhBBC3LOU1g5ACCGEEEIIIYQQQtyYJHCEEEIIIYQQQggh7nGSwBFCCCGEEEIIIYS4x0kCRwghhBBCCCGEEOIeJwkcIYQQQgghhBBCiHucJHCEEEIIIYQQQggh7nGSwBFCCCGEEEIIIYS4x6mtHcCtMBqNxMbG4ujoiEKhsHY4QgghhBBCCCGEEKXCZDKRmZmJr68vSuX159ncFwmc2NhY/P39rR2GEEIIIYQQQgghRJm4cOECfn5+191/XyRwHB0dAfPNODk5WTkaIYQQQgghhBBCiNKRkZGBv7+/JfdxPfdFAqdo2ZSTk5MkcIQQQgghhBBCCFHh3KxkjBQxFkIIIYQQQgghhLjHSQJHCCGEEEIIIYQQ4h4nCRwhhBBCCCGEEEKIe9x9UQPnVhkMBvR6vbXDEEI8IDQaDSqVytphCCGEEEIIIR4AFSKBYzKZiI+PJy0tzdqhCCEeMC4uLnh7e9+04JgQQgghhBBC3I0KkcApSt54enpiZ2cnL6SEEGXOZDKRk5NDQkICAD4+PlaOSAghhBBCCFGR3fcJHIPBYEneuLu7WzscIcQDRKfTAZCQkICnp6cspxJCCCGEEEKUmfu+iHFRzRs7OzsrRyKEeBAV/e6R+ltCCCGEEEKIsnTfJ3CKyLIpIYQ1yO8eIYQQQgghRHmoMAkcIYQQQgghhBBCiIpKEjhCCCGEEEIIIYQQ9zhJ4NzDNm3ahEKhKPX26AqFgqVLl5bqOYt06NCBMWPG3PHxgYGBTJ8+vdTiKStDhw7l0UcftXYYt+xO4r2Vn5PbPW9kZCQKhYKDBw/eVixCCCGEEEII8aC777tQ3e+2b99O27Zt6dq1K6tWrbJ2OHftr7/+QqPR3PHxe/bswd7evhQjKhtfffUVJpPJ2mEwadIkli5detOEyJ3EGxcXh6urK2BOvAQFBXHgwAEaNmx4V+cVQgghhBBCCHH7ZAaOlf3000+8/PLLbN26laioKGuHc1232mHHzc0NR0fHO76Oh4eH1TuK3cq9Ojs74+LiUvbBlJI7idfb2xtbW9tSP68QQpQVY14eOfv2kbV5s7VDEUIIIYQodRUugWMymcgpKLTKv9udiZCdnc2SJUt44YUX6NmzJ/PmzbvpMT/88AP+/v7Y2dnRp08fpk2bVuIF9LJly2jcuDFarZbg4GAmT55MYWFhsTFxcXF0794dnU5HUFAQv//+u2Vf0TKXJUuW0KFDB7RaLQsWLCA5OZmBAwfi5+eHnZ0d9erV49dffy123quXUOXn5zNu3Dj8/f2xtbWlevXqzJkz57r3d/USKoVCwY8//kifPn2ws7OjevXq/PPPPwAYjUb8/PyYPXt2sXPs378fhULB2bNnAUhPT2fEiBF4enri5OREp06dOHTokGX8pEmTaNiwIT/99BPBwcHY2tpiMpn4448/qFevHjqdDnd3d7p06UJ2djZQculQfn4+r7zyCp6enmi1Wtq0acOePXss+4uWw61fv54mTZpgZ2dHq1atOHXq1HUfC4A333yTGjVqYGdnR3BwMBMmTLAkmObNm8fkyZM5dOgQCoUChUJx3Z+hq+Pt0KEDr7zyCuPGjcPNzQ1vb28mTZpU7Jgrl1AFBQUB0KhRIxQKBR06dLjmeVetWkWbNm1wcXHB3d2dnj17EhERccN7vFpcXBw9evSw/GwuWrSo2M/FtZZhpaWloVAo2LRpk2Xb8ePHefjhh3FwcMDLy4unn36apKQky/4bfX83bdpEs2bNsLe3x8XFhdatW3P+/Pnbug8hRPkrTEri/FODiH5ltLVDEUIIIYQodRVuCVWu3kCdiautcu3j74dhZ3PrD+nixYupWbMmNWvWZNCgQbz88stMmDDhum2Jt23bxvPPP8+nn37KI488wrp165gwYUKxMatXr2bQoEHMmDGDtm3bEhERwYgRIwB47733LOMmTJjAJ598wldffcX8+fMZOHAgISEh1K5d2zLmzTff5IsvvmDu3LnY2tqSl5dH48aNefPNN3FycuLff//l6aefJjg4mObNm18z5sGDB7Njxw5mzJhBgwYNOHfuXLEX0bdi8uTJTJ06lc8++4yvv/6ap556ivPnz+Pm5saAAQNYuHAhzz//vGX8okWLaNmyJcHBwZhMJnr06IGbmxsrVqzA2dmZ7777js6dO3P69Gnc3NwACA8PZ8mSJfz555+oVCri4+MZOHAgU6dOpU+fPmRmZrJly5brJunGjRvHn3/+yc8//0yVKlWYOnUqYWFhhIeHW64B8M477/DFF1/g4eHB888/z7Bhw9i2bdt1793R0ZF58+bh6+vLkSNHGD58OI6OjowbN44nnniCo0ePsmrVKtatWweYZ8Tcqp9//pmxY8eya9cuduzYwdChQ2ndujVdu3YtMXb37t00a9aMdevWUbduXWxsbK55zuzsbMaOHUu9evXIzs5m4sSJ9OnTh4MHD6JU3lq+ePDgwSQlJbFp0yY0Gg1jx44lISHhlu8LzEmg9u3bM3z4cKZNm0Zubi5vvvkmjz/+OBs2bCAuLu6639/CwkIeffRRhg8fzq+//kpBQQG7d++WduFC3AdULuZln6a8PIy5uSh1OitHJIQQQghReipcAud+MmfOHAYNGgRAt27dyMrKYv369XTp0uWa47/++mu6d+/O66+/DkCNGjXYvn07y5cvt4yZMmUK48ePZ8iQIQAEBwfzwQcfMG7cuGIJnP79+/Pcc88B8MEHH7B27Vq+/vprZs6caRkzZswY+vbtWyyGomsDvPzyy6xatYrff//9mgmc06dPs2TJEtauXWu5p+Dg4Ft/gC4ZOnQoAwcOBOCjjz7i66+/Zvfu3XTr1o2nnnqKadOmcf78eapUqYLRaOS3337j7bffBmDjxo0cOXKEhIQEy3Kgzz//nKVLl/LHH39YklsFBQXMnz8fDw8PwDyLp7CwkL59+1KlShUA6tWrd834srOzmTVrFvPmzaN79+6AeabU2rVrmTNnDm+88YZl7JQpU2jfvj0A48ePp0ePHuTl5aHVaq957nfffdfyeWBgIK+99hqLFy9m3Lhx6HQ6HBwcUKvVeHt73/bjWr9+fcvPRPXq1fnmm29Yv379NRM4RY+Lu7v7Da/Vr1+/Yl/PmTMHT09Pjh8/TkhIyE1jOnnyJOvWrWPPnj00adIEgB9//JHq1avf8n0BzJo1i9DQUD766CPLtp9++gl/f39Onz5NVlbWdb+/KSkppKen07NnT6pWrQpQLLEphLh3Ke3tUGg0mPR6DKmpksARQgghRIVS4RI4Oo2K4++HWe3at+rUqVPs3r2bv/76CwC1Ws0TTzzBTz/9dN0EzqlTp+jTp0+xbc2aNSuWwNm3bx979uxhypQplm0Gg4G8vDxycnIs9WVatmxZ7DwtW7YsUQi36AX0lef55JNPWLx4MTExMeTn55Ofn3/dosMHDx5EpVJZEhZ3qn79+pbP7e3tcXR0tMzIaNSoEbVq1eLXX39l/Pjx/PfffyQkJPD4448D5scjKysLd3f3YufMzc0ttrSnSpUqliQFQIMGDejcuTP16tUjLCyMhx56iMcee8xS1PdKERER6PV6Wrdubdmm0Who1qwZJ06cuO69+Pj4AJCQkEBAQMA17/2PP/5g+vTphIeHW5IOTk5ON37AbtGVsRTFc7szXa4WERHBhAkT2LlzJ0lJSRiNRgCioqJuKYFz6tQp1Go1oaGhlm3VqlW75uN+I/v27WPjxo04ODhcM8aHHnrout9fNzc3hg4dSlhYGF27dqVLly48/vjjlu+XEOLepVAoULm6UpiQQGFKKhpfX2uHJIQQQghRaipcAkehUNzWMiZrmTNnDoWFhVSuXNmyzWQyodFoSE1NveYLVpPJVGIZx9VLeoxGI5MnTy4xcwa47iyPIlef++rEzBdffMGXX37J9OnTqVevHvb29owZM4aCgoJrnk9XSu98Xt3VSqFQWBIDAE899RSLFi1i/PjxLFq0iLCwMCpVqgSYHw8fH59itVGKXFk76Op7ValUrF27lu3bt7NmzRq+/vpr3nnnHXbt2mWpB1Ok6Htwre/N1duuvJeifVfey5V27tzJgAEDmDx5MmFhYTg7O/Pbb7/xxRdfXHP87brZ43onevXqhb+/Pz/88AO+vr4YjUZCQkKu+zNytestUbtye9FSrCu3XV142mg00qtXLz799NMS5/Lx8bnp93fu3Lm88sorrFq1isWLF/Puu++ydu1aWrRocUv3IYSwnqIEjiE11dqhCCGEEEKUqgpXxPh+UFhYyC+//MIXX3zBwYMHLf8OHTpElSpVWLhw4TWPq1WrFrt37y62be/evcW+Dg0N5dSpU1SrVq3EvytrkOzcubPYcTt37qRWrVo3jHvLli307t2bQYMG0aBBA4KDgzlz5sx1x9erVw+j0ch///13w/PerSeffJIjR46wb98+/vjjD5566inLvtDQUOLj41Gr1SUej6Ikz/UoFApat27N5MmTOXDgADY2Nvz9998lxlWrVg0bGxu2bt1q2abX69m7d+9dLb3Ztm0bVapU4Z133qFJkyZUr169RCFdGxsbDAbDHV/jVhXVvLnRtZKTkzlx4gTvvvsunTt3pnbt2qTe5guoWrVqUVhYyIEDByzbwsPDSUtLs3xdNFMqLi7Osu3q2WOhoaEcO3aMwMDAEt/3omTdzb6/jRo14q233mL79u2EhISwaNGi27oXIYR1qC69AWJIkwSOEEIIISqWe3+qSgW0fPlyUlNTefbZZ0sUnX3ssceYM2cOL730UonjXn75Zdq1a8e0adPo1asXGzZsYOXKlcVmeUycOJGePXvi7+9P//79USqVHD58mCNHjvDhhx9axv3+++80adKENm3asHDhQnbv3n3D7lBgTlT8+eefbN++HVdXV6ZNm0Z8fPx1kxSBgYEMGTKEYcOGWYoYnz9/vtgSp9IQFBREq1atePbZZyksLKR3796WfV26dKFly5Y8+uijfPrpp9SsWZPY2FhWrFjBo48+WmKZWJFdu3axfv16HnroITw9Pdm1axeJiYnXvFd7e3teeOEF3njjDdzc3AgICGDq1Knk5OTw7LPP3vF9VatWjaioKH777TeaNm3Kv//+WyKBFBgYyLlz5zh48CB+fn44OjretPX3nfD09ESn07Fq1Sr8/PzQarUlfnZdXV1xd3fn+++/x8fHh6ioKMaPH39b16lVqxZdunRhxIgRzJo1C41Gw2uvvYZOp7P8nOt0Olq0aMEnn3xCYGAgSUlJxWoFAbz44ov88MMPDBw4kDfeeINKlSoRHh7Ob7/9xg8//MDevXuv+/09d+4c33//PY888gi+vr6cOnWK06dPM3jw4Lt7EIUQ5ULl6gIgM3CEEEIIUeHIDBwrmDNnDl26dLlmx6B+/fpx8OBB9u/fX2Jf69atmT17NtOmTaNBgwasWrWKV199tdjSqLCwMJYvX87atWtp2rQpLVq0YNq0aZZCrUUmT57Mb7/9Rv369fn5559ZuHAhderUuWHcEyZMIDQ0lLCwMDp06IC3t3exFtLXMmvWLB577DFGjRpFrVq1GD58uKVVc2l66qmnOHToEH379i22dEuhULBixQratWvHsGHDqFGjBgMGDCAyMhIvL6/rns/JyYnNmzfz8MMPU6NGDd59912++OILS5Hiq33yySf069ePp59+mtDQUMLDw1m9evVt1265Uu/evXn11Vd56aWXaNiwIdu3by/Rdaxfv35069aNjh074uHhUaKte2lRq9XMmDGD7777Dl9f32JJsiJKpZLffvuNffv2ERISwquvvspnn31229f65Zdf8PLyol27dvTp08fSeevKn/OffvoJvV5PkyZNGD16dLHkJICvry/btm3DYDAQFhZGSEgIo0ePxtnZGaVSecPvr52dHSdPnqRfv37UqFGDESNG8NJLLzFy5Mjbf+CEEOVOfen3bqEkcIQQQghRwShM1ys6cQMzZ87ks88+Iy4ujrp16zJ9+nTatm17zbGbNm2iY8eOJbafOHHipkt2imRkZODs7Ex6enqJAq55eXmcO3eOoKCgm9Z4qYiGDx/OyZMn2bJli7VDEaJMREdH4+/vz7p16+jcubO1wynhQf8dJMS9JnHG1yTNnInLgCfwmTTJ2uEIIYQQQtzUjXIeV7rtJVSLFy9mzJgxzJw5k9atW/Pdd9/RvXt3jh8/ft1OOmDuLnNlIFd2/BG37vPPP6dr167Y29uzcuVKfv7552Ktv4W4323YsIGsrCzq1atHXFwc48aNIzAwkHbt2lk7NCHEfcBSAyc1zbqBCCGEEEKUsttO4EybNo1nn32W5557DoDp06ezevVqZs2axccff3zd4zw9PYt1/RF3Zvfu3UydOpXMzEyCg4OZMWOG5XshREWg1+t5++23OXv2LI6OjrRq1YqFCxeW6JolhBDXcjmBI0uohBBCCFGx3FYCp6CggH379pUoTPrQQw+xffv2Gx7bqFEj8vLyqFOnDu++++41l1UVyc/PJz8/3/J1RkbG7YRZoS1ZssTaIQhRpsLCwggLC7N2GEKI+5QUMRZCCCFERXVbRYyTkpIwGAwlir96eXkRHx9/zWN8fHz4/vvv+fPPP/nrr7+oWbMmnTt3ZvPmzde9zscff4yzs7Pln7+//+2EKYQQQogHlKWIsbQRF0IIIUQFc0dtxK9sWw1gMplKbCtSs2ZNatasafm6ZcuWXLhwgc8///y6NS3eeustxo4da/k6IyNDkjhCCCGEuKkra+Dc6PmJEEIIIcT95rZm4FSqVAmVSlVitk1CQsINWzJfrUWLFpw5c+a6+21tbXFycir2TwghhBDiZlRF9fYKCzFmZVk1FiGEEEKI0nRbCRwbGxsaN27M2rVri21fu3YtrVq1uuXzHDhwAB8fn9u5tBBCCCHETSl1OhQ6HSB1cIQQQghRsdz2EqqxY8fy9NNP06RJE1q2bMn3339PVFQUzz//PGBe/hQTE8Mvv/wCmLtUBQYGUrduXQoKCliwYAF//vknf/75Z+neiRBCCCEE5kLGhbm55gROQIC1wxFCCCGEKBW3ncB54oknSE5O5v333ycuLo6QkBBWrFhBlSpVAIiLiyMqKsoyvqCggNdff52YmBh0Oh1169bl33//5eGHHy69uxBCCCGEuETt4kphbByFMgNHCCGEEBXIbS2hKjJq1CgiIyPJz89n3759xYoRz5s3j02bNlm+HjduHOHh4eTm5pKSksKWLVskeYO5btDIkSMJCAjA1tYWb29vwsLC2LFjh2WMQqFg6dKl5R7bxx9/jEKhYMyYMeV+bSGEEOJuqdzcAHMhYyGEEEKIiuKOulCJu9evXz/0ej0///wzwcHBXLx4kfXr15OSkmLVuPbs2cP3339P/fr1rRqHEEIIcacud6KSGThCCCGEqDjuaAaOuDtpaWls3bqVTz/9lI4dO1KlShWaNWvGW2+9RY8ePQAIDAwEoE+fPigUCsvXAMuWLaNx48ZotVqCg4OZPHkyhYWFlv0KhYJZs2bRvXt3dDodQUFB/P777zeNKysri6eeeooffvgB10tPfoUQQoj7jcrVBZAEjhBCCCEqloqXwDGZoCDbOv9MplsK0cHBAQcHB5YuXUp+fv41x+zZsweAuXPnEhcXZ/l69erVDBo0iFdeeYXjx4/z3XffMW/ePKZMmVLs+AkTJtCvXz8OHTrEoEGDGDhwICdOnLhhXC+++CI9evSgS5cut3QfQgghxL1IXTQDJ00SOOL+ZDKZyD10CNMtPrcUQgjxYKh4S6j0OfCRr3Wu/XYs2NjfdJharWbevHkMHz6c2bNnExoaSvv27RkwYIBl6ZKHhwcALi4ueHt7W46dMmUK48ePZ8iQIQAEBwfzwQcfMG7cON577z3LuP79+/Pcc88B8MEHH7B27Vq+/vprZs6cec2YfvvtN/bv329JFAkhhBD3q6IlVFLEWNwv0v74A1OhAdcBTwCQvXUrF4aPwL5VK/zn/IhCobByhEIIIe4FFW8Gzn2iX79+xMbG8s8//xAWFsamTZsIDQ1l3rx5Nzxu3759vP/++5ZZPA4ODgwfPpy4uDhycnIs41q2bFnsuJYtW153Bs6FCxcYPXo0CxYsQKvV3vW9CSGEENakcimqgZNm3UBEhZJ3/DgFV3RaLS0FkZHEvTuB+EmTyNl/AIDkH+cAYFujhiRvhBBCWFS8GTgaO/NMGGtd+zZotVq6du1K165dmThxIs899xzvvfceQ4cOve4xRqORyZMn07dv32ue70au9wRg3759JCQk0LhxY8s2g8HA5s2b+eabb8jPz0elUt3aTQkhhBBWJkWMRWnLPXyYyCcGgMmEfatWuD/3LPatWpXKudP/+cfyedI33+Dx6hhydu0CtRq3IYNL5RpCCCEqhoqXwFEobmkZ072oTp06xdqGazQaDAZDsTGhoaGcOnWKatWq3fBcO3fuZPDgwcW+btSo0TXHdu7cmSNHjhTb9swzz1CrVi3efPNNSd4IIYS4r0gRY3E7jAUFZG/dhn3rVihtba85Jn3pUkutw+zt28nesYMqCxdgFxp6V9c2GY2k/+9yAid7+3YKk5IAcO7RA42Pz12dXwghRMVS8RI494Hk5GT69+/PsGHDqF+/Po6Ojuzdu5epU6fSu3dvy7jAwEDWr19P69atsbW1xdXVlYkTJ9KzZ0/8/f3p378/SqWSw4cPc+TIET788EPLsb///jtNmjShTZs2LFy4kN27dzNnzpxrxuPo6EhISEixbfb29ri7u5fYLoQQQtzrLEWM09MxGQwo5I0IcR0mk4nY114nc+1aXJ9+Gu933i45prCQjFWrAfCePJmsTZvI2riRi59+SuBvv6FQKChMSQGTCbW7+21dP3f/fvQxMSjt7XHo1ImMZcvIP30aALdhw+7+BoUQQlQoUgPHChwcHGjevDlffvkl7dq1IyQkhAkTJjB8+HC++eYby7gvvviCtWvX4u/vb5k9ExYWxvLly1m7di1NmzalRYsWTJs2jSpVqhS7xuTJk/ntt9+oX78+P//8MwsXLqROnTrlep9CCCGENahcXMyfGI0YMjKsGou4t6XM+5nMtWsBcyFhQ3p6iTHZO3dhSElB5eqKS98++Lw/GYWdHXmHDpPx7wqSZs/mTKvWnGndhvAuXYl///1iBbRv1EmqaPaNY1gYHqNHg9r83qp9u7Zoa9YozVsVQghRAShM90F/woyMDJydnUlPT8fJyanYvry8PM6dO0dQUJAU4L1EoVDw999/8+ijj1o7FCEqPPkdJMS96VTTZhgzMwlesQLb4CBrhyPuIcaCAvTRMeQdPULsW2+DwYDS3h5jdjaeb7yO+7PPFhsf+/Y7pP/1Fy4DB+BzqeNn0qxZJH41A4VGg0mvL3ENlbs77sOfI3ffPjI3/Ydt1aq4P/ccTt3CUFxK0hjz8znTpi3GzEwC5s3DvkVzEr6cTur8+QT8PA9dvXpl/2AIIYS4J9wo53ElWUIlhBBCiApH5eqKMTMTQ1oqIAmcisKYl0f2tm3knTxJfng4huQUjHl5YDSicnJE6eiEyskJpZMjKidn8zYHBxQaG4x5uWRt3ETW5s2YcnMt53Tq0QP7Vi2Je+ddUhYsxG3IEAxpaRQmJmITGGiZoeP88MOWY9yGDiV18RIK4+NBpcJ7wrs49ehBzr59JHz+OQXhESR88qllfP7Jk8S+/jopP/1ElUULUWq1ZK5ejTEzE7WPD3bNmgLg+eoYPF8dUz4PphBCiPuOJHCEEEIIUeGo3dzQR0Whj4uzdijiLuhjY8mPOEthUhK5hw+RsfxfjJmZd31ehZ0dNpUrowsNxWvcG6BWkzDtSwrj4rjw/Avk7NqFSa9HodNhys1F7eWF7opunUqdDt9PPyX5++9xG/YMDq1bA+DYoQP2rVqRNGsWmatW49C+PU7du5G1bRspc+eRd/w4KT//gvuzw0j89lsAXJ94HIVSqhoIIYS4OUngVED3wao4IYQQFYgxO5uC6Bg0Pt6objDttzzZ1qhB7sGD5J84AT16WDsccYtMJhN5x4+TtX49mes3kH/qVIkxGl9f7Jo3x7Z6dTTeXii0WlAoMGZlYUjPwJCRjjEjE0NGBsbMDAxZWeZlTkYTdo0b4xgWhrZuHRQKRbHzug4YQNK335K9dSsACq3WMlPHqWePEkkW++bNsG/erER8ShsbPEePxnP0aMs2XYMG2Pj7E/vGOJK//x4UCvTno1C5uuI66Om7ftyEEEI8GCSBI4QQQoi7cn7IUPKOHgXMtT/8pn+JXdOmVo1JG1IXlkDusWNWjUNcnzE/n4LISAoiIsgPjyA/IoLcw4cpvHLWlFKJbdWqqD080FSujNPD3bFr3rxMZqy4PvUkmRs3oLJ3oNKLo7Br0oTcw4fJj4jAuWfPuz6/U48epMz7mbxjx0icNg0A9xEjUDnY3/W5hRBCPBgkgSOEEEKIO6ZPSLAkbwAMycmk/PKLVRI4mQWZrIlcQ54hj751GwKQd/wEJpOpxGwLUb5MJhOG5GTyI86Sd/QoWVu2kLNvH1yjALBCp8OhTRscOnfCoX17S1v4sqZ2cyP4r7+KbbMLDcUuNLRUzq9QKvEcN46oIUPM1/P0xHXggFI5txBCiAeDJHCEEEIIccdyDx0CzEuWfD7+iMh+j5H132YMWdnlPrMgqyCLSTsmoVaqGfj4ThQaDcb0dPTR0dj4+5drLMIs99gxMlasIHPVavQxMSX2K52csK1aFdtqVbEJropt9erYNWmMsoJ29bNv3gzHrl3IXLuOSi+/VGHvUwghRNmQBI4QQggh7ljuwYMA6Bo2RFunDjZBQRScO0fWxo0497r7ZSe3w0XrAkChsZAchR7bGjXIO3aMvKNHJYFTjkwmE7n795vryWzfcXmHQoHGzw/b6tWxb9EC+7ZtsAkMfOBmR/l+/jn5p8+gqxdi7VCEEELcZySBI4QQQog7lnvQPANH17AhCoUCp+7dSJo5i4xVq8o9gaNT69CpdeQW5pKal4o2JMScwDl2DKfu3cs1lgeJMT+f3P37yd6+g9wjR8g/eRJDWpp5p1qNY5cuOHXvjkPbNijt7Kwa671AaWsryRshhBB3RBI4QgghhLhlhsxMcvbuxaFNGzCZLPVvdA0bAuDYzZzAyd68GUNWFioHh3KNz8XWxZzAyU/Fv24dQAoZlxWTwUDqwkUkzpiBMSur2D6FRoNznz5UGjkCTeXKVopQCCGEqFgkgSOEEEKIW5J36hTRL7+CPioK1yefxLnPo5jy81E5O2MTFAiAbfXq2FStSkFEBFkbNuD8yCPlGqOr1pW47DhS81KpXreuOW4pZFzqco8eI/6998i7lBxTe3pi37Ildk2bYFurNrbVqkp9FyGEEKKUlX4PRnFLEhISGDlyJAEBAdja2uLt7U1YWBg7dlxeK65QKFi6dGm5xFNYWMi7775LUFAQOp2O4OBg3n//fYxGY7lcXwghxL0t/X//I/KJAeijogBI/f13MlauAkDbsIElOaJQKHDq1s08ZvESTAZDucbpamvuWJSan4q2evVihYzF3TNkZRE/5SMiH3+cvGPHUDo54T1pEtU2bcT3009weewxdCF1JXkjhBBClAGZgWMl/fr1Q6/X8/PPPxMcHMzFixdZv349KSkpVonn008/Zfbs2fz888/UrVuXvXv38swzz+Ds7Mzo0aOtEpMQQgjrM2RmEj/5fTKWLwfAvnVrjDk55B44QMrcuQDoGjQodoxz70dI/vFHcvft4+Inn+L9ztvlFq+r1pzASctLQ2Fjc7mQ8bFjUsj4LuSHh5O6ZAnpfy/FmJkJgFPPnniNfxN1pUpWjk4IIYR4MEgCxwrS0tLYunUrmzZton379gBUqVKFZs2aWcYEBgYC0KdPH8v+yMhIAJYtW8akSZM4duwYvr6+DBkyhHfeeQe12vztVCgUzJw5k3/++YdNmzbh7e3N1KlT6d+//3Vj2rFjB71796ZHjx6W6//666/s3bu3tG9fCCHEPchkNJL0zTfk7N2HQ6eO2DdrRuamTaT9tpjChARQqag06gUqPf88Ofv2ETV4CJhMANhdqn9TxCYgAN9PPyFmzKukzp+PTZUquA16qlzuw8XWBYCUfPMbIkWFjHMPHrLMDBI3ZzKZyDtyhIyVq8jauJGCS89BAGyCgvB69x0cWre2XoBCCCHEA6jCJXBMJhO5hblWubZOrbul9fUODg44ODiwdOlSWrRoga2tbYkxe/bswdPTk7lz59KtWzdUKhUAq1evZtCgQcyYMYO2bdsSERHBiBEjAHjvvfcsx0+YMIFPPvmEr776ivnz5zNw4EBCQkKoXbv2NWNq06YNs2fP5vTp09SoUYNDhw6xdetWpk+ffgePhBBCiPuJsaCAuPFvkbFiBQA5u3cX26/x88P3s6nYNWoEgH2zZtg1b07Orl2gUKCtX7/EOZ26daPg1SgSv/ySix9/jGPXrmi8PMv8Xq6cgQNg37IFaYsXk/bnn7iPHIHa1fWGxxdERpIfGYljhw5lHOm9qSAykvRly0lfvgz9+ajLOzQaHNq2xXXgQOxbt0KhlFX4QgghRHmrcAmc3MJcmi9qbpVr73pyF3aam7fHVKvVzJs3j+HDhzN79mxCQ0Np3749AwYMoP6lJ8EeHh4AuLi44O3tbTl2ypQpjB8/niFDhgAQHBzMBx98wLhx44olcPr3789zzz0HwAcffMDatWv5+uuvmTlz5jVjevPNN0lPT6dWrVqoVCoMBgNTpkxh4MCBd/ZgCCGEuC8YCwq4MHIkOTt2gkaD2+CnyT10iNwDB7Fr3BiXx/rh+NBDJWqaeLzyMucH78WuUaPrdppyHzGcjNWryD9+gpzdu3Du1avM76cogZOanwqA40MPYVu7NvknTpA0c9YNl3Plh4cTOfBJjJmZBP75B7pLRZAfBNk7dpA442tyDxywbFPodDh26oRj167Yt2ld7h3FhBBCCFFchUvg3C/69etHjx492LJlCzt27GDVqlVMnTqVH3/8kaFDh173uH379rFnzx6mTJli2WYwGMjLyyMnJwc7O3MCqWXLlsWOa9myJQcPHrzueRcvXsyCBQtYtGgRdevW5eDBg4wZM8ayREsIIUTFdPHjj8nZsROlnR1+33yNfatWt3ScXePGBC9bhtrt+jNaFAoF9s1bXErg7C6fBE5REeM8cwJHoVTi9cbrRA17ltRff8XtqSexubRM+UqFyclceP4FS32X3AMHK2QCx6TXk3fyFLn791FwPgqTyUjB2XPm2VQAKhX2rVvh3KsXjp06obS3t27AQgghhLCocAkcnVrHrid3We3at0Or1dK1a1e6du3KxIkTee6553jvvfdumMAxGo1MnjyZvn37XvN8N3Kj5V1vvPEG48ePZ8CAAQDUq1eP8+fP8/HHH0sCRwghKqj05f+S9utvoFBQ+avpt5y8KWIbHHTTMXbNmpIydy45u/fcaZi3pagGTlp+mmWbfatW2LdtS/aWLSR8OR2/r6YXO8ZUWEj0iy8V61SVd/x4OURbtkyFheSHh1Nw9iz54eHk7D9A7qFDmHKvsdRco8F1wAAqjRiO+tIsYCGEEELcWypcAkehUNzSMqZ7UZ06dYq1DddoNBiuar8aGhrKqVOnqFat2g3PtXPnTgYPHlzs60aXahdcS05ODsqr1rOrVCppIy6EEBVQYXIymWvXcnHqZwC4Pz8Sh7Zty+Rado0bg0JBwfnz6C8mlHkdHDetGwApecW7Onq+/hrntmwhc906DFnZqBwuzyzJ3rmL3IMHUTo44D5yBIlfTLsvEzj6+Hj0sXEUJlwke9s2Mteuw5CWVmKc0tkZu0aNsK1ZE4VGg8LWBqdu3aRLlxBCCHGPq3AJnPtBcnIy/fv3Z9iwYdSvXx9HR0f27t3L1KlT6d27t2VcYGAg69evp3Xr1tja2uLq6srEiRPp2bMn/v7+9O/fH6VSyeHDhzly5Agffvih5djff/+dJk2a0KZNGxYuXMju3buZM2fOdWPq1asXU6ZMISAggLp163LgwAGmTZvGsGHDyvSxEEIIUT4MmZlkrllD+vLl5OzaDZcS9HbNm+Px0ktldl2VkxPa2rXJO36cnD17cO7Zo8yuBeCidQEgsyATvVGPRqkBQFuzJho/P/TR0eQe2F8sYZW9ZTMAjt3CcO7Rg8QvppEfHo4xPx/lNRoN3EuMOTlkbtxI6sJF5O7fX2K/0tER22rVsAkOQlevPnaNQ7GpWlWKEAshhBD3IUngWIGDgwPNmzfnyy+/JCIiAr1ej7+/P8OHD+ftty8XV/ziiy8YO3YsP/zwA5UrVyYyMpKwsDCWL1/O+++/z9SpU9FoNNSqVctSsLjI5MmT+e233xg1ahTe3t4sXLiQOnXqXDemr7/+mgkTJjBq1CgSEhLw9fVl5MiRTJw4scweByGEEGXDZDJRmJBIYVIi+vPnza2g//sPU0GBZYw2JASnbmG4DhyI4lKnw7Ji17RpuSVwnG2cUaDAhIn0/HQq6SpdjqNZM9Kjo8nZvbtYAifrP3MCx6FtO9Q+PqhcXDCkpZF/+gy6eiFlGu/tMun1ZO/cReaaNeQc2E/B2XOWZBwqFRofH9SVKmFbuxZOYWHYNWmCQi1P94QQQoiKQP6iW4GtrS0ff/wxH3/88Q3H9erVi17XKPgYFhZGWFjYDY/19fVlzZo1txyTo6Mj06dPl7bhQghxHytMTSX976Wk/f47BefOldhvU60qzj174dTj4XJdLmPXvBkpP/9Mzp6yr4OjUqpwtnUmLT+N1LzU4gmcpk1J/+uvYvV4Ci5coCAyEtRq7Fu1RKFQoK1Th+zt28k7ftzqCRyTyUTeseNkb91K7oED5Bw4gDEjo9gYta8PLn364vL44+XSql0IIYQQ1iEJHCGEEOI+ZzIYSF24iMTp0zHm5Jg3qlSo3dxQeVTCvmVLnHv1Mtc8uUFB+7JiqYNz9iyFiYllXiTXxdaFtPy0YoWMwZzAAcg9ehRjdjZKe3uyNptn39g1aoTK0REAbd3LCRxrMBUWkrNvP5nr1pG5fh2FsXHF9qsqVcKxaxcc2rVDW7cuGk9J2gghhBAPAkngCCGEEPchk8mE/sIFsrZsIf2vv8k7dgwA21q1cH1yIE4P9yhWqNeaVM7O2NaqRf6JE+Ts3YtT9+5lej03rRuRGZGWVuJFbPwqo/H1RR8bS86Bgzi0aW1J4Ni3u7ykSntpyXF5JnD0MTGkL1tG7oGD5Bw8iDE93bJPodNh37oV9k2bogsNRVunTpkvexNCCCHEvUcSOBWQyWSydghCCCFKmSE9nZw9e8jetZu8E8cpOBOO4YoX+UpHRzxfew2Xx/vfkwVq7Zo2If/ECXKPHi3zBE5RK/GrEzjmOJqS/r//kbN7N3ZNm5gLOgMO7dpbxhQlcPJPncKk16PQaMosVmN+Pslz5pD83feY8vMt21XOzjh06oRj1y7Yt2qFUqstsxiEEEIIcX+QBI4QQghxjyq4cIHM9evJWreenP37LxerLaJWYxcain3bNrg8+miZL026G26Dh+D21FNoAgLK/FquWlcAUvOvkcBp1sycwNmzh8w1azHl5aH28sK2RnXLGI2/P0oHB4xZWeSfPYu2Zs2bXjP36DFyDx8CkwkKCylMTqEwOQlDUjKFSUmgUmETWAXboCBsgoJQe3mR9d9/pP/1N4UJCQDomjTG6aEwdA3qo61bV4oPCyGEEKIYeWYghBBC3COMBQXk7t9P9rbtZG3aRP6ZM8X22wQHY9+iObpGjcytoYOC7puZGTZ+lcvtWpYEzrVm4DS7VAfnwAFyDxwAwLFzp2K1gRRKJdratcnZs4eUn3/BoV1b7Fu0QOXiUuJ8+pgYEr6YRsaKFTeNK+/w4WtuV3t54fXmOBy7d7dKjSJhfSl5KYB5+R9AYk4ir//3Ok/XeZrOAZ3l50IIIQQgCRwhhBDCqgouXCBzzVqyd+wgZ+9eTHl5l3eqVNg1aYJj5844dOpUrkmQ+5llCdU1ZuBo/PxQ+/qYCwMrlTj3eRSPV18tMU7XoD45e/aQ/tdfpP/1F2oPDwLmzcW2alXLmKwtW4h+ZTSm3FxQKLBv0walnR0KlQqVmxvqSu6o3N1RV6qESa+n4FwkBefOmf/FxKCtUQOXx/vj2KkTChubMns8xL0tR59Dv3/6YTQZ+V/v/+GidWH+ifnsT9iPCRNdqnSxdohCCCHuEZLAEUIIIcpZQVQUWZs2kbFiJbkHDxbbV9Q1yqF1axzat7/mrA9xY0UzcNLy0krsUygU+E6ZQtbWrbj064dtcPA1z+H27LMobGwoiDxP7sGD6GNjOf/0YAJ+moO2Vi0y160j+tWxoNeja9wY73ffQVu7dlnelrCipNwknln1DPYae/rX6E/3oO7YaexK5dzro9aTlJsEwC/Hf+GZkGf4/dTvAAwLGVYq1xBlo6xrZAkhxNUkgSOEEEKUIZPBQO7hw+Ts3EneqdPknTiO/nzU5QFKJfYtmuPQvj12LVtiW726LJe4S66216+BA2DfsiX2LVve8BxqV1c8XnkFgMLUVC48+xx5x49z7tE+KB0dMWZng9GIY7duVP5sqryIu88VGAqwUV1/FtTS8KVEZkQCcGzHMWYfns2vPX6lkq7SXV/7n4h/LJ8vPLGQQmMhWfosqjpXpZ1fu7s+vygbF55/gaxNm1A6OaHx9cX3k4/R1qpl7bCEEBWcJHCEEEKIUmQqKCB71y5yjxwh/+QpcvbswZB6VSJBrcaucWMcO3XEsXt3NJ6e1gm2grpRDZw7oXZ1JWDeXKJfGU3Ozp0YMzMBcO7dG58pH0qx4fvcguMLmLpnKu+1fI9+Nfpdc8zKcysB6BLQhcNJh4nPjufbg9/yXsv37uraF7MvsituFwB+Dn5EZ0Uz99hcAJ4JeQal4t7rKCfM3eOyNm0yf56RQX5GBnFvv0Pg70tQqFTWDU4IUaHJMw4hhBDiLhQmJpIfEYE+Joa8Y8fIWLESQ1pasTFKR0fsW7dGVy8E2xo10DVogMrJyToBPwCKauCk5adhMplKZUaTysmJgLk/YUhLw5CaBoBNUKDMlrrP7Ynfw+d7P8eEidmHZ9O7Wm/UyuJPjyPSIjidehq1Qs2kVpOISItgyKoh/HXmLwbWGojeqOfzPZ9jNBlp6NmQtpXb0sS7yS1d/99z/2LCRKhnKEPqDmH0xtEAeNl58XDQw6V+v6J0FMbHA6DQ6agyfz5RzzxD3vHjpC1ZguvAgVaOTghRkUkCx0oSEhKYMGECK1eu5OLFi7i6utKgQQMmTZpEy0vTuhUKBX///TePPvpomcezefNmPvvsM/bt20dcXFyJ6+r1et59911WrFjB2bNncXZ2pkuXLnzyySf4+vqWeXxCCHGvMGZnk7lxE5lr1pB78KClBfSVVJUq4dC6FbY1a6GrF4KuYUNZYlOOijr55BvyyS3MLbVaJQqFArWrK2pX11I5n7CupNwkxm0eh8FkACA+O571UesJCwwrNq5o9k2ryq1wtnUm1CuUrlW6svb8Wt7c/CYxWTHkFuYCsD9hPz8d/YnuQd15NfRV9l7cy3/R/xHsHMzAWgMts8MATCYTyyKWAdCrai86+nektlttTqScYHCdwWhU8jvjXqWPiwNA4+2NLqQuHqNHc/HDD0n4cjqODz2E2t3dyhEKISoqSeBYSb9+/dDr9fz8888EBwdz8eJF1q9fT0pKilXiyc7OpkGDBjzzzDP061dy+nBOTg779+9nwoQJNGjQgNTUVMaMGcMjjzzC3r17rRCxEELcHpPJROaatWRt3AgmEwobDXZNmuDQuTMqB4drji+Mjyf/9Gnyw8PJPxN+6eMZTPn5lwcqFNgEBKDx98cmwB+Hjp2wb9lCltVYkU6tw0ZpQ4GxgNT81FJL4Ih7Q1ZBFuFp4ZxJO0NKbgq5hbkYTAbsNfY42jjiaOOIg8bB8nnR1yaTic0xm9kQtYHwtHBismIoNBZSzaUarXxb8cvxX1hwfEGxBI7JZGJV5CoAugd1t2x/NfRVNl3YRHhaOACtfVsTFhjGnvg9/HvuX1aeW2lJ/BSZd2weQ+sO5YUGL6BQKDiRcoLwtHBslDY8FPgQCoWCGZ1msDt+Nz2CepT9A/mA0sfHo/byuqvZc/o48wwcjY8PAK4DB5D215/kHz9BwtTP8P30k1KJVQghribPLq0gLS2NrVu3smnTJtq3bw9AlSpVaNasmWVMYGAgAH369LHsj4yMBGDZsmVMmjSJY8eO4evry5AhQ3jnnXdQX3qxoFAomDlzJv/88w+bNm3C29ubqVOn0r9//+vG1L17d7p3737d/c7Ozqxdu7bYtq+//ppmzZoRFRVFQEDAbT8OQghRWgoTE4l9czyGzEwc2rbFpkoAWVu3kXvgALa1auL88MNkrFxJ5tp1xY5L+/0PFDY2aOvXw8Y/AJWzM4b0dAoTEsg7cQLDdZLqmoAAnLp3x6FtG7S1a6O0ty+P2xS3SKFQ4Kp15WLORVLzUqnsIO3X72cGo4HU/FQOJR7i7zN/szVmq2XWzN3ytfdlWodpOGgcWHRyEQcTD7LwxEI2Rm0kOiuaOu51OJ9xHluVLR39O1qO83fyZ0T9Ecw8OJMnaj7Bm83eRK1U06d6H56q/RQTtk/gTOoZKjtUJiwwjB2xOziRcoJZh2ZR170u7f3b88PhHwDoHNAZJxvzkkpve28eqfpIqdybKCll/gIuTpmCx5jRVHr++Ts+jz4uFgC1jzcACpUKn/feI3LAQNL/9z+cevXCoU3rUolZCCGuVOESOCaTCVNurlWurdDpbimb7+DggIODA0uXLqVFixbY2tqWGLNnzx48PT2ZO3cu3bp1Q3WpINrq1asZNGgQM2bMoG3btkRERDBixAgA3nvvciG9CRMm8Mknn/DVV18xf/58Bg4cSEhICLVLscVpeno6CoUCF2lxK4SwovyICC4MH4E+1vyEOu/IkWL79dHRZK1bb/5Crcb1yYFovLwwpKWTuX49BWfPkrt3H7l795U8uUqFTVAgttWrY1utGrbVqmNbvbrUPrkPFCVwknOTrR2KuE0Go4FDiYfYeGEjmy5sIiozCqPJWGyMp50n1V2q423vjU6tQ6lQkq3PJrMgk8yCTLL0WcU+zzeYZ81Vc6lG1ypdaeLVBH9HfzztPFEpzc+xHg56mH8i/uGT3ZdnT8RkxQDQ3q899priidrnGzzPoNqDcLApPoOvbqW6LO65mPPp5wl2CUapUDImdAyf7f2M+cfnM23fNFy1rqyLWocCBSPqjyjth1BcgzEnh6SZMwFImjUb50ceQePri8loxFRQgFKrveVzFVpm4FwuI6Br0ADXQYNInT+f+IkTCV72jyT3hRClruIlcHJzORXa2CrXrrl/Hwq7m0/TVqvVzJs3j+HDhzN79mxCQ0Np3749AwYMoH79+gB4eHgA4OLigre3t+XYKVOmMH78eIYMGQJAcHAwH3zwAePGjSuWwOnfvz/PPfccAB988AFr167l66+/ZualP1x3Ky8vj/Hjx/Pkk0/iJIU4hRBWknfqNOcHD8aYno6mSgDuQ4eSvWMn+rg47Js3Q9ekCTl79pCxYiXqSpXw+eD9Ym1ePca+Sv6ZM+SfPoM++gKG9AxUrq6o3VzNSZuaNW/rSf2DasXZFWyO2Yy3nTeBzoF0D+qOrarkmxNlLicFDiyAwnwCnQI5mXKSM2lnaO/fvvxjEbcsLS+NiPQIzqaf5VDCITZHby7RAl6BAh97H8KCwni02qMEOwff1jUKDAXkGfIsM12uZXCdwaw8txIFCvrV6Edr39bsit/FufRzvNDghWsec3XypohGqaGaa7XL8SsUPN/gef6J+Iez6Wd5af1LAPQI7lFsnCg7qYuXWDoCmvLzSZj2JZ6vjeXCqBfRx8RQdfWqW65vZamB4+NdbLvnmNFkbdiAPiaGi598ivfECVL/TAhRqipcAud+0a9fP3r06MGWLVvYsWMHq1atYurUqfz4448MHTr0usft27ePPXv2MGXKFMs2g8FAXl4eOTk52F1KIBUVQi7SsmVLDh48WCqx6/V6BgwYgNFoLLWEkBBC3C5jfj6xr7+GMT0dbYP6+M+ahdrNrUQHEMcOHfB6441rnkOhUKCtUQNtjRrlEXKFpDfqmbRjkqWIK0BCToJ1ZhXoc2DtBFCqCen7BasiV3E06Wj5xyGuy2gyEp4WztaYrWyP3c6Z1DOk5JVcquhk40Q7v3Z08O9AqGcoblo3y0yZO2GjssFGZXPDMTXdavK/R/+HndoOd525CG1pJv+cbJwYWX8kU/dMJTU/FbVCzagGo0rt/OL6jHl5JP80BwDXp54iddEiMpYvJ3v7dstS2byjx3Bo2+aWznc5geNTbLvS3h7v9ydz4dnnSPv9d7I2bcL1yYG4P/fcHSdyTHq9VZJAJqMRQ3o6hrQ0FBoNmsqVZeapEPeACpfAUeh01Nx/jWnw5XTt26HVaunatStdu3Zl4sSJPPfcc7z33ns3TOAYjUYmT55M3759r3m+G8ZXCr909Xo9jz/+OOfOnWPDhg0y+0YIYTWJ06aRfyYclbs7/jNnonZzs3ZID6TTqafJLczFQeNAc5/mrI9az8pzK62TwNFd+hkwFlLHKQiAY8nHyj8OYWEwGtifsJ/Vkas5nHiYc+nnyDPklRjna+9LsEsw1V2q06ZyGxp5NUKjLP8Xrf6O/mV6/gE1B7DoxCKis6LpU70P/k5lez1hlvbHnxgSk1D7+uD15jiMOTmk//13sTpnRXVtbsZkMlF4KYGj9vYpsd+hdWu8Jk4gaeYsChMTSfxqBia9Ho9XXrntuDNWryHm9ddxf+5ZPEePvu3jb8aYn0/u/v1kb99BfkQEhtRUDGlp5o8ZGWC8vHRR6eSEtnZtbAL80VSujH2btuhC6pZ6TEKIG6t4CRyF4paWMd2L6tSpw9KlSy1fazQaDIbiRfpCQ0M5deoU1ardeLrtzp07GTx4cLGvGzVqdFfxFSVvzpw5w8aNG3GXFolCCCvJ3r6dlJ9/AcBnyofSstWKDiUcAqCBZwPeb/0+/0X/R3haOGfTzhLscnvLXO6ajR1o7ECfQx1tJRQoiM+OJyk3iUq6SuUbywMurzCPJaeW8POxn0nITSi2T6vS0tS7KW0qt6GBRwOCnIMemE5hGpWGLzp8wbKIZTzf4M6L6IpbZ8jKIum72QBUGj4chY0NHq+OIe/4cTR+fii1WjL+/dcyq+ZmjBkZGHNygJJLqIq4Pfkkro89RsrCRSR8+inJc+fhOnAg6kslEm5FQXQMce+8A3o9yd99j2PHjugulVq4W4aMDFLm/UzKL79gzMq64ViloyOmvDyMGRnk7NpFzq5dACRO/wq75s1xf3YY9m3byuwcIcpJhUvg3A+Sk5Pp378/w4YNo379+jg6OrJ3716mTp1K7969LeMCAwNZv349rVu3xtbWFldXVyZOnEjPnj3x9/enf//+KJVKDh8+zJEjR/jwww8tx/7+++80adKENm3asHDhQnbv3s2cOXOuG1NWVhbh4eGWr8+dO8fBgwdxc3MjICCAwsJCHnvsMfbv38/y5csxGAzEx5sLuLm5uWFjc+NpyUIIUVoMaWnEvvU2AC4DnsCxQwfrBvSAO5R4KYHj0QAnGyda+rRkS8wW1pxfw/MuVniBaucO6TnYF+QR5BzE2fSzHE8+Tju/duUfywPEYDRwPPk4h5MOczLlJFtjtpKUmwSYlw51DuhMO792VHetTmWHyqiVD+5T0DrudajjXsfaYTwwkr75FkNiEpoqATj36weAxtOT4P8tNe///gf4918KY28tgaO/9PxX5eqK8gaz7xU2NrgNHULGqpXkHTpM4syZ+FxRr9KYm0vukSOonJxQe3kVq79jKiwk9o03zMkVjQb0euLenUDQn3/c1XIqk8lE+p9/cnHqZxgzMgBQe3pi37IluoYNULm7o3JxQe3qisrFBZWzMwobG0wFBeSHh5N36jT6mBjyT58mc8MGS0LHtno13IY+g2NYGCoHKdwsRFl6cP96WpGDgwPNmzfnyy+/JCIiAr1ej7+/P8OHD+ftt9+2jPviiy8YO3YsP/zwA5UrVyYyMpKwsDCWL1/O+++/z9SpU9FoNNSqVctSsLjI5MmT+e233xg1ahTe3t4sXLiQOnWu/2Rh7969dOx4uT3m2LFjARgyZAjz5s0jOjqaf/75B4CGDRsWO3bjxo10kBdQQohyYDKZiH//fQovXsSmShW8xo2zdkgPvCsTOAAPBT50OYFjjRkGdm6QfgFykgmpFMLZ9LMcTToqCZwyEpURxTcHvmFrzFYy9ZnF9vna+zKi/ggeqfoIGpUUchXlL+/0aVLmzwfA+913UV7jDceiOja3OgOnqOOh+jqzb66kUCjwfO01ogYPIe33P3AfMgSbwEAA4j/4kPS//rKMdX9+JJ5jxgCQ9P335B44gNLBgYC5P3Fh+AjyT58m8Ztv8XjlZRSqy/WgDJmZpC1ejMbPD6du3a4bS2FSEvGTJ5O5dh0ANtWq4vHSyzg+1BWFUnnj+7CxQVunDtorXkvo4+JI+fkX0pYsIf9MOHHvvEP85MnYt2qFyxOP49Chg8zKEaIMSALHCmxtbfn444/5+OOPbziuV69e9OrVq8T2sLAwwsLCbnisr68va9asueWYOnTogMlkuu7+wMDAG+4XQoiyZjKZSP97KRkrVoJKhe9nU1Hep0tm71cmk4mFJxbyd/jfjG82niDnIGKyYlCgoH4l89T+jv4dUSvUnEk9w7n0cwQ5B5VvkHaXltPlJFPHvQ7/RPwjdXDKQIGhgLlH5/L94e8pMBYA4KhxJNQrlNrutanjVoc2ldtI4kZYjclk4uIHH4LBgGPXLji0bXvNcZrK5lbgRYmZm7lcwNj3JiPN7Js1w6F9e7L++4+k2d/h+4n5+X/29u2AubaMMSODlLnzcBs0CJRKkn/4EQDv9yaiq1cPr7ffInbcmyR/9x0Zy5bh1PsRND4+GDMzSf5xjqW7VsGYSNxHjrQkTgpTU0lf+j8y160j98ABc00bjQbPMaNxGzq0WCLodml8fPAa/yaVRr1A6uLFpP3xB/rzUWRt2kTWpk3oGjTAY+xY7Js3u+NrXK3otYgkhsSDTBI4Qggh7lmFqank7NhB1vbtZG/fbpniXunFUaVWC0Dcmmx9NhO3TWTNefObA1N2TuGlRuZWyFVdqlraKTvbOtPctznbYrax9vza8i9mfEUCJ6Sy+QXb0aSjmEwmedJfSvbG7+WDnR9wNv0sAC19WvJioxcJcQ+5q05RQpSmzLVrydmzB4VWi9f48dcdZ5mBc/EiJoPhpkmNwjjzEiqN981n4BRxGzaMrP/+I3v7dkwmE4akJArj40GppPrGDZwfNoy8Q4cttd1Mublo69bFqWdPAJx69UIfF0/KTz+hj40ledbsYudXe3pSmJBA4vSvKIg8j8bfD33UBTJWrcKUn28Zp61XD5/Jk4rNpLlbKicnKg0fjvtzz5F/5gzp//sfqQsXkXvoEFFDhuDQpTNe48ZhExBwx9cwmUxkLF9OwpdfmotRe3tj4++PXYsW2LduhbZOHfn9Lh4YksARQghxzymIjCThy+lkrlkDV8z+U2g0OPXoQaURVuhw9AA7mnSU8VvGcz7jPGqlGo1SQ0R6BF8f+Bq4vHyqSFiVMLbFbGPxqcX0r9EfV63rtU5bNoo6UeUkU9O1JmqFmpS8FC7mXMTb/tZfcIniTCYTBxIO8OvJX1kVuQoAd60745qOo3tQd3nxJO45Dh064PHqq5YW2Nej9vAAlQr0egqTktF4ed7wvJYZOL4lO1Bdj65BfdBoKExIQB8TS/7p0wDYVg1GaW9PpZEjiR71IqmLFln+5lV6cZTl/5VCoaDSyBG4DRlMxoqV5OzejSE9HWNeLk4PPYTLY4+RsnAhCZ98SvoVDVEAbGvXxqVfPxw7drjh43C3FAoF2ho10L7xBm5DhpA8ezapi5eQtW49WZv+w75FCxy7dEFbqyZqDw/UXl4o1Dd/KZp36hTxH3xA7t7LXYb1Fy6gv3CB7O3bSZw2DYeOHfH9+CNULi5ldn9C3CskgVMByVInIcT9Kv/sWVLmziPt77+hsBAA2xo1sG/VCvvWrbBr3FiWTZWhC5kXOJ16mpY+LbHT2JGWl8aik4v44fAPFJoK8bLz4vP2n7MjbgczD860zMAokcAJDGPO0TmczzjPm5vfZFaXWeU3M+OKGThatZZqrtU4mXKSo0lHJYFzm0wmE8eTj7PxwkbWR60nPO1ys4P+NfozOnQ0zrbOVoxQiOtT2thQaeTNk/0KtRq1lyeFsXEUxsXePIETX9RC/NZ/nyi1WrR1apN36DC5B/ZTcC4SAG3dEMCcbLKtXo38M+b/Y7Z1auNwRW3KK8/j0rcPLn37lNjnPnQoNv7+ZK5Zg8JWi9LRAcfOndE1alTuCVaNpyfeEyfiOnAgFz/5lOxt28jeupXsrVstY1SVKuE+bBiuA5645t/1wpQUkmbNNie1DAYUWi2Vnn8epx4PU5iQQN6Jk2Rv3072li1kbdzI2b598fvyS3QNGpQ4lxAViSRwhBBCWJUxJ4fMjRtJX/o/srdssWx3aN8ej7Fj0dasYcXoHhy74nYxeuNosvXZ2KpsqetelyNJR9Ab9YA5KTOhxQScbZ0Jdglm/vH5ZBaYi9Y28Cz+hNlOY8eXHb7kqRVPmZM9h2bycqOXy+dG7C7PwAGo616XkyknOZR4iC5VupRPDPe5yPRI/j33L/+e/ZcLmRcs27UqLQ8HP8zAWgOp5VbLihEKUbo0Pr4Uxsahj41Fd1WzjqsVLeW91Ro4RewaNrqUwDlAQXQ0ANp65gSOQqnEfcQIYt8wF+b3GDXqjpIujp0749i5820fV1Zsq1cnYM6P5J89S+badWRt2WxOlCUmYkhKImHqVJJ/+AG3Z57B9cknMaankbl+PZlr15Gzb5+5Zg/g+NBDeI1/E42v+TG38ffHrnFj3AY9Rd7x40S/+ir681GcH/oMAXPmYBfayJq3LUSZqjAJHJl1IoSwBvndc+cKzp8ned480v/3D6acHPNGhQKHzp1wf+YZ7Bo3tm6AD5AVZ1fwzrZ3KDQWYq+xJ1ufzf6E/QDUdqvN0LpDiy2TcbJx4uk6TzPz4EycbJwIdAoscc7qrtWZ2HIib215ix8O/0D/Gv3LZwZM0QycXHNRz+Y+zfnzzJ/8efpPngl5Bjet2w0PXx+1nhPJJxjVcBRKxY07s1Qk+YZ8/j7zN/9E/MORpCOW7Tq1jjaV29DBvwPt/drLjBtRIWl8fMjl5p2oTAYD+osXLx1ze7/PdKGh8PPP5Ow/QOGlc+jq1bPsd+rency161BobXHo1On2buAeZxscjO3IEZYZUSa9nvR/lpH03Xfoo6JInDaNpJkzMeXlFTtOW7cuHmNfxaF16+ueW1unDkF//knM6DFkb9vGhZEjqTL/F7S1JMksKqb7PoGj0Zi7G+Tk5KDT6awcjRDiQZNzKfFQ9LtI3FhhcjJZGzeSsXYt2Zu3WNb6a/z9cerZA5c+fe6q0KG4fdtitjF+y3hMmHioykN81PYjItIiOJR4iEaeja4702JwncFEpkfS1LvpdRMdPYN7suD4Ao4lH2PfxX30CO5RlrdidsUSKoCHqjzEXLe5nEg5wTcHvmFiy4nXPXRbzDbGbhqL0WSkiXcTWvi0KPt4rSSjIIPozGgMRgNn088y8+BMYrPNXXhUChUtfVvSI7gHnfw7YaeRZYuiYrMUMo69cQKnMCkJDAZQqcy1c26DrlFDAPJPnjRvUKuxrVnTsl+hVuM346vbOuf9SqHR4NKvL869HyHj339JmjWbgshIUCqxCw3FoUtnHLt0wcbP75bOp3JwwO/rGUQ9N5zc/fuJevY5Ahf/dsvHC3E/ue8TOCqVChcXFxISEgCws7OTQnpCiDJnMpnIyckhISEBFxcXVHfRirOiK0xKIn3ZcjLXryN3/wHLlGgA+/btcH9mGHbNm8nvbiuIy4rjzS1vYsJE76q9eb/1+ygVSuq416GO+427lNhr7Pm03ac3vUYjz0YcSz7GgYQDVkngqJQq3mz2JkNXDeXPM3/yRM0nqOlWs8RhkemRvPHfGxhN5p/Po0lHK0wCx2QykZCTwIGEA+y7uI/9Cfs5k3oGE8VnEHrqPBkaMpSHgx7GXedupWiFKH+WVuJXzcApiI7GkJqG7tJSJ/0F85JCtZfnLRXgLXYNT080fn7oi5ZP1aiB0tb2bkO/rynUapx798apZ0/yjh9H4+uL2v3Ofvco7ezw/2425wcPIf/ECaJfepnARQulbp6ocO77BA6A96UiYkVJHCGEKC8uLi6W30GiuNxDh0hZsJCMVatAr7ds19ati2OXzjiGhWEbHGzFCB9s2fpsXvvvNdLz06njXocJLSeUyZKhhp4NWXBiAYcSD5X6ua/JksBJMScLlUoaezUmLDCM1ZGr+WzvZ/z40I/FDsk35PPyhpfJ1Gdio7ShwFjAieQT5RNvGTCZTJxIOcHqyNXsvbiXc+nnLPWKruSudcdWZYtWraVncE8G1RmETi2zmcWDxzID56oEzoXnn6cgPAK/2bNwaN+epO++B0B3qfjw7dI1anQ5gXPF8qkHnUKlKrac7E6pHB3xn/kt5x7rT/7Jk8S9+y6+X3whbxCJCqVCJHAUCgU+Pj54enqiv+JFghBClCWNRiMzb65izMkhY80aUhcuIu/I5Toa2gb1ce7RE8cunS1FCEX5yyrI4r/o/1gTuYZtsdvIN+TjZOPEtA7TsFWVzTvBjTzNxSRPp54mW5+Nvca+TK5jUVTE2GSA/HTQmVuYv9r4VVZHrmZX3C5S81KLtTbfHrOdyIxI3LXuvNH0DcZvGc/x5ONlG2cp0hv1bIjawIqzK4jLjiM+O57U/NRiY5QKJTVdaxLqFUqoZyihXqFU0lWyUsRC3FvUliVUscW266PMM27i3n4Hj5dfInvLFhQaDR5jX72j69iFNiJj2TIAtCF17yJicT0aHx/8vprO+aHPkLFiJbY1alDp+eetHZYQpaZCJHCKqFQqeTElhBDlzGQykbtvH2m//0HG2rWWgsQKjQanhx/GddAgy/RzUf70Rj1bo7eyNHwpW2O2UmAssOyr4lSF91q+R2WHymV2fU87Tyo7VCYmK4ZDiYdo5duqzK4FgNoWbBygIMs8C+dSAqeyQ2WquVQjPC2cvRf30rVKV8shm2M2A+ZOW20qtwEgOiua9Pz0e7Zo77n0cxxIOMCxpGNsit5EQk7xWchalZZ2fu3oGNCRmq41CXAKKLMknRD3u6I3Fozp6RiyslE52GPS6zEVmH9fGlJSiJ/8PgBuzw7DNijojq6ja3S5O1JpzDgR12bXpAne775L/KRJJE7/Ck3lyjj36mXtsIQoFRUqgSOEEKL8GLKyyVi+jNRFv5J/+rRluyYgAJe+fXDp3/+O17KLO5een86yiGXsjt9NYk4iF7IukJ6fbtkf6BRI1ypdCQsMo4ZrjXKZWt7AowExWTEcTDhY9gkcMM/CKcgy18Fxr2rZ3NS7KeFp4eyJ32NJ4JhMJrZEm9vXt/Vri7OtsyXhdDLlJM19mpd9vLcgrzCPI0lH2BO/h7Xn1xKeFl5sv7vWnX41+tHAowGedp4EOAZI8WEhbpHKwQGloyPGzEwK4+NQVauGMTvbsl9ha4spPx+Nry+VRo684+vYVq+OrkEDTEYjttWqlUbo4jpcBzxBwfnzpMydS+zb76D28MS+xb3x+1yIuyEJHCGEELfMVFBA9p49ZK5dS8ay5ZYnuAqt1txFql8/dA0bynpzK0jJS2HG/hksP7ucfEN+sX1uWjd6BfeiV9Ve5Za0uVIjz0asOLeCgwkHy+eCdu6QFmUpZFykqXdTfj35K3vi91i2nUk7w8Wci2hVWpp4NQGgjnsdYrJiOJ583KoJnMScRDZEbWBd1Dr2XtxLobHQsk+tVBPqGUrdSnVpUKkB7fzaoVFJNzwh7pTGx4f8zEz0cXHYVquGIevS3zdbW3zen0ziVzPwmfIhyrvoeqtQqQhc/FtphSxuwvON19HHxpK5ejUXRo3Cf+a32LeoGMXpxYNLEjhCCCFuyJCZSdam/8jcsJ7szVuKvStpExiI65MDcX70UVROTlaM8sGVV5jHv2f/5cv9X1pm2tRwrcEjVR/B39EfTztParrVRKO03ov7ojo4h5MOYzAaUCnLeLnzVZ2oihQlaMLTwknJS8FN68bmaPPyqWY+zdCqtYA5gbP2/NpyL2RcYCjgRMoJ9l/cz4aoDRxKPFSsU5SnzpNGXo1oW7ktHQM64mQj/+eEKC0aX1/yT5+2tBIv+luntLfHuXdvnHv3tmZ44g4olEp8P/2E6MwMsrfv4MKIkVSe8RWOHTpYOzQh7pgkcIQQQpRgMhjI3b+ftD//ImPVKkx5eZZ9Ko9KOHboiNPD3bFr0UJm25Sz6MxoTqScIDwtnMOJh9kTv8cy46ama03eav4WoZ6h99T3pZpLNew19mTrszmTdoZabrXK9oJXdqK6gqvWlequ1TmTeoa98Xt5KPChy8unKre1jKvjZm6hfjylfAoZp+enM2P/DJaGLy1WowjMy886B3SmU0AnAhwD7qnvqxAVidrH3FFSH18ygSPuX0qtFr9Zs4h5dSxZGzYQ/dLLVP5sKk7du1s7NCHuiCRwhBBCAJeKER84QPrff5O5YSOG5MuzF2yCg3Hs2hXHzp3QhoSgUJZ+u2lxbbmFueyI3cF/0f+xK24XMVkxJcZ42XnxdJ2near2U6iV996fdpVSRf1K9dkRt4ODCQfLMYGTXGJXM+9mnEk9w574PTT3aW5pb97W73ICp7Z7bQDOZ5wnsyATRxvHOwrDaDKSlJtEbFYsJkz4O/rjrnW3JGGyCrL4J+IfZh2aRVp+GgCutq408GhAq8qt6OTfCS97rzu6thDi9qhcXAAwpmeYPxYlcBwcrBWSKCVKW1v8vppO7Ftvk7F8OTGvvY4xJweXfv2sHZoQt+3ee5YnhBCiXBmzs0n/5x9zMeIzZyzblU5OOHbpgkv/x6SuTTlLyUthc/RmNkRtYEfsDvIMl2dAqRVqarrVpJpLNWq41qClb0uquVS7578/oV6hJOYmYqOyKfuLFbUSv0YCp6lXUxaeWMjOuJ1o1VoMJgNVnasW68TlqnXFx96HuOw4TqacpKl30xteLjEnkVmHZnE48TCFxkIKjAVkFmSSUZCB0WQsNtZeY0+AYwAedh7sid9DbmEuYJ6l9Fazt2jq3fSe/16KcpCfBZunQtPh4OJv7WgeCCoHc6LWkJUJgDE7CwClvRQDrwgUGg2+n36C0s6OtCVLiHvnXQrOnaPSyy+jtJUOfeL+IQkcIYR4QOWfO0fqr7+S/tffGLPMT1QVWi1ODz+Mc6+e2DVpgkIjRVHLQ74hnwMJB9geu52dsTs5kVK89oqvvS8dAzrSpnIbQj1D78vuQiPrj+T5Bs+Xz8Wus4QKoLFXYxQoiMyIZN6xeQD0CO5RYlwd9zrEZccxcdtEarnVomdwTzpX6VxsjNFkZO7RuXx/+HtyCnOuGYpKocLLzguFQkFsVizZ+mxOpJywfI+DnIMYWGsgj9V4zKp1ioQVGY3w13Ng0EP/eaBUwYEFsO0rOLUKXtwFktQrc0pH80wbY0ZRAkeWUFU0CpUK78mTUDo4kPLTTyT/OIfMTZvwevNN7Fu2RKGWl8bi3ic/pUII8YDJ2bOHpO9/IHvLFss2mypVcH3qSSlGXI4KDAVsidnCv2f/ZUv0lmKzbABqudWik38nOgV0skrnqNJWrvHrrj8Dx0XrQkPPhhxIOEBlh8qMqD+C3lVLFidt79ee9VHric6KJjormnVR63iz6ZsMqjMIgEJjIRO3TWTZ2WUA1K9Un2Ehw3C0cUSj0uCoccTJ1gk3rZtlWVuBoYDozGjOZ5wnNjuWWm617rl6ReI6TCbYNxdsHKD2I6DRlt65o3bA0T/Nnx/5A0L6wc5vzV83HynJm3Kicrx6Bo45gaOSBE6FolAo8Br3BnahjYh7bxIF4RFcGD4ClasrTj164PHyS6icna0dphDXdUcJnJkzZ/LZZ58RFxdH3bp1mT59Om3btr3pcdu2baN9+/aEhIRw8ODBO7m0EEKIO5Rz4ACJX80gZ+dO8waFAof27XF96insW7eSujZlrMBQwNn0s5xIPsGWmC1sj91Otv5yRy8PnQctfVvS0rclLXxaUElXyYrR3uduUAMH4Iv2XxCRHkFjr8bXnfXSp3ofGns1JjIjko0XNvLH6T/4dM+nxGbH0sizESvPrWTt+bWoFWreafEOfav3Ram48f8hG5UNwS7BBLsE39XtCSs4tQKWv2r+XDcOWoyCtq9DafzePPTr5c//+9ScsEmLArtK0PDJuz+/uCVKR/ObF8ZM84zUyzNwrl0D58OdH7I5ejOVHSpT2702I+uPxNlWXvjfLxy7dEHXuDFJ33xLxooVGFJTSV2wgMw1a/B+f7J0qhL3rNtO4CxevJgxY8Ywc+ZMWrduzXfffUf37t05fvw4AQEB1z0uPT2dwYMH07lzZy5evHhXQQshhLh1BdExJE77gowVK80bNBpc+vXFfdgwbG7we1vcnQJDAWfSzrAnbg//Rf/HwYSDFJoKi43x1HnycPDDPBz0MLXcaslMjNJykwSOh50HHnYeNz1NgFMAAU4BtK3cFk87T2YenMn84/OZf3w+ABqlhs/bf06ngE6lFrqwgvQY2DsHmj4HTr7XHnPkD/NHlQ3kpsLGKeAaBPX739219blw/H+Xz50ScTlR1GwEaHR3d35xy1RFS6gyzTNwDFlFNXBKzsDRG/QsObUEEybisuPYe3EvSTlJTG0/tfwCFndN7eqK94R38XprPNnbt3Pxo48piIwk+vkXsGvWDLehQ3Fo3w6FSmXtUIWwuO0EzrRp03j22Wd57rnnAJg+fTqrV69m1qxZfPzxx9c9buTIkTz55JOoVCqWLl16xwELIYS4OVNhIblHjpC6YCEZq1dDYSEoFDj37YPHiy+i8b3OixRxVy5mX2TFuRWsilzF6ZTTJRI2TjZO1HCtQWOvxnTw70Ad9zo3nbUh7kBRAic3FYwGc02Ru6BQKHihwQv4OfixJnINaflpKBQKnm/wPK18W5VCwMJq9Lmw6HG4eBSSTsMTC0qOKciG06vMnz+zCk4ug61fwrpJULunOfFyepV5mVVAC7C/jdlzp1ZCfgY4+0OTZ2D9+1CQBWqdOaEkyo2yaAlV5s1r4FzMuYgJEzZKG95s9iZTdk1hZeRK+tfsf9Oi5+Leo1CrcWjXDrtmzUj8agYp8+eTs3s3Obt3o9BqsQkOwq5JEzxefFGWVwmru60ETkFBAfv27WP8+PHFtj/00ENs3779usfNnTuXiIgIFixYwIcffnjT6+Tn55Ofn2/5OiMj43bCFEKIB47JaCTvyBEy128ge9dO8k+dxpR3uaaKXcsWeI0bh7Z2bStGWXGYTCZOpZ7iUMIhjqccJyItgtisWBJzE4uNc7Z1JsQ9hLZ+bWlXuR1+jn4yy6Y8FHWhwgS5aWDvXiqn7VW1F72q9iqVc4l7xL+vm5M3ACf/hdTz4Fql+JhTK0GfY55xUzkUvOrA4d8hI9q85OnicTiz+vJ431B4+HPwa2wuTBx70HxOB8+S1z/0m/lj/ceh2UjY8a155lijQaX2cytuTVENHGNWFiajEWO2uTD5tRI4cdlxAPg4+PB4zcc5lXKKJaeX8MnuT1jcc7Gl7pW4vyi1WrzeHIfbkMGkLlhA6pLfMWZkkH/8BPnHT5C5cpV5eVXHjtYOVTzAbuu3S1JSEgaDAS8vr2Lbvby8iI+Pv+YxZ86cYfz48WzZsgX1LVb2/vjjj5k8efLthCaEEBWWqaDA/IlGgz4mhuwdOy63+zaaKDgbQd6x4xjS04sdp7Czw6lrF1wHD0ZXt245R31vMpqMxGfHY8KEWqHG087zlhIqBqOBmKwYwtPCOZJ0hNWRq7mQeeGaY0M9Q+lZtSdtfNvgbe8tCZtydDEjj3F/HMZgNLHA1hny0yE3RV4Ii8tMJkg4ARePQfRuOLgAFEpzciYlAnZ/D2FTih9z9C/zx5B+5vo0Gh10mWTuHLX1S/M+tRZcAyHxJMTuhzldoFZPiNoJ2QnmWTr1n4A2r4J7VfMxWYkQvs78ef0BYOsAvWeaa+K0H1cej4a4QtEMHEwmjDk5lu6MSoeSCZz4bPPrHm87bwBebvSyeeZl6ml+P/07A2sNLJ+gRZnQeHvj+frreLz6KvoLF8g7cYLEr2aYl1e9MAq7Jk1wGzYMhw7tpX6gKHd3lB6++smoyWS65hNUg8HAk08+yeTJk6lRo8Ytn/+tt95i7Nixlq8zMjLw9/e/k1CFEOK+lL1zF6kLF5B3+jT6qAvmFx1Kpbnd7HUo7eywb98Oxw4d0Narj02VgAdq3faZ1DPkFOZQx70OGqWGuKw4DiUdopZrLQKdAzmRfIJ3t73L6dTTlmP8HPzoFtSN5j7NqexQGWdbZ9Lz00nISeBkykmOJx/nTOoZzqWfK9ElSqvSEuoVSl33utR0q4mfox9+Dn5SxNKKFAr473QiCgWYvN1Q5KdfqoNT3dqhidKSFgXHlkL8EXMiJjvRvAzKWAhaZ9C5gNal+EdbR1CozEuVTq2AlLPFz9nxHfAKgV+fgP3zocNb5nOnnjNvD19rHhfS7/IxIf1g1yyI2Qf2njDwN/OMm8yLsHYCHF4MJ/4xj9XYgz4bDsw317sZtQOc/cx1d0wG8G0EHpeeJ9fsZv4nysTJlJNM3zedFxu+SD2PesX2KWxtQaMBvR5jZuYNl1BZEjj25gSOi9aFlxu9zJRdU5ixfwad/DvhZe9V4jhxf1GoVNgEBmITGIhDx44kzvialF9+IWfvXnL27sWuSRMqT/8SdSVpOiDKz20lcCpVqoRKpSox2yYhIaHErByAzMxM9u7dy4EDB3jppZcAMBqNmEwm1Go1a9asoVOnkoX/bG1tsbW1vZ3QhBCiQjDp9SR+/Q3JP/xgTtpcyWgEtRpd/froGjZEoVaDyYjG3x9tnbpoa1RHYWNjncCtbPHJxXy8+2MMJgP2Gns8dB5EZkRa9tdwrcHZtLMUmgpRK9SolWr0Rj3RWdH8eORHfjzy402vYaM0dxCq5lKN9n7taefXDjuNXRnelbhdzjpzRymTCQy6SqhTz0FGjJWjEnesMB/Ob4ekM+ZZLNF74Ox/gOna4/XZkBl78/OqteZlTu7BENAKGlyaLeEWbE7uzG5jTt5cyaO2eelUEaUSHp8PhxaZj3f2M2939IK+30O9x+H4UqgRBjW6mRM9/75mXq614UMI+wi2f2M+ptUrt/OoiDtkMpn4YOcHHE48TExWDH/1/qtYFzqFQoHK0RFDSgqGjBsncK5cQlWkf43+LItYxuGkw3y460NmdJwhMzArEKVWi9e4Ny4vr1q4iJy9eznX7zEqT/8Su0aNrB2ieEDcVgLHxsaGxo0bs3btWvr06WPZvnbtWnr37l1ivJOTE0eOHCm2bebMmWzYsIE//viDoKCgOwxbCCEqntzDh4l//wPyjprrMTj364tzr17YVq2KwtYWY14eKgcHlHaSNChiMBr4fO/nLDhhLjyqU+vI1meTrc9GqVBS1aUqZ9POWmbddK3SlXeav4O7zp0cfQ6bozez5vwazqSeITYrlgJjATq1DjetG9VcqlHHvQ41XWtSzbUafg5+qO6yGG6Fpc+D9GhwrmzVrjm2ahV2NipyCgzkutXGMXYPxB0qPnNC3NtyUuDMWvNMmfD1UJBZckxQOwhqD151waky2Nibp1/lpZtrHuWlFf9YkAUmI6CAKq3MCRXba7SGbv4CrHzDnLxRasCztjnhYjJC6NMlxztXhnZvXPs+qncx/ysS0AIemQE/dDIvkcpNNd+bVz2o8+htPkjiTuyM28nhxMMARGZE8vsp81KnX0/+yvmM84xrOg6lowOGlBSMWZcTOKobJXDsLydwVEoVk1pN4vHlj7PpwiZWn19Nt0CZTVXRaLy88HztNZz79CX6pZcoOHuW8wOfxL5VS1wHPY1Dxw6SuBNl6raXUI0dO5ann36aJk2a0LJlS77//nuioqJ4/vnnAfPyp5iYGH755ReUSiUhISHFjvf09ESr1ZbYLoQQD5r8s2dJ/+svjDm5FCYmkrnWPE1f6eiIzwfv49St+BM/lZOTNcK8p31/+HtL8uaVRq8wLGQYp1JPEZ8dT6hnKC5aF1LyUtgcvRlPnSctfVtanljZaezoFtSNbkHmx9loMlJgKECr1lrtfu5b83pAzF7z5y4B0O8n8LdOJxYXnYacAgPpLnVwBIg9YJU4xE0YjebkSMJxSDxl7gCVdBqSwy8lWy5x8AL/ZuaPzv5Q91FzrZmy0GiQeaaMrQO0Hm3+Wc5NNc/K8SmFd9crN4Z6/eHI75e7WnV61zybR5S52YdmA+Dv6M+FzAvMPDSTY8nH+CfCvNSte1B3nB0c0WPuRGXILqqBUzLZd/USqiLVXavzXL3nmH1oNpO2T+J40nGeqPUElR0ql+GdCWuwDQ4icMkS4t+fTMbyf8nevoPs7TtwfeopvN59R5I4oszcdgLniSeeIDk5mffff5+4uDhCQkJYsWIFVaqYK/bHxcURFRVV6oEKIURFkrF6DbFvvYUpJ6fYdufevfF4bSwaz2t0KxHFHEo8xHeHvwNgcqvJ9K3eF4A67nWo4355qYOb1o1Hqz160/MpFUpJ3tyJrITLyRsw1yjZ8TX4/2KVcJztbIhNz+OiYx38AGIPmddUyZNp68pONifTkk6bP0asv1Sf6Bq8QqBmd/M/n0bll+CwsYO+3xXfpnM1J15KS+eJcPwfMOSDX1PzEitR5vbE72F/wn40Sg0/PvQjo9aNIiI9wpK8AYjNisW1qBNVZuZ1u1CZTCZis8xL9a6cgVNkeL3h7IjdwaHEQ8w9Npf5J+Yzs/NMWvq2vO24L2RcYNq+aTxR6wla+LS47eNvhclk4lzGOc6mnSU1P5W0vDTS8s3/UvNSSc9PR61UU9u9NrXcauHn4IePgw++9r4PfJJC5WBP5alT8XhlNKkLF5Iybx6pCxcCSBJHlJk7KmI8atQoRo0adc198+bNu+GxkyZNYtKkSXdyWSGEuG8ZsrK5+PFHFCYkYirUk7NjJwC6Jo2xa9oUhVqNQ9u26OrXt3Kk94dsfTZvbXkLg8nAw0EPW5I3wgou7DZ/9KgNvabDT2Fweg3kZ117mUoZc9aZn9rE2gTSWGVr7kSVcvZy5x9RfvS55jbZx/6CyK3FZ9YA2DiCTwOoVB08akKlGuBZB5xKviiuMFwCzEmcbdMh7GNJLJYDk8nEtwe/BaBv9b74OvjyetPXeWHdC+jUOio7VCY8LZzY7FjqX0rgGNIzLG+wXJ3AydRnklNo3nf1DBwAG5UNP3f7mc3Rm/np6E8cTDzIp7s/5Y9H/rit9uL5hnzGbBrD6dTT7E/Yz/96/w8XrcudPATXFJkeydxjc9kavZWE3ISbjt+fsL/Y10HOQQypM4SeVXtiq3qwa5fa+FXG681x2FarSty7E0hduBClnQ7P116zdmiiArqjBI4QQojbc3HKFNL//rvYNrchQ/B843VzMWJxW6bumcqFzAv42PvwTot3rB3Ogy36UgLHvxn4Nze3Y049Z14iUu+xcg/HRWcu5J2WZwLveubZQbEHJIFTXkwm8yysk/+akxRZFy/vq1QDPGqZa8sEtTf/zKg01z1VhdXqJfM/US5WnFvBvov7sFXZ8mzIswC0qdyG+d3nU0lXib/O/EV4Wjjx2fGWVuKFFy//3F6dwClaPuVi64JOfe2aXyqlio4BHWns3ZiH/3qYiPQIlkUso0/1PsXG5ehz0Kl115yp8fmezy3121LyUvh87+d82ObDO3wULkvMSWTGgRn8E/EPxktJVRulDbXcauGmc8PF1gVXW1ecbZ1x1briYutCtj7b0pUxLjuO2OxYzqWfY9KOSXx94GsG1RlE/xr9H/gujC79zPXW4t55l+QffsSuSRMc2re3clSiopFXDUIIUcYyVq02J2+USjzfeAOVkxM2QYHYhYZaO7T70vrz6/nrzF8oUDClzRScbKQ2kFVduCKBo1BASF/Y8gUc+9s6CRw7c0IgLUdvbs9clMCxQiwPjLjD5lbb5zZDzH5zu+4izgHQ9NmyrV0jxHVkFmTy+d7PARhRf0SxrlENPRsC4OvgC5gLE6sczd3E9EUdd9Vqc3vxKxQlcK61fOpqTjZODK83nM/3fs43B7+hW1A3S9Ln24PfMvvQbGxVtvg6+PJiwxcJCzQvqVsftZ7fTv0GwKiGo5h1cBb/i/gfPav2vOZSqovZF9FpdDf9e7j+/Hom7ZhEWn4aAO392vNU7ado5NnopkuIe1XtZfk8qyCLP8/8yfzj87mYc5Gv9n/F94e/p71fezpX6UwHvw4P7JJkl379yDt5itT584kd/xZBS5ei8ZJl8aL0SAJHCCHKkD4ujrj33gPAffhw3J8Zat2A7nMJOQm8t8P8eA4LGUZTb+sUyn2g5aRAxAao3QtQXC4S7NfM/LFuH3MC58xayMsAbfkm2JyLEji5eqh8qfBs7MFyjeGBkZUAq982F+W9UlEHp6bPQoMnQW1jnfjEA+/bg9+SlJtEoFMgQ+sOveaYokRMbFYsSkdz/bTCSwkcpb19idkxcVnmDlTXWj51LQNqDWDhiYXEZcex6MQinq1nngW06py5kHW+IZ9z6ef4eNfHtPdrj0qh4tPdnwIwtO5QXmjwAim5Kfx26jfGbhpL/xr9zUvB7H1Jy0/j24Pf8nf437jYuvBd1++o5Var2PUTchLYdGETGy5sYFvMNgBqudXi3Rbv0sCjwS3dw9UcbBwYUncIT9Z6klWRq5h7bC5nUs+wKnIVqyJX4WnnycuNXqZXcK8Hsnuj5xuvk7N3L/knThD90kt4vTUeXaNGUhNHlApJ4AghRBnJ2raN2PHjMaanow0JweOlF60d0n3JZDJxPuM8O+N28teZv0jPT6e2W21ebCiPZ7mL2QeLB0NGNIQOgcZDoDAPtC7gXs08xisE3KtD8hnzMqr6j5driEVLqNJz9eDb0Lwx7pC565F0+ykdRiMc+AXWTjS37kZhbs1dtaO5TXelmpK0EVZ3MuUkv578FYC3mr+FjeraP5NFCZz47HhUjua6XXpLAseuxPhrtRC/EVuVLc83eJ73tr/HinMreLbes2QWZBKZEQnAbz1/Y+zGscRmx7I0fCkqpYq47Dg8dB6Wv3OjQ0dzIOEAp1JP8dPRn/jp6E8AKFBgwgSYl1kNWzWMzzt8jp+DHxcyL/D76d/ZeGGjZamUAgXPhDzDSw1fQlMKyxc1Kg29qvaiZ3BPjiQdYV3UOlacXcHFnItM2DaB+cfnM7bxWFr5trrr5EVaXhq/HP+F5LxkvOy88Hf0p6l301tOpJUnpY0Nlad9QWS/x8g7coTzTz6Ftl49PMe+in3L2y9mLcSVJIEjhBClxGQykXvgILkHDpB76BCZa9YAYFOtKpW/nIZC8wDWergLhxIP8cfpP9gZt9MyZR1Ap9bxSdtPSuXJp7hFJhPs/xlWjDN3zwE4uBBsLhUp9mt6OTmiUJhn4WyeCnvnQt2+oCq/pxvFllBVqgtqHRRkQkqEuViuuDuxB2Hlm3DBXIgd7/rm4tWl2alJiFKgUWqoX6k+XvZetPJtdd1xRQmALH0W+ZeKoBfNwFFdVf8Gbj+BA9DOrx0AZ1LPkFmQyfHk4wBUdqhMXfe6DA0Zyke7PmLu0bmWhMyz9Z61LENysHFgcc/F/Bf9H4tOLGLvxb0YTAZMmKhfqT6jGo7i+8Pfsz9hPyPXjixx/foe9eno35FOAZ0Idg6+5bhvlUKhoL5Hfep71OfFhi/y64lf+f7I95xOPc3z656nuU9z+lbrSzu/djjY3F5xe4PRwJ9n/mTGgRmk56eX2F/VuSqjGo7iocCHSut2SoVtUBCBf/xB8k9zyPhnGXlHjhD1zDAcOnbE4+WX0Napc/OTXMFUWEj6suWk/PILNlWq4Dv1U5Q2l5OSxrw8UhcsoCAmBoVKjY2/H64DB6KwKZm4NJlMMhvoPiYJHCGEuEvGvDzSly0jdf4C8k+fLrbP9cmBeI4bh1L7YK4FvxPhqeF8feBrNlzYYNmmUWoI9QylhW8LwqqE4e/kb8UIHzA5KfDPy3Byufnrmg+bl0ad3wo7Z5q3+TcrfkyDAbB9BkRth5VvQI9p5dZtx1lnTuCk5xaYE0c+9eHCLvNSL0ng3JmcFPNsqn3zzI8lgMYeOr0LzUaUa4JOiFtV1aUqP3f/mbzCvBuOs9PY4WLrQlp+GumaQgBMej0ASvuSyYaiNxS8HW595kclXSX8HPyIzormcOJhTqWeAqCOu/lFfJ9qfZh9aDax2eb25B46D/pV71fsHCqlik4BnegU0AmjyUhmQSa5hbl42XmhUCgI9Qpl4raJrDu/Dlu1LQ4aBzr4d2BgrYFUdSm/Iu62KluGhgzl0WqP8sORH/j15K/sitvFrrhdaJQaAhwD8LTzJKRSCE/WfpJKukrXPdfBhIN8tOsjTqScAKCaSzUeqvIQibmJnEw5ybHkY0SkR/Daf6/xRPwTvNH0jXuqI5ZtcBC+H36I59ixJM2eTeqiX8nauJGsjRvR1quH+7PP4tQt7KbnyT1yhJjXXkcfFQVA/okTxKnV+E79FIVSSd7Jk8S8/joF4RHFjstcu47KX89A7eqKyWgkc80akmZ/hyElBZ+PPsKhTesyuW9RtuQvrhBC3CF9fDypi34lbckSDGlpACh0OhzatEEbEoJ982boGja0aoz3C4PRwI64HSw4scCyRl+pUPJI1UfoHtidRl6NrtvtQ5SSwgJYOQ6idkLNbhDY1lzr5tCvkJNsrmvS6V1o9Yq589RPYXDpnWL8rqpF5F4V+v4ASwbD3p/AqTK0e71cbsNFd8UMHDAXMr6wC85vL/flXPe17CRzIepjf5t/JkwG83al2jzDqsskcPazaohC3IxSocROU3IZ1NV87H1Iy08jRZWH65XH32AGjrfd7S3daeTZiOisaA4kHOBc+jkAQiqFAKBVaxlcZzDT908His++uRalQomzrXOxrk86tY7P2n92z8yucNG68EbTNxhYayB/nvmTdefXEZkRSUR6BBHpEeyI28HPx36mT/U+DAsZZikmna3PZuOFjaw4u4ItMVsAcNQ48mKjF3mi5hPFWrGn56cz9+hc5hydw+JTizmRfILvun5327N8yprazQ3vt9/GdcAAkr75loy1a8k7coSYMWPIe34kHqNHX/d7lrN/PxeGj8CYnY3KzQ2nnj1IXfQrGcuXYzIUYsrJJXv7dkx6PSqPSrg89hgUGkj99Vdy9u7lXL9+2FSpQkHkeQrj4iznvTB8OJVGjaLSqBdQqB68OkX3M4XJZDJZO4ibycjIwNnZmfT0dJycpNuIEMJ6TCYTuQcPkjp/Phmr14DB/KJG4+uL61NP4fJYP1TOD3YbzdtxNu0sf5z5g1XnVpGYmwiY1+h3qdKFlxq+RLBL6U/1FteQnwmLn4azG6+9v1JN6Pv95ZoyAL/0hrObAAWMj7p2seJd35mTQihgzGFwCSj92K9yLDadHjO24uFoy553upiTUPP7gMoWXt578xjij0DiqQeza1VBNpxaCYcXmx83Y+HlfZ51zMvhQgeDo5f1YhSiDIzeMJoNFzbwgftQar7+o2W740MP4TfjK8vXBqOBxgsaYzAZWPfYOrzsb/3/wu+nf+f9He/TzLsZMVkxxGTF8ONDP9Lcpzlg7uzU759+2KptWdJzSYXr4mQymYjOjCY6K5rYrFj+Dv+bQ4mHAFAr1HQN7EpqXir7Lu5Db9RbjutTrQ+jQ0fjrnO/7rm3xWzjzS1vkp6fTmOvxszuMvuefvwKk5NJnvMTKT+Zaxk5934Ej7Fj0Xhd/nkyZGWRuXYd8R98gCknB7tmzfCbOROVgz1pS5cSN/6tYud06NgRnykfonZzAyA/PJwLL4xCf+GCZYzS0RG3wYMpTEgg7Xdz8XltvXp4T3oPXd26ZX3b4iZuNechM3CEEOIWmAoLyVi5kpRf5pN35Ihlu13TprgOfhrHTp3kHYxbpDfo2R2/m19P/sp/0f9ZtjvbOtMruBdP1n4Sf0dZIlVu8rNgXk+IOwgaO+gwHqL3QvQe89KoBgOhWhe4uuZQx3cgciv4t7h+p6nmI80diqL3mFtMNxpU5rfjYnepiHGO3vxOdHBHCGpnvv76D6DfD9c/OO4w/NQN9NngGgR+D0hdF30u7JoNW7+8VJT4Ep+G5llLtXqCaxWrhSdEWStqLx6vyKDmFduvnoGTmJuIwWRArVDfcOnPtTTyMHfFO5hwkAJjAXB5CRWY69ws67MMBYoKWeNNoVDg7+RvWQLdt3pf9sTv4YcjP7Azbicrz620jK3iVIVugd14OPjhW6rZ07pya77r+h3PrX6OfRf3MXbTWL7q9BUa5b35OKrd3fEa9wY2QYHET5pM+v/+If2fZdg1bYrS3h5DSgp5x49blvLZt2qF37ffoNSZZyK7PPoopvwCsjZvxi40FPtWLbGtVavYLB7batUI+n0JGWvWoNRqUXt6oQ2pi8rBPDvJrklj4j/4kLwjR4js/zjuw57BY8wYFGpJD9zr5DskhBA3kbNnD/EffGipb6OwscGpZ0/cnh6EtnZtK0d3f8jR57A1ZisbLmxg84XNZOozAfNsmw7+HehbvS+tfVtXyCet9zSTCZaPMSdv7CrBU0tuvRitfzN4cTfYXf9dUcC8FCt6jznZUx4JnEtLqAoMRnL1Buxs1ND1A/i+PRxZAi1egMqhJQ/MvAi/DjQnb8C8TKyiJXCMRkg6BVE7IGoXpJw1L41KuwDZCeYxLlWg/hNQrz941LBuvEKUk6KCxDGkFdt+kQw2nVjEgFoDUCqUnM84D4CXvddtt8cOdgnG0caRzALz379Ap0AcbRyLjblep6yKSKFQ0MynGc18mnE48TArz63E18GXNpXbEOgUeNvLwOq61+Wbzt/w/Nrn2RKzhc/3fM5bzd+6+YFW5Nq/PzaVK5P47Uxy9+0jZ/fuYvttgoJwevhh3EcMR2lbvLaP6xOP4/rEjZcFq1xccH382mOce/fGrmVLEj6dSsa//5L84xxyjx6j8pfTULu6XvMYcW+QBI4QQlyHMTub+Ckfkf7XXwConJ1xGzoEl8cfR+1+kxetAoCjSUdZdGIRa86vIb+oexHgpnWja5WuDKo9iEDnQOsF+KDbN888Q0ahggELb7+TkPstFMYMbANbp0HktjsK8XbZ2ajQqBToDSbSc/XmBI5vQ3NS4vBiWDcJhvxT/CBDIfz2pLk9epG4Q+USb5lKjjDX/kk+Awkn4MJuyEu79lgnP3ONo/qPw22+MBXifleUwDlvTCq2fVPyLn7a/R9Gk5Enaz/Jtwe/BaChZ8PbvoZSoaShR0NLXZcrZ9886Io6WN2txl6N+bTdp4zeOJpFJxdRy60Wfar3KYUIy459q1bYt2pFQXQ0WZs3o1CpUbm4YFutKrZVy7b4tMbTk8pffI5j167Evv02OTt3EvlYfwJ/X2JZiiXuPZLAEUKIa8g9dozY116nIDISFApcnngcj9Gj5V2JW1BgKGB15Gp+O/kbh5MOW7b7OfjROaAznat0pn6l+rf97qUoRannzcVpN35k/rrzRAhoUTbX8m9uLnybHmW+bhkvxVEoFDjrNCRlFZCWo8fH+VLx647vmBM45/4zd1Wyu+LJ6blNELMXbJ3NS8hWv3X/JXD0uRCxEdKjITMWwtdD/OGS4zR24NcEAlqCV11Q2YDaFgJageberRkhRFmyzMDJi0eh1WLKM3euSlWZP07fP52k3CQOJBxAp9YxJnTMHV0n1CvUksApKmAsSlengE6MajiKmQdn8sHODwhyDrqjhFt5s/Hzw+3JJ61ybaduYdhWDTbXzImOJm7CRPy++Rr9+fPEf/QRdo2b4D5i+D1RHFtIAkcIISwKIiNJ+3spWRs3WpZLqb28qPz5Z9g1bXqTox9sJpOJ48nHWXZ2GSvPrSQlLwUAtVJNt8BuDKw1kHqV6skff2tKu2BO2hxfCjH7Lm+vHmbuLFVWbB3AN9S8JClya7nUUrkygWPhWsVcjDnplHlWSu2el/edWWv+WLe3ucPS6rcg8SQU5IDNzTvYWI0+F+KPmlu87/8FclOK71eoLidqKlU3Lx3zrl+ynpEQD7iiGjiJOYkoHV0wXErgZGuMgJJ8Qz5zjs4BYFSDUXjb314HqiINPRpaPq/rLkVjy8rI+iM5lXKK9VHreWXDKyx4eAEBTmVfRP9+Zlu9On7ffE1k/8fJWr+ehM8/J33p/zAkJ5O9eQsFkZH4vD8ZhUb+flibJHCEEA80k8FA1ubNpC5cRPbWrZd3KJU4du2K96T3ZNbNDeToc/j33L8sPrmYU6mnLNs9dZ70r9mfx2o8dtuFHkUpMJkgIxYy4yHpNBz+Dc7+h6Xtt0IJVVpD3Ueh4SBQKss2nsA2lxM4jZ4q22tRVMg4m/TcgqviaH0pgbPtqgTOGvPH6g+BozfYe5prwlw8Bv73WPI25Swc/x8c/8c8S6iovTeAs7+5bbqDF3jXMxcftpflnkLcjJvWDRulDQXGAkz2WjA3RST3UtkRJxsnMgoyqOZSjafq3PnvsJBKIbhp3TCZTNRyq1UKkYtrUSqUfNTmI55Z/QzHk4/zwroXmP/wfNy0sizoRrS1auExZgwJn31GyhxzhyxNQAD6mBjS//4bQ0YGft98bZU340wmE4Wxsah9fR/4NwMlgSOEeCDpY2NJX/4vaUuWoI++VPdCocC+XVuce/bEoW1bVC4uVo3xXmUymQhPC+f307+zLGIZWfosAGxVtnQK6ETP4J609G15z3Z/qNByUuDgQtg7F1IiSu6v0sactKn9SPm2grbUwdl687GloKiQcbEZOGBOWu39CSK3XN6WHGFOiig1ENQeFArwaQDha83Fna2dwMlOhlMrIGK9uYZNRkzx/fYe4NfUXCC6RjepXyPEHVAqlHjbexOVGYVeZ0PR/6JcG9CpdXzW7jO+P/I9bzZ9867+tmnVWn7t8SsAdpp7eHZfBWCnsePbzt8yaMUgojKjGLVuFN91/Q5nW2drh3ZPc3tmKFlbtpCzcye6Jo3xnzWLnL17iXllNFnr15N/6hTaWuWffMz4dwWxr7+Ox6uvUmnkiHK//r1EEjhCiAdGYUoKGatWkfHvCnL3XV5ConR2xqVfP1wHDsDGX9pXX0uhsZCDCQfZdGETm6I3WTpxgLnd5+M1Hqd3td7yxMhajAbY86O5TfalDico1eaZGI7e5jbgDZ8E10DrxOff3Lycp5zq4DjbXUrg5F6VwAlsY/4YfxRyU0Hnenn5VJWWl9uh+za8nMCxhrQoOPkvnFgOUdvBZLy8T6Ey30fdR80zhpwqm5NOQoi74uPgQ1RmFHk6FUXNw3NtwF5jT6vKrWhVuVWpXMfXwbdUziNurpKuErO6zGLwysEcSz7G0FVD+eGhH2Rm8A0olEr8Z80ke+dO7Fu1Qmlri2PHjuiaNCZnx05yDx22SgIne8d2APKOHin3a99rJIEjhKjQTCYTObt2k7JgPlkbN4Hh0nIDhQK7Jk1w7v0ITj16oNTprBrnvaiors0fZ/5g3fl1pOWnWfZplBraVm7LE7WeoIVPC5SKMl6CI0oymSD1nLlY7YEFl5MNXiHQbDiEPGauP3MvsHUw11+J3mNevlTGCRwXnbkVb/rVCRxHb3Crap6dFLUTanb/P3tnHR7F9bbhezWycfeEEAgEd7eiBQoFCi0tlLq7Um+/tr+6C22p0FKhpUChFCjuroEgEeLuskk2a98fJ0KKWzZy7uvaK5szszNnIzszzzzv89aVT0WMrFvPv4v42pBBxic3ia5gqbvrd8MCUQ4VOU6UgAX2AK3ujJuQSCSXTk2Qsd7OWivgVGoV6DTy/60p08q1FfPGzOPu1XcTXxTPrJWzmDtqrhTSzoHSwQHnYcPqjTl07iIEnOhD521ffjUwnBDZlKac3Abfd2NDCjgSiaTZYamspHT1avS7d1O+azfG1NTaZfYdOuAyfjwuY69F49uAJSRNBKvVSmxhLOtT1rMmZQ1xhXG1y1ztXBkcOJihwUMZEDhAntQ2NMZK4caIXwcZB0Rb6FNDa+1cYcQr0OP2q59pcymEDYTMaCjNvOq7cj1bCRUIEaQgQZRztRpcV9bVZlTdOjUCTs4xMBlEl6arRVEqrH5RhEvXoFBCcF+R09NunO2cUxJJC6ImH6Xcrs7RVm4HbmpZ6tTUae3Wmh+v/ZG7V99NSmkKs1bNYu7IuYS5htl6ak0Ghy6izXtl9Bm6G15lrGYzhjhxPmrMzWnw/Tc2pIAjkUiaDabCQop+/4OCn37CXFB3YatwdMR14gQ8br4ZuzZtbDjDxoveqOefk/+wMHYhxwuO145rlVpGhI5gUptJ9PTtiVopDxsNSn6CEGzi10DiFjBV1F+uVIsL/Yjh0PWWhs21uVgGPApDZjdIq2q36hKq00KMQeQA7f9JOIEOLQCzAVxDwDuybh3XYHDwEAJZdoxwD50Li0UIMGl7RbmTxQSVxeL1JRmitbfVCp7h4NlGdIRyCYATqyB2lQgiViih5x0QNVF07Wos7ilJg7AvuQCrFXqGCRGh0mhm/o5kpvYMqg7lllxtnLXOAJTbWWvHKqtLqCRNn2Dn4FonTlJJErNWzeKTYZ80iRbjjQGHzkLAMcQnYC4rQ+XUcMeoquQUrAYDAKbcPKwWC4rGeKOqgZBn4hKJpEljKixEv3UbJStXUrZ5M5hMAGgCAnAZNxaHHj1w7NmzQQ80TYnE4kQWHF/A0oSl6I16QIg2AwIHcE3INQwLHiZzbRoSY4VwhMStEaJNwcn6y539hVgTOhB82oNX28bd5vpUHBqum1uNgHNWBw4IF1PGAfG8/XX1c2RqgoxPboD1r4sMn/bXiXbc/yV1D6yaDel7zz+xzENnLssKGwRj3hKlUpIWR16Zgelzd2GxWNn49FCC3B3560A6b644xh97U1n9+OAW33WlIXDWCAGnTFsn4FRowUkjzx+aC346P+aNmcd9a+/jeMFxZq2axa1Rt/Jg1wexV1/9mwtNGbWXF5qAAIwZGVQeOYKub99zrl959CiaoCBULi6XvW9DbF2XU4xGzEVFqD1abkcxKeBIJJImhyk/n5J//qF4+T9UHj4s7mxXYx8Vhcdts3C59loUGtkF6UxYrBa2pG3h1+O/sj1je+14mEsYU9tOZULrCbjZu9lugi2N4nQ4vlyINklbwFRZt0yphpB+IoQ4YoQQEOSF3Hk5ZwmVaxB4hAtxTG0Pve6CYS+cvl5IPyHgJKwXj60fwfTfoPU1devs/wmWPQJYQeskgqK1TqITlL0r2LuBi79w9ADkxUF+HOTFQ1GyEGy63yrEOEmjJrO4ggmfb8PVQcM9g8O5vmsgWvWVuQP8b0wWVSYRVD1/ZzKzx7Tju62JANzYK1iKNw1EjQOnVGuuHTNoZbeo5oangyffj/6et3e/zbKEZcyLmcfiuMUMDxnOhNYT6OnX09ZTbLTYd+mMMSODikPR5xRwStetI+3Bh1B5eOD30os4jxlzWZ9jlSdO1PvelJMjBRyJRCJp7FitVir276fgp/mUrltX67QBsGvXDqchQ3C9bjx2ERE2nGXjxmK1sC5lHXMOzanNtlGgYEjQEKa3m07fABlG3GCUZkHsv3BkESRuBupESFwChVjTZqRoa21/+XevWho1JSenhRjXMPlbIZZ1vlEILGei/8NC7ClKEb+jlO3w601ww3fCMXN4Iax4SqzbcQqM/p8IST4Xp5ZpSZoUyw5mkFtqILfUwDN/RjN380kWPdAfF/vLv1Gw4nBdLtSC3al0C3YnLqcMJzs103rJzogNhZNWOG2KNOJzw+Sgwaqwnr2EylQFxanVYq0rqORNo6aCs9aZNwe+yajQUby5600y9ZksiV/CkvgljA8fz+zes6X7+Aw4dO5C6cpVVJwnB6do4Z8AmAsKSH/8Cdy2b8f/9dcveb81AcY1mHJywAadsBoLUsCRSCSNGktVFaUrV1Lw03wqY2Jqx+07dcL1+ok4jxyJxsfHhjNsGuzJ2sN7e97jWMExQNT039DmBm5sdyPBzvIC4apitULuCSECZEWLEpqs/5z8hPQTHZEiRgo3hrzjflm4OdRk4JxFwAnqIR7nQusI3W4Rzwc9AQtvgxMr4PcZ9dfr9xCMekP+zmyIwWQmp8RAsMelOSViMor5eG0cj49oS1TAmQXTNUezARgW6c3B1CLicsr4YWsSj464vFy1/DIDOxLyAfBy0pJXVsXTC0WZ3bSewVdEIJJcGDUOnEK1yM4y2WuAqrMLON+PqivDVNnBTb8I4V3SZBgSPISBgQPZn7Of5SeX81f8Xyw/uZwdGTu4q9NdTGozSWYgnUJNkHFF9CGsVVWUrFmDfWRkvZun5qIiyrZtA8Bt+k0ULfidooV/4vXAA2j8z3LD5DwYqh04SmdnLKWlQsBpwUgBRyKRNDqsRiP67dspXbee0nXrMOeLk1uFVovLhOvwmDkT+0h5J/t8WK1W9ufsZ17MPDambgSEcDOj/QxmRs2Ud5euFlYrpO+H9H1CqEnaAoVJp68X2AMix0KnqVe9rXZLo6aEqsxgwmi2oFFdprNMbQdTf4QVT8KRJVBVKsrbBj4Bw56X4o0NSckv5/Z5u0nI1TOzbygvjGuPvUZ1wa/XG0zc//N+UgrKMZgs/HRH79PWyS8zsC+lEIA3J3Vib3Ihj/x2gO+2nuT2gWE4aFQs2J2Czk5N33BPAtwcLnj//8ZkY7FCp0BXJnYN4I1/jlFqMKFUwO0Dwi54O5LLpyYDJ8tRCDjlrnZA1ZlLqKrK68QbEGHofz8GD+6SAeRNDJVSRS+/XvTy68WUNlN4adtLnCw+yTt73uGLg1/QL6Af4a7h9PDtQb+Afraerk2xj4oCtRpzbh4J112HMTkFAOcxY/B+6EHsIiIoWb0ajEbs2rXD/5VXqNh/AMOJEyIT5xIEHHNpKcb0dAB0/fpRuno1ptyW3UpcCjgSiaTRYDWbKVmxgtzPPseYklI7rvbxwf3mm3G7cRpq94YLQm2KZJRlsDtrN8cLjrM3ay8nCqvvWiiU3NDmBh7o+gCeDp42nmUzw1ghukUVJokT+sN/iLKbU1FpRRvtwB7g21E4bhpzx6gmjotDnWuhuMKIl9MVaAOu1sKEz8TDWCk6TckLNZtRXGHkUGoRj/9+kHy9uOCevzOZ3YkFTOsVTIiHIz1D3XHXnbuD09srj5NSUA7AlrhcUgvKT3PyrDueg9UKHQNdCHBzYJyLPZ+sjSUhV8/czSc5llnK2mPZtet3CnTl3Rs6095fuHkK9FU42anPmJlTUz41tpM/U3sG88HqWCqMZkZ38LtkR5Hk0qgpoYrxLMf/vXdZUvYPVG07c4hxibigROsMTx6HOf3E5/6md2DUpZeKSGxLZ+/OLLxuIX/F/8XPx34msTiRNclrapePDB3JC31eaLHnUUp7e+wjI6mMicGYnILSyQlLWRmlq1ZRtmEDIT/8QMk/KwBwGTcWEKKP4cQJKmOO4jx8+EXvs6Z9uNrfH7uICEpXr8YoHTgSiURiW6xWK6Vr15L36acY4uIBULm74zxmNM7DR6Dr01sGEp+C0WwkpTQFk8VElbmKpJIkYgtj2ZGxo1awqcFOZcd1ra9jZvuZhLuF22jGzQyzCZK3wtFlkLobco6KNtCnonUSgo1vRyHatBosL/YbEJVSgYu9mpJKE0XlV0jAOZUGaIUuEc6XpxYewkGr4tObuqFWKTmSXsx9P+8jrbCidr0OAS7cMzic15cf40R2Ka8vPwqAi72at6d0Zmyn+nd9LRYrWSWVbIvPY/7OZACCPRxILahg4d5UnhhV3+G5trp8akR7IbqqlAoeGd6GRxcc5LP14pilVStp5+fMkfRiDqcXM/GLbdw+IIx9SYXsTS7EU6flxl7BzOwXir+rQ+37256QB8C4Tv64Omh4eHgE87Yl8cjwyyvNklw8LlohuJmxoB0znIzN/0LaWdqIF6eJr66B4rP92vfgtxth55fQ5aYzd6yTNAm0Ki3TIqdxQ9sb2Je9j2P5xzhReIIVJ1ewJnkNe7P2cnvH27mh7Q21ZXctCeeRI6iMicF10iR8nnkaU04u2W++Sfnu3aTdfz/mkhIAXK6tE3CKlyyh8ujRS9pfTfmUfdu2qH28ATDlSAeORCKR2ASr1Yp+23ZyP/lEdJMClC4ueN5xBx4zZ6DUtdy6Y7PFzOG8w8QWxpJQlIAVKw5qB5KKk9iZuZNyU/kZX6dUKOns1ZmOXh1p79mewYGDZUepU0ndLcKDrRZRAhPaD8IGg+osh8MqPeQch9xjkHMMco8Ll015fv317N3Ao5XobhQ5VjyaSnvvZoqbo5aSShPFFVW2norkEsgrM3DL3F2cyC4FoF/rVG7pHcLsxdG14o2HTsvQtt68fn1HdHZq+rf2Yv6OJBJy9cRkFJOUX84Dv+xncrdAhrbzwctJy+qYbJYdyqBAX/d3MbNvKH3CPXjo1wP8sTeNR4a3ocpsoajciIdOy5Y4IbLUCDgA4zsH8MnaOE7m6XHQqPhuVk/6R3iRW2rg2UXRrD+ew9ebTtaun6+v4suNCSzYI9qCeznZseRAOpZqZ0+Ip/i8eGBoBA8MlWH8V42KIjjws+gY51i/i42D2gGVQoXZaqbMWIbeqAfO0oWqRsBxCRRfI8dAu/Gio+Dfj8Edq0Q3OkmTRalQ1pZWAcxoP4MXt71IbGEsH+77kK+jv+bezvdyW4fbWlSnOK/77sN9xgxUTuKmlNrdneCv5pA867bac3mHrl3RBon/DfsOUQCXLODUdKCyi4xEXZ15KTNwJBKJxAaU79tH7kcfU753LwAKR0c8Zs7E847bUbm27GyW1JJUZm+ZTXTe2VP+dRpd7clmoFMgbd3b0tm7M4MCB7VMwcZQBiufhcoiaDsGPFvDiZWQsgP8OkPnaRCzBHZ9dfprHT0hdAC4h4GDO1QUQmkmZEZDXiz1OkTV4OABUROg9XAI7C5O4lvQCVxTwN1RQ0oB5JVJAaepkV9m4Oa5O4nNLkOrVlJlsvDh6hMYjGaOpJfgbKdm7ZND8HWp74Tydrardc8YzRY+WhPLnE0JLD6QzuID6fXWVSsVhHg40ifcg+fGtkOlVODuqCGrpJLnlxzm35hsiiuM+DjbUWE0E+BqT4dTAo5VSgVvTurElxvjeWxEG3qEetTO4btZPflxexJLD2UwvJ0Pk7sHEZ1WzDurjpOYp+frTQk8NTqSuVuEwHNLH5mB1WCsfBaiF4hQ+Vv+qLdIoVDgpHWi2FBMaVVprYCjU5/hZlJNCZVrUN3Yte/AyU2Qtlsca/o9eLXehcQGtPdsz4JxC1h+cjk/xvxIQnECH+77kOjcaN4Y+EaLCjuuEW9qUDo6EvzVHJJumo4xNRWXCdfVLrOPjASFAlNODqbcXNTe3he1L8Ox4wDYtW2L2lsKOCAFHIlE0sBUHD5C7mefot+8BRDBxO7Tb8LznntQe7bMmuIarFYrf8X/xTt73kFv1KPT6Oju050I9wg0Sg3lxnI87D3oH9if9h7tZcvvGvR58MtUyNgvvj++vP7ytD2w97u679tPEIJLZTHE/SvcNMeWnX37Oh/waQfe7cVXnyhRFiVbxtayPT6P7Qn5hHg60t7PhY6BLja/Ixnu7cShtGJis0oZ3eE87b0lDY7VamVbfD4n88oorzIT7qVjZJQvFUYzd/y4l9jsMnxd7Pjlrj7c//N+4nLKeOMf0UXvkeFtThNv/otGpeSZMe0YGunDkgNpnMgqJb2ogl5hHtzQI4gBEV6nhVtP6R7Et1sT+WNvWu1YTqkBgJFRvqf9Tfdr7Um/1qcftxQKBbcNaMVtA1rVjgW4OWCnVnL7vD3M35mMi72G7BIDvi52TO4eeHE/PMmlUXASDi8Uz+P+hYQN0HqYyDArToPwIThpziDgnLGEKlV8PVXAcQ0S+TfLH4N1r9fdTJA0GzQqDZPaTGJixET+jP2Tt3a/xdqUtRxbdoxbo25lYsTEFiXknIra05OwX39Bv3MXLmOvrR1X6nRoW7Wi6uRJKo8dw+kiBByLwVDr3HHo3AmFnfjcN+XlYTWbUahapstNCjgSieSqY7VaKd+xg7y5cynfsVMMqtW4TZ6M1wP3o/FruRdXWfosKkwV5FXk8cn+TziUK9rHdvfpztuD3sbf6dJaLrYYSjJh3jgoSBCumB63QcJ6cXIdPhRaDRFdoI79LZw2130KbUbUvd5sguRtIsemMFk4eBw9xcO3A/h3lWHD58FisfLAr/spKq9r2f325E7c1DvEhrOCKH8XlhxI52hmiU3n0dzJLqlk+tydXBPpw4vjo05bbrVayS0zEJtVhpujho6BwmE5d8tJ/rfieL11+4V7olUrOZRahJujhl/v7ktrbydeGh/Frd/vBiDM05FZ/cMueH69W3nQu5XH+VcEbukbyoI9qWjVSp4c1ZbxnQLYGp/HiexSbr+IfZ6NoZHedA1242BqER+siQXg7kHh2Klb5kVIg7P1Y5FXptKCuQr+fQGGPA1L7gNTJTy0rzbT5PwCzhkcOCCOQTFLIHETLLoTxn0oXJqSZoVSoWRa5DQiPSJ5YsMTpJel89but/j84Oe8O/hdBgYOtPUUbYLa2xvX68afNm4fFSUEnKNHcRo8+IK3VxkTg9VoROXlhSY4GMxmUCrBbMZcUHDRbp7mghRwJBLJVcNqNlO6ejX5c7+tq31VqXAdPx6vBx9AG2LbCzxbUlpVygtbX2BD6oZ64w5qB+7rch+zomahkvXz58ZigSX3CPHGLQRmLAGvCBjxSv31eswSnaIUKtFJ6FRUaggfIh6SSyIpX09RuRGtSkkbXydiMkpYHp1pcwGnptwlJkMKOFeTBbtTOZmr52RuIuO7BNA12K12WVphOTd9s7M2s0apgA+mdSHS14X3/hW5BoPbeuPqoGHN0Sx2nBTZUnZqJd/N6klrb6fada7t6Me/MVm8cl2HM3ZzuhK08tKx5ZlhOGhVta3Ix3X2ZxxXRkhXKBQ8PrIts6rFKHdHDdNt/H/SYihOh4O/iudTf4S/7oecGFh4W906eSdqBZwyY1lt1tw5Q4xd/uOeUihEp7o5/UVe2txhouvgDT+AyyX8HVmtkLITArqC5sLb018yJgOUFwhnakX11/IC4Tj16ywcqP89jrZgunh3YdmkZSyNX8qvx38luSSZR9c/yqfXfMqAwAG2nl6jwT4qipLly6mMubgcnIoDBwBw7NZVOCDVatSenphyczHm5EgBRyKRSK4UFoOB4r+Wkv/9dxiTRTtlhb09blOn4nnbLDSBLdMufqLgBLkVuRjMBj7e9zFJJUkoFUp0Gh1qhZqBgQN5tPuj+Oqk4+OC2PmlyDHQONaJN2ejIU58WyiH04sBiApw4cNpXbjmg03sSsynzGDCyc52pxk1LZxTCsopqTTiYi9L3q40VquVvw7WZcv8b8Uxfr+nb22p0c87U0grrECpENkw2SUGnvjjEL7O9hjNVkZF+fL1zB4oFApS8st5edkR9iYV8sG0LrWZMjV8Or0bBfqq85ZOXS7nazt+uQxu40WPUHf2JRdy+4BW6Gz4P9Ki2PYJWIwQOhDajYUhz8K/z4llWieoKoPitNqW4UWGIipMQng8TcCxWs+cgVODeyjctRa2fgRHFossttUvwA3fX/y8N70DG98S5VjTF1zZrDWrFZK3Q/wacSzNPSF+DudCqRailVsIRAyHHreDg9uVm1MTRKfRcXP7m5nadipPbXqK9anreWT9I3w+/HP6BfSz9fQaBfZRlxZkXL5fCDgO3epcbGpvb0y5uZhyW24nKnnUkEgkVwyryUTR4sXkffElpmzRdlXl6or7jBm4z7gFtbu7jWdoO9alrOOxDY/VG/Nx9OGTYZ/Q0aujbSbVlMk6AuteE89H/+/c4o3kqnI4TQg4nYNcCfd2IszTkaT8crbG5TGmo+3KI911WgJc7ckoruR4ZukFl9FILpyDqUUk5umx1yixWmF3YgFrj+UwMsoXs8XKkgPCpfD5zd0Z08GPF5ce4dddKWSVVOLlpOWtyZ1qxZ4QT0fm3d4bi8WKUnn6RapGpbzq4k1DoFAomHNLdzbG5jKpW8u8mdHg5MXB3mrxZPBT4mvvu0UOmnsYZEWLGwLFqTg7CgdOTnldSOppAk5FIRirO0G6BJx5nz7tYfI30Pd++GYoHFkEAx4F/y4XPu+UXULAAYhdBYf/hM5TL/z15yJxM6x/A1J3nb5MoRKB/o6eolOXoycYSiHzoPiZFSWLR9IW2Pw+dJ8l3qdb8JWZWxNFo9Lw/pD3eXLTk2xI3cBTm55i0YRF+OlabkxADfZR7QEwpqdjzM4GFCjt7VA6O6NQntlRabVaax04Dt261o6rfXzg6NEWHWQsBRyJRHLZWC0WSletIveTT6lKTgZA7eeH5x2343bDDSgdW3Y75ZzyHF7ZLsp6QpxD0Gl0hLmG8UyvZ/By8LLx7JogxkpYfLfIMGh7rcgckNiMGgdOTbbJsHY+/LAtiQ3Hc2wq4IBwBWUUVxKTUSwFnKvAX9WdncZ08MPfzYE5GxN4e+UxBrf1YkdCPtklBtwdNYxo74tSqeDN6zviZKdmyYF0PpjaBU8nu9O2eSbxprnh42LPtJ4t+2K3wbBaRecpixHajBKhxSBKgoZVO3B2FIqvxWk4u7UDRD4dgFqpRqv6jyurpnzK0ev87s6AbtDxBjjyJ6x9DWYurltWlgPxa8HOGZz8RJlUTTh+ZYk4zlktwvFSkg4rnxHz113GeUNFIfzzpBCUANT2EHW9yIwL6im2becqckb+S43zqChV5Mbt+VZ83fmF6LrVYRJ0vlGUJKtP/99uCWhUGj4Y8gEzV84kJj+GZzY/w/ejv0etbNmX3CoXFzTBwRhTU4kfMrRugUKBbsAAgr/+6rRA4qqkJMwFBSi0Wuw7dKgdr2slLh04EolEctFYLRbK1q8n94svMRwT3UFU7u543XcvbjfdhNKuZR7AT8VitfD81ucpNhTT3qM9v4z9BY3sXnR5rHtNnDTqvEXWgGzf3aAU6qvYlpDHqCg/1EpFbcZM5yAh4FxTI+CcyMFqtdq0G1VUgCtrj+VwVObgXHGMZgt/R2cCcH23QLqHuvP7nlQScvW8vvwohdWh1hO7BtZm1igUCp4f257nrm1n8y5lkhbCiRWQsE4EF495+8zr1JRBFaXiFNETgOxy4SI+Y/7NucqnzsQ1L8DRv8Q8EjdDq+oQ1xVPwdGldet1vQWu/1I8X/OycLm4hsA9G+HH60Rmz+K7Ycw74N227nXx62DTu6J067pPziwqVRRB3BpY+4qYv0IFPe+AQU9eeDaPQiHes2sQhPYTr49fB9s/Ee/ryJ/ioXWGrtPFtp1bnvtEo9Lw3uD3mLp8KgdyDvDRvo94rPtjLf7cz/maayj48UfxjVIpcgytVvRbt1KyfDmuEyfWW7/iwEEA7Dt1QqmtE1HrBBzpwJFIJJILwmo0UnnsGOV791G0eBFV8QmAaBPoccfteMy6DZVTy2yh+F8MZgNv736bXZm7cFA78M7gd1r8AfyySVgvrO4AE78Ep5YZYGcrTmSVcuePe0grrOC2/mHM7BdKmcGEvUZJRHXgbO9WHjhqVeSUGojJKKl15tiCqOocHNmJ6sqzJS6XAn0VXk5aBkZ4oVYp+WBqF+74cQ8/70yhxkhzQ4/TL3KleCNpEIwVsGq2eN7/4bO39K4RYorTakOMaxw4NZk49ahx4FyogOMRLpyie76F7Z8JAcdqhaRtYrlvR8g+Aod+qy7xUsD+n8SySXNA5wkTP4NvR4pj4Be9IKiXKN8qLxClTACpO8Xcpi8AexcwG+H4P7DvB0jcIjpw1cxn8rcQ1OPC5n82FArR1bHNCMg4KOZ8/B8oy4Ld38D++dDnXiHk2Ltc3r5qyI4Bfa5wJbkEgrZxOryDXYJ5td+rPL35aX46+hMrE1dyY+SNzIia0WLbjPvMfhaPO25HqdOh1OmwGo3kf/steZ9+Ru6nn+Fy7bUoThFqKg7sB0SA8amofcR5nxRwJBKJ5AIwZmWRPGMmxrS02jGlkxPuN9+Mx+23teiMm1PRG/UczjvMu3veJa4wDoDnej9HK9dWNp5ZE8RshPT9cHKjaMuaKrq30OsuaDvKplNraaw5ms1jCw6grxIXAX/sTaW1tzgRjfJ3Qa0SLgs7tYoBEV6sOZrN+uM5NhVwajpRxWWXUWWyXLXuRS2R3/ekAnBdl4Da3/2wdj48OrwNH6+Nw2IVQdK2/P1LWjjxa6EoRVzoD3ry7Ou5VpezlWXhrBI5S9l64cBx1JxBILhYAQeg+61CwEnZCRazcMGU54lQ4LvWwe+3iPlu+1QILVYztB4OYdXtqAN7wB2rRCv02JWQtqdu20oNdLlJuHmSt8GcAUL0KU4TYkcNXpHQ/joY+DjYnUGYuhwCuorH2PfFsXrD/yBtN2z7WHT/Gv4SdJp66Q0FSjJh9YvC4VODUg1BvSHiGhGmfDmlZVeBMa3GUGgo5Jvob8ityOXzg5+z4MQCHu/xOOPDx6NUXPzxqNhQzF/xfxHiHMKwkGGnLc+ryCOnPAelQomPow8e9o2ndFihUKDxrWvSodBq8bz9dop+W4AxPZ3CPxbiMeOW2uW1Acbdu9fbjnTgSAFHIpFcIFarlcwXX8KYlobS2RnHHj3Q9euL6+TJqJydbT09m1NuLGdZwjIWxi4krjAOK1YAPOw9eHPgmwwMHGjjGTYx9Hmw+T048AtUldZfFjoARr5um3m1QIxmC+/9e4JvNp8EoG+4B3llVcTnlPHhmlgAOge51XvNNe18WHM0m78OpnPfkNY2E06C3B1wtldTWmkiPqeMqIArdBe4hZNeVMGao+IC979tsB+5pg3RacWsP57DjL6yRbbEhrS/Du74F6r0oD2H60HnJbJgTJU4m0wAVFmqxCL1RbQQPxc+HUCjA0MJ5B4XwcoAvh1AYy8Epvi1cPAXkXsDolPWqQT3hum/ClEqZacIFDZVQuRY4S7qdRf8PAWKU8QDRKlxj9ug683CeXO1USpFTk/4UBG8/O8LUJAAyx6GlbOhzUjw6whOviIfyK/TubdnqoJdc0SJWFUZoADPCCjLFj/LlO3isftbmPIttBp09d/jRTC93XRuaHMD/yb/y5yDc0gpTeGFrS8wN3ou0yKnMTFiIi7a8x+X9EY9Xx36ij9O/EG5qRwFCt4b8h6jw0YDYLKY+O7wd3x16CtMVvE3rFaoea7Pc0yLnFa7nXJjOX/F/0WRoYjbO96Og9q2HTqVDg54PXA/Wa/9H3lffYXbpOtR6nSY8vOpShAOf4du3eq9RlMt4FTGxpL50kt4zJqFXUTLamQhBRyJRHJBFC1ciH7rVhRaLWELfsOu9VmsyC2MtNI0fjv+G0villBqrBMa/HR+9PbrzeM9HpdBxRdDaba4S7lzTp1w4+AhQhFbDREnhR7SyXQ1MJjMPLfoMHuSC5jaI5hJ3QLZnVjAvO1JtUHFt/UP44Vx7flzXxrPLT5cm3PyX5fF2I7+vP/vCU7m6pmzMYFHR7Rp8PcD4o5flL8LuxILOJpZIgWcK8QvO5OxWKFfuCdtfesL+Eqlgq9n9iAmo4QuQdJ9I7ExIX3Pv05Ntkt+PE5V5fUWnTsD5yIEHJValCwlbhadnwqTxHhAtbsgtD8E9xVlUCCOdyF9zrwttxDx+C8BXeHBXZC0VThd7FwgsLttAoUVCoi8VriIdn0Fu76GkjSRBXT0r7r1Wg+HIc+c/nsylMGJlbD5XcgTNwoI6iUcPgFdxfcFiXByA+z8CvJOwE8TYPgrMPCxq//+LgKNSsP48PGMCh3F/KPzmXt4LkklSby7512+Pfwtn1/zOZ28zy5klVaVct/a+4jOjQbA096T/Mp8ntvyHFqlFr1Jz6/HfuVw3mEAvBy8sFgtFFQW8PrO14ktjKWDZwfiiuJYGr+UkipRUrw2ZS0fDf2IUJfQq/9DOAduN9xA/g/zMKakULRoMR63zqRk+XIA7Dt2PM3db9emDY69elG+Zw9FC/+kaOGf6AYNwuO2Wej6928RJboKq9VqtfUkzkdJSQmurq4UFxfj4iJPviSShqYqLZ3ECROwlJfj88wzeN5xu62nZFOsViu7s3bzy7Ff2Ji6sdZtE+oSys3tbmZ02Gg8HTxtO8mmhMUsavgP/gYxi0V3KQD/rjD8ZQgfduaOGJIrht5g4t75+9gan3fG5S72at69oUttV6mKKjN931pHcYUQcFY/Pvi0C/llhzJ45LcDaFQK/nlk0GnLG4rX/o7hh21JTO8dwluTz3O3FziaUUJ8bhkTupylPXALp9Jopv/b6ynQV/HVjB427zQmkVwRfpoIJzcSM+oVbor7oXZ4ZOhIPhz6Yf11P+oIxalw5xrhirlQ1r8pBIku04WLJ2kLXPcp9Jgllseuhl+r24TftgLCBlzmm2pEWK2QsV8EKRenQnG6ELNqcnnCBomcIn0exP0r1qtp1e7oBSP/T/zcznQuUKWHFU8L9xLAqDfEthopeqOef07+w/yj80kqScJeZc+7g989Y0lUsaGY+9bcx5H8I7hoXWod3U9teop1Kevqreuscea5Ps8xPnw8AHMPz+WzA5+dts0Q5xD0Rj35lfnoNDqe6fUM10dcf0klXVeKgl9/Jfv/XkcbGkr4yhUkXj8JQ2wsfq+8jPv06aetb7Vaqdi/n4J5P1K6dq34+wKcR48m6JOPG3j2V44L1TykA0cikZyGubQUhZ0dSq0Wq8VC5gsvYCkvx6F7dzxm3Wrr6dmMClMFK06u4Jfjv9Rm2wAMCBjALe1vYUDgAJseAJscZbnVQYc/idDDGoJ6Qb+HoP0EKdxcZZLy9Kw/nsMfe1M5nlWKo1bFQ9dEsOpIFtFpxbTy0jG5WyDTegXj62Jf+zoHrYqbegfz9aaTOGhUtPY+PU/hus7+LD2QzrrjOTy7KJrF99vmztjQSNEVa9G+NO4f0poQz7OHXqbkl3Pj1zsoNZjwd7WnV5gHJZVG7py3h96tPHh6dLsGnPnFcyyzhDY+TrWZNFcKvcHElrg8lApIzNNToK8iwNWeEe19ruh+JBKbUZ1n41ReWG/4tBBjixlKMsTziymhAgiudtSk7BDhwyAcMjW0GQkDHhPumeYk3oBw5AT2EI8aChJFRs6BX4SYVRPGXIN7K+g8Dfo+AA5uZ9+2Vie6d3m0gvVviKwcO5c6YayRodPomBY5jXHh43hy05NsS9/GIxseoYdvD8aFj8NZ40yhoZA9WXvYkraFSnMlbnZufDvqWyI9IgF4e9Db3L/2fvZm76WdRzv6B/Rnervp+OnqBPV7Ot9Da9fW/HT0Jxw0DgQ5BdHHvw/XBF9DQWUBT216iv05+3ll+yssjlvMK/1eoY27bdyybhMnkvvhR1QlJ5P/9dcYYmNR2NnhMm7cGddXKBQ49uiBY48eVKWkUDD/Z4oXLUI3oH8Dz9w2SAeORCKph377dtIeehilszPBc76kfP8Bst94A4WDA+F/LUEbalurpS0wWoz8duw3vjn8DcUGUUrioHZgQusJ3NzuZsLdGqCuvLlgrICEDXBsGcQsEfX7APZu0OF66DYTgnracoYtgrTCcv634hgrDtcJZ64OGubd3otuIe5YrVZKKky4OKjPKrpkFVdy0zc7GNLWm9cmdjzjOpnFFQx7fyOVRgsrHx1Ee/+GP4ZbrVZmfLeLbfH5jO3kx5e3nLnzitFsYepXOziYWgTAA0Nb88yYdvyxN5Vn/ozGTq3kyGuj0VxhceRKMX9HEi8tjWFsJz++uFlcFL618jgbT+Tw2fTuRPpduAPqiw3xrI7JwtvZHrVSwabYXCqM5nrrPD06kgeHtazcAUkzZuPbsPEt8rtOZ2jxttrhGe1n8GzvU7JoSjLgw/aiDfdLuaBUXfg+KorgnVPOodQO8FyaKK9qyRSnifDmwwtFaVibURA5RpSXXYzob7WK9uvbPwUUcMtCIYo1YowWI+/sfoc/TvxR6+b+L2EuYXww9APauretN262mKkwVeCkvbRAapPFxC/HfuHLg19SbirHXmXPa/1fY2z42Eva3uWS9b//UfjTfPE7t1pxGT+ewPffu+DXm0tKxM1nOxuUDF4hpANHIpFcNKUbNpD+6GNYq6qwlJeTNGMmWESYns+TT7ZI8WZf9j5e3/E6CcUiTC3QKZDp7aYzqc2kCwqekwBV5XBihRBt4taCUV+3LKC7sDq3Gw9q7dm3IblszBYruxML+OdwBgv3pmEwWVAqoF9rT4ZF+jC+cwB+rsJlo1AocHU8d8t7P1d7Nj59uuX7VPxdHegS5MauxAKOpBfbRMBRKBS8OC6KcZ9uYcXhLHYnFtC71emdOT5aE1sr3gBsicvjmTGw8YTodGEwWTiRVdoouyoVVxj5oDpQesXhLP7Ym0qVyVIbPH3fz/tY+tAAXOzrfqdGswWL1Yqduv4F6N6kAt7790TNlmvHQz0dcbZXk5irx8NJe1p4sUTSpKl24DiXZNUbdlQ7iiDdmuNTTXaNS8DFiTcgXCTe7SH3mPjev7MUb0D87Me+Kx6Xg0IhSq3KC+Dgz7DoTrh7w9nbxzcCNEoNL/Z9kbs63cXyk8vZnLYZlUKFi9aF1m6tGRE6gvYe7c94I0WlVF2yeAOgVqqZ1WEWo8NG8+r2V9mWsY1ntzzL8cLjPN798QZ3zHrcfLMQcKq9JW5TJl/U61UtyOQhPzUkEglWq5WiBQvIevN/YDLhNGI4ljI95TtFmJ5jnz6433x6DWpzxmQx8dWhr/gm+husWHG3c+eR7o8wKWISqos9aWupFCaLQOL9P0FlUd24S6DoDtJhkrCUt4DAuYbmjeVHWXYogx/v6E17fxeKy41M/Xo7sdlltev0Dffgles6XHVRpUOAK7sSC4jJKGHqVd3T2Wnv78KNvYL5bXcqb608xpIH6pcnJOfrmbNJiLSvTejAK8tiOJJRTE5JJVti63KBDqQWNUoB58sN8RSVG3HQqKgwmnl12VFM1eK7g0ZFYp6ep/44xP1DWxOdVszW+Dy2V+cdrXpsMMEeoqzMZLbw4l9HABjTwY+BbbworjDSv7UnXYPdUCgU1Bi3W0JQpKQFUS3gaEsysHOzw2A2AKA7uhQ2fAG3/SOEgO3VmSIB3c62pXMT0qdOwAnofu51JRePQgHjPxTBx2m7YcHNcNdasGvc3VL9dH7c1eku7up0l032/cXwL/j84Od8e/hbfjjyA0FOQUyLnIbFamFz2mbaurclwOnq5sJpw8LQDR6EfvMWNAEBOPY5S4i3RAo4EklLx1xURMaLL1K2VoShuYwfT8Dbb4HFQva771EZE0PA/95E0UKySJJLktmYupF/Tv7DsQJxkjWx9USe7vU0rnaN78Kt0WGxQOIm2D0XYlfWtUN1C4GONwjhJqCbFG2uIlvicvl2ayIAsxdFs/iBAby96jix2WU426sZ08GPCV0DGBjh1SAX4R2qOz8dzSi56vs6F4+PaMtvu1M5kFJEXpkBL6c6m/XmuDysVujdyoNZ/cP4bXcKx7NK+XhdHKUGU+16B1OKmNm3cTgR04sqyC4RJYg/bE8C4LPp3fhuayI7TuYDQoS5b2hrpn21g9VHs1ld3fr7VFYeyeSeweIO9Y87kjmeVYqbo4b/Te6Eh+50V5wUbiTNEtdg8bU4DWefSAwV1QJOXgKUFsDC22DY88JNqlTDNS9e2n6C+8C+eeJ5oBRwrgpqO7hxPnw9RLRsX3QX3PTrxTumWhAqpYpHuz+Kq9aVD/Z9wHt73qOLdxe+P/I9KxJX4Kx15ovhX9DN5xKFywvE++FHqEpMwvuhB1vMdcelIAUciaQFY0hMJPWeezGmpoJGg+9TT+I+c2bth6bfiy/YeIYNg9FsZG3KWhYcX8D+nP214zqNjpf7vmyzeuAmRX6CcNocXljXYhVEB6k+94qadnnydNXRG0w8t/hw7feH0op5dlE0f+5LA+DbW3vSJ7xhO6TVOFZiMoqxWKwolbYRAHxc7Gnr60Rsdhn7kgsZ3aEu7HFHgnCjDIrwAmBwW2+OZ5WyYHcKAH4u9mSVVHIwtfD0DduA/SmF3Dx3J5VGS+1Y/9aeDG/vQ1SACzd9sxN3Rw3vTe2Ms72GNyZ1ZPaiaNwdtXQOcqVHqDsFeiPfb0tkc2we9wxuTYG+io+qy7CeHdPujOKNRNJscal2Fxj1OKkdqfHdORqrc9qyouH3GeJ573vAO/LS9hN8iqvgUl08kvPj7Ac3/QLzxkHsKlj5LIx9T948Og+3driVHZk72J6xnZv+uQmTRdzAKK0q5Z7V9/DB0A8YHDT4qu3foVNHItasvmrbby5IAUciaaGU79tH2gMPYi4uRhMUROAnH+PQoYOtp9WgZOmzWBi7kEWxi8ivFHes1Qo1Pf16MiRoCKPCRuHjKLusnBWLWZwY7fkWEtbXjdu7Qqdp1Se5bc/+eskV5/3VJ0grrCDQzYGZ/UJ5e+XxWvHmxp7BDS7eALT21mGnVqKvMpNcUE4rL12Dz6GGnmEexGaXsTepoFbAsVis7EgQ///9I8TPZ1AbL77ZfBJLdabkA8Na8/LSGBJy9RRXGHF1OHc+0NUkMU/PnfP2UGm04OaoodJoxk6t4qXxUSgUCgLcHFj35BDUSkWtW2Zaz2AmdAnATq2sHYvPKeP7bYnsTiygvMrEkgPplBlMRPm7cGPPYJu9P4nEJmgcQOcN+lxclHX/306n9nqxmMDRE4Y8e4YNXCAe4dB1hmif7SlDwK8qQT1h8jfwxyzYM1c4gQc8YutZNWqUCiVvDHiDKcumUGgoxEHtwFsD32JR3CK2pG/hyY1PsvqG1bjbuzf43PIq8vj+yPdMbTuVVq6tGnz/jQkp4EgkLQyr2Uz+99+T++lnYDRi37kzwV9+gdrLy9ZTaxCKKotYnbyalYkr2Ze9rzb139vBm6ltpzKl7RQp2pwLq1VYko/9LRw3xanVCxSi20O3mcJto7E/52auBgdSClErlXQKapmlbpnFFfxYXUrzv8mdGBjhxaojWRxMLcJTp+W5sbZpga1WKWnn58yhtGJiMoptK+CEuvPrrhT2Jtc5aY5nlVJYbsRRq6JzkBsAvcI8sFMrMZgsqJQKJnYN5NstiaQUlBOdVsSgNt4NOu/skkrWHM0mu6SSvw6mU1hupHOQK7/d3RednRqr1VqvtOlMnbLsNfUdcK29dQS6OZBeVMHOk/m1Qt/0PiE2c0lJJDbFNQj0uThR9/+js1hEydTAJ2DzuzD6rXO3tD4fCgVc/8Xlz1VyYURNhFFvwOoXYM1LQjgb+LitZ9Wo8Xb05pNrPuGXY79wW4fb6OjVkcHBg5m0dBLJJckcyj3E0OChDT6v30/8zvyj8yk3lvNq/1cbfP+NCSngSCQtCFNeHumPP0H5nj0AOI8eTcDbb6F0cLDxzK4uJouJDakb+Cv+L7anb8dkrcu06OXXixsjb+SakGvQKG13V71RYzZByg44sVLU/xcm1i1z8IDuM6HnHeAeZrMpFuiruOmbnaiVCna/MAKdXcs7vP0TnYnFCr3C3BnSVggMH07rwv8tP8qdA1vh5mi7kpgOga4cSivmSHoJ4ztf3SDEc9ErTHSfOpJeTKXRjL1Gxfbq8qnerTxqhQ97jYrerTzYEpdHj1B3XB00dA12I6WgnIMpZxZw0grLySiqpHuIG+or1GrcbLEyf0cS7/17An1VXRvvYA8HvpvVq/bv/FJyaRQKBUMivfl1VwpfbTrJscwStColE2z4+5FIbIprEGQcwMlS57rRWawiAPeaF2DAo2B36V1/JDai34NQWSwEuLWvQpUehr0gy6nOQTefbvXybjRKDd18upFckkx0brRNBJzjBccByNRnNvi+Gxst7wxXImmhGLNzSLntNqoSE1E6OuL7wgu4Tp7UbAMpy43lROdFsydrD8sSlpGlr2sN2t6jPde2upYxYWPwd/K34SwbOQWJcOBnOPgLlJ5ywFTZQfgQ6DBZdJKygdvmv+xJKsBgsmAAdicWMKxd83NRVVSZSczTk1Kgp7W3E21863fV+PtQBgATutRdgId7OzHv9t4NOs8zURNkHJNRfJ41ry5B7g74ONuRU2rgUGoRfcI968qnWtcvL5veO4QtcXnMqA4t7hrsxrJDGfVajddgMJm5Yc4Oskoq8dRpua5LAI+PaFvbin1fcgEFeiMj2vuc9TPXarWSW2qo3p6Ff2OyWLg3jRPZpQB0DHShW7A7AW4OTOkeiLez3Rm3czEMbiMEnN2JBQCM7OB73vbxEkmzxSUQAGdz3U0eR6sFtNWftVK8aZooFEKA0zoKAWfze1BVDqPflCLORdDJqxN/xf9FdF60TfYfVxgHQE55jk3235iQAo5E0gIwZmWRMus2qpKTUfv7E/L9d9i1ap71oyklKfwQ8wPL4pdRZamqHfew92BKmymMbz2ecNdwG86wkVOUAod+h2PLRGhjDQ7u0HYMRI6F1tc0uhPZvUkFtc+3xucxrJ0PFouVdcdz6BXmblP3yeVSWmnk8w3x/LAtiSqTCK1VKuC1iR1rOyIl5+s5lFaMUgHXdmp8omSHAFHWdjSj5LRyn4ZEoVDQK8yDfw5nsje5kB6h7uyqFi/6t65fRjq2kz+Jb42tnWvXEDcADqYWnfYeVhzOJKu6I1S+vop525NIyC3jx9t7cyC1iBu/3onJYuWxEW14bMSZc6He+/cEX25MOG3c2U7Ns9e24+beV760qX+EJ2qlAlO14+CGHkFXdPsSSZPC3g0A59McOI3reCe5RAY+DhodrHwadn4BRj2M+whkt6MLoot3FwCO5B3BbDGjasDGFKVVpaSXiQYZuRW5DbbfxooUcCSSZo4xI4PkWbdhTE1FExBAyE8/og1qXifpFaYKNqZuZPnJ5WxN34qlunW1n86P7j7dGRg4kFFho7BTXf4d62aJxQLxa0UYcdxqqM4FQqGEVoOhx20QOQ7UjVcE2Z1Ul2myLV6UxHy/LZE3/jnG9N4hvDW5k62mdsFYLFb2pRTioFHRxteJ3FIDSw9m8MO2JPLKhDPDzVGDp05LQq6el/46QnphBc+MjmR5tHBIDYjwqtceu7HQzs8ZlVJBvr6KrJJK/F1tV7bZI9RdCDhJBfRv7UmZwYSrg4b2/i6nrXuqSBPl74JGJd5DYp6ecO+6i7qfdiQD8OjwNnQKdOWh3/azJS6Pd/49zt8HM2oFko/XxqFRKXlwWP3wUpPZwm/VHa8UChE11TXYjSndA7muS8BVEyBd7DV0D3Vnd2IBPs52tV24JJIWib34DHA215UrOlksooRK0jzoc49w4ix7WLRzz0+ACZ+BR/O8qXklae3WGge1A3qjnsTiRCLcGy6EO74ovvZ5saEYg9nQos/ppYAjkTRjqtLSSZk1C2N6OprgYELn/YAmMNDW07oi5JTnsCpxFVvTt7Ive189t82gwEHc2elOevj2sOEMmwAVRaI8avfc+rk2rQaLLlKR14Ku8V/QlVeZiEmvK805nlVKTkklP+5IAjhjyUtjwmq1sjE2l3dXneBYZglAPVcEQCsvHS+Nb8+wSFEa9um6eD5aG8tXmxKIySgmo6gCgPGdG5/7BkSmTIS3EyeyS4lJL7GpgFOTg7M7sYBHFxwEoG+4B6rzuFvsNSr6hnuyJS6PP/el8cwYEQp9JL2YAylFaFQKZvQNxdvZjv+b0JFnFkXz9aaTgPj9TegSwCfr4njv3xNE+DjVa2O+O7GAwnIj7o4a9rwwAqVC0WBBwhO6BLA7sYCZfUOvWHaPRNIksRMCjpNJnE8oAAerFbTSgdOs6DYDNI6w9EFI2gJz+kPfB6DjFPBpL8uqzoJaqaaDZwf2Zu/lcN7hcwo4ueW5vLrjVTp6deTOjneiVV3eTYjYgth63+dV5BHo1DyuZy4FKeBIJM0UU2FhnXgTGkLovHlo/Bvnxd2FYraY2Zi6kYWxC9mRuaPWaQMQ6BTIuPBxjAsfJ0ukzkdBImz/FA4tAGO5GLNzFSc1Pe8Ar6bV2vRgahEmixV/V3s8dFpiMkp4e9VxUguEqHEytwyzxXreC3RbsD+lkHdWHq8t49FpVahVSoorjCgU0LeVJ5O6BXJ9t0C06rqL60dHtCHYw4HnlxxmS5xwHGlUinqiQGOjQ4CLEHAyShgR5WuzebT3d8ZRq0JfZUZfUI6Psx2PDG9zQa+9pU8oW+Ly+H1PKo+OaIOdWsVP1ULhtR39a3NppvYMYntCHn8dzECrVvL5zd3oEOBKUXkVP+5I5pddKfV+VyuOCAfV6A5+DS6i3NInhD6tPGjtLS9SJS2cGgeOyQAqcFRqUMBZS6iqTBbSCstx1Kpxc9Sc1ulN0ojpOBkCugknTtIW2PK+ePh1gvGfQJC8AXgmOnl3Ym/2XqLzopnUZtJZ1/v52M9sTtvM5rTNrEpcxZsD36SjV8dL3m9sYX0BJ7c8Vwo4EomkeWG1WMh45lkh3oSEEPrTT2h8bXfBdLkUG4pZEreE347/RoY+o3a8m083RoSMYEDgAMJdw5ttIPMVozBZdGE4+JtopQngEwW974HO00Bru/bOl8OeRFE+1TPMgwBXe2IySli8P712ucFkIb2wghBPR1tNkeySSv4+lEEbX2c6BriwO7GA3/emsvGEqOXWqpXM6hfKA0MjcHPUkFFciValPGdQ7eTuQaJc59cDnMguZWikT6PO+pnYLZAOga4MiPA8/8pXEbVKyU29QvjrYDq39gvlnsHhOGov7HRoRHsf/FzsySqpZNWRLHq38mDpQfGZdGu/0Nr1FAoFb07qRJC7I/1ae9ZmAN02oBU/7khma1wuOSWV+LjYY7ZYWXUkG7BNfpFCoTgtEFsiaZFUO3CcqyrBAXSK6kDvs5RQTZmzncPV7k+1UsHXM3swvH3TPddqcXi0gluXQcxiOPwnJKyDrMPw3QjRcWzQUzL/6D908RI5ONG5Zw8ytlgtrExcCYCdyo6TxSe5b+19rL1hLfbqS2t68V8Bp6UHGUsBRyJphuR/Mxf9li0o7OwI+uzTJinemCwm9mfvZ1XSKpafXE6FSbgp3OzcmNJmCpPbTCbEJcTGs2wiVJbAlg9g55dgri41ixgBAx6DsIFN3i68N1m4V3qHuRPqqePrzSdrl7k7aigsNxKfW2ozAaeovIrpc3dyMld/2jKlAqZ0D+KxkW0JdKsrKzr1+blo4+vM0ocG8G9M1mkhvI2NIW29a9ub25qXr4vi5euiLvp1apWSm/uE8OGaWL7edJIP18RiMFnoFOhKj1D3euvq7NQ8NTqy3lgrLx3dQtw4kFLEskMZ3DUonL1JBeSVGXB10JzWCUsikTQg9kJo9TOUg4MKH2W1gK49XcCpNJprxRtVdcnrK8tiGBDhJZ04TQmlEjrdIB76fFg1Gw7/AVs/gj3fQ49bof0E8Gojmjm0cDp5izzB+KJ4fjjyA/Ni5tHOox33dbmvtu34wZyDZOoz0Wl0LJ24lKl/T6XQUEhsYSydvTtf9D4tVgtxRaIDVYRbBPFF8S0+yFgKOBJJM6Nsy1ZyP/0UAL+XX8I+MvI8r2hcFBuK+eHID/wZ9yfFhrpckwi3CGa0n8G48HGXrOC3OEoyRL7Nvh+gojrkt9VguOZlCO5l27ldIUxmC/uT6xw4YZ46tColVWYLvVt54O1kxz+HM4nPKeOadnVCZpnBxL7kQvq08riqJ9sGk5l75u/jZK4eLyctjlo1KQXl+LrYMbl7ENN6BtPK6/KcT/YaFRO7tlwrcUNzU69gPl0Xx9HqvKIgdwe+vKX7BTsAJ3cL5EBKEUsOpHPXoHBWHskCYER7XzQyg0YisR3VAk47fQkfTPyeiEOLgUNndGFkV3edc9Co2PfSCK55fxNphRV8vy2RB4Y2rTJkSTU6T5gyF6ImwpqXoSABtn8mHgDe7WH8hxDa37bztCE+jj746fzI0mfx4b4PAdiesZ3tGdsZGjyU9wa/x4rEFQAMDxmOr86XKK8otqVv41j+sUsScNLL0tEb9WiUGnr69iS+KF46cGw9AYlEcuWoOHyYtEcfBYsF10mTcJ082dZTumDKqsqYf2w+P8X8RJmxDAB3O3eGBA9hfPh4evv1liVS56MkE2JXQuJmyIyGgpPUdpTyjIBRb0Lb0U3ecXMqxzJL0VeZcbZXE+nrjFKpYFAbL9Ydz+H2/mEczyoFID5H/E3llRn4YkM8f+5No9RgYkr3ID6Y1uWKzqmiysyn6+M4nllCSkE5Cbl6nO3U/HxXH9r5uVBSaUSnVTfKTB7J+fFxsWd0Rz/+ic4k1NOR3+7uS8AFOqYAxncO4P+WHyUmo4SvNyWw5IAo9xvbqfHmF0kkLYLqEiqqShkVMhwOLK4eP92Bk1UsBBw/V3sctWqevTaSx38/xBfr47mhRxA+zvJGU5Ol/XiIHCu6cu77QZRVlaRD7jH4YSz0uQ+GPttiHTndvLuxUr8SZ60zD3R5gPiieJbGL2Vj6kae3fwsB3IOADCu1TgAojyqBZyCY5e0v5ryqQi3CPydRJlxbrl04EgkkmZAVVISqffci7W8HF3/fvi/9mqTEDwqTZUsOL6A7458R5GhCIC27m15sOuDDAkagkoprcinkZ8A6fuhqgwMpZB7HDIPQfaR09cN6Q/9HhAnI83wZ1lTPtUj1L22a8/7U7sQn1tGrzCP2k5ONQLOw78eYMfJ/NrXLzmQxqPD21xSedW2+Dy2xOVxLLMEFwcNs69th5+LPY8sOMCao9m162lUCubM6EE7P3Fx4GKvubQ3K2k0vDI+ig4BLpd0oeau0zI00oc1R7N5a+VxANr6OjGwTeMugZNImgNlBhNL9qcxsVvg6Z/F1SHGABhKxPEVztiFKqvagePrIsqsJnYJZN72ZA6lFvHuqhO8P/XK3hiQNDBKJUSOEQ+A8gLhyjkwH3bNgf0/QfeZIivHJcC2c21gHu/xOB29OjI2fCxeDuK4NT58PPesuYf1qesB8LD3oLd/bwCiPEW58tH8o5e0vxoBp417G7wdRBl2ToV04EgkkiaOKTeXlLvuxlxYiH1UFIGffoZC23jDTAGMZiN/xv3J3Oi5tbWsYS5hPNj1QUaFjUKpaOGlBJUlcGKFuPOTKy7y0DhC7gnIO3H21wX2hLZjILA7+HdpEm3AL4eaFuHdQ+ruhLnrtPTSiVbRET7ixDshV092SSU7TuajUMB3s3oyb3sym2Nz+WpzAv+b1Om0bVutVvanFOLrYk+Qe32B59ddKTy/5HC9sW3xefQO82DN0Wy0aiXPXduOQDcHOgS6XnCmjaRp4ONif1llEjf3DmHN0WwcNCruHRLOPYPDsVM3P4FVImlsvP73UX7fm8rOxAK+uLl7/YVqO1DZgdkgjsE1As4ZHDg1JVR+LkLAVSoVvDw+iilztvPnvjSm9giiT7jMtGo2OHrAxM8h6npY+ypkH4ZdX8HhhXDDDxA+xNYzbDD8nfy5tcOt9cZ6+vXkf4P+x9ObngZgdNho1EohM7T3bA9AXFEcVeaqi24pHlco8m/aurfFx9EHkA4cKeBIJE0cc1kZKffcizEtDU1ICMHffI3KqfF2EzJZTPyd8DdfHfqqtqNUgC6A+7rcx3Wtr6v9wG/RpOyCRXdBccqZlyvVQqhx9ASNA3i2Br/OENQLnJteYPXlUCPgdA12O+PyVl46lAoorjDy227x8+wW7MY17XxxstOwOTaXP/em8cg1bfBzFSfiFouVf2Oy+GJjPEfSS3DQqHhtQgem9gxCoVCw62Q+Ly8VbqexnfzoG+7JH3tTOZJewqoYkWfy0bSujOvc8B2FJE2DYe18WPrgAPzd7GWphUTSQOSUVNaWLK44nMmJrFIi/f4jzti7gj5HOHCqhHPzzCVUBgB8Xev+f3uEujO9dwi/7RYC/4pHB0lhtrnRZgREDIeTG4UjJysa5l8Pw54XpVVn6VjWEhgTNgZ9lZ5FcYuY2X5m7XiALgAXrQslVSXEF8XXOnIulJi8GAAiPSLxdhQOHCngSCSSJovVZCLt4YcxHDuGytOTkG/novZqnI4Lg9nA0vil/BjzIyml4kLa28Gbezrfw5Q2U9CoZFkJxkrR+WDze6LNt2sItBsLPu1BpYUqvXDUtL6mNmyxJVOgryI5vxyALkFuZ1zHXqMi2MOR5Pxy5m1PAmBUB5E10ruVB73DPNidVMAHq0/w6oQO5JYaeHZRNLsSRWmWQgEVRjPPLIrm7+gMQjwcWXkkC5PFyvjO/nw2vRsKhYJpPYN5ZWkMSw6k8+y17aR4IzkvXc4iOkokkqvDD9uTqDJbALBa4dP1cXw4rQtv/nOMxDw9c2/tib29ixBwKs9XQiU6Y9Y4cGqYPaYda45mkZCr56uNJ3l0RJur+6YkDY9CAa2HQchqWP4EHPoV1r8BWz+BbrcIMaeFnqNNaTuFKW2n1BtTKBS092zPrsxdHMs/dlECTrY+mwx9BkqFkk5enbBaRVl8qbGUcmM5jhrbdBe1NVLAkUiaMDkffEj5jp0oHR0J/uZrtCGNr612aVUpv5/4nZ+P/kx+pcgecbNz486Od3JjuxtxULfg0hKzCTIPgrEcynLECUBholjWaRqM+6B+Tb6kHofSigAI99Lh6nh2ATDC24nk/HKKyo0AjIqqcyk9MKw1u38oYOG+NJYdEo4wg8mCg0bFXYNaMat/GL/vSeXDNbFsicurfV3HQBfeu6FLbc6UvUbFOzd05vXrO6JVt/DyP4lEImlklBlM/LwzGYAnRrblwzWxrDicSWpBOdFpouPlwdQi+tYEGVcWg6HGgXMGAae4fglVDa6OGl4aH8WjCw7y0dpYNsbmcGu/UK7vGnhJuYQGk5mlBzMYFumDt7PdRb/+fJgtVhJyyziUWoTFamVklB8eurOXuBjNFjadyGXN0WyGtfNhTMcWHL6ucYDrv4SwgbD1Q8iPF2VVaXtgxmJwcLP1DBsNUZ5RQsC5yCDjA7kiEDnSPRKdRofVasVB7UCFqYK8ijxCNI3vuqchkAKORNJEKVm1ioIffgDA/+23cOjQwcYzqk9ueS7zj81n4YmFtV2l/HR+zIqaxeQ2k1usal5LaRb8PhPSdtcfd/KD0W9CpxtsM68mxMGUIuDs5VM1RPg4se54Tu3zcO+6k/Ehbb159booftyRTGKeHoD+rT15Z0pngj3E3+iDwyIY0tabLXF5GExm7DUqpvUMxkF7ujVeijcSiUTS+FiwO4XSShPh3joeGhbBscwSVh7JqhVvoDrXpuamyaklVNozZeCcXkJVw4QuARxMLWL+jmQOpBRxIKWI0koTt/YLu+h5v/nPMX7akUy3EDcW3de/Nqz/ShCXXcptP+whvaiiduzFv44wuI03vq722KmVhHs70S/ckyqThUX701h6MJ28sioA/tyfxnezejI00ge9wcT64znsTynkaEYJ4zr7X9L7bXIoFMJ102U6JKyDxfdA+j5RVjVzSYvtVPVfojyE6+ZY/sUJOIdyDgHQ1acrINw8Po4+JJckk1uRS4iLFHAkEkkTwXAykYznXwDA8647cRk1ysYzqiNbn83cw3NZHLcYo0U4HiLcIri94+1c2+paNMoWWipltcLx5cJpgxU2vw+lmcKa7Rokcm0iRsDgp1p0DfXFUJt/E+J2zvVa+9QJNqe6b0CcDNw2QDhtjmaWUF5lpmeo+2l3SjsGutIxsGVaoiUSiaQpozeY+GbzSQDuGRSOUqngsRFt2RSbi6uDhgA3B/YlF5JZXFnXSryy+KwhxhaL9bQQ41NRKBS8cl0H7h/ami83JDBvexKfrY9nao8zC/9nY3diAT/tEK6hAylF/Lk/jWk9gy/27Z+RjKIKbv1+N5nFlThqVXQMcEVfZSImo6T2hsfZ8HLSEuLhyP6UIh78ZT/3DmnNTzuSaoUdgF2JBWQWV/LM6Mgm0RH1slEqoc1ImPU3/DQBMg6Im3S3Lm2WHUAvlpog4xOFJzBZTBecd1nTkryrd9faMS8HLyHgtOAcHCngSCRNDGtVFelPPYm1vBzH3r3xfuwxW08JgMLKQr4/8j2/Hf8Ng1ncmerm0407Ot7B4KDBsqvU3u/hnyfqj3m3g5t+FSHEkovCarXWllBdiAOnhpr8m/+iUCjoECAFGolEImlufL0pgZxSAyEejkzqHghApJ8zm58Zhou9ho/WxrIvuVCURdVkl5RmASJv478lVPn6KkwWKwoF5yxr8nG254Vx7Vl7LJu0wgp+2ZXMXYPCa5cbzRZOZJXiZKfGy9kOJ7u6y7JKo5lnF0UDEOjmQHpRBe+sPM7oKL9zlgxfCEXlVbXiTYSPEwvv7Yd7ddnU8awSNsfmUl5lpqLKzKG0IvanFIEVRkT5MKV7EIPbemO1wm0/7GZ7Qj4frhFtnoM9HBjezhelQsH32xKZszGBQn0Vb07qhOoKOocaNX4dhYjz3ShI2gKb3oVhz9l6VjYn2DkYnUaH3qjnha0vYLFa0Kq06DQ6+vj3YXjI8NNeU24s53iB6MLazadb7biPg+hElVPecluJSwFHImli5H76KYajx1C5uhLw3nso1Lb9Ny6tKuXnoz/z49Ef0RtFCUp3n+481O0hevn1suncGg35CbD6RfE8dCBodeARXh10JzNuLoWk6kwbrVpJO79z/wzb+7kQ6OaAl5OWztJFI5FIJC2G9KIKvq523zw/tl29rlBeTkJ88a8ug8osrgCf6mNEiehWhUIJ/yn5rnHfeDnZoVGd++aURqXkkWva8MyiaL7alMDNfUJw1IrztleXxfDLrrpuk4+PaFsbevz5+ngS8/T4ONux7KEBTPt6Bwm5el5bHsOb13eq5+RJKyznm80nsVitjOngT99wD9RnmZfRbOGBX/YTn1OGn4s9P97Ru1a8AWjn53LaMdVgMmO1iqy3U5kzowe3freL9KJKHhkewfTeIbU/j7a+Tjy/5DAL9qRSVG7k45u6nvb6ZotvBxj/MSy+Cza9A2EDoNVgW8/KpigVSjp6dmRX1i5WJK6ot+z3E7+zZMISwt3C640fyTuC2WrG19EXf6e6xhC1nagqpANHIpE0AfQ7d5L/3fcA+L/5BhpfH5vMw2q1kl6WzqK4RSw4vqA246a9R3se7vYwAwMHtgzL7IVgNomaaGO5OIDPXCqstpILpspkYcfJfLoEueLmKE40D6YWAtAhwOW8uTMOWhWbnh6KFa5ofoBEIpFIGjfvrjqOwWShTysPRp/FgVlTBpVVXAnB1eJFcbWAo3UWOSencLYA47MxqXsgn2+IJ6WgnPk7krl3iHDdbo0XwfhatZIqk4WvNydw24AwsML320RDg9cmdMDTyY7XJnRkxne7WLw/nY0ncpnaM4hANwdySw3M3XKSSqPorvXzzhQC3Rz48Y7e9dynNbz5zzG2J+Sj06qYd0cvAt3O30jibK3QXR00LHlgAAoFp53z3dQ7BDdHDY/8dpBVMVnc+t1uhrbzRqNUcjC1iO0JeYR66vjj3n7NMzuu81RI3AgHfobfboYes6D33eAeZuuZ2Yxnej/DsvhlOGoccdY6Y7QYWZ+ynkO5h/jswGd8NOyjeuvXlE+d6r4B8HGUDhwp4EgkTQRTYSEZz84GqxW3adNwHjGiwedgtBj5dP+n/Jv0L5n6zNrx1q6tub/r/YwMHSlLpU6lsgSWPw7pe8HOFa6fI8Wbi8BqtbL6aDZvrThGUn45g9p4Mf/OPsCFBxjXcLa7kRKJRCJpnhxIKWTpwQwUCnhpfNRZbyz5uwoRI7P4lBDjGgfOmTpQVTtwfC9QwNGolDwwtDWzFx9meXQm9w5pTWmlkeT8cgB2Pjec6d/s5ER2Kb/vScFsgfIqM5G+zrVdnga28eLDaV34cE0saYUVfL3pZL199G7lQWtvHauOZJFeVME9P+1lyYMDcNCoWHIgjaT8cnJKDCzanwbAhzd2Pa979UI4102RMR39mXe7hrt/2svupAJ2JxXUW15YXsSi/WlM731hQbRZxZUs3JuKvspMKy9HAtwcsFOr0NmpaO/n0vhu0Fz7LuQcF+eAOz6HnV9Cj9tg2Iug87z07ZbliA5YTSwvsa17W57q9VS9scGBg5ny9xTWpqwlOjeazt6da5fVdKCqCTCuwdtBOnCkgCORNAGsVitZr7yKKTsbbatW+M5+1ibz+Pbwt8yLmQeAWqGmi08XZkbNZFjwMCnc1GC1ihO/tD2w9lUoTBIW7Os+FmHFkgvmjX+O8d3WxNrvt8TlcTK3jCB3R1bFZAHQK8zDVtOTSCQSSSPGU2fH6A6+ONtrzhlC71ddQpVbZsCkdREXRyUZYqH2dAGnNsDY9cLbeg9s4wXAscwSKo1mjmWKgOQAV3s8dFruGBjGs4sOM29bEmaryN65e3B4PdFpcvcgJnQJ4J/DmexIyKek0kiVycJ1XQKY0CUAhULBk6MimfDZVk7m6bn7x73klRk4Wd1hsYbHR7Q9qxvpStM/woslDw7gjz2pFFcYKTeaaevjTEmlke+2JvLFhnhu6BF0zlK0k7llfLIujn+iMzFZrGdcp1+4J5/f3A1Ppyvfav2S0ergzjUQvxZ2zYGE9SIP8fAi6HsfdJ8FroEXvr2cY6IBRsxicA6AO1fXf31uLKx6Vpx3gnD7jPtAlOyfSmkWVBSBT7vLfIOXT4R7BNeFX8fShKV8vP9jvhv1HQqFAovVQnSOyID6rwOnpoQquSSZnPKcWkdOS+KSBJwvv/yS9957j8zMTDp06MDHH3/MoEGDzrju1q1befbZZzl+/Djl5eWEhoZy77338vjjj1/WxCWSlkTx4sWUrl4NGg0B77+H0rHhW3Afyz/GN4e+AWB279lMipgkW4GfSlku7PsB9s2ru3MH4BoCU+ZCSF+bTa0psik2t1a8eWBoaw6lFbEtPp/f96YS5e9CdokBb2c7hrdveQduiUQikZyfEE9Hvp7ZE6PZcs71PHVaNCoFRrOVEosDHgDVzRjO5HLIvMgSKqA6h82OvDIDMRnFHM0Q7cujAoQLZmLXQN5ddYKM4hp3jx0TugScth21SsnEroFM7HrmC38vJzu+ubUnN3y1vdbx4uVkx/jO/jhoVUT6Op9xu1eTtr7OvDg+qt5YRZWZpQfTSSusYMmB9DN218ovM/Dpujh+2ZVSK9z0buVBOz9nEvP05JQYMJotpBdVsONkPhM+38bXM3s0ro6RSiW0HSUeSVth1WzIOiyycTa/D52nwbgPQXue8+kdX8K/z1MbrF2SBr9MhTtWijK/gz/DymdFuX4NBSdh7nC46RcI6gX58bBzDhz8FSxGGPi4cAOpbOvneKDrA6xIXMGerD3sztpNH/8+7M/eT6mxFJ1GR1v3tvXWD3YWfys55TmMXjSasa3GMqvDrNPWa85c9G/s999/57HHHuPLL79kwIABfP3111x77bUcPXqUkJDTLXA6nY6HHnqIzp07o9Pp2Lp1K/feey86nY577rnnirwJiaQ5Y8zOJvvN/wHg8+gjOHTo0OBzqDJX8fzW5zFZTYwMHcnN7W6WGTc1ZB6CnV/BkT/BXN1CU6kWHabCBsHQ2eDgZtMpNjWKyqt45s9DANzWP4xnxrRj1ZEstsXns2hfGtuq75bO7Bt61tp8iUQikUiA8wYNK5UKfJztSS+qINdkRz1f5xlKqLIvsoQKREZM12A31h7L5kBKEbHZwoET5S8EHHuNilv6hvLpujgAbh/Q6pKzYToGuvLJTd14fflRRkb58vjItrjYX17nqiuNg1bFPYPD+d+K43yxIZ7J3QJrS50rjWZ+2JbElxviKTWYABjR3odHh7elU9Dp4kxsdin3zt9HYp6eKXO289bkTkzu3ggdz2ED4Z5NcPQv2PM9JG+FQ78JYWX672cvq9r2Cax5WTxvN144d5Y9BDkx8M0wqCiACpELSKshMOQZ4QZf8zJk7Id548T3/Me9tPUjSN0Nk74CtwsrY7saBDgFMLnNZH4/8Tu/HvuVPv59WBy3GIAxYWNOaznup/PjqxFf8U30N+zP2c+yhGUsS1hG/4D+3NbhNvoF9LPF22hQFFar9cxetLPQp08funfvzpw5c2rH2rdvz/XXX89bb711QduYPHkyOp2O+fPnX9D6JSUluLq6UlxcjIuL7NgiaVmkP/EkJStW4NC1K6G//oLCBhkqn+z/hG8Pf4uHvQdLJi7Bw76Fl62YTXDiHyHcpGyvGw/sAX3uh/bjRX2y5KLRG0w89vtB1hzNJtxLxz+PDMJBq8JottDvrfXklYm7olq1kh2zr2lcdmmJRCKRNElumLOdvcmFzL/WjkEbptQtaDdeOBhOYeSHm4jLKWP+nb0Z1Mb7gvfxxYZ43vv3BOM7+5OUr+dIeglfzehRm3OTW2rgmvc3olYp2Pj0MFwdGpfocqXRG0wMfGc9heVGJncP5O3JnTmcXsxjvx8gtaACgI6BLjw/tj39W3udc1vFFUae+P0g646LYNvb+ofx8vioxpeLcypJ22DBzVBZBO6tYNATEHW9yGGqKofkbXB4IUT/LtYfMlvcFFQoIOMA/DAOqru/onWGwU9C/0frsharyuGv++DoUvG9yk400xj8FJRmwtKHoaoU1A4w6Eno/zBoLlyUvJKcLDrJxKUTUSqU/DH+D2asmEGluZKfx/5MF+8uZ31ddG40P8b8yNqUtVisFsaFj+PtQW834MyvLBeqeVyUA6eqqop9+/Yxe/bseuOjRo1i+/btZ3lVfQ4cOMD27dt54403zrqOwWDAYDDUfl9SUnIx05RImg36nbsoWbEClEr8Xn6pQcSbvIo8Xtz2Ip72nrzQ5wXiiuL4/ojofPVyv5dbtnhTXgD7f4I930JxqhhTqiFqohBugmXb9EvBarWSV1bFvuQCXl9+jPSiClRKBR9M61LbKlWjUjK1ZxBzNiYAMKlroBRvJBKJRHJFqMnByaj8j2hid/pFVE2I8cWUUAF0CXIDYH9yIXllwrHbIaBu+97Odqx8bBAqpaLZizcAOjs1r07owBN/HGLx/nSOpBeTkKvHbLHi72rPM2Mimdgl8IJEGFcHDXNv7cnH6+L4dF0c87Yn4WKv5olRkQ3wTi6RsAEiI+fnKVCYCMsehn+eFLmJpsr66w57QThragjoBrP+Fi6e4L4Q2B1U//mb0TrC1B9FJo7GEXTe9Rtp+HWGZY+IbWx4A2KWwI3zwbP1VXvLZyPcLZw+/n3YlbmLRzc8SqW5kgi3CDp7dT7n6zp7d+aDoR+QVprGz8d+ZmLriQ00Y9tyUQJOXl4eZrMZX1/feuO+vr5kZWWd87VBQUHk5uZiMpl49dVXueuuu8667ltvvcVrr712MVOTSJodlspKst54HQD3m27EPirqPK+4fDLLMrlr9V2klKYAkFCUgN6ox2K1cF34dQwPGX7V59AoMVbA1o9h+6d19cWOntDjduh1J7g0bD15U6O00siR9BLa+DrhdYroUqCv4uO1sSzal4a+ylw7HuTuwFuTO9EtxL3edm7sGVwr4Nw+MKxB5i6RSCSS5o9/tYCTVqGtv+A/JVTlVSZKK0VZj6/rxQk4nYNdhXmiOufG2U5NkHt9t26Qe8vKFpzYNRA3Ry0P/rKf2OwyACZ0CeCNSR0vuuxLqVTwxMi2BLs78PSf0Xy6Pp6Oga6MaqDA5kvCuy3cu0nkJx76DfJi65Y5+QlHd8cpENr/9NcG9RCPc6FQgEerMy/zbA23LYcji0Q2T01J1pS50Hb0Jb+lS2V6u+nsytxFepnIkZwUMemC4xqCnIOY3Xv2+VdsJlxSatF/f5hWq/W8P+AtW7ZQVlbGzp07mT17NhEREUyfPv2M6z733HM88cQTtd+XlJQQHHx6uJVE0lypiIkh49lnqYpPQOXujvejj171fcYXxvPAugfI1Gfir/OnwlRBTH4MAD4OPjzb2zadr2xO3Fr453EoEqIWvh2hz33Q6QZZJnUeTuaW8cO2JBbvrxNoWnvrCPFwxNFOzebY3NoTYYVC3M2c0DWAR4e3wVF7+uEpzEvH5zd3w2yxXpH2pxKJRCKRAPhVtxJP0v8nV+0/XaiyqsUXR60KZ7uLu4xysdfQ2tuJ+BwhVLQPcJF5gsCQtt78eX8/Pl0Xx/B2vkzuHnhZP5epPYOJyShh3vYknvjjEH89qCPCpxG33Hb0EOVTAx8XThyFSmQn2rmIk6OriUIhzmdDB8DCWZC6C367CW5bAaHVWTLGSlDbXfW5DAkagr/On0x9JmqlmutaX3dV99eUuahPHi8vL1Qq1Wlum5ycnNNcOf+lVSuh/nXq1Ins7GxeffXVswo4dnZ22NlJa7ykZWGtqqJs+3ZKVqygZMVKMJlQeXsR+P4HqFyvXqK+1WrljxN/8N7e9zCYDYS5hDF31FwMZgP3r72fzLJM/m/A/+Fq14hS/RsCkwHWvgY7vxDfuwTC6DdFfbI84TonOaWVfLI2jgV7UjFXd47w1GnJ11eRkKsnIbeupWmUv6hv79XK/YICicd3lm4niUQikVxZahw4GSUmUW5S7bZNLVez90Aa13cVokJctfji52J/SSJD12C3WgGnJsBYAu38XPjylvO4SS6CF8a152hmCbsTC7h57i5+vbsvET6nB1I3KhSK01t+NxQu/jBrOSy+W4QsL7kH7tsGcatFaVdQT5g2/6o25VAr1dzS/hbe3/s+o0JH4W7vfv4XtVAuSsDRarX06NGDNWvWMGnSpNrxNWvWMHHihdecWa3Wehk3EklLxVJVhX77dkpX/Uvp+vVYTsl7ch49Gr9XX0HtfvU+wCpNlby07SVWJa0CYEDgAN4c8CaeDiIJf+nEpRRUFuCrO7dA22ywWkV7x9hVcPhPyDshxvvcB8NfBq3OtvNr5BzNKGH+ziT+OpBBhVE4bq5p58OdA1vRv7UnxRVG9qeI2v+yShP+rvaM6uCHqjGHDEokEomk2VOTgZNVXCmcD9UCzh/RhXy2/RBGs5Up3YP4eK3oEjUk8sLDi0+lS7Abf+5LA+paiEuuPBqVkjm3dOeWb3dxPKuUm77Zya9396GtbyN24tgatRYmfCY6VxWlwLyx4pwYIHEz/DAWZiwSYs9VYmbUTMJcwujhe+XEvObIRZdQPfHEE8ycOZOePXvSr18/vvnmG1JSUrjvvvsAUf6Unp7OTz/9BMAXX3xBSEgI7dq1A2Dr1q28//77PPzww1fwbUgktsVqMmGIj8cQF09V4kks+nI0QUGoXJzR79iJftcuND4+uE6ahH3HjlQejaF8z17KNmzAUlZWux2VlxcuY8bgMm4sDl27XlVrbWFlIY+sf4SDuQdRK9U83v1xZkTNQKmoCzjTqDQtQ7ypKhdtwHfPhazounEHd5j4JbQba7u5NXKyiiv5+1AGSw+lcyS9ToDsEuTK82Pb0ye8ri2mm6OWa9q1gL8niUQikTQpahw42SWVWANcUJSJaoPs6lDj1/8+SkZRBccyS3C2V/PwNW0uaT/dgt1qn0sHztXF08mOX+/uy4xvd3E0s4Rbv9vNikcH4aHTnv/FLRV7F5j0TX3xpsvNkLBOZOTMGwcP7BAlVVcBpULJkOAhZ16YGwsrn4Yhz545E6gFcdECzo033kh+fj7/93//R2ZmJh07dmTFihWEhoYCkJmZSUpKSu36FouF5557jsTERNRqNa1bt+btt9/m3nvvvXLvQiJpYKwWC5VHj6HfugX99h1UHDmCtbz8nK8xZWZScejQaeNqb2+cR43CefQoHHv0QKE6fxnJ5RKdG82zm58lrSwNZ60znwz7hF5+LbCDUsFJ2Ps97J8v2jgCqO2h9XCIHAOR40Dnec5NtESKy42sPJLJXwfT2ZVYgFVUSaFWKhjd0Y9b+4bSu5WHrO2XSCQSSZPA28kOpQJMFismjTM18blFFnGhWmow1bpvHrmmzSWLAJF+zoR767BYrNIN0gB46LT8encfJs/ZzslcPU/8cZDvZ/Vq3O3FbU1oPxj+Cmx6F4Y8DQMeg6Jk+GYoFCRA+j7bCCgHfoKTG0Hn0+IFHIXVWnPq3Xi50J7oEsnVxGqxUBkTQ8nKVZSsWIHpP1lQSp0Ou3btsAtvhVLnhDE9DVNePg5du6IbOADDiViK//oLY3Y29u3b49CpE07DhgqnTQO0BwcwW8x8E/0NX0d/jdlqJtApkC+Hf0m4m41qbm1BWY5olXh4IaTtqRt3CxUdpbrNFIFyklryygxsi88jKa+cw+lFbIrNxWiuO3T0DvNgQtcAxnXyx13e2ZJIJBJJE6Tv/9aRVVLJ4YivcU7bBMDNVc+z3dIRO7USg8lCqKcjqx8ffEGZbWejojrU30F79W/YSQTHs0qY+Pk2DCYLz45px/1DG75VdpPDYgblKX+jC26B48th5Osw4JGGn8/8SZCwHsIGie5ZzZAL1TwuqQuVRNJSMKanU7Z9O/rt2ynfvgNzcXHtMqWjI479++E0YACOPXuiDQ8/p3vGacAAPO+4vSGmfUZMFhPPb3melUkrAbi21bW82PdFXLQtQBQ1G+HYMuG0SdwEVosYVyghfBj0vgfajKx/oJJgtlj5dVcy7646QanBVG9ZOz9nru8WyHVdAgh0k924JBKJRNK08XW1J6ukkjIcqfHG6K322KmVvH59R9779wRvXN/xssQbkMKNLWjn58JrEzowe/Fh3l99gv6tPelySjmb5Az895w4sIcQcNL32mY+2aIzLqVZ516vBSAFHInkP1irqij5dzUFP8+n8lB0vWVKnQ7doEG4jBuL0+DBKJtItzSjxcjszbNZnbwatULNawNeY0LrCbae1tWlSi8cNomb4eCvUJpZtyywB3SaCh0mgbOf7ebYiDCZLexKLGDF4Uy2J+RjslgwmqxklYiWqW18nOga7Ea4txPXtPMh0k9avyUSiUTSfPB3secQUGp1pCamtQwHdHZqpvUMZlrPYFtOT3KZ3NgrmK3xeSyPzuTZRdEse2ggWnXDOOCbBUE9xde0fQ2/77JcKMsWz089n2+hSAFHIkGUR5Xv2kXJqn8pXbMGc0GBWKBS4dClC7r+/dH174dDp04oNJpzb6yRYTQbeWbzM6xNWYtaqebDIR8yLGSYrad19chPgO2fCdHGfEq3O50P9LgNutwEntI6W4PFYuWfw5l8uCaWxDz9acud7NQ8MyaSW/qEym5REolEImm21HSiKrLY146VWR3Q2UnHTHNAoVDw2oQObE/I53hWKV9ujOexEW1tPa2mQ0A34VwvSRMumIa8AZoTU/e8qgwMpWDXcm8kSgFH0qKxGo2UrFhB3ty5VMUn1I6rvL3wuPlm3KZNQ+3ZdENsjWYjT256kg2pG9AoNXw87GMGBw229bSuPMYKOLESon+HuNV1JVIugRA6ANqMgqgJVy01vylhsVjZcTKf5dGZpBaUk5inJ72oAgBXBw1jO/kxKsoPV0cNRpOFSD9n3Bxlro1EIpFImjcu9uKyqMSqqx3TY4+7Vl4uNRc8nex45booHl1wkC82xJNWWIFWrUSrUmKnVtLax4kbugfJkOMzYecM3u2FmJK2F9qPP/u6xkrY+pFw7bQZefn7zo6p/31plhRwJJKWSMWRGDKffx5DbCwASicnXK69FufRo9H16d3knDb/xWwx14o3WqWWj4d9zKCgQbae1pVDnyfCiOPWQNIWMJ7SBazNKJGaH9ofZCekWv6NyeLNf46RUlC/Y5qTnZq7B4Vz56BWONnJw4JEIpFIWh7O9uK8r8ha58DRYy+Pi82MCV0C+PtQBmuP5fDnvrTTlq89ms1HN3ZFJ3/vpxPUQwg46ecRcHZ/DZveFs873whj3r68BiH/FXBKMsCrzaVvr4kj/zIlLY6q5GQKf1tAwfz5YDajcnPD4/bbcb95Oirn5qPmfhP9DRtSN2CnsuPTYZ/SP7AZtNyzWEQC/b4fIHYVWE4J1nUNhs7ToPNN4N04LbGZxRW4OmhwtMHdvJ0n83no1/0YzVac7dRM6BpA9xB3/N3s6RDgiqtD0xYsJRKJRCK5HJyqHThFZhHMb1Q5YkWJo7yQb1YoFAo+vLErfx1Ip8xgospkwWi2UFppYsHuVFYfzWbqVzv44fZe+LrYn3+DLYnAnrD/J+HAOReHF9Y9j/4dMqPhvq2gusT/pewj4qtCKVz2LTzIWH4iSVoMlSdiyX7jDcr31LWOdr52DH4vvYTao3m1jd6RsYM5h+YA8Eq/V5q+eFNVDtELYOccyIutGw/oLkqjIkaCb4dG7bY5mVvGqI8206+1J/Pv7NOg+07O13P/z/swmq2M7eTH+1O72EREkkgkEomkseJcLeDkm8VFu1EtSqmcZAZOs8PFXsOt/cJOG5/YNZB75+/laGYJd/24lz/u7YedWsmvu1MoqTRy3+DWLbu8qibIOOMA5MXB9k/BtxN0nwma6o6kuScg6zAo1TB9AfxxK+Qeg/w48Gl/8fs0myDnePX+e0PqzhYfZCzP4CXNHqvVSvHixWT93+tYDQZQKtENGID7LTfjPHSorad3xcnSZzF7y2ysWJnSZgrXtb7O1lO6NKxWyIqGI4th/49QUSjGtc7QbQb0mHVpBwIbsTepEJPFypa4POJzyojwcbqq+zuZW8bbK4+TUlBOemEFpQYTnYNc+WBqV9nCVCKRSCSS/1BTQpVucgOgTCMyEHXyhkeLoUeoO4vu78+kL7dzOL2YJ/44iMVq5d8Y0QHJyU59RuGnxeDdDrROIkj4y751TvjN78LgZ6D33XD4TzEWMULk3/h3hZTtkHno0s7b8+NFUxKtE4T0kQIOUsCRNHPMJSVkvf4GJX//DYBu0CD8/+81NP7+53ll06TYUMz9a++noLKASPdIZveebespXTxV5bD7G9jzHRSn1I27hUKf+4R4Y+9iu/ldIgl5ZbXPF+1P49kx7a7avmKzS7l57i7yyuq6cAV7ODD31p5SvJFIJBKJ5AzUZN3sN4bChM9ZkegCecgslBZGqKeOr2b04JZvd7LyiCjVUSjEfcW3Vx5nWKQPwR6ONp6ljVCqRDeqpC1CvAkdAMWpUJQCK58Gox6OVAs4HW8QX/271Ak4XW66+H3WlE/5RInmJCAFHFtPQCK5Wuh37CBj9nOYsrNBqcT7kUfwvOduFEqlrad2Vag0VfLI+keIL4rHx8GHT6/5FHt1E6rdNRlg34+w5X0oE3c6UDtAxHARgNZunDhwNFFO5ta16F68P42nRkVelbbcR9KLufX73RToq2jv78KzYyLxcrIjwscJe03T/flJJBKJRHI1qelCVVZlhu4zSUw9AiTLEOMWSO9WHrx5fSeeWRSNj7Mdc2Z0552VJ9idVMBziw8z/87eKP5Ttm+1WimpNDX/TME+94k23n3uE4KMxQRbP4YNb8DaV8U6ageIvFY89+8ivmYeurT91QQY+3aoa10uM3AkkuZH8dKlZDz3PFgsaENDCXjnbRy6drX1tK4aZouZ2Vtmsz9nP84aZ+aMnEOAU4Ctp3VhmE0i32bjO3WOG7cQGDIbOkwCbfO4y3Eyt86Bk11iYGt8HkPael/WNiuqzKw/noO7o4YuwW78siuZ9/+NpcpsoVOgK/Pv7C1bgEskEolEcgHUlFCVVpqwWq3oq8wAOMoMnBbJtF7BdA91x9fFDmd7De/c0JkxH29ma3we077ewe0DWjEqyhe1SkmBvopHFxxgS1wedw1sxbPXtkOjap43jGk/vn4HKpUGhjwNlUWw43Mx1m4s2FVHBdQKONGiGcnF3kivJ+BUX9uUSAeORNKsKPztN7Je+z8AXCdOwO+VV1A6Ng8R4ExYrVbe3PUm61LWoVVq+eSaT2jr3ji7MNXDYoGjf8GG/4lgMwAnP3EQ6HYrqJuP8GAyW2pbd49o78vaY9l8u+Uk+5MLOZmnZ0hbb8Z18sdBq6LSaCatsIK0wnKS8vQczSwhIVfPlO5B3NwnBACLxcqSA+m8v/oEmcWVp+1veDsfPryxa/O/CySRSCQSyRWipguV2WKl0mhBbxD5HtKB03I5Na+wlZeO1yZ04MW/jrAnqZA9SYV46rRc28mPDcdzSS+qAODbrYlEpxXzxS3d8Xa2s9XUG56RrwsR5+Bv0OuuunGvtqC2h6pSKEwEz9YXvk2rFTL2i+d+nU5x4GSKZY24ecnVRH4iSZoNVpOJnA8/ouD77wFwnzkT3+dmN9uSqRq+jv6ahbELUaDg7cFv08uvl62ndG6sVoj9F9a/AdmHxZiDBwx8XHzgNxPHzamkFVZgNFux1yh5ZHgEa49lsyUujy1xeQD8fSiD15bFYKdR1cutOZX9KYV46LQMbOPFQ7/uZ+OJXAD8qltcZpVU4qhV8fL4KG7sFXyatVcikUgkEsnZ0WlVKBVgsUJppZGyagFHhhhLaripdwhDI334ZVcyv+1OIa+sip93Cvd4Ky8ds/qF8v7qWHYnFfDy0iPMmdHDxjNuQJRKmPgFjP0ANKdEOKjUwj2Tvg8yD16cgFOYCPpcUGpEGLKi+prOYoTyAtB5Xsl30GSQn0iSZoEpN5f0x5+gfO9eADzvvw/vRx5p9hex65LX8cXBLwB4oc8LjAwdaeMZnQOLBWJXwpYPIV38ntA6Q/+Hoe/9TTKY+EI5WR1gHOapo1OgKyOjfNmdWED/1p6EeelYHp1BaoHoFAXibl+QuwPBHo6093MmpaCcvw5m8NjvBwj10HEiuxR7jZJHh7fl9gFh2KmVZBRX4uqgkXcKJRKJRCK5BBQKBU52akoqTZRUmmodODLEWHIqfq72PDkqkkeGt2FbfB5/H8pEo1Lw3Nj2uDpoaOfvwk3f7GR7Qj4Wi7XltR3XnCF/079LtYBzCDpOufBtpe4RXwO61m1X5y1EndIMKeBIJE0VY04OKTNvpSo5GaVOh/9b/8Nl1ChbT+uqk1ScxAvbXgBgZtRMbmx3o41ndBbMRtFScNvHkHtcjKkdoM89MOAxcPSw5ewahJoA43BvHQqFgrm39qy3/OlRkUSnF6NWKgh2d8TFQV1PfDSZLRSWG9kUm8uJ7FI8dVq+v60XXYLdatcJdHNokPcikUgkEklzxdleQ0mliTKDifLqDBydzMCRnAGNSsnQSB+GRvrUG+8R6o69RklxhZGTefp6ZVgtlksNMk7dJb4G96kbc/arFnCyRFlVC0QKOJImjSk3l5RZt1GVnIwmIIDgb7/FLryVrad11Sk3lvP4xsfRG/V09+nO4z0et/WUTqeqHA7Mh+2fiRaDAHYuokyq7/3g5HPu1zcjTuZVCzheZz6IK5UKup4ixvwXtUrJ5zd34+6f9lJhtPDZTd0I8Wx+pWYSiUQikdgS5+ocnHolVNKBI7kINColnQPd2J1UwIGUQingQH0B52Kya1J3i6/BvevGnP0h63CLbiUuP5EkTRZTfj7Jt91OVWIian9/Qn76EW1QkK2n1SC8u+dd4ovi8XLw4v0h76NRNqKw2io97PoKdnwB5fliTOcD/R6AnneAvatt52cDajpQhXvrLnkbzvYaFtzT70pNSSKRSCQSyX+oE3BMMsRYcsl0CxECzv6UIqb2DLb1dGyPTxQo1VBRKG7uWsxgtYhMm6CeZ3bSVJZATnUHqqD/CDjQojtRyU8kSZPEVFBAym23U5WQgNrPj9Af57UY8WZt8loWxS1CgYJ3Br2Dt+PltaK+YpiqYN882Pwe6HPEmFsoDHgUut5y5prYFkJdCZW8CyORSCQSSWOlRqwpqzShN9SUUMnLJcnF0S3EHYADKYU2nkkjQW0HPu2Fc2bZw/WXaRzh4X3gElB/PH2fEHncQsDFv268RsCRDhyJpOlgys0l5a67McTFofbxIXTeD2hDQmw9rQYhW5/NqzteBeD2jrfT27/3uV/QEFjMcHihaAdelCzG3MNg6HPQ8QaRPt+CKa00klMqOktdjgNHIpFIJBLJ1cXZXjiaC8qrqDJbANGdSiK5GLqHuAEQm11KmcFEbHYpP+9MpqLKjNliZVb/MAZEeF3RfZotVt5ffYJwL13jdP30exi2fCCaljh6CkdOVjQUpcDGt2HCp/XXry2f6lN/vLaVeNbVn3MjpWVfWUmaHBUxMaQ9+BCmrCxU3l6EzJuHNizM1tNqECxWCy9se4FiQzFRnlE81PUh207IVAWH/4CtH0F+vBhz8oXBT0P3WaDW2nZ+jYTE6vwbLyc7XOwbUambRCKRSCSSetSUUGUVV9aOSQeO5GLxcbEn0M2B9KIKtsfn8dLSI2SXGGqX70kqYM0TQ/Bysrti+1x7LJs5GxNQKxUMauONn2ud891ssfLDtkQ8dFomdg1EZYvOWF1uFI9TSdkJ348WZVX9HgLvtnXLagKMg/5zs7rGqVOacfXm2shR2noCEsmFUrp+A8m3zMCUlYW2VSvC5s9vEYHFNfwU8xO7MnfhoHbg7UFvo1HZQAywWmHX1/DDOHg7BJY+KMQbB3cY/go8cgB63y3Fm1OoEXCk+0YikUgkksaN038EHK1aiUYlL5ckF0+3ahfO80sOk11iIMTDkdev70g7P2cKy428uizmiu7vz31pAJgsVn7ckVRv2fwdSbzxzzGe+OMQ4z7dwpa43Cu670smpC9EjhOlUuteqxu3WCBtr3ge/B8Bp8aBk3UYFt5e12q8BSE/kSRNAv2OHaQ/+ijWykp0gwYR9vuCFuO8ATiWf4xPDnwCwDO9nqGVq42Eq73fw8pnIHkrmCpEHerI1+GxIzDoCdC2bJHiWGYJwz/YyBO/H8RUbb0+kl4MQLhXy/7ZSCQSiUTS2KlxymaVCAFHBhhLLpXu1Tk4eWVVALw2sQMz+4by3g1dUCkVLI/OZHXMhZcB7U8p5P1/TzD1q+289+/xesvyywxsOJ5T+/2vu1IorzLVLvtwTSwgBMnjWaXM/G43C3anXNb7u2IMf1mEGR9fDmn7xFjqLjAUg9YJfDvWX9+nA0SMFKJPzGL4bgTMvQaiF4rqgBaAFHAkjZ6K6GhSH3wIq9GI88gRBM/5EpWLi62n1WAYzUZmb5mNyWJieMhwprSZYpuJFCTC6pfE834PwYN74IljMOARsGv+4bxmi5WdJ/M5mFpEelEFZou13vL4nDJmfLuLhFw9iw+k88qyGNYdy+a7rYkA9G7lYYtpSyQSiUQiuUBqSqiyqwUcR5l/I7lEahw4AKM7+DIs0geATkGu3D0oHIAX/zpCfpnhTC+vxx97U5n85XY+3xDPnqRCvtiQQE5JXZnf0oMZmCxWOga6EOrpSHGFkUX70wF4798TlFSaiPJ3Ycfsa7ixOh/nuSWH+etA+pV6u5eOTzvoXF1atWuO+HrgZ/G1w/WnZ2mq1DDjT7h3s2iSotKKwOPFd8HvMxps2rZEysqSRo0hPp7Uu+/BWl6OY7++BLz/Pgp1y/qz/fHoj5wsPomnvSev9nsVhcIGdasWCyx9CIx6CB0gXDfKlqX/frkhng+q72CAOKnrGOBKax8dSoWCNUezyddXEerpSEpBOb/sSmHBnlQsVpjaI4hJ3QJtOHuJRCKRSCTno8ZxU9N8QDpwJJdKhwBXfJztqDCaefm6DvWWPTaiDWuOZpGQq+ephYf4/rZeZz2/rzJZ+Kj6/HNYpDdJ+eUk5ulZdzyH6b1FE5dF+0X51LSewVgsVl79+yhfbUwgJr2Y3/emAsIB5Olkx9tTOqFRK/h5ZwpPLjyEvsrEzb1DbHN9UUOf++DQbxDzl2iCErNEjHebefbX+HeB67+EEa/Bvh9gz7fQ0UY3uRuYlnUFJmlSVKWlk3LnXZiLi7Hv3Jmgzz5HaXflwr6aAln6LL6J/gaAJ3s+iZu9m20msmeuKJvS6GDiFy1OvCkzmPi22knj5WSHRqWgvMrM7qQCftudyi+7UsgpNRDp68ySBwbw4rgoQLh2hrT15n+TO9n2wCiRSCQSieS81HShqnHZygBjyaWiVStZ/shA1j4xhEA3h3rL7DUqPr+5O1q1kg0ncmvd2mdi8f40Mosr8XWxY86MHkzpLm4IrjmaDYjy/ZiMEjQqBdd1DmBqz2Cc7dWkF1WwYE8qVitc3zWAXmHCCa5QKPi/CR2Z2iMIs8XKC0uO8OiCg5QZTKftu6i8int+2ssP284+vytCQFcRVmwxwoJbxA1jz4jTO1CdCSdvGPKMiHPoOPnqzrORID+VJI0SY1YWKXfegSk7G21Ea4K//gqVU8vLEHl3z7tUmCro7tOd8eHjG2anpirY+iHovKHnHVBwEta8IpaNfA08Wk5wdA2/7UqhuMJIuJeONU8MAeBkbhmH0opJL6wAQGenYkr3INx1Wu4YEIYCiM8t44Wx7WUAokQikUgkTYD/Om6kgCO5HHyc7c+6rL2/Cy+Nj+Klv47w9srjxGSUMK6TP0MjvVFXnzeazBa+3JgAwD2DW2OvUTEyyo/3V8eyNT6P8ipTrfgzvJ0v7jrRROTLW7qz7lgObo4afF3smdAloN6+lUoF70zpTISPE+/+e4JlhzKIzS7l17v74qGra0QyZ1MCq49ms/poNoXlRh4f0ebq3ZDsfQ+k7YbcY+L7bjPgYvbVghqoyE8lSaPDcDKRlLvuxJSRiSYwkJDvvkPt7m7raTUoFaYKPtn/CWuS16BSqHi+z/MN4+AwVsIft0Lcv+L71N1QmCQCi1sNgZ53Xv05NDIMJjPfbj0JwL1DwmtbL7bxdaaNr/MZX6NQKLhjYMsTuiQSiUQiacrUZODUoJMZOJKryIw+IexLKuCvgxksOZDOkgPpdAhw4YNpXWjr48zPO5NJKSjHU6dlem+RXdPW14lgDwdSCyr4etPJ2vKpe4eE1253UBtvBrXxPue+lUoF9w5pTc8wd+77eT/Hs0q5ee5OfrmrD55OdhTqq5i/I7l2/U/XxWG1WnlyVORV+EkAURPh3+dBnwMKFXSZfnX20wyQt4UljYqKw0dIvuUWTBmZaMPCCP3pRzS+vraeVoNRbixnZeJKpv09jV+O/QLAA10fINLjKn1YnoqhFH6dJsQbtb348IxeAKk7QesMEz9vcaVTAEv2p5NdYsDPxZ7rZY6NRCKRSCTNlpouVDVIB47kaqJQKPjoxq4sur8/dwxohauDhpiMEq77bCv93l7Hq38fBeDOQa1w1KprXzOyvWil/cm6OKxWGN/Zn24hl3azu0eoBwvu6YuPsx3Hs0qZPncnKfnlfL8tkfIqM1H+Lrw4rj0An62PJ7O44gq8DynWegAARX9JREFU8zOg1kKv6hvFbcfUtQuXnIb8VJI0GvTbt5P20MNYysux79iR4G++Ru3R/Dv3lBvL2ZK+hTXJa9ictpkKk/hg9Hbw5v8G/B8DAwde/UlkHIA/q8ultE5w8+9groI/ZoGhBEa/CW4hV38ejYxVRzJ54x9h5bxrUCvs1PJOnEQikUgkzRWn/zhwZIix5GqjUCjoEepOj1B37hsazgtLjrDmaDbZJQac7dVc3zWQOwbUd3WPiPLh++pcGo1KwTOj213WHFp7O7Hgnr5Mn7uT2Owyxn+2hZpmq48Mj2BMR39+35NKXE4Zcdll+Ls6nHuDl8qgJ8E1SAg4krMiP5UkjYKSVf+S/vTTYDTi2K8vQZ993uQyb6xWK8WGYlJKU6g0VRLoHIiTxondWbvZnbkbH0cfxoePx9/Jn5zyHPZl72NN8hq2pG2h0lzXCjDIKYhrW13LrA6zcLVzvfoT3z0XVj0ngsNcgmDaTxDUQyy7fzsUJkKrwVd/HjbGaLaw8UQu64/nYLVaKTOYWB6dCUDfcA9u6RNq4xlKJBKJRCK5mpxWQmUnb9xIGg4fZ3u+mdmDXYkFVFSZ6R/hecabh73CPHCxV1NSaWJWvzBCPB0ve9/h3k789eAA7v95PwdTiwCI9HVmVJRwwrTy0hGXU0Zinp7Bbc9dnnXJqDQi++YM5JRWMmdjArf0CSXCx+nq7L+JIAUcic3R79xF+lNPgcmE8+jRBLz3Lkpt4w+iMlvMxOTHsCtzFwdzD3I49zCFhsJzvuazA5/hbu9OQWVBvfEgpyBGho1kdOhoojyjGibvxmKBNS/Bjs/F9+3Gw4TPwPEU15NbsHg0Y8wWK99tPck3mxPJKzOctvzuQa14dky72kA5iUQikUgkzRONSom9Rkml0QLIEipJw6NQKOgb7nnOdTQqJS9f14Etcbk8PLzNFdu3v6sDv9/bl//9c4zl0Zm8OL49yursx1be4sZ6Yp7+iu3vYvhlZwo/bEuiuMLIh9O62mQOjQX5qSSxKYaTiaQ98giYTLiMvZaA995DoWq8dztMFhM7M3ey4uQKNqVtoqSq5LR1fBx8cNA4kFGWgdFiJMwljH4B/YgvimdP1h4KKgtQKpS0dmvNkKAhjAwdSXuP9g3bZrqiCJY9BMf+Ft8PfxkGPnFxae/NgKQ8PU8tPMTeZCG8eTlpGd85AC8nLQaThd6tPM4bAieRSCQSiaT54GSnodIobujotPJSSdI4uaFHEDf0CLri27VTq3htYkdendCh3rVJuJcQcBJyy674Pi+EE1mlYv85ttl/Y0J+KklshqmwkNT77sNSUoJD1674v/VWoxRvUktT2Zm5kx0ZO9idtZtiQ3HtMmeNM338+9DDtwddvLsQ4R6Bg1rUhVqsFkqrSuuVQWWWZZJbkUuEWwT/3959h0dVpm8c/85kkkkPCekEQuhNekcUaYK9oisCrg1cUVlcd0UsqL8V0bUrzQoqgqwNlUVBFERAkKZSAwECISG9l8nMnN8fA8FIh2Qm5f5cF5czZ84585xl3wxz5z3P6+99/tMdz8m+VfDZOMg7AF4+cPV06HijZ2pxM5vd9Ru1jMIyZv6whwXrD2BzOAm0Wph8eVtu6BanJb9FRETqsWBfS8WMXM3Akfrqz79YTgh33bbkqRk4u9JdAU5SRhGGYbj3F981jH4qiUc4bTYO3jue8uRkvOPiiJv+Bmar1dNlVUgrSmP+jvl8s+8bDhYerPRaqDWUS5teyvCE4XSM6IjFfOJhZDaZj+thExMYQ0xgTLXVfVq/vANfTQQMCG0K170FjXt4rp5qUu5w8s3WNIJ9vWkVFcSG/Tm8tSqJTcm5x+17YYtwnr3+AuJCPRSoiYiISI3xxz44geqBIwK4euAApOSWUFruwNfbfWOjzO5gf1YxAAVldjIKy4gM8nXb+9c0CnDE7QzDIHXyo5Rs3Ig5KIjGM2fUiNWmSuwl/JTyE0v2LeG7/d9hN+wAWEwWOkZ0pHdsb/rE9KFDeIeThjY12ro3YfE/XI87/QUuex6sQZ6tqRrY7E7Gz9vIt9sOn3K/3s3CeGBQK/o0P/V9xiIiIlJ//HElKs3AEXEJD/QhyGqhoMxOcnYxraKC2Hwgl2YRAQT7elfre+/NLMJxdFksXLNwFOCIuFHm9Onkf/klWCzEvfIy1hYtPFpPWlEac7bO4dPETym2F1ds7x7Vnb+0+Qv9GvUjwLt2rYh1nLUzYcm/XI/73gdDnq71/W7K7A5WJWYS7OdNu5hg/H28yC+xM/HjzXy3Ix0fi5m4Bn7syyqigb8Po3rHc1OPxgT6WjCbTFoaVERERI4TZD32ZdRfPXBEANctVc0iAthyMI+kjCIO55cy6u11NGrgxzu39aB1dOVfCmcVltHA3wcv8/l/39h1uHLfm72ZRadt9FyX6aeSuFXel1+R+Zpr1aPoxx8joG9fj9VSXF7Ma5teY/7O+didrtk2sQGxDG06lMsSLqNtw7Yeq61KrXkDvnnE9bjfBBg8pVaHN6XlDuavS2bmiiTS8l3Lr5tM4ONlpuxIjxurxcybo7tzUasIyuwOvM3mii76IiIiIidT+RYqfVUSOSoh3BXg7M0sqmhmnJJbwg0zVvPGyK4Vy4v/si+bG2etoVVkEP93bQd6ND2/Oy12Hy6o9DzJQ42Uawr9VBK3Kd64kdRHXEFC2B23EzpihEfqcBpOVqWs4pmfnyGlMAWAHtE9uKPDHfSN7Vu3mmKtfg2+fdT1uP8/YOCjtTq8yS8t56/vrmfDkVWjIoKseJlMpOWXVoQ3sSG+/OfGTvRtEQ64uumLiIiInInKt1Dp3xAiRx1tZJx4uIDvd6Yf2RbA3swixn2wgbWPDCLY15uVuzIwDNh5uIAbZ67hngHN+dewNuf8vkdn4Bx9r6QMzzRSrikU4IhbFCxfzqF/PIRRXk7QkMFEPvig22sosZfwwbYP+DTx04rGxDEBMTzR5wn6Nern9nqq3Y7Fx8Kbi/8FAybV6vAmt9jG6HfW8evBPIJ9LfxzWBtu7B6H1eJFRkEZpeUOwgOt+PnoH1siIiJyboL+0M9DM3BEjkmIcLWUWLI1jWKbg1B/bxbf35/BL64gJbeEXw/kcWHLcLYeygegTXQQO9IKmPHDHv7atymRwefWtybxyApUl7aPZuaKPSR5aCWsmkI/laRaGYZB1uw3yXj5ZTAM/Hv1InbaNExm9y7VnJSXxIM/PMju3N0ABHgHcG2LaxnfZXzt729zIjn74PNxrsc974ZLHvFoOWdrT0YhP+zMIC7Uj4TwAJbvSOf9NftJyS0hLMCH9+/oSfvYYyt8RQTVnBXMREREpPYK/sMMHPXAETmm2ZGVqIptDgAGt43Cz8eLzk0akJJbwpaDuVzYMpzfD+UB8O9rO/DP//7KnowitqXmn1OAU2Z3sO/IClSXto9i5oo9JGcXU+5w4u3l3u+TNYV+Kkm1cZaWkjr5UfK//hqA0Fv+QtSkSZi8q7dT+R8ZhsFXSV/xf2v/j2J7MeF+4UzoOoEh8UPw966jy0bby2DhbVCaB426w9B/e7qiM1ZUZufV5Ym8/eNe7H/oNn9UVLCV9+/oRauourd6loiIiHje0Vk3Pl5mfCz18wuiyIk0Da/8S++h7aMB6BzXgK9/TWXLgVwyCso4nF+GyQRtooNpFxtSEeAMaB151u+5L7MYh9MgyGqhU1wD/H28KLY5SM4upnlEYJVcV22jAEeqRfnhwxy8dzylv/8OFgvRj04m9Oab3VpDTmkOT699mqX7lwLQM7on0y6aRrhfuFvrcCunEz4bB4c2gV8o3PgeWHw8XdUZ2Xwgl/HzNnIwpwSAHk1DKSpzsDujkLbRQdzSqwlXdorVb8NERESk2hy9hUr9b0QqC7RaiAyykl5Qhr+PF/1bur5TdYxzzYr/9WAeW4/MvmkWHkCA1ULbmCC+3ALbUwtOet5T2XWkgXHLqEDMZhMJ4QFsPZRPUkaRAhyRqlKyZQsHxo/HkZGJV4MGNHrlFQJ69XRrDUm5Sdy19C7Si9OxmCyM6zSOOy+4Ey9zHf4wNgzXalNbPwWzBW54Bxo09nRVp2WzO5m7Zh/Tluyg3GEQF+rHU1e3Z2CbKMA1i6pONZYWERGRGutoE+MA9b8ROU5CeADpBWVc3CoCX2/X96oOjUIwmyAtv5TlO9IrtgG0iwkGYNuRYOdsJaa7Ghi3jHTNvm8WEXgkwCkEos7nUmot/WSSKpX35VekTp6MYbNhbdmSuOlv4NPYvSHC9qztjF06lpyyHJoGN2XaRdNo17CdW2vwiJ9ehp9nuB5fMwOaD/RoOaeTW2zj3Z/2MW9dMhkFZQAM7xDNtBs6EvyHBoIKb0RERMRd2scGE+rvTb/mdXjGtsg5GtIuil/253Br7/iKbQFWCy0jg9h5uIDPNrpW+G0f6wpu2h35b1JmEcU2+1nPpE/8wwwcONaHpz6vRKUAR6pM9rx5HH7qaQACBw0idto0vALd2yB49aHV/OOHf1BQXkC7hu2YNXgWDXwbuLUGj9g8D5ZNcT0e+m/o6Jkl2s+Ew2nw0bpk/vPtTnKLywGIDLJy36CW3NqriQIbERER8ZjwQCvrJw/GUk8bpIqcyp39mzGqTzxWS+W7Gjo1DmHn4QIKyuwAdDiy2EhkkC/hgVYyC8vYmVZAlyahZ/V+21NdK1od7X/Z7MhKWHvr8UpUCnDkvBmGQdabb5Hx4osAhI4aRdSkh9260pTTcPLWb2/x+qbXMTDoGtmV1we9TpBPPWh2u+tb+GK863Hf+6DveM/WcwLp+aV8sfkQ6/Zlsyk5h8xCG+BaXvDeS1pwaftoNQoUERGRGkHhjcjJ/Tm8AegY14CPfzlY8fyPq8W2iw1m5a4MtqeeXYCTXWSrWIGqU1wDgIq+N7+m5LLlQC6dGjc4hyuo3RTgyHlxFBSQ+vjjFPxvCQAN7xlHxP33u3UWhd1pZ/KqySzeuxiA61tez6Rek7B61YOlpdO3u1acMhzQ8WYY/JSnK6qQWVjGyl0Z/O/3NJbvSMfxh1WlQvy8mTikFSN7NdE/kkREREREarHOfwhS4kL9CPE/1g6hbUwQK3dlsC317PrgbDmQC7hm3Rw9X7uYYPo2b8jqPVmMfmcd8+/uTdsjfXbqCwU4cs5Kt2/n4P0PUH7gAFgsRP3zIcJGj3ZrDQ6ng0d/epTFexdjMVl4rM9jXNfyOrfW4DGl+bDgVigvgoSL4OrXwQ2znj7bdJDYED96NWt4wtd/TsriteW7+WlPJsYfVgLvFh/KsPbRdI1vQPvYkIrGZyIiIiIiUnu1jg7Cx2LGZndW3D511LFGxvlndc5NyTkAdGl8bNaO2Wxi9ujujH77ZzYm53LrWz+zYGwfWkTWnxWpFODIOclfvJhDj0zGKC3FOzaWRi++gF/nzm6tweF08NhPj/F10tdYTBb+M+A/DGoyyK01eIxhwBd/g6zdENwIbngXvLxPf9x5SjxcwN8XbMHLbOLtMd0Z0Dqy4rXd6QU89vlW1iRlVWxrHxvMxa0iuLZLI1pG1YPb2URERERE6hlvLzPtY4PZlJxLh0aVZ8QcbWi8I60Ap9PAbD6zOzU2HZmB07lJg0rbA60W3v1rT0a+tZbfU/IZ+dZaPh7bh/iG7u296ikKcOSsOAoKyHjlVXI++ACAgP79afSf5/EKCTnNkVVch9PB46sf58ukL/EyefHcxc/Vn/AG4OeZsP1L8PKBEe9DgHtWSth6JDl3OA3+9uFG3r+jJ6H+Pnz9ayqvLd+NzeHE28vEiO6NGXdxcxqH+bulLhERERER8Zx7Lm7O26v2cn23uErbE8ID8fU2U2xzMGtlEmYT+Pt4EeLvQ5fGDU74fcHpNNh8JMDpcoI+NyF+3sy9vRc3z17DrsOF3PLmzywc14fYBn7VcWk1igIcOSOGYZD3xRek/+cFHJmZADS8604iJkzA5OXeW2EcTgdPrnmSRXsW4WXyYtpF0xgSP8StNXhU2u+w9HHX40ufgbhubnvrXUeW8vMymyi2Obh+xppKrw9oHcH/XdOBuFAFNyIiIiIi9cXQ9tEMbR993HYvs4nW0cFsOZDLtCU7Kr0W4ufNiocG0MDfp9L2pMxCCkrt+HqbaRN94ln8YQE+fHBnL26atZa9mUX8fcFmFoztU3UXVEMpwJHTKt2+nbSn/4+SjRsB8GnalKhHHyXwwn5ur6XQVsjDPz7MioMrMJvMPNv/WS5teqnb6/CY8hL45A5w2KDVcOhxp1vf/miA8+DQVnyz9TBbDuTi5+1F88gAbu+XwLVdGmkZcBERERERqXD/wBbMXplEgNVCiJ83JTYHG5JzyCgo460f9/KPS1tX2n9Tci4AHRs1OOWCJ5FBvnx4Zy/+vmAz067vWJ2XUGMowJETsh1MIfe/Cyla9ROlW7eCYWDy9yf8nnE0HDMGk4/P6U9SxVIKUxj/3Xh25+7Gx+zDM/2fqV/hDcC3j0HGDgiMcjUtdnNYsutwIeDqNH9X/2bkFNuICLQqtBERERERkRMa1DaKQW2jKm37ZmsaY9/fwLs/7eX2CxMICzj2/fJk/W9OJLaBX72YeXOUAhw5TtHP6zh433048491Cg++bDiR//wn3tHHT4tzh7SiNO745g5SClOI8IvglUte4YKICzxSi8fsXALr33Q9vmaG2/reHFVss3MgpxiA1lFBeHuZiQzydWsNIiIiIiJS+w1tF0X72GC2Hspn9sokHh7epuK1zUdm4Jyo/019V/1rDkutYRgGuZ98QvKdd+LMz8e3QwdinnmGFitW0OjFFz0W3mSXZnP30rtJKUyhSVATPrr8o/oX3hQcdq06BdD7XmhRfQ2b7Q4nT3zxO2+v2ltp++70QgwDGgb40DDQWm3vLyIiIiIidZvJZGLikFYAzFm9j8zCMgCKyuzsPNK2oUuT0JMeX19pBk49Zjidrlk2JhPlqakcnjaN4jVrAQgaPozYqVMx+3p2hkWBrYBxS8exN28vUf5RvDn0TaICok5/YF1ydMnw4iyIugAGP1Gtb/e/39OYs2Y/FrOJUb3j8bG4ct6jt0+1jAqs1vcXEREREZG6b2CbSDrGhfDrwTwWrD/AvZe0YMnvaTicBvEN/YkO0Wz/P1OAU8+U7txJ9vvvU7plC7bkAxhlZZVeN/n4uPrcjB2LyezZCVol9hLGfzee7dnbCfMN482hbxIbGOvRmjxi66ewexlYfOGGt8FSvbNfjs68sTsNkrOLaBHp6vyeeCQJbxV14k7wIiIiIiIiZ8pkMjGmT1MeXLiF+euTuefi5izccACA67vGnebo+kkBTh1nOJ2Ubt9O8fr1FP6wguK1a0+8o8lE0ODBRP7rn/jEeX6w2Bw2/v7D39mYvpEg7yBmDp5JQkiCp8tyv7IC+Gay6/GFEyGi9an3P08b9uew+UjTMIDd6ccCnF0KcEREREREpApddkEMU77cyoHsEuavP8DapGxMJri+m+e/k9ZECnDqKGdZGXmLFpH97nvYkpKOvWA2EzzsUkKuvhqfZs3wjoqqWMnI5O3toWorKyov4oHlD/Bz2s/4evnyxuA3aNuwrafL8owVz0FBKoQ2hX4PVPvbvfOnvjd7MgorHh+9hUoBjoiIiIiIVAU/Hy+u7dKIuWv2M+XLrQD0ax5OowZ+Hq6sZlKAUweVJSZy4G/3Un7ANf3M7O+Pf48e+PfsQdClw/CJa+ThCk8upzSHe5bdw9asrfhb/Hl14Kt0iezi6bLczzDgt//C2umu58OfA+/qvQc0KaOQ//2eCsAVHWP46tdU9qS7QpvCMjspuSUAtFIPHBERERERqSI392jC3DX7sdmdANzYXbNvTkYBTh1TuHIlKX+fiLOoCEtkJGF//SsNbrwRr8AAT5d2WmlFady99G725u2lgbUBMwbPoEN4B0+X5X7ZSbDsSdj2uet5u6uh1aXV9nal5Q7e+jGJN77fg9OAvs0bHgtwjszAOdr/JjLISgN/n2qrRURERERE6pd2scF0atyALQdyCfK1cGl7z6x+XBsowKlDcj7+mLQpT4LTiX+PHjR69RUsobVj6bWkvCTGLh1LWlEaUf5RzB46m2YhzTxdlvvk7Ietn7n+pG52bTNb4KJ/Qv+J1fa2WYVljHl3Hb+n5APQLT6UZ6/rSJndAcCejCIMwyBRt0+JiIiIiEg1uat/AuPnbeKWXk3w9fbydDk1lgKcOsAwDLJmzSbj5ZcBCLnuOmKmPIHJp3bMlEgtTOWOb+4gsySTpsFNmT1kNjGBMZ4u69wZhuu/R3oLUZwN+36EoBiI63Fse+4B1yybrZ9ByoZjx5vMkHAxDHocGnWt0tIcToMfdqbj72MhyNfC/fM3kZRRRFiAD09c2Y6rOsViMpmw2Z14mU0Ultk5nF/Gun3ZgCsdFxERERERqUpXdIylS5NQooO1dPipKMCp5Qynk/Rp08ieMxeAhmPHEjHhAUxHQ4IartBWyL3L7yWzJJOWoS15a+hbhPmGebqsM2cYkLUHDqyFAz9D+g7I3AW2IlfjYd9gOLQZDNeMFsKaQ/QFkLoFcv7QMNhkhqYXQvtroc2VEBhRLeU+9eVW5qzZX2lbbIgvH9zZi2YRx3rb+FjMxIf5k5RZRGJ6Ad/vSAdgQKvqqUtEREREROo3NS4+PQU4bpb73/+SOX0G0U8+SWD/C8/rXEZ5OYcmTyZ/0ZcARE16mLAxY6qiTLewO+08tPIhEnMSCfcL542Bb9SO8MZhh70rYMdXkLgM8pJPvF9W4rHH4a0h7yBk73H9AcAE8f2g/TWuPjeBkdVa9vx1yRXhTeMwP1JySujQKISZt3Yj9gQ/LJtFBJKUWcSnG1PIKrIR5GuhR0It+PsRERERERGpgxTguFHOgo9Je+IJADJeeYWAC/ud80wZ2759pD75JMVr1oKXF7HP/JuQq6+uynKr3fPrn2dVyip8vXx5beBrNfu2qbJC2LcKdi+DbV9AUfqx17ys0KgbNO4JMZ0gvBVYgyBnHxSmQ+Mertk4ZYWu0Cf/EMR2htgu4OeeHkXr9mbz2Be/A/DgkFbcN6gldocTi5f5pMc0jwxg2XZYtOUQABe3isD7FPuLiIiIiIhI9VGA4yY5CxdWhDcApb//TumWLfh17nxW53EWF5M5YwZZ782B8nJMvr40evklggYMqNqCq9mH2z9k3o55AEztP7VmrjaVtcfVn2bP967bo5zlx17zC3PNmmk9HJr2Bx//448Pja/83BoInW6u3ppPYNGWQzy0cAvlDoPLLohm/MAWAKcMbwBaHLmlyuF09fQZ1LZ6ZwiJiIiIiIjIySnAcYPy9HQO//sZAMLGjMaRl0/e55+T/eE8Gp1FgFP44yrSpkyhPCUFgID+/Yma9DDWZrVrtaaVB1fy3PrnAJjQdQKD4wd7uKI/cNhh30r4eTbsWgIYx15r0ASaD3KFNs0Hgpe3x8o8U68sS+SlZbsAuKR1BP+5sdMZz/pqHnmsJ47ZBANaKcARERERERHxFAU4buAdGUnc669TtHo1kQ/9g9Kt28j7/HPylywh6p8PgdmMUV6Od3Tl9e4dublkzZlD8c/rsCUn48jMdJ0vNpaoxx4lcMCAWtOs+Kid2Tt5aMVDOA0n17a4lts73O7pklzSd8C6WbBtERRnHtv+x8AmrNmxFaRqgZ1pBRXhzbiLm/PQpa3xMp95/c3/0NS4e3wYoQG1Y1UzERERERGRukgBjpsEXtiPwAv7AeDXoT1+nTtTsnkze0fchD0tDSwW4l57laABAzBsNrLeeYest97GWVh47CReXoTdOpKI++/HHBDgoSs5d5klmYxfPp5iezE9o3vyWO/HPB9AHd4G3//b1ZvmKL8w6HAd9BoH4S09V9t5+vBnV8PiYe2jeXh4m7M+PsTPm4ggKxkFZbp9SkRERERExMPOqSPp9OnTSUhIwNfXl27duvHjjz+edN9PP/2UIUOGEBERQXBwMH369OGbb74554LritCRIwGwp6a6lqIuLyfl/gfI/exz9o28lYyXX8FZWIi1dWtipk6l6X//S6u1a4iaNKlWhjcZxRmMWzqOtKI0mgY35cUBL+LtyVuQ7Db4firM6n8svGlzBdz6KfxjF1z+Qq0Ob4rK7Hy60XWr3a2940+z98nd2C2OhPAAru7cqKpKExERERERkXNw1jNwFixYwIQJE5g+fTr9+vVj1qxZDB8+nG3bttGkSZPj9l+5ciVDhgzhmWeeoUGDBrz77rtceeWV/Pzzz3Tp0qVKLqI2Cr78MhzZWeBlIXDAAA5PnUrhd9+ROmkSAF4hIUQ9Opngyy/HZK7dK/8k5SVxz9J7OFR0iDDfMN4Y9AYh1hDPFFNwGH6dDxveg+wk17bWl8GgJyDy7Gep1FSLthyisMxOQngAfZs3POfz/HNYG/45rO787yIiIiIiIlJbmQzDME6/2zG9evWia9euzJgxo2Jb27Ztueaaa5g6deoZnaN9+/bcdNNNPP7442e0f35+PiEhIeTl5REcHHw25dYaTpuNg/f8jaKffsKvezcaPf883jE1eFntM7T60GoeWvEQ+bZ84oPjmTFoBo2DG7u/EKcT1rwG3z19bDUp/4Zw2fPQ/rpa1dvmdAzD4IrXVrH1UD6TL2vLXRfVribXIiIiIiIi9cmZZh5nNQPHZrOxYcMGHn744Urbhw4dyurVq8/oHE6nk4KCAsLCwk66T1lZGWVlZRXP8/Pzz6bMWsns40PjWTMp3bET37ZtMHl5ebqk82IYBu9ufZdXNr6C03DSMaIjrw18jTDfk/+9V5vibPj8b7Drf67ncT2gyyhofy341r1AcE1SFlsP5eNjMXNDtzhPlyMiIiIiIiJV4KwCnMzMTBwOB1FRUZW2R0VFkZaWdkbneOGFFygqKmLEiBEn3Wfq1Kk8+eSTZ1NanWCyWPDr0N7TZZy34vJiHl/9ON/sc/U6urbFtUzuPRmrl9X9xexeBl+Mh4JU8LLC8GnQ7bY6NePmjw5kF3P/R5sAuK5LI60cJSIiIiIiUkec0ypUf145yDCMM1pN6KOPPmLKlCl88cUXREaefFWbSZMmMXHixIrn+fn5NG7sgdtu5KwdyD/A/d/fz+7c3VjMFib1nMSNrW50/2pTDjt8MwnWzXY9D2sON7wDsZ3dW4cb5ZeWc/t768kstNEuJpjHrmjn6ZJERERERESkipxVgBMeHo6Xl9dxs23S09OPm5XzZwsWLOCOO+5g4cKFDB48+JT7Wq1WrFYPzNaQ87Itaxvjlo4jpyyHcL9wXhrwEp0jO7u/EHsZfHInbF/ket5zLAyeAj7+7q/FTYptdu6c8wuJ6YVEBVt5+7buBFjPKZ8VERERERGRGuisljfy8fGhW7duLF26tNL2pUuX0rdv35Me99FHH3Hbbbcxb948Lr/88nOrVGq0X9J+4fZvbienLId2Ddux4IoFnglvygrho7+4whsvH7jpA7jsuTod3pTYHNz+3nrW7c0myGrh7TE9iAnx83RZIiIiIiIiUoXO+lf0EydOZNSoUXTv3p0+ffowe/ZskpOTGTduHOC6/SklJYW5c+cCrvBm9OjRvPLKK/Tu3bti9o6fnx8hIR5aSlqqjGEYLNy1kGnrpmFz2uge1Z3XBr5GoE+g+4vJ2AkLRkHmTvD2h5vnQfNL3F+HG9kdTu6a+wtrk7IJtFqYe0dPOjTSuBIREREREalrzjrAuemmm8jKyuKpp54iNTWVDh06sHjxYuLj4wFITU0lOTm5Yv9Zs2Zht9u59957uffeeyu2jxkzhvfee+/8r0A8pqi8iCmrp7Bk3xIABjYeyLSLpuFr8XV/MTv/57ptylYIQTGumTdx3d1fh5u9tnw3q3ZnEuDjxZzbe9KlSainSxIREREREZFqYDIMw/B0Eadzpmuii/sk5ydz//L72ZO3B4vJwoRuExjVbhRm01ndlVc1dnwNH48Gpx2a9nc1Kw48eZPsumLd3mxunr0GpwGv3NyZqzs38nRJIiIiIiIicpbONPNQl1M5aysPrmTSj5PIt+UT6RfJi5e8SKeITp4pZsdi+HiMK7zpcD1cOxu86v7/rXOLbUyYvwmnAdd3jVN4IyIiIiIiUsfV/W+6UmUOFx1m2vppLN3vamLdMaIjLw94mQj/CM8UtPN/R2belNer8MbpNJj48RYO5ZXStKE/T17d3tMliYiIiIiISDWr+9925bzZnXY+3P4h0zdPp9hejJfJi5FtR/JA1wfw8fLxTFE7l7gaFjvLof119Sa8AZj+w26W70jHajHz+i1dCdRy4SIiIiIiInWevvnJCTkNJ1szt7L+8Hq+SvqKxJxEADpFdOKx3o/ROqy154rbsgAWjXeFN+2ugeverDfhzcpdGby4dBcAT1/TQStOiYiIiIiI1BP141uvnJW8sjwe+P4BNhzeULEtxBrCxG4TuabFNZ5pVAzgdMCyKbD6VdfzdtfA9W/Vm/Bm3d5sxr6/AacBN/dozIjujT1dkoiIiIiIiLhJ/fjmK2csrSiNcUvHsSdvD34WP/rE9KFHdA8ub3Y5ob4eXKLa6XAtE771U9fz/v+ASyaD2UNhkptt2J/NX99dR0m5g/4tw5lylfreiIiIiIiI1CcKcARw3TL1ddLXvPDLC2SVZhHpH8mMwTNoFdrK06WBYcBXE1zhjdkbrpvlalpcT5SWO7h77gaKbA76tWjIm6O74+vt5emyRERERERExI0U4NQzhmHwe+bv/Jb5G8kFyaQXp+M0nKQUprAjewcALRq0YPqg6cQExni4WlzhzbePwsa5YDLDDW9Du6s9XZVb/e/3VLKKbDRq4Mdbo3sovBEREREREamHFODUE2lFaSzbv4xPEj9hd+7uE+7jZ/FjbMexjGo3ynOrS/3Zyudhzeuux1e9Vu/CG4CP1h0A4KYejfHzUXgjIiIiIiJSHynAqcNK7aV8sfsLPtv9GVuztlZs9/XypXdMb5qGNCU6IBpvszcWs4ULG11IpH+kByv+k7Uz4Pt/ux4Pexa63OrZejxgT0Yh6/ZmYzbBjd3jPF2OiIiIiIiIeIgCnDrIMAzm7ZjHm7++SVZpFgAmTHSK6MRlzS7j8maXE+wT7OEqT2P16/DtZNfjAY9A73s8W89ZKLbZKSy1Exnse97nmr8uGYBLWkcSE+J33ucTERERERGR2kkBTh1jc9h4YvUTfJX0FQAxATGMbjeaYQnDCPcL93B1Z8AwYOnjx5YK73s/XPxPz9Z0huwOJ/PWJfPi0l0Ultp55eYuXN4xhpwiGzNX7KFbfChD20ef8fmyi2x8sjEFgJt7NqmuskVERERERKQWUIBTh+SV5XH/8vvZmL4RL5MXD/V4iBGtR+Bt9vZ0aWfGUQ6L7oct81zPB0+BfhPAZPJkVWdkd3oh9364kZ2HCyq23T9/E/uzi/hwbTIpuSX4eJlZOvEi4hsGHHe8YRisScpi84FcMgtsJKYXsHpPFg6nQVSwlUtaR7jzckRERERERKSGUYBTR6QXpzN26Vh25+4myDuI/wz4D31j+3q6rDNnK4KFt0Hit2DygqterTU9b77fkc79H22ioMxOqL83E4e0YtOBXD7dmMJzS3YCrgzK5nDy9FfbeGtMj4pjS2wOPt10kPd+2kdieuFx524XE8zjV7bD4mV22/WIiIiIiIhIzaMApw5Izk/m7qV3k1KYQqRfJDOHzKRlaEtPl3XmykvhgxsgeTVY/ODG96D1ME9XdVqFZXZeWrqLd37ai2FAj6ahTB/ZjYggK7f0MjBh4pONBxncNoq/XdKcETPXsGx7Ot9tP0xUsC9fbjnE/PUHyCspByDAx4tBbaOIaeBLdLAvF7eKoFlEoIevUkRERERERGoCk2EYhqeLOJ38/HxCQkLIy8sjOLiGN989DbvTzrasbbRv2B4v8/kvCb0zeydjl44lqzSLJkFNmD10No0CG1VBpW7idMInt8PWz8AaAiMXQpNenq7qlHKLbXz5ayqvL0/kcH4ZALf0asKUK9vjYzk2U8YwDA7nlxEVbMVkMvHM4u3MXpl03PmahPkzpm9TbuweR7BvLbndTURERERERKrEmWYemoHjRuWOcib8MIGVB1cyvvN4xnYae17n23B4A/d9dx8F5QW0CWvDjMEzakej4j9a/rQrvDF7w80f1Kjwxu5w8ltKHonphSRlFJGeX8qhvBI27M+h3OHKPeMb+vPkVe0Z0Pr45ddNJhPRIcdWorp/UEsWbT5EWn4pAT5e9G0RzojujRnYJhIvc83v8yMiIiIiIiKeowDHTcqd5Ty08iFWHlwJwLwd8/hrh7/i4+Vz1ufKLc3l9c2vs3DXQpyGk66RXXlt0Gs1f2nwP9swB1a96Hp81auQcJFn6/mD/VlFjH1/AzvSCk74etuYYK7v2ohbe8fj631mM6kCrRa+GN+PA9nFdIxrUGm2joiIiIiIiMipKMBxA7vTziM/PsJ3yd/hY/bB39uf7NJsvtn3DVc2v/KMz2MYBl/s+YLn1z9Pvi0fgMsSLmNK3yn4Wfyqq/zqsWc5fPV31+OL/wWdb/FsPUfYHU6WbU/nX5/8Sl5JOUFWCx0bh9AiIpCYBn5EBlnp0CiEVlFB53T+qGBfooJ9T7+jiIiIiIiIyB8owHGDvLI8tmdvx2K28NIlL7EjewevbXqND7d/yBXNrsB0imWyS+2lJOYksr9gP4t2L2JN6hoAWoa2ZFLPSfSI7nHSY2usw9vg4zFgOKDjTTBgkqcrYk9GIa99l8j3OzMqmgp3btyAmbd2q3QblIiIiIiIiIgnKMBxg4Z+DXn30nfZmbOTCxtdSPuG7Zm5ZSZbs7aydP9SDhcfxmk4ubXtrRWNjcscZXy882Pe+u0tskuzK85l9bLyt85/Y3S70VjMtfCvryAN5o2AsnyI7wdXveZaY9tDyh1OZq3Yw6vf7cbmcALQwN+bG7rG8dCw1lgt599oWkREREREROR81cIEoHaK8I8gwj8CcAU6wxOGs2jPIh5c8WDFPok5iTzV7yk2Ht7I5FWTOVR0CIBQayjNGjSjeUhzRrcfTXxwvEeu4bzZiuCjmyHvADRsATd9ABarx8opLLNzx3vr+XmvKyC7qFUE9w1sQZfGDbB4qT+NiIiIiIiI1BwKcDxkdLvR/G/v/3AYDjpFdGJLxha+2PMFBwoOsDljM07DSaR/JPd0uoerW1yNt7mWLy9dmg8Lb4NDm8C/oWu5cP8wt5ZQ7nDyzdY0GgZYaRruzz0fbGTzgVwCrRaevqY913RudMrb2UREREREREQ8xWQYhuHpIk7nTNdEr23SitKwelkJ9Q3lq6SveOTHRzBw/XVc1fwqJveajL+3v4errAJZe+Cjv0DmTrD4wuhFbl8uvMzu4N4PN7Fs++FK2xv4ezP39p50jGvg1npERERERERE4MwzD83A8aDogOiKx1c0uwLDMHh/2/uMbDuSq1tc7cHKqtDuZfDf26E0D4Ji4eYPoFE3t5ZQZndwzwcbWb4jHR+LmfAAHw7llRIeaOX9O3rSNqbuhIIiIiIiIiJSN2kGjlQPw4DVr8KyKWA4oXEvGPE+BEW5sQSD5TvSef6bnexIK8BqMfPWmO70bxlBen4pfj5eBPnW8lvTREREREREpFbTDBzxnPISWHQf/LbQ9bzLKLj8Bbc2LC6xObj7/V/4MTETgGBfCzNv7UbfFuEARAZraXARERERERGpPRTgSNXKOwjzR0LqZjB5wfBp0ONOty4V7nQaPLhwMz8mZmK1mPlrvwTGXdyMBv4+bqtBREREREREpCopwJGqk74d3r8WClJdK03dOAcS+ru9jOe/3cni39Lw9jIx9/ae9GrW0O01iIiIiIiIiFQlBThSNQ7+Ah/eACU5ENEGbvkYQuPdWsLG5BxeWZbIil0ZADx7XUeFNyIiIiIiIlInKMCR82MYsHkeLP4HlBdDo+4wciH4h7m1jGcWb2f2yiQAvMwmHhzaiuu7xbm1BhEREREREZHqogBHzl1ZAXz192PNipsPghFzwRro1jLeWbW3Iry5sVsc4we2IL5hgFtrEBEREREREalOCnDk3GTuhvm3QOZOV7PiSybBhRPB7OXWMr7dmsbTX28D4JHL2nD3Rc3d+v4iIiIiIiIi7qAAR86OYcD2L+GL8VCWB0ExcON70KS320tZsyeL+z7ahGHALb2acFf/Zm6vQURERERERMQdFODImcvaA//7F+xe6nreuBeMeB+Cotxeyi/7srljznrK7E4GtYnkqavaY3LjUuUiIiIiIiIi7qQAR06vrBB+/A+seQMcNjB7Q9/xMOARsPi4tZTcYhvvr9nPrJVJFNsc9G8Zzhsju2LxMru1DhERERERERF3UoAjJ1ZeCnuWw94VsO0LKEh1bW8xGIZNg/AWbi/pvxsO8tjnv1NS7gCgT7OGzB7VHV9v9/bdEREREREREXE3BThyvJz9MO8myNh+bFuDeBj2LLQeDh64VWnlrgz+9cmvOJwG7WKCGXtxMy6/IEYzb0RERERERKReUIAjlR38BT66GYoywD8c2l0NCRdBq2Hg7euRknamFXDvhxtxOA2u69qIF27spH43IiIiIiIiUq8owBGX4mxYMQ3WvwVOO0RfAH9ZACGNPFpWbrGNO+asp6DMTs+EMKZed4HCGxEREREREal3FODUN3kpsHEupPziWlWqMB3MFrCXgqPMtU+7q+Hq6WAN9GipTqfB3xds5mBOCU3C/Jl1azesFvW7ERERERERkfpHAU5dZxiQmQjJq2H3MtixGAzHifeNbA+X/huaX+LeGk9i+g+7+X5nBlaLmRm3diU0wL0rXomIiIiIiIjUFApw6ip7Gfy2ENbOgMO/V34t/kK44HoIbwVBMa6QByAsAcyen+FSYnPw8ne7mL0yCYCnr+5A+9gQD1clIiIiIiIi4jkKcOqitN9gwa2Qs8/13OILcT2gSW9odw1Ed/Bkdae0+UAuD8zfxP6sYgBu69uUET0ae7gqEREREREREc9SgFPX/PZf+GI82EsgMBp63wPdxoBfqKcrO60VuzIY9/4GSsodRAf78vQ1HRjSLsrTZYmIiIiIiIh4nAKcusIwXKtI/TDV9bz5ILj+LfAP82xdZ+irXw/x9wWbKXcY9G8ZzhsjuxLs6+3pskRERERERERqBAU4dYHDDl//3bW6FEC/B2DQEzWin82Z+Gl3JhPmb8buNLiyUywv3NgJH4vZ02WJiIiIiIiI1Bj6luxu2Umw7EkoSKua89mKYP4trvDGZIbLX4QhT9Wa8GZ3eiHjPtiA3WlwVadYXrmps8IbERERERERkT/RDBx3St8Bc66EonTIO+C6xel8FGbAvBFwaCNY/OCGd6DNZVVTqxvklZRz+3vrKSi10y0+lOdu6IjZbPJ0WSIiIiIiIiI1jqY6uMvhrfDe5a7wBmDr51Bw+NzOZRiuZsWzLnKFN35hMObLWhXeADz15TaSs4uJC/Vj9qhu+HrXjllDIiIiIiIiIu6mAMcdCtLgvSugOBNiOkFMZ3CWw4Z3z/5chzbDu8Phkzug4BCENYM7lkLjHlVddbVavuMwn2w8iMkEr9zcmYaBVk+XJCIiIiIiIlJjKcBxh8Ao11LejbrB6EXQ9z7X9l/eAbvt1MfabZC+HRKXwqL7YPYASF7jumXqkslwz2oIb1Htl1CV8orLmfTpbwDceWEC3eJrx0pZIiIiIiIiIp6iHjjuYDK5VoWyl4K3H7S9yhXqFB6GbydDSS6YLXDZc2ANch1TVgjr34I1r0NRRuXzdbgBhjwJIXFuv5TzZRgGkz//jcP5ZTQLD+DBoa09XZKIiIiIiIhIjacAx11MJld4A2Dxge63ww9TYd3sY/vkHYCRC2H3d/DlA65brgCswRAaD6EJ0PtvEN/H/fVXkQ9+TuarX1OxmE38Z0Qn9b0REREREREROQMKcDylx12Q+K3rcZM+sGEO7PsRpveGnH2u7WHNof+D0HEEeHl7rNSq8ntKHk9/uQ2Afw1rQ9cmoR6uSERERERERKR2UIDjKQEN4a7lx563uRzev+5IeGOCfg+4etxYfDxVYZUxDIOFvxzkmf9tx+ZwMrhtFHf2T/B0WSIiIiIiIiK1hgKcmiK+L4z82HVLVY+7oNnFnq6oSuxOL+CRz35n3d5sADo0CuaFGzthMpk8XJmIiIiIiIhI7aEApyZJuMj1pw4oLXfwxve7mbliD+UOAz9vLx4c2orb+jbF4qXFz0RERERERETOhgIcqXKrEjN59PPf2JdVDMDgtpFMuao9caH+Hq5MREREREREpHZSgCNVxjAMpizaypw1+wGICrby5FXtubR9tG6ZEhERERERETkPCnCkyjz3zU7mrNmPyQRj+jTlwaGtCPKt/atniYiIiIiIiHiaAhypEm+v2suMH/YAMO26jozo0djDFYmIiIiIiIjUHQpw5LyUljuYunh7xW1TD13aWuGNiIiIiIiISBVTgCPnLDmrmLvf/4UdaQUAjL+kBX8b0NzDVYmIiIiIiIjUPQpw5JzsTi9g5Fs/czi/jIYBPvxnRCcuaR3p6bJERERERERE6iQFOHLWNiXncMecX8gustE6Koi5d/QkKtjX02WJiIiIiIiI1FkKcOSM7cko5KWlu/jq11QAOsaFMOevPQkN8PFwZSIiIiIiIiJ1mwIcOS2n0+DtVXt57psdlDsMAK7sFMu/r+1AsJYJFxEREREREal2CnDkhHanF/DZphTKHQa/HsxlbVI2ABe3iuBfw9rQLjbYwxWKiIiIiIiI1B8KcOQ4yVnFXD9jDXkl5RXbfL3NPH5Fe/7SszEmk8mD1YmIiIiIiIjUP+ZzOWj69OkkJCTg6+tLt27d+PHHH0+6b2pqKrfccgutW7fGbDYzYcKEc61V3KDE5mDcBxvIKymnTXQQd1/UjPsGtuCr+/pzS68mCm9EREREREREPOCsZ+AsWLCACRMmMH36dPr168esWbMYPnw427Zto0mTJsftX1ZWRkREBJMnT+all16qkqKlejicBo989hvbUvNpGODDu3/tQUyIn6fLEhEREREREan3TIZhGGdzQK9evejatSszZsyo2Na2bVuuueYapk6despjBwwYQOfOnXn55ZfPqsj8/HxCQkLIy8sjOFi9V85Hsc3Ofzcc5GBOCQE+FsKDfLioZQTBvt48sGATP+zMwGyCD+7sRd/m4Z4uV0RERERERKROO9PM46xm4NhsNjZs2MDDDz9cafvQoUNZvXr1uVV6AmVlZZSVlVU8z8/Pr7Jz1ycOp8Ev+7LZcjAXs8lEfqmdD9fuJ6vIdty+gVYLhWV2fL3NPH9DJ4U3IiIiIiIiIjXIWQU4mZmZOBwOoqKiKm2PiooiLS2tyoqaOnUqTz75ZJWdr75xOg1eXZ7Ihz8nk1FQdtzr8Q39GdQmipJyB3syCvllXzaFZXYaNfBj1qhudGgU4oGqRURERERERORkzmkVqj83sjUMo0qb206aNImJEydWPM/Pz6dx48ZVdv66zOE0+Ncnv/LfDQcBCPK10L9lON5eZgwDLmoVwTWdY7F4HetfnVVYxi/7c+iVEEYDfx9PlS4iIiIiIiIiJ3FWAU54eDheXl7HzbZJT08/blbO+bBarVit1io7X31hdzj5x8ItfL75EF5mE09f3YEbusXhYzn1YmMNA61c2j7aTVWKiIiIiIiIyNk6q2XEfXx86NatG0uXLq20fenSpfTt27dKC5OzU+5wMmHBZj7ffAiL2cSrN3fhll5NThveiIiIiIiIiEjNd9a3UE2cOJFRo0bRvXt3+vTpw+zZs0lOTmbcuHGA6/anlJQU5s6dW3HM5s2bASgsLCQjI4PNmzfj4+NDu3btquYq6jmb3cn9H21iydY0vL1MvH5LV82oEREREREREalDzjrAuemmm8jKyuKpp54iNTWVDh06sHjxYuLj4wFITU0lOTm50jFdunSpeLxhwwbmzZtHfHw8+/btO7/qaym7w1mpB835MAyDBxduYcnWNHy8zMwc1ZWBbarudjYRERERERER8TyTYRiGp4s4nTNdE72mMwyDV75L5I3vd/PCiM5c1Sn2vM/50tJdvPJdIt5eJt4c3Z0BrSOroFIRERERERERcYczzTzUIMWNXlqWyMvLEil3GLz6XSLnm519suEgr3yXCMC/r7lA4Y2IiIiIiIhIHXVOy4jL2Xt52S5ePRK2WMwmdqcXsiYpi77Nw8/6XBv2Z/Pi0l38tDsLgLEXNWNEDy2zLiIiIiIiIlJXKcBxg/T8Ut79aR8Aky9rS3J2Me+v3c/c1ftPG+DY7E7yS8tpGOBDdpGNf3+9nU83pQDg7WVidJ+m/HNYm+q+BBERERERERHxIAU4bhAZ7MuHd/Zi/b5s/tovgV2HC3h/7X6+3ZZGSm4JXiYTdqeTuFD/imMMw+CzTSk8s3g7mYU2Qvy8cRoGBaV2TCYY0a0x9w1qUekYEREREREREambFOC4SYdGIXRoFAJAq6gg+jRryJqkLK56bRVZRTa8vUx8eGdveiaEkVNk428fbmRNUlbF8Xkl5QC0jQlm6nUX0LlxA09choiIiIiIiIh4gAIcDxnTN541SVlkFdkAKHcY3DtvIwvu7s2EBZv59WAevt5m7h/UktF9mpKcVUx+aTnd4kPxrqIlyEVERERERESkdtAy4h5iGAYLfzmI2WyiV0IYd8xZz67DhXh7mSh3GIT6e7NgbB9aRQV5ulQRERERERERqSZaRryGM5lMjOjRmBu6xdE4zJ+Zt3Yj0Gqh3GEQZLUw9/ZeCm9EREREREREBFCAU2M0iwhk1qhuDGwTyXu39+CCuBBPlyQiIiIiIiIiNYR64NQg/VqE06/FqZcVFxEREREREZH6RzNwRERERERERERqOAU4IiIiIiIiIiI1nAIcEREREREREZEaTgGOiIiIiIiIiEgNpwBHRERERERERKSGU4AjIiIiIiIiIlLDKcAREREREREREanhFOCIiIiIiIiIiNRwCnBERERERERERGo4BTgiIiIiIiIiIjWcAhwRERERERERkRpOAY6IiIiIiIiISA2nAEdEREREREREpIZTgCMiIiIiIiIiUsNZPF3AmTAMA4D8/HwPVyIiIiIiIiIiUnWOZh1Hs4+TqRUBTkFBAQCNGzf2cCUiIiIiIiIiIlWvoKCAkJCQk75uMk4X8dQATqeTQ4cOERQUhMlk8nQ58gf5+fk0btyYAwcOEBwc7OlyROQPND5FaiaNTZGaS+NTpOaqy+PTMAwKCgqIjY3FbD55p5taMQPHbDYTFxfn6TLkFIKDg+vcIBKpKzQ+RWomjU2RmkvjU6Tmqqvj81Qzb45SE2MRERERERERkRpOAY6IiIiIiIiISA2nAEfOi9Vq5YknnsBqtXq6FBH5E41PkZpJY1Ok5tL4FKm5ND5rSRNjEREREREREZH6TDNwRERERERERERqOAU4IiIiIiIiIiI1nAIcEREREREREZEaTgGOiIiIiIiIiEgNpwBHRERERERERKSGU4Ajx5kyZQomk6nSn+jo6IrXDcNgypQpxMbG4ufnx4ABA9i6dWulc5SVlXHfffcRHh5OQEAAV111FQcPHnT3pYjUeitXruTKK68kNjYWk8nE559/Xun1qhqPOTk5jBo1ipCQEEJCQhg1ahS5ubnVfHUitdfpxuZtt9123Gdp7969K+2jsSlS9aZOnUqPHj0ICgoiMjKSa665hp07d1baR5+dIp5xJuNTn5+npgBHTqh9+/akpqZW/Pntt98qXnvuued48cUXef3111m/fj3R0dEMGTKEgoKCin0mTJjAZ599xvz581m1ahWFhYVcccUVOBwOT1yOSK1VVFREp06deP3110/4elWNx1tuuYXNmzezZMkSlixZwubNmxk1alS1X59IbXW6sQkwbNiwSp+lixcvrvS6xqZI1VuxYgX33nsva9euZenSpdjtdoYOHUpRUVHFPvrsFPGMMxmfoM/PUzJE/uSJJ54wOnXqdMLXnE6nER0dbTz77LMV20pLS42QkBBj5syZhmEYRm5uruHt7W3Mnz+/Yp+UlBTDbDYbS5YsqdbaReoywPjss88qnlfVeNy2bZsBGGvXrq3YZ82aNQZg7Nixo5qvSqT2+/PYNAzDGDNmjHH11Vef9BiNTRH3SE9PNwBjxYoVhmHos1OkJvnz+DQMfX6ejmbgyAklJiYSGxtLQkICN998M0lJSQDs3buXtLQ0hg4dWrGv1Wrl4osvZvXq1QBs2LCB8vLySvvExsbSoUOHin1E5PxV1Xhcs2YNISEh9OrVq2Kf3r17ExISojErch5++OEHIiMjadWqFXfddRfp6ekVr2lsirhHXl4eAGFhYYA+O0Vqkj+Pz6P0+XlyCnDkOL169WLu3Ll88803vPnmm6SlpdG3b1+ysrJIS0sDICoqqtIxUVFRFa+lpaXh4+NDaGjoSfcRkfNXVeMxLS2NyMjI484fGRmpMStyjoYPH86HH37I8uXLeeGFF1i/fj0DBw6krKwM0NgUcQfDMJg4cSIXXnghHTp0APTZKVJTnGh8gj4/T8fi6QKk5hk+fHjF4wsuuIA+ffrQvHlz5syZU9FAymQyVTrGMIzjtv3ZmewjImevKsbjifbXmBU5dzfddFPF4w4dOtC9e3fi4+P5+uuvue666056nMamSNUZP348v/76K6tWrTruNX12injWycanPj9PTTNw5LQCAgK44IILSExMrFiN6s/JZXp6esVvMqKjo7HZbOTk5Jx0HxE5f1U1HqOjozl8+PBx58/IyNCYFakiMTExxMfHk5iYCGhsilS3++67j0WLFvH9998TFxdXsV2fnSKed7LxeSL6/KxMAY6cVllZGdu3bycmJoaEhASio6NZunRpxes2m40VK1bQt29fALp164a3t3elfVJTU/n9998r9hGR81dV47FPnz7k5eWxbt26in1+/vln8vLyNGZFqkhWVhYHDhwgJiYG0NgUqS6GYTB+/Hg+/fRTli9fTkJCQqXX9dkp4jmnG58nos/PP3F/32Sp6R588EHjhx9+MJKSkoy1a9caV1xxhREUFGTs27fPMAzDePbZZ42QkBDj008/NX777TfjL3/5ixETE2Pk5+dXnGPcuHFGXFycsWzZMmPjxo3GwIEDjU6dOhl2u91TlyVSKxUUFBibNm0yNm3aZADGiy++aGzatMnYv3+/YRhVNx6HDRtmdOzY0VizZo2xZs0a44ILLjCuuOIKt1+vSG1xqrFZUFBgPPjgg8bq1auNvXv3Gt9//73Rp08fo1GjRhqbItXsnnvuMUJCQowffvjBSE1NrfhTXFxcsY8+O0U843TjU5+fp6cAR45z0003GTExMYa3t7cRGxtrXHfddcbWrVsrXnc6ncYTTzxhREdHG1ar1bjooouM3377rdI5SkpKjPHjxxthYWGGn5+fccUVVxjJycnuvhSRWu/77783gOP+jBkzxjCMqhuPWVlZxsiRI42goCAjKCjIGDlypJGTk+OmqxSpfU41NouLi42hQ4caERERhre3t9GkSRNjzJgxx407jU2RqneicQkY7777bsU++uwU8YzTjU99fp6eyTAMw33zfURERERERERE5GypB46IiIiIiIiISA2nAEdEREREREREpIZTgCMiIiIiIiIiUsMpwBERERERERERqeEU4IiIiIiIiIiI1HAKcEREREREREREajgFOCIiIiIiIiIiNZwCHBERERERERGRGk4BjoiIiIiIiIhIDacAR0RERERERESkhlOAIyIiIiIiIiJSw/0/FgrU8lNaeKQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/isofit-tutorials/build/html/_static/_sphinx_javascript_frameworks_compat.js b/isofit-tutorials/build/html/_static/_sphinx_javascript_frameworks_compat.js new file mode 100644 index 0000000..8141580 --- /dev/null +++ b/isofit-tutorials/build/html/_static/_sphinx_javascript_frameworks_compat.js @@ -0,0 +1,123 @@ +/* Compatability shim for jQuery and underscores.js. + * + * Copyright Sphinx contributors + * Released under the two clause BSD licence + */ + +/** + * small helper function to urldecode strings + * + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL + */ +jQuery.urldecode = function(x) { + if (!x) { + return x + } + return decodeURIComponent(x.replace(/\+/g, ' ')); +}; + +/** + * small helper function to urlencode strings + */ +jQuery.urlencode = encodeURIComponent; + +/** + * This function returns the parsed url parameters of the + * current request. Multiple values per key are supported, + * it will always return arrays of strings for the value parts. + */ +jQuery.getQueryParameters = function(s) { + if (typeof s === 'undefined') + s = document.location.search; + var parts = s.substr(s.indexOf('?') + 1).split('&'); + var result = {}; + for (var i = 0; i < parts.length; i++) { + var tmp = parts[i].split('=', 2); + var key = jQuery.urldecode(tmp[0]); + var value = jQuery.urldecode(tmp[1]); + if (key in result) + result[key].push(value); + else + result[key] = [value]; + } + return result; +}; + +/** + * highlight a given string on a jquery object by wrapping it in + * span elements with the given class name. + */ +jQuery.fn.highlightText = function(text, className) { + function highlight(node, addItems) { + if (node.nodeType === 3) { + var val = node.nodeValue; + var pos = val.toLowerCase().indexOf(text); + if (pos >= 0 && + !jQuery(node.parentNode).hasClass(className) && + !jQuery(node.parentNode).hasClass("nohighlight")) { + var span; + var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.className = className; + } + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + node.parentNode.insertBefore(span, node.parentNode.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling)); + node.nodeValue = val.substr(0, pos); + if (isInSVG) { + var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); + var bbox = node.parentElement.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute('class', className); + addItems.push({ + "parent": node.parentNode, + "target": rect}); + } + } + } + else if (!jQuery(node).is("button, select, textarea")) { + jQuery.each(node.childNodes, function() { + highlight(this, addItems); + }); + } + } + var addItems = []; + var result = this.each(function() { + highlight(this, addItems); + }); + for (var i = 0; i < addItems.length; ++i) { + jQuery(addItems[i].parent).before(addItems[i].target); + } + return result; +}; + +/* + * backward compatibility for jQuery.browser + * This will be supported until firefox bug is fixed. + */ +if (!jQuery.browser) { + jQuery.uaMatch = function(ua) { + ua = ua.toLowerCase(); + + var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || + /(webkit)[ \/]([\w.]+)/.exec(ua) || + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || + /(msie) ([\w.]+)/.exec(ua) || + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || + []; + + return { + browser: match[ 1 ] || "", + version: match[ 2 ] || "0" + }; + }; + jQuery.browser = {}; + jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; +} diff --git a/isofit-tutorials/build/html/_static/basic.css b/isofit-tutorials/build/html/_static/basic.css new file mode 100644 index 0000000..f316efc --- /dev/null +++ b/isofit-tutorials/build/html/_static/basic.css @@ -0,0 +1,925 @@ +/* + * basic.css + * ~~~~~~~~~ + * + * Sphinx stylesheet -- basic theme. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/* -- main layout ----------------------------------------------------------- */ + +div.clearer { + clear: both; +} + +div.section::after { + display: block; + content: ''; + clear: left; +} + +/* -- relbar ---------------------------------------------------------------- */ + +div.related { + width: 100%; + font-size: 90%; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* -- sidebar --------------------------------------------------------------- */ + +div.sphinxsidebarwrapper { + padding: 10px 5px 0 10px; +} + +div.sphinxsidebar { + float: left; + width: 230px; + margin-left: -100%; + font-size: 90%; + word-wrap: break-word; + overflow-wrap : break-word; +} + +div.sphinxsidebar ul { + list-style: none; +} + +div.sphinxsidebar ul ul, +div.sphinxsidebar ul.want-points { + margin-left: 20px; + list-style: square; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar #searchbox form.search { + overflow: hidden; +} + +div.sphinxsidebar #searchbox input[type="text"] { + float: left; + width: 80%; + padding: 0.25em; + box-sizing: border-box; +} + +div.sphinxsidebar #searchbox input[type="submit"] { + float: left; + width: 20%; + border-left: none; + padding: 0.25em; + box-sizing: border-box; +} + + +img { + border: 0; + max-width: 100%; +} + +/* -- search page ----------------------------------------------------------- */ + +ul.search { + margin: 10px 0 0 20px; + padding: 0; +} + +ul.search li { + padding: 5px 0 5px 20px; + background-image: url(file.png); + background-repeat: no-repeat; + background-position: 0 7px; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li p.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* -- index page ------------------------------------------------------------ */ + +table.contentstable { + width: 90%; + margin-left: auto; + margin-right: auto; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +/* -- general index --------------------------------------------------------- */ + +table.indextable { + width: 100%; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable ul { + margin-top: 0; + margin-bottom: 0; + list-style-type: none; +} + +table.indextable > tbody > tr > td > ul { + padding-left: 0em; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +div.modindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +div.genindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +/* -- domain module index --------------------------------------------------- */ + +table.modindextable td { + padding: 2px; + border-collapse: collapse; +} + +/* -- general body styles --------------------------------------------------- */ + +div.body { + min-width: 360px; + max-width: 800px; +} + +div.body p, div.body dd, div.body li, div.body blockquote { + -moz-hyphens: auto; + -ms-hyphens: auto; + -webkit-hyphens: auto; + hyphens: auto; +} + +a.headerlink { + visibility: hidden; +} + +a:visited { + color: #551A8B; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink, +caption:hover > a.headerlink, +p.caption:hover > a.headerlink, +div.code-block-caption:hover > a.headerlink { + visibility: visible; +} + +div.body p.caption { + text-align: inherit; +} + +div.body td { + text-align: left; +} + +.first { + margin-top: 0 !important; +} + +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +img.align-left, figure.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; +} + +img.align-right, figure.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; +} + +img.align-center, figure.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; +} + +img.align-default, figure.align-default, .figure.align-default { + display: block; + margin-left: auto; + margin-right: auto; +} + +.align-left { + text-align: left; +} + +.align-center { + text-align: center; +} + +.align-default { + text-align: center; +} + +.align-right { + text-align: right; +} + +/* -- sidebars -------------------------------------------------------------- */ + +div.sidebar, +aside.sidebar { + margin: 0 0 0.5em 1em; + border: 1px solid #ddb; + padding: 7px; + background-color: #ffe; + width: 40%; + float: right; + clear: right; + overflow-x: auto; +} + +p.sidebar-title { + font-weight: bold; +} + +nav.contents, +aside.topic, +div.admonition, div.topic, blockquote { + clear: left; +} + +/* -- topics ---------------------------------------------------------------- */ + +nav.contents, +aside.topic, +div.topic { + border: 1px solid #ccc; + padding: 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* -- admonitions ----------------------------------------------------------- */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +/* -- content of sidebars/topics/admonitions -------------------------------- */ + +div.sidebar > :last-child, +aside.sidebar > :last-child, +nav.contents > :last-child, +aside.topic > :last-child, +div.topic > :last-child, +div.admonition > :last-child { + margin-bottom: 0; +} + +div.sidebar::after, +aside.sidebar::after, +nav.contents::after, +aside.topic::after, +div.topic::after, +div.admonition::after, +blockquote::after { + display: block; + content: ''; + clear: both; +} + +/* -- tables ---------------------------------------------------------------- */ + +table.docutils { + margin-top: 10px; + margin-bottom: 10px; + border: 0; + border-collapse: collapse; +} + +table.align-center { + margin-left: auto; + margin-right: auto; +} + +table.align-default { + margin-left: auto; + margin-right: auto; +} + +table caption span.caption-number { + font-style: italic; +} + +table caption span.caption-text { +} + +table.docutils td, table.docutils th { + padding: 1px 8px 1px 5px; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +th { + text-align: left; + padding-right: 5px; +} + +table.citation { + border-left: solid 1px gray; + margin-left: 1px; +} + +table.citation td { + border-bottom: none; +} + +th > :first-child, +td > :first-child { + margin-top: 0px; +} + +th > :last-child, +td > :last-child { + margin-bottom: 0px; +} + +/* -- figures --------------------------------------------------------------- */ + +div.figure, figure { + margin: 0.5em; + padding: 0.5em; +} + +div.figure p.caption, figcaption { + padding: 0.3em; +} + +div.figure p.caption span.caption-number, +figcaption span.caption-number { + font-style: italic; +} + +div.figure p.caption span.caption-text, +figcaption span.caption-text { +} + +/* -- field list styles ----------------------------------------------------- */ + +table.field-list td, table.field-list th { + border: 0 !important; +} + +.field-list ul { + margin: 0; + padding-left: 1em; +} + +.field-list p { + margin: 0; +} + +.field-name { + -moz-hyphens: manual; + -ms-hyphens: manual; + -webkit-hyphens: manual; + hyphens: manual; +} + +/* -- hlist styles ---------------------------------------------------------- */ + +table.hlist { + margin: 1em 0; +} + +table.hlist td { + vertical-align: top; +} + +/* -- object description styles --------------------------------------------- */ + +.sig { + font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; +} + +.sig-name, code.descname { + background-color: transparent; + font-weight: bold; +} + +.sig-name { + font-size: 1.1em; +} + +code.descname { + font-size: 1.2em; +} + +.sig-prename, code.descclassname { + background-color: transparent; +} + +.optional { + font-size: 1.3em; +} + +.sig-paren { + font-size: larger; +} + +.sig-param.n { + font-style: italic; +} + +/* C++ specific styling */ + +.sig-inline.c-texpr, +.sig-inline.cpp-texpr { + font-family: unset; +} + +.sig.c .k, .sig.c .kt, +.sig.cpp .k, .sig.cpp .kt { + color: #0033B3; +} + +.sig.c .m, +.sig.cpp .m { + color: #1750EB; +} + +.sig.c .s, .sig.c .sc, +.sig.cpp .s, .sig.cpp .sc { + color: #067D17; +} + + +/* -- other body styles ----------------------------------------------------- */ + +ol.arabic { + list-style: decimal; +} + +ol.loweralpha { + list-style: lower-alpha; +} + +ol.upperalpha { + list-style: upper-alpha; +} + +ol.lowerroman { + list-style: lower-roman; +} + +ol.upperroman { + list-style: upper-roman; +} + +:not(li) > ol > li:first-child > :first-child, +:not(li) > ul > li:first-child > :first-child { + margin-top: 0px; +} + +:not(li) > ol > li:last-child > :last-child, +:not(li) > ul > li:last-child > :last-child { + margin-bottom: 0px; +} + +ol.simple ol p, +ol.simple ul p, +ul.simple ol p, +ul.simple ul p { + margin-top: 0; +} + +ol.simple > li:not(:first-child) > p, +ul.simple > li:not(:first-child) > p { + margin-top: 0; +} + +ol.simple p, +ul.simple p { + margin-bottom: 0; +} + +aside.footnote > span, +div.citation > span { + float: left; +} +aside.footnote > span:last-of-type, +div.citation > span:last-of-type { + padding-right: 0.5em; +} +aside.footnote > p { + margin-left: 2em; +} +div.citation > p { + margin-left: 4em; +} +aside.footnote > p:last-of-type, +div.citation > p:last-of-type { + margin-bottom: 0em; +} +aside.footnote > p:last-of-type:after, +div.citation > p:last-of-type:after { + content: ""; + clear: both; +} + +dl.field-list { + display: grid; + grid-template-columns: fit-content(30%) auto; +} + +dl.field-list > dt { + font-weight: bold; + word-break: break-word; + padding-left: 0.5em; + padding-right: 5px; +} + +dl.field-list > dd { + padding-left: 0.5em; + margin-top: 0em; + margin-left: 0em; + margin-bottom: 0em; +} + +dl { + margin-bottom: 15px; +} + +dd > :first-child { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +.sig dd { + margin-top: 0px; + margin-bottom: 0px; +} + +.sig dl { + margin-top: 0px; + margin-bottom: 0px; +} + +dl > dd:last-child, +dl > dd:last-child > :last-child { + margin-bottom: 0; +} + +dt:target, span.highlighted { + background-color: #fbe54e; +} + +rect.highlighted { + fill: #fbe54e; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +.versionmodified { + font-style: italic; +} + +.system-message { + background-color: #fda; + padding: 5px; + border: 3px solid red; +} + +.footnote:target { + background-color: #ffa; +} + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +.guilabel, .menuselection { + font-family: sans-serif; +} + +.accelerator { + text-decoration: underline; +} + +.classifier { + font-style: oblique; +} + +.classifier:before { + font-style: normal; + margin: 0 0.5em; + content: ":"; + display: inline-block; +} + +abbr, acronym { + border-bottom: dotted 1px; + cursor: help; +} + +.translated { + background-color: rgba(207, 255, 207, 0.2) +} + +.untranslated { + background-color: rgba(255, 207, 207, 0.2) +} + +/* -- code displays --------------------------------------------------------- */ + +pre { + overflow: auto; + overflow-y: hidden; /* fixes display issues on Chrome browsers */ +} + +pre, div[class*="highlight-"] { + clear: both; +} + +span.pre { + -moz-hyphens: none; + -ms-hyphens: none; + -webkit-hyphens: none; + hyphens: none; + white-space: nowrap; +} + +div[class*="highlight-"] { + margin: 1em 0; +} + +td.linenos pre { + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + display: block; +} + +table.highlighttable tbody { + display: block; +} + +table.highlighttable tr { + display: flex; +} + +table.highlighttable td { + margin: 0; + padding: 0; +} + +table.highlighttable td.linenos { + padding-right: 0.5em; +} + +table.highlighttable td.code { + flex: 1; + overflow: hidden; +} + +.highlight .hll { + display: block; +} + +div.highlight pre, +table.highlighttable pre { + margin: 0; +} + +div.code-block-caption + div { + margin-top: 0; +} + +div.code-block-caption { + margin-top: 1em; + padding: 2px 5px; + font-size: small; +} + +div.code-block-caption code { + background-color: transparent; +} + +table.highlighttable td.linenos, +span.linenos, +div.highlight span.gp { /* gp: Generic.Prompt */ + user-select: none; + -webkit-user-select: text; /* Safari fallback only */ + -webkit-user-select: none; /* Chrome/Safari */ + -moz-user-select: none; /* Firefox */ + -ms-user-select: none; /* IE10+ */ +} + +div.code-block-caption span.caption-number { + padding: 0.1em 0.3em; + font-style: italic; +} + +div.code-block-caption span.caption-text { +} + +div.literal-block-wrapper { + margin: 1em 0; +} + +code.xref, a code { + background-color: transparent; + font-weight: bold; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + background-color: transparent; +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: sans-serif; +} + +div.viewcode-block:target { + margin: -1px -10px; + padding: 0 10px; +} + +/* -- math display ---------------------------------------------------------- */ + +img.math { + vertical-align: middle; +} + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} + +span.eqno a.headerlink { + position: absolute; + z-index: 1; +} + +div.math:hover a.headerlink { + visibility: visible; +} + +/* -- printout stylesheet --------------------------------------------------- */ + +@media print { + div.document, + div.documentwrapper, + div.bodywrapper { + margin: 0 !important; + width: 100%; + } + + div.sphinxsidebar, + div.related, + div.footer, + #top-link { + display: none; + } +} \ No newline at end of file diff --git a/isofit-tutorials/build/html/_static/css/badge_only.css b/isofit-tutorials/build/html/_static/css/badge_only.css new file mode 100644 index 0000000..c718cee --- /dev/null +++ b/isofit-tutorials/build/html/_static/css/badge_only.css @@ -0,0 +1 @@ +.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}} \ No newline at end of file diff --git a/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Bold.woff b/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Bold.woff new file mode 100644 index 0000000..6cb6000 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Bold.woff differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Bold.woff2 b/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Bold.woff2 new file mode 100644 index 0000000..7059e23 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Bold.woff2 differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Regular.woff b/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Regular.woff new file mode 100644 index 0000000..f815f63 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Regular.woff differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Regular.woff2 b/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Regular.woff2 new file mode 100644 index 0000000..f2c76e5 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/Roboto-Slab-Regular.woff2 differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.eot b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.eot new file mode 100644 index 0000000..e9f60ca Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.eot differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.svg b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.svg new file mode 100644 index 0000000..855c845 --- /dev/null +++ b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.svg @@ -0,0 +1,2671 @@ + + + + +Created by FontForge 20120731 at Mon Oct 24 17:37:40 2016 + By ,,, +Copyright Dave Gandy 2016. All rights reserved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.ttf b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.ttf new file mode 100644 index 0000000..35acda2 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.ttf differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.woff b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.woff new file mode 100644 index 0000000..400014a Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.woff differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.woff2 b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.woff2 new file mode 100644 index 0000000..4d13fc6 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/fontawesome-webfont.woff2 differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/lato-bold-italic.woff b/isofit-tutorials/build/html/_static/css/fonts/lato-bold-italic.woff new file mode 100644 index 0000000..88ad05b Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/lato-bold-italic.woff differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/lato-bold-italic.woff2 b/isofit-tutorials/build/html/_static/css/fonts/lato-bold-italic.woff2 new file mode 100644 index 0000000..c4e3d80 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/lato-bold-italic.woff2 differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/lato-bold.woff b/isofit-tutorials/build/html/_static/css/fonts/lato-bold.woff new file mode 100644 index 0000000..c6dff51 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/lato-bold.woff differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/lato-bold.woff2 b/isofit-tutorials/build/html/_static/css/fonts/lato-bold.woff2 new file mode 100644 index 0000000..bb19504 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/lato-bold.woff2 differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/lato-normal-italic.woff b/isofit-tutorials/build/html/_static/css/fonts/lato-normal-italic.woff new file mode 100644 index 0000000..76114bc Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/lato-normal-italic.woff differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/lato-normal-italic.woff2 b/isofit-tutorials/build/html/_static/css/fonts/lato-normal-italic.woff2 new file mode 100644 index 0000000..3404f37 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/lato-normal-italic.woff2 differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/lato-normal.woff b/isofit-tutorials/build/html/_static/css/fonts/lato-normal.woff new file mode 100644 index 0000000..ae1307f Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/lato-normal.woff differ diff --git a/isofit-tutorials/build/html/_static/css/fonts/lato-normal.woff2 b/isofit-tutorials/build/html/_static/css/fonts/lato-normal.woff2 new file mode 100644 index 0000000..3bf9843 Binary files /dev/null and b/isofit-tutorials/build/html/_static/css/fonts/lato-normal.woff2 differ diff --git a/isofit-tutorials/build/html/_static/css/theme.css b/isofit-tutorials/build/html/_static/css/theme.css new file mode 100644 index 0000000..19a446a --- /dev/null +++ b/isofit-tutorials/build/html/_static/css/theme.css @@ -0,0 +1,4 @@ +html{box-sizing:border-box}*,:after,:before{box-sizing:inherit}article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}[hidden],audio:not([controls]){display:none}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}blockquote{margin:0}dfn{font-style:italic}ins{background:#ff9;text-decoration:none}ins,mark{color:#000}mark{background:#ff0;font-style:italic;font-weight:700}.rst-content code,.rst-content tt,code,kbd,pre,samp{font-family:monospace,serif;_font-family:courier new,monospace;font-size:1em}pre{white-space:pre}q{quotes:none}q:after,q:before{content:"";content:none}small{font-size:85%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}dl,ol,ul{margin:0;padding:0;list-style:none;list-style-image:none}li{list-style:none}dd{margin:0}img{border:0;-ms-interpolation-mode:bicubic;vertical-align:middle;max-width:100%}svg:not(:root){overflow:hidden}figure,form{margin:0}label{cursor:pointer}button,input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}button,input{line-height:normal}button,input[type=button],input[type=reset],input[type=submit]{cursor:pointer;-webkit-appearance:button;*overflow:visible}button[disabled],input[disabled]{cursor:default}input[type=search]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}textarea{resize:vertical}table{border-collapse:collapse;border-spacing:0}td{vertical-align:top}.chromeframe{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}.ir{display:block;border:0;text-indent:-999em;overflow:hidden;background-color:transparent;background-repeat:no-repeat;text-align:left;direction:ltr;*line-height:0}.ir br{display:none}.hidden{display:none!important;visibility:hidden}.visuallyhidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.visuallyhidden.focusable:active,.visuallyhidden.focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}.invisible{visibility:hidden}.relative{position:relative}big,small{font-size:100%}@media print{body,html,section{background:none!important}*{box-shadow:none!important;text-shadow:none!important;filter:none!important;-ms-filter:none!important}a,a:visited{text-decoration:underline}.ir a:after,a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}.rst-content .toctree-wrapper>p.caption,h2,h3,p{orphans:3;widows:3}.rst-content .toctree-wrapper>p.caption,h2,h3{page-break-after:avoid}}.btn,.fa:before,.icon:before,.rst-content .admonition,.rst-content .admonition-title:before,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .code-block-caption .headerlink:before,.rst-content .danger,.rst-content .eqno .headerlink:before,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-alert,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before,input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week],select,textarea{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}/*! + * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome + * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) + */@font-face{font-family:FontAwesome;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713);src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix&v=4.7.0) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#fontawesomeregular) format("svg");font-weight:400;font-style:normal}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14286em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14286em;width:2.14286em;top:.14286em;text-align:center}.fa-li.fa-lg{left:-1.85714em}.fa-border{padding:.2em .25em .15em;border:.08em solid #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa-pull-left.icon,.fa.fa-pull-left,.rst-content .code-block-caption .fa-pull-left.headerlink,.rst-content .eqno .fa-pull-left.headerlink,.rst-content .fa-pull-left.admonition-title,.rst-content code.download span.fa-pull-left:first-child,.rst-content dl dt .fa-pull-left.headerlink,.rst-content h1 .fa-pull-left.headerlink,.rst-content h2 .fa-pull-left.headerlink,.rst-content h3 .fa-pull-left.headerlink,.rst-content h4 .fa-pull-left.headerlink,.rst-content h5 .fa-pull-left.headerlink,.rst-content h6 .fa-pull-left.headerlink,.rst-content p .fa-pull-left.headerlink,.rst-content table>caption .fa-pull-left.headerlink,.rst-content tt.download span.fa-pull-left:first-child,.wy-menu-vertical li.current>a button.fa-pull-left.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-left.toctree-expand,.wy-menu-vertical li button.fa-pull-left.toctree-expand{margin-right:.3em}.fa-pull-right.icon,.fa.fa-pull-right,.rst-content .code-block-caption .fa-pull-right.headerlink,.rst-content .eqno .fa-pull-right.headerlink,.rst-content .fa-pull-right.admonition-title,.rst-content code.download span.fa-pull-right:first-child,.rst-content dl dt .fa-pull-right.headerlink,.rst-content h1 .fa-pull-right.headerlink,.rst-content h2 .fa-pull-right.headerlink,.rst-content h3 .fa-pull-right.headerlink,.rst-content h4 .fa-pull-right.headerlink,.rst-content h5 .fa-pull-right.headerlink,.rst-content h6 .fa-pull-right.headerlink,.rst-content p .fa-pull-right.headerlink,.rst-content table>caption .fa-pull-right.headerlink,.rst-content tt.download span.fa-pull-right:first-child,.wy-menu-vertical li.current>a button.fa-pull-right.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-right.toctree-expand,.wy-menu-vertical li button.fa-pull-right.toctree-expand{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left,.pull-left.icon,.rst-content .code-block-caption .pull-left.headerlink,.rst-content .eqno .pull-left.headerlink,.rst-content .pull-left.admonition-title,.rst-content code.download span.pull-left:first-child,.rst-content dl dt .pull-left.headerlink,.rst-content h1 .pull-left.headerlink,.rst-content h2 .pull-left.headerlink,.rst-content h3 .pull-left.headerlink,.rst-content h4 .pull-left.headerlink,.rst-content h5 .pull-left.headerlink,.rst-content h6 .pull-left.headerlink,.rst-content p .pull-left.headerlink,.rst-content table>caption .pull-left.headerlink,.rst-content tt.download span.pull-left:first-child,.wy-menu-vertical li.current>a button.pull-left.toctree-expand,.wy-menu-vertical li.on a button.pull-left.toctree-expand,.wy-menu-vertical li button.pull-left.toctree-expand{margin-right:.3em}.fa.pull-right,.pull-right.icon,.rst-content .code-block-caption .pull-right.headerlink,.rst-content .eqno .pull-right.headerlink,.rst-content .pull-right.admonition-title,.rst-content code.download span.pull-right:first-child,.rst-content dl dt .pull-right.headerlink,.rst-content h1 .pull-right.headerlink,.rst-content h2 .pull-right.headerlink,.rst-content h3 .pull-right.headerlink,.rst-content h4 .pull-right.headerlink,.rst-content h5 .pull-right.headerlink,.rst-content h6 .pull-right.headerlink,.rst-content p .pull-right.headerlink,.rst-content table>caption .pull-right.headerlink,.rst-content tt.download span.pull-right:first-child,.wy-menu-vertical li.current>a button.pull-right.toctree-expand,.wy-menu-vertical li.on a button.pull-right.toctree-expand,.wy-menu-vertical li button.pull-right.toctree-expand{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);-ms-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scaleY(-1);-ms-transform:scaleY(-1);transform:scaleY(-1)}:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:""}.fa-music:before{content:""}.fa-search:before,.icon-search:before{content:""}.fa-envelope-o:before{content:""}.fa-heart:before{content:""}.fa-star:before{content:""}.fa-star-o:before{content:""}.fa-user:before{content:""}.fa-film:before{content:""}.fa-th-large:before{content:""}.fa-th:before{content:""}.fa-th-list:before{content:""}.fa-check:before{content:""}.fa-close:before,.fa-remove:before,.fa-times:before{content:""}.fa-search-plus:before{content:""}.fa-search-minus:before{content:""}.fa-power-off:before{content:""}.fa-signal:before{content:""}.fa-cog:before,.fa-gear:before{content:""}.fa-trash-o:before{content:""}.fa-home:before,.icon-home:before{content:""}.fa-file-o:before{content:""}.fa-clock-o:before{content:""}.fa-road:before{content:""}.fa-download:before,.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{content:""}.fa-arrow-circle-o-down:before{content:""}.fa-arrow-circle-o-up:before{content:""}.fa-inbox:before{content:""}.fa-play-circle-o:before{content:""}.fa-repeat:before,.fa-rotate-right:before{content:""}.fa-refresh:before{content:""}.fa-list-alt:before{content:""}.fa-lock:before{content:""}.fa-flag:before{content:""}.fa-headphones:before{content:""}.fa-volume-off:before{content:""}.fa-volume-down:before{content:""}.fa-volume-up:before{content:""}.fa-qrcode:before{content:""}.fa-barcode:before{content:""}.fa-tag:before{content:""}.fa-tags:before{content:""}.fa-book:before,.icon-book:before{content:""}.fa-bookmark:before{content:""}.fa-print:before{content:""}.fa-camera:before{content:""}.fa-font:before{content:""}.fa-bold:before{content:""}.fa-italic:before{content:""}.fa-text-height:before{content:""}.fa-text-width:before{content:""}.fa-align-left:before{content:""}.fa-align-center:before{content:""}.fa-align-right:before{content:""}.fa-align-justify:before{content:""}.fa-list:before{content:""}.fa-dedent:before,.fa-outdent:before{content:""}.fa-indent:before{content:""}.fa-video-camera:before{content:""}.fa-image:before,.fa-photo:before,.fa-picture-o:before{content:""}.fa-pencil:before{content:""}.fa-map-marker:before{content:""}.fa-adjust:before{content:""}.fa-tint:before{content:""}.fa-edit:before,.fa-pencil-square-o:before{content:""}.fa-share-square-o:before{content:""}.fa-check-square-o:before{content:""}.fa-arrows:before{content:""}.fa-step-backward:before{content:""}.fa-fast-backward:before{content:""}.fa-backward:before{content:""}.fa-play:before{content:""}.fa-pause:before{content:""}.fa-stop:before{content:""}.fa-forward:before{content:""}.fa-fast-forward:before{content:""}.fa-step-forward:before{content:""}.fa-eject:before{content:""}.fa-chevron-left:before{content:""}.fa-chevron-right:before{content:""}.fa-plus-circle:before{content:""}.fa-minus-circle:before{content:""}.fa-times-circle:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before{content:""}.fa-check-circle:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before{content:""}.fa-question-circle:before{content:""}.fa-info-circle:before{content:""}.fa-crosshairs:before{content:""}.fa-times-circle-o:before{content:""}.fa-check-circle-o:before{content:""}.fa-ban:before{content:""}.fa-arrow-left:before{content:""}.fa-arrow-right:before{content:""}.fa-arrow-up:before{content:""}.fa-arrow-down:before{content:""}.fa-mail-forward:before,.fa-share:before{content:""}.fa-expand:before{content:""}.fa-compress:before{content:""}.fa-plus:before{content:""}.fa-minus:before{content:""}.fa-asterisk:before{content:""}.fa-exclamation-circle:before,.rst-content .admonition-title:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before{content:""}.fa-gift:before{content:""}.fa-leaf:before{content:""}.fa-fire:before,.icon-fire:before{content:""}.fa-eye:before{content:""}.fa-eye-slash:before{content:""}.fa-exclamation-triangle:before,.fa-warning:before{content:""}.fa-plane:before{content:""}.fa-calendar:before{content:""}.fa-random:before{content:""}.fa-comment:before{content:""}.fa-magnet:before{content:""}.fa-chevron-up:before{content:""}.fa-chevron-down:before{content:""}.fa-retweet:before{content:""}.fa-shopping-cart:before{content:""}.fa-folder:before{content:""}.fa-folder-open:before{content:""}.fa-arrows-v:before{content:""}.fa-arrows-h:before{content:""}.fa-bar-chart-o:before,.fa-bar-chart:before{content:""}.fa-twitter-square:before{content:""}.fa-facebook-square:before{content:""}.fa-camera-retro:before{content:""}.fa-key:before{content:""}.fa-cogs:before,.fa-gears:before{content:""}.fa-comments:before{content:""}.fa-thumbs-o-up:before{content:""}.fa-thumbs-o-down:before{content:""}.fa-star-half:before{content:""}.fa-heart-o:before{content:""}.fa-sign-out:before{content:""}.fa-linkedin-square:before{content:""}.fa-thumb-tack:before{content:""}.fa-external-link:before{content:""}.fa-sign-in:before{content:""}.fa-trophy:before{content:""}.fa-github-square:before{content:""}.fa-upload:before{content:""}.fa-lemon-o:before{content:""}.fa-phone:before{content:""}.fa-square-o:before{content:""}.fa-bookmark-o:before{content:""}.fa-phone-square:before{content:""}.fa-twitter:before{content:""}.fa-facebook-f:before,.fa-facebook:before{content:""}.fa-github:before,.icon-github:before{content:""}.fa-unlock:before{content:""}.fa-credit-card:before{content:""}.fa-feed:before,.fa-rss:before{content:""}.fa-hdd-o:before{content:""}.fa-bullhorn:before{content:""}.fa-bell:before{content:""}.fa-certificate:before{content:""}.fa-hand-o-right:before{content:""}.fa-hand-o-left:before{content:""}.fa-hand-o-up:before{content:""}.fa-hand-o-down:before{content:""}.fa-arrow-circle-left:before,.icon-circle-arrow-left:before{content:""}.fa-arrow-circle-right:before,.icon-circle-arrow-right:before{content:""}.fa-arrow-circle-up:before{content:""}.fa-arrow-circle-down:before{content:""}.fa-globe:before{content:""}.fa-wrench:before{content:""}.fa-tasks:before{content:""}.fa-filter:before{content:""}.fa-briefcase:before{content:""}.fa-arrows-alt:before{content:""}.fa-group:before,.fa-users:before{content:""}.fa-chain:before,.fa-link:before,.icon-link:before{content:""}.fa-cloud:before{content:""}.fa-flask:before{content:""}.fa-cut:before,.fa-scissors:before{content:""}.fa-copy:before,.fa-files-o:before{content:""}.fa-paperclip:before{content:""}.fa-floppy-o:before,.fa-save:before{content:""}.fa-square:before{content:""}.fa-bars:before,.fa-navicon:before,.fa-reorder:before{content:""}.fa-list-ul:before{content:""}.fa-list-ol:before{content:""}.fa-strikethrough:before{content:""}.fa-underline:before{content:""}.fa-table:before{content:""}.fa-magic:before{content:""}.fa-truck:before{content:""}.fa-pinterest:before{content:""}.fa-pinterest-square:before{content:""}.fa-google-plus-square:before{content:""}.fa-google-plus:before{content:""}.fa-money:before{content:""}.fa-caret-down:before,.icon-caret-down:before,.wy-dropdown .caret:before{content:""}.fa-caret-up:before{content:""}.fa-caret-left:before{content:""}.fa-caret-right:before{content:""}.fa-columns:before{content:""}.fa-sort:before,.fa-unsorted:before{content:""}.fa-sort-desc:before,.fa-sort-down:before{content:""}.fa-sort-asc:before,.fa-sort-up:before{content:""}.fa-envelope:before{content:""}.fa-linkedin:before{content:""}.fa-rotate-left:before,.fa-undo:before{content:""}.fa-gavel:before,.fa-legal:before{content:""}.fa-dashboard:before,.fa-tachometer:before{content:""}.fa-comment-o:before{content:""}.fa-comments-o:before{content:""}.fa-bolt:before,.fa-flash:before{content:""}.fa-sitemap:before{content:""}.fa-umbrella:before{content:""}.fa-clipboard:before,.fa-paste:before{content:""}.fa-lightbulb-o:before{content:""}.fa-exchange:before{content:""}.fa-cloud-download:before{content:""}.fa-cloud-upload:before{content:""}.fa-user-md:before{content:""}.fa-stethoscope:before{content:""}.fa-suitcase:before{content:""}.fa-bell-o:before{content:""}.fa-coffee:before{content:""}.fa-cutlery:before{content:""}.fa-file-text-o:before{content:""}.fa-building-o:before{content:""}.fa-hospital-o:before{content:""}.fa-ambulance:before{content:""}.fa-medkit:before{content:""}.fa-fighter-jet:before{content:""}.fa-beer:before{content:""}.fa-h-square:before{content:""}.fa-plus-square:before{content:""}.fa-angle-double-left:before{content:""}.fa-angle-double-right:before{content:""}.fa-angle-double-up:before{content:""}.fa-angle-double-down:before{content:""}.fa-angle-left:before{content:""}.fa-angle-right:before{content:""}.fa-angle-up:before{content:""}.fa-angle-down:before{content:""}.fa-desktop:before{content:""}.fa-laptop:before{content:""}.fa-tablet:before{content:""}.fa-mobile-phone:before,.fa-mobile:before{content:""}.fa-circle-o:before{content:""}.fa-quote-left:before{content:""}.fa-quote-right:before{content:""}.fa-spinner:before{content:""}.fa-circle:before{content:""}.fa-mail-reply:before,.fa-reply:before{content:""}.fa-github-alt:before{content:""}.fa-folder-o:before{content:""}.fa-folder-open-o:before{content:""}.fa-smile-o:before{content:""}.fa-frown-o:before{content:""}.fa-meh-o:before{content:""}.fa-gamepad:before{content:""}.fa-keyboard-o:before{content:""}.fa-flag-o:before{content:""}.fa-flag-checkered:before{content:""}.fa-terminal:before{content:""}.fa-code:before{content:""}.fa-mail-reply-all:before,.fa-reply-all:before{content:""}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:""}.fa-location-arrow:before{content:""}.fa-crop:before{content:""}.fa-code-fork:before{content:""}.fa-chain-broken:before,.fa-unlink:before{content:""}.fa-question:before{content:""}.fa-info:before{content:""}.fa-exclamation:before{content:""}.fa-superscript:before{content:""}.fa-subscript:before{content:""}.fa-eraser:before{content:""}.fa-puzzle-piece:before{content:""}.fa-microphone:before{content:""}.fa-microphone-slash:before{content:""}.fa-shield:before{content:""}.fa-calendar-o:before{content:""}.fa-fire-extinguisher:before{content:""}.fa-rocket:before{content:""}.fa-maxcdn:before{content:""}.fa-chevron-circle-left:before{content:""}.fa-chevron-circle-right:before{content:""}.fa-chevron-circle-up:before{content:""}.fa-chevron-circle-down:before{content:""}.fa-html5:before{content:""}.fa-css3:before{content:""}.fa-anchor:before{content:""}.fa-unlock-alt:before{content:""}.fa-bullseye:before{content:""}.fa-ellipsis-h:before{content:""}.fa-ellipsis-v:before{content:""}.fa-rss-square:before{content:""}.fa-play-circle:before{content:""}.fa-ticket:before{content:""}.fa-minus-square:before{content:""}.fa-minus-square-o:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before{content:""}.fa-level-up:before{content:""}.fa-level-down:before{content:""}.fa-check-square:before{content:""}.fa-pencil-square:before{content:""}.fa-external-link-square:before{content:""}.fa-share-square:before{content:""}.fa-compass:before{content:""}.fa-caret-square-o-down:before,.fa-toggle-down:before{content:""}.fa-caret-square-o-up:before,.fa-toggle-up:before{content:""}.fa-caret-square-o-right:before,.fa-toggle-right:before{content:""}.fa-eur:before,.fa-euro:before{content:""}.fa-gbp:before{content:""}.fa-dollar:before,.fa-usd:before{content:""}.fa-inr:before,.fa-rupee:before{content:""}.fa-cny:before,.fa-jpy:before,.fa-rmb:before,.fa-yen:before{content:""}.fa-rouble:before,.fa-rub:before,.fa-ruble:before{content:""}.fa-krw:before,.fa-won:before{content:""}.fa-bitcoin:before,.fa-btc:before{content:""}.fa-file:before{content:""}.fa-file-text:before{content:""}.fa-sort-alpha-asc:before{content:""}.fa-sort-alpha-desc:before{content:""}.fa-sort-amount-asc:before{content:""}.fa-sort-amount-desc:before{content:""}.fa-sort-numeric-asc:before{content:""}.fa-sort-numeric-desc:before{content:""}.fa-thumbs-up:before{content:""}.fa-thumbs-down:before{content:""}.fa-youtube-square:before{content:""}.fa-youtube:before{content:""}.fa-xing:before{content:""}.fa-xing-square:before{content:""}.fa-youtube-play:before{content:""}.fa-dropbox:before{content:""}.fa-stack-overflow:before{content:""}.fa-instagram:before{content:""}.fa-flickr:before{content:""}.fa-adn:before{content:""}.fa-bitbucket:before,.icon-bitbucket:before{content:""}.fa-bitbucket-square:before{content:""}.fa-tumblr:before{content:""}.fa-tumblr-square:before{content:""}.fa-long-arrow-down:before{content:""}.fa-long-arrow-up:before{content:""}.fa-long-arrow-left:before{content:""}.fa-long-arrow-right:before{content:""}.fa-apple:before{content:""}.fa-windows:before{content:""}.fa-android:before{content:""}.fa-linux:before{content:""}.fa-dribbble:before{content:""}.fa-skype:before{content:""}.fa-foursquare:before{content:""}.fa-trello:before{content:""}.fa-female:before{content:""}.fa-male:before{content:""}.fa-gittip:before,.fa-gratipay:before{content:""}.fa-sun-o:before{content:""}.fa-moon-o:before{content:""}.fa-archive:before{content:""}.fa-bug:before{content:""}.fa-vk:before{content:""}.fa-weibo:before{content:""}.fa-renren:before{content:""}.fa-pagelines:before{content:""}.fa-stack-exchange:before{content:""}.fa-arrow-circle-o-right:before{content:""}.fa-arrow-circle-o-left:before{content:""}.fa-caret-square-o-left:before,.fa-toggle-left:before{content:""}.fa-dot-circle-o:before{content:""}.fa-wheelchair:before{content:""}.fa-vimeo-square:before{content:""}.fa-try:before,.fa-turkish-lira:before{content:""}.fa-plus-square-o:before,.wy-menu-vertical li button.toctree-expand:before{content:""}.fa-space-shuttle:before{content:""}.fa-slack:before{content:""}.fa-envelope-square:before{content:""}.fa-wordpress:before{content:""}.fa-openid:before{content:""}.fa-bank:before,.fa-institution:before,.fa-university:before{content:""}.fa-graduation-cap:before,.fa-mortar-board:before{content:""}.fa-yahoo:before{content:""}.fa-google:before{content:""}.fa-reddit:before{content:""}.fa-reddit-square:before{content:""}.fa-stumbleupon-circle:before{content:""}.fa-stumbleupon:before{content:""}.fa-delicious:before{content:""}.fa-digg:before{content:""}.fa-pied-piper-pp:before{content:""}.fa-pied-piper-alt:before{content:""}.fa-drupal:before{content:""}.fa-joomla:before{content:""}.fa-language:before{content:""}.fa-fax:before{content:""}.fa-building:before{content:""}.fa-child:before{content:""}.fa-paw:before{content:""}.fa-spoon:before{content:""}.fa-cube:before{content:""}.fa-cubes:before{content:""}.fa-behance:before{content:""}.fa-behance-square:before{content:""}.fa-steam:before{content:""}.fa-steam-square:before{content:""}.fa-recycle:before{content:""}.fa-automobile:before,.fa-car:before{content:""}.fa-cab:before,.fa-taxi:before{content:""}.fa-tree:before{content:""}.fa-spotify:before{content:""}.fa-deviantart:before{content:""}.fa-soundcloud:before{content:""}.fa-database:before{content:""}.fa-file-pdf-o:before{content:""}.fa-file-word-o:before{content:""}.fa-file-excel-o:before{content:""}.fa-file-powerpoint-o:before{content:""}.fa-file-image-o:before,.fa-file-photo-o:before,.fa-file-picture-o:before{content:""}.fa-file-archive-o:before,.fa-file-zip-o:before{content:""}.fa-file-audio-o:before,.fa-file-sound-o:before{content:""}.fa-file-movie-o:before,.fa-file-video-o:before{content:""}.fa-file-code-o:before{content:""}.fa-vine:before{content:""}.fa-codepen:before{content:""}.fa-jsfiddle:before{content:""}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-ring:before,.fa-life-saver:before,.fa-support:before{content:""}.fa-circle-o-notch:before{content:""}.fa-ra:before,.fa-rebel:before,.fa-resistance:before{content:""}.fa-empire:before,.fa-ge:before{content:""}.fa-git-square:before{content:""}.fa-git:before{content:""}.fa-hacker-news:before,.fa-y-combinator-square:before,.fa-yc-square:before{content:""}.fa-tencent-weibo:before{content:""}.fa-qq:before{content:""}.fa-wechat:before,.fa-weixin:before{content:""}.fa-paper-plane:before,.fa-send:before{content:""}.fa-paper-plane-o:before,.fa-send-o:before{content:""}.fa-history:before{content:""}.fa-circle-thin:before{content:""}.fa-header:before{content:""}.fa-paragraph:before{content:""}.fa-sliders:before{content:""}.fa-share-alt:before{content:""}.fa-share-alt-square:before{content:""}.fa-bomb:before{content:""}.fa-futbol-o:before,.fa-soccer-ball-o:before{content:""}.fa-tty:before{content:""}.fa-binoculars:before{content:""}.fa-plug:before{content:""}.fa-slideshare:before{content:""}.fa-twitch:before{content:""}.fa-yelp:before{content:""}.fa-newspaper-o:before{content:""}.fa-wifi:before{content:""}.fa-calculator:before{content:""}.fa-paypal:before{content:""}.fa-google-wallet:before{content:""}.fa-cc-visa:before{content:""}.fa-cc-mastercard:before{content:""}.fa-cc-discover:before{content:""}.fa-cc-amex:before{content:""}.fa-cc-paypal:before{content:""}.fa-cc-stripe:before{content:""}.fa-bell-slash:before{content:""}.fa-bell-slash-o:before{content:""}.fa-trash:before{content:""}.fa-copyright:before{content:""}.fa-at:before{content:""}.fa-eyedropper:before{content:""}.fa-paint-brush:before{content:""}.fa-birthday-cake:before{content:""}.fa-area-chart:before{content:""}.fa-pie-chart:before{content:""}.fa-line-chart:before{content:""}.fa-lastfm:before{content:""}.fa-lastfm-square:before{content:""}.fa-toggle-off:before{content:""}.fa-toggle-on:before{content:""}.fa-bicycle:before{content:""}.fa-bus:before{content:""}.fa-ioxhost:before{content:""}.fa-angellist:before{content:""}.fa-cc:before{content:""}.fa-ils:before,.fa-shekel:before,.fa-sheqel:before{content:""}.fa-meanpath:before{content:""}.fa-buysellads:before{content:""}.fa-connectdevelop:before{content:""}.fa-dashcube:before{content:""}.fa-forumbee:before{content:""}.fa-leanpub:before{content:""}.fa-sellsy:before{content:""}.fa-shirtsinbulk:before{content:""}.fa-simplybuilt:before{content:""}.fa-skyatlas:before{content:""}.fa-cart-plus:before{content:""}.fa-cart-arrow-down:before{content:""}.fa-diamond:before{content:""}.fa-ship:before{content:""}.fa-user-secret:before{content:""}.fa-motorcycle:before{content:""}.fa-street-view:before{content:""}.fa-heartbeat:before{content:""}.fa-venus:before{content:""}.fa-mars:before{content:""}.fa-mercury:before{content:""}.fa-intersex:before,.fa-transgender:before{content:""}.fa-transgender-alt:before{content:""}.fa-venus-double:before{content:""}.fa-mars-double:before{content:""}.fa-venus-mars:before{content:""}.fa-mars-stroke:before{content:""}.fa-mars-stroke-v:before{content:""}.fa-mars-stroke-h:before{content:""}.fa-neuter:before{content:""}.fa-genderless:before{content:""}.fa-facebook-official:before{content:""}.fa-pinterest-p:before{content:""}.fa-whatsapp:before{content:""}.fa-server:before{content:""}.fa-user-plus:before{content:""}.fa-user-times:before{content:""}.fa-bed:before,.fa-hotel:before{content:""}.fa-viacoin:before{content:""}.fa-train:before{content:""}.fa-subway:before{content:""}.fa-medium:before{content:""}.fa-y-combinator:before,.fa-yc:before{content:""}.fa-optin-monster:before{content:""}.fa-opencart:before{content:""}.fa-expeditedssl:before{content:""}.fa-battery-4:before,.fa-battery-full:before,.fa-battery:before{content:""}.fa-battery-3:before,.fa-battery-three-quarters:before{content:""}.fa-battery-2:before,.fa-battery-half:before{content:""}.fa-battery-1:before,.fa-battery-quarter:before{content:""}.fa-battery-0:before,.fa-battery-empty:before{content:""}.fa-mouse-pointer:before{content:""}.fa-i-cursor:before{content:""}.fa-object-group:before{content:""}.fa-object-ungroup:before{content:""}.fa-sticky-note:before{content:""}.fa-sticky-note-o:before{content:""}.fa-cc-jcb:before{content:""}.fa-cc-diners-club:before{content:""}.fa-clone:before{content:""}.fa-balance-scale:before{content:""}.fa-hourglass-o:before{content:""}.fa-hourglass-1:before,.fa-hourglass-start:before{content:""}.fa-hourglass-2:before,.fa-hourglass-half:before{content:""}.fa-hourglass-3:before,.fa-hourglass-end:before{content:""}.fa-hourglass:before{content:""}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:""}.fa-hand-paper-o:before,.fa-hand-stop-o:before{content:""}.fa-hand-scissors-o:before{content:""}.fa-hand-lizard-o:before{content:""}.fa-hand-spock-o:before{content:""}.fa-hand-pointer-o:before{content:""}.fa-hand-peace-o:before{content:""}.fa-trademark:before{content:""}.fa-registered:before{content:""}.fa-creative-commons:before{content:""}.fa-gg:before{content:""}.fa-gg-circle:before{content:""}.fa-tripadvisor:before{content:""}.fa-odnoklassniki:before{content:""}.fa-odnoklassniki-square:before{content:""}.fa-get-pocket:before{content:""}.fa-wikipedia-w:before{content:""}.fa-safari:before{content:""}.fa-chrome:before{content:""}.fa-firefox:before{content:""}.fa-opera:before{content:""}.fa-internet-explorer:before{content:""}.fa-television:before,.fa-tv:before{content:""}.fa-contao:before{content:""}.fa-500px:before{content:""}.fa-amazon:before{content:""}.fa-calendar-plus-o:before{content:""}.fa-calendar-minus-o:before{content:""}.fa-calendar-times-o:before{content:""}.fa-calendar-check-o:before{content:""}.fa-industry:before{content:""}.fa-map-pin:before{content:""}.fa-map-signs:before{content:""}.fa-map-o:before{content:""}.fa-map:before{content:""}.fa-commenting:before{content:""}.fa-commenting-o:before{content:""}.fa-houzz:before{content:""}.fa-vimeo:before{content:""}.fa-black-tie:before{content:""}.fa-fonticons:before{content:""}.fa-reddit-alien:before{content:""}.fa-edge:before{content:""}.fa-credit-card-alt:before{content:""}.fa-codiepie:before{content:""}.fa-modx:before{content:""}.fa-fort-awesome:before{content:""}.fa-usb:before{content:""}.fa-product-hunt:before{content:""}.fa-mixcloud:before{content:""}.fa-scribd:before{content:""}.fa-pause-circle:before{content:""}.fa-pause-circle-o:before{content:""}.fa-stop-circle:before{content:""}.fa-stop-circle-o:before{content:""}.fa-shopping-bag:before{content:""}.fa-shopping-basket:before{content:""}.fa-hashtag:before{content:""}.fa-bluetooth:before{content:""}.fa-bluetooth-b:before{content:""}.fa-percent:before{content:""}.fa-gitlab:before,.icon-gitlab:before{content:""}.fa-wpbeginner:before{content:""}.fa-wpforms:before{content:""}.fa-envira:before{content:""}.fa-universal-access:before{content:""}.fa-wheelchair-alt:before{content:""}.fa-question-circle-o:before{content:""}.fa-blind:before{content:""}.fa-audio-description:before{content:""}.fa-volume-control-phone:before{content:""}.fa-braille:before{content:""}.fa-assistive-listening-systems:before{content:""}.fa-american-sign-language-interpreting:before,.fa-asl-interpreting:before{content:""}.fa-deaf:before,.fa-deafness:before,.fa-hard-of-hearing:before{content:""}.fa-glide:before{content:""}.fa-glide-g:before{content:""}.fa-sign-language:before,.fa-signing:before{content:""}.fa-low-vision:before{content:""}.fa-viadeo:before{content:""}.fa-viadeo-square:before{content:""}.fa-snapchat:before{content:""}.fa-snapchat-ghost:before{content:""}.fa-snapchat-square:before{content:""}.fa-pied-piper:before{content:""}.fa-first-order:before{content:""}.fa-yoast:before{content:""}.fa-themeisle:before{content:""}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:""}.fa-fa:before,.fa-font-awesome:before{content:""}.fa-handshake-o:before{content:""}.fa-envelope-open:before{content:""}.fa-envelope-open-o:before{content:""}.fa-linode:before{content:""}.fa-address-book:before{content:""}.fa-address-book-o:before{content:""}.fa-address-card:before,.fa-vcard:before{content:""}.fa-address-card-o:before,.fa-vcard-o:before{content:""}.fa-user-circle:before{content:""}.fa-user-circle-o:before{content:""}.fa-user-o:before{content:""}.fa-id-badge:before{content:""}.fa-drivers-license:before,.fa-id-card:before{content:""}.fa-drivers-license-o:before,.fa-id-card-o:before{content:""}.fa-quora:before{content:""}.fa-free-code-camp:before{content:""}.fa-telegram:before{content:""}.fa-thermometer-4:before,.fa-thermometer-full:before,.fa-thermometer:before{content:""}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:""}.fa-thermometer-2:before,.fa-thermometer-half:before{content:""}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:""}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:""}.fa-shower:before{content:""}.fa-bath:before,.fa-bathtub:before,.fa-s15:before{content:""}.fa-podcast:before{content:""}.fa-window-maximize:before{content:""}.fa-window-minimize:before{content:""}.fa-window-restore:before{content:""}.fa-times-rectangle:before,.fa-window-close:before{content:""}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:""}.fa-bandcamp:before{content:""}.fa-grav:before{content:""}.fa-etsy:before{content:""}.fa-imdb:before{content:""}.fa-ravelry:before{content:""}.fa-eercast:before{content:""}.fa-microchip:before{content:""}.fa-snowflake-o:before{content:""}.fa-superpowers:before{content:""}.fa-wpexplorer:before{content:""}.fa-meetup:before{content:""}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-dropdown .caret,.wy-inline-validate.wy-inline-validate-danger .wy-input-context,.wy-inline-validate.wy-inline-validate-info .wy-input-context,.wy-inline-validate.wy-inline-validate-success .wy-input-context,.wy-inline-validate.wy-inline-validate-warning .wy-input-context,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{font-family:inherit}.fa:before,.icon:before,.rst-content .admonition-title:before,.rst-content .code-block-caption .headerlink:before,.rst-content .eqno .headerlink:before,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before{font-family:FontAwesome;display:inline-block;font-style:normal;font-weight:400;line-height:1;text-decoration:inherit}.rst-content .code-block-caption a .headerlink,.rst-content .eqno a .headerlink,.rst-content a .admonition-title,.rst-content code.download a span:first-child,.rst-content dl dt a .headerlink,.rst-content h1 a .headerlink,.rst-content h2 a .headerlink,.rst-content h3 a .headerlink,.rst-content h4 a .headerlink,.rst-content h5 a .headerlink,.rst-content h6 a .headerlink,.rst-content p.caption a .headerlink,.rst-content p a .headerlink,.rst-content table>caption a .headerlink,.rst-content tt.download a span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li a button.toctree-expand,a .fa,a .icon,a .rst-content .admonition-title,a .rst-content .code-block-caption .headerlink,a .rst-content .eqno .headerlink,a .rst-content code.download span:first-child,a .rst-content dl dt .headerlink,a .rst-content h1 .headerlink,a .rst-content h2 .headerlink,a .rst-content h3 .headerlink,a .rst-content h4 .headerlink,a .rst-content h5 .headerlink,a .rst-content h6 .headerlink,a .rst-content p.caption .headerlink,a .rst-content p .headerlink,a .rst-content table>caption .headerlink,a .rst-content tt.download span:first-child,a .wy-menu-vertical li button.toctree-expand{display:inline-block;text-decoration:inherit}.btn .fa,.btn .icon,.btn .rst-content .admonition-title,.btn .rst-content .code-block-caption .headerlink,.btn .rst-content .eqno .headerlink,.btn .rst-content code.download span:first-child,.btn .rst-content dl dt .headerlink,.btn .rst-content h1 .headerlink,.btn .rst-content h2 .headerlink,.btn .rst-content h3 .headerlink,.btn .rst-content h4 .headerlink,.btn .rst-content h5 .headerlink,.btn .rst-content h6 .headerlink,.btn .rst-content p .headerlink,.btn .rst-content table>caption .headerlink,.btn .rst-content tt.download span:first-child,.btn .wy-menu-vertical li.current>a button.toctree-expand,.btn .wy-menu-vertical li.on a button.toctree-expand,.btn .wy-menu-vertical li button.toctree-expand,.nav .fa,.nav .icon,.nav .rst-content .admonition-title,.nav .rst-content .code-block-caption .headerlink,.nav .rst-content .eqno .headerlink,.nav .rst-content code.download span:first-child,.nav .rst-content dl dt .headerlink,.nav .rst-content h1 .headerlink,.nav .rst-content h2 .headerlink,.nav .rst-content h3 .headerlink,.nav .rst-content h4 .headerlink,.nav .rst-content h5 .headerlink,.nav .rst-content h6 .headerlink,.nav .rst-content p .headerlink,.nav .rst-content table>caption .headerlink,.nav .rst-content tt.download span:first-child,.nav .wy-menu-vertical li.current>a button.toctree-expand,.nav .wy-menu-vertical li.on a button.toctree-expand,.nav .wy-menu-vertical li button.toctree-expand,.rst-content .btn .admonition-title,.rst-content .code-block-caption .btn .headerlink,.rst-content .code-block-caption .nav .headerlink,.rst-content .eqno .btn .headerlink,.rst-content .eqno .nav .headerlink,.rst-content .nav .admonition-title,.rst-content code.download .btn span:first-child,.rst-content code.download .nav span:first-child,.rst-content dl dt .btn .headerlink,.rst-content dl dt .nav .headerlink,.rst-content h1 .btn .headerlink,.rst-content h1 .nav .headerlink,.rst-content h2 .btn .headerlink,.rst-content h2 .nav .headerlink,.rst-content h3 .btn .headerlink,.rst-content h3 .nav .headerlink,.rst-content h4 .btn .headerlink,.rst-content h4 .nav .headerlink,.rst-content h5 .btn .headerlink,.rst-content h5 .nav .headerlink,.rst-content h6 .btn .headerlink,.rst-content h6 .nav .headerlink,.rst-content p .btn .headerlink,.rst-content p .nav .headerlink,.rst-content table>caption .btn .headerlink,.rst-content table>caption .nav .headerlink,.rst-content tt.download .btn span:first-child,.rst-content tt.download .nav span:first-child,.wy-menu-vertical li .btn button.toctree-expand,.wy-menu-vertical li.current>a .btn button.toctree-expand,.wy-menu-vertical li.current>a .nav button.toctree-expand,.wy-menu-vertical li .nav button.toctree-expand,.wy-menu-vertical li.on a .btn button.toctree-expand,.wy-menu-vertical li.on a .nav button.toctree-expand{display:inline}.btn .fa-large.icon,.btn .fa.fa-large,.btn .rst-content .code-block-caption .fa-large.headerlink,.btn .rst-content .eqno .fa-large.headerlink,.btn .rst-content .fa-large.admonition-title,.btn .rst-content code.download span.fa-large:first-child,.btn .rst-content dl dt .fa-large.headerlink,.btn .rst-content h1 .fa-large.headerlink,.btn .rst-content h2 .fa-large.headerlink,.btn .rst-content h3 .fa-large.headerlink,.btn .rst-content h4 .fa-large.headerlink,.btn .rst-content h5 .fa-large.headerlink,.btn .rst-content h6 .fa-large.headerlink,.btn .rst-content p .fa-large.headerlink,.btn .rst-content table>caption .fa-large.headerlink,.btn .rst-content tt.download span.fa-large:first-child,.btn .wy-menu-vertical li button.fa-large.toctree-expand,.nav .fa-large.icon,.nav .fa.fa-large,.nav .rst-content .code-block-caption .fa-large.headerlink,.nav .rst-content .eqno .fa-large.headerlink,.nav .rst-content .fa-large.admonition-title,.nav .rst-content code.download span.fa-large:first-child,.nav .rst-content dl dt .fa-large.headerlink,.nav .rst-content h1 .fa-large.headerlink,.nav .rst-content h2 .fa-large.headerlink,.nav .rst-content h3 .fa-large.headerlink,.nav .rst-content h4 .fa-large.headerlink,.nav .rst-content h5 .fa-large.headerlink,.nav .rst-content h6 .fa-large.headerlink,.nav .rst-content p .fa-large.headerlink,.nav .rst-content table>caption .fa-large.headerlink,.nav .rst-content tt.download span.fa-large:first-child,.nav .wy-menu-vertical li button.fa-large.toctree-expand,.rst-content .btn .fa-large.admonition-title,.rst-content .code-block-caption .btn .fa-large.headerlink,.rst-content .code-block-caption .nav .fa-large.headerlink,.rst-content .eqno .btn .fa-large.headerlink,.rst-content .eqno .nav .fa-large.headerlink,.rst-content .nav .fa-large.admonition-title,.rst-content code.download .btn span.fa-large:first-child,.rst-content code.download .nav span.fa-large:first-child,.rst-content dl dt .btn .fa-large.headerlink,.rst-content dl dt .nav .fa-large.headerlink,.rst-content h1 .btn .fa-large.headerlink,.rst-content h1 .nav .fa-large.headerlink,.rst-content h2 .btn .fa-large.headerlink,.rst-content h2 .nav .fa-large.headerlink,.rst-content h3 .btn .fa-large.headerlink,.rst-content h3 .nav .fa-large.headerlink,.rst-content h4 .btn .fa-large.headerlink,.rst-content h4 .nav .fa-large.headerlink,.rst-content h5 .btn .fa-large.headerlink,.rst-content h5 .nav .fa-large.headerlink,.rst-content h6 .btn .fa-large.headerlink,.rst-content h6 .nav .fa-large.headerlink,.rst-content p .btn .fa-large.headerlink,.rst-content p .nav .fa-large.headerlink,.rst-content table>caption .btn .fa-large.headerlink,.rst-content table>caption .nav .fa-large.headerlink,.rst-content tt.download .btn span.fa-large:first-child,.rst-content tt.download .nav span.fa-large:first-child,.wy-menu-vertical li .btn button.fa-large.toctree-expand,.wy-menu-vertical li .nav button.fa-large.toctree-expand{line-height:.9em}.btn .fa-spin.icon,.btn .fa.fa-spin,.btn .rst-content .code-block-caption .fa-spin.headerlink,.btn .rst-content .eqno .fa-spin.headerlink,.btn .rst-content .fa-spin.admonition-title,.btn .rst-content code.download span.fa-spin:first-child,.btn .rst-content dl dt .fa-spin.headerlink,.btn .rst-content h1 .fa-spin.headerlink,.btn .rst-content h2 .fa-spin.headerlink,.btn .rst-content h3 .fa-spin.headerlink,.btn .rst-content h4 .fa-spin.headerlink,.btn .rst-content h5 .fa-spin.headerlink,.btn .rst-content h6 .fa-spin.headerlink,.btn .rst-content p .fa-spin.headerlink,.btn .rst-content table>caption .fa-spin.headerlink,.btn .rst-content tt.download span.fa-spin:first-child,.btn .wy-menu-vertical li button.fa-spin.toctree-expand,.nav .fa-spin.icon,.nav .fa.fa-spin,.nav .rst-content .code-block-caption .fa-spin.headerlink,.nav .rst-content .eqno .fa-spin.headerlink,.nav .rst-content .fa-spin.admonition-title,.nav .rst-content code.download span.fa-spin:first-child,.nav .rst-content dl dt .fa-spin.headerlink,.nav .rst-content h1 .fa-spin.headerlink,.nav .rst-content h2 .fa-spin.headerlink,.nav .rst-content h3 .fa-spin.headerlink,.nav .rst-content h4 .fa-spin.headerlink,.nav .rst-content h5 .fa-spin.headerlink,.nav .rst-content h6 .fa-spin.headerlink,.nav .rst-content p .fa-spin.headerlink,.nav .rst-content table>caption .fa-spin.headerlink,.nav .rst-content tt.download span.fa-spin:first-child,.nav .wy-menu-vertical li button.fa-spin.toctree-expand,.rst-content .btn .fa-spin.admonition-title,.rst-content .code-block-caption .btn .fa-spin.headerlink,.rst-content .code-block-caption .nav .fa-spin.headerlink,.rst-content .eqno .btn .fa-spin.headerlink,.rst-content .eqno .nav .fa-spin.headerlink,.rst-content .nav .fa-spin.admonition-title,.rst-content code.download .btn span.fa-spin:first-child,.rst-content code.download .nav span.fa-spin:first-child,.rst-content dl dt .btn .fa-spin.headerlink,.rst-content dl dt .nav .fa-spin.headerlink,.rst-content h1 .btn .fa-spin.headerlink,.rst-content h1 .nav .fa-spin.headerlink,.rst-content h2 .btn .fa-spin.headerlink,.rst-content h2 .nav .fa-spin.headerlink,.rst-content h3 .btn .fa-spin.headerlink,.rst-content h3 .nav .fa-spin.headerlink,.rst-content h4 .btn .fa-spin.headerlink,.rst-content h4 .nav .fa-spin.headerlink,.rst-content h5 .btn .fa-spin.headerlink,.rst-content h5 .nav .fa-spin.headerlink,.rst-content h6 .btn .fa-spin.headerlink,.rst-content h6 .nav .fa-spin.headerlink,.rst-content p .btn .fa-spin.headerlink,.rst-content p .nav .fa-spin.headerlink,.rst-content table>caption .btn .fa-spin.headerlink,.rst-content table>caption .nav .fa-spin.headerlink,.rst-content tt.download .btn span.fa-spin:first-child,.rst-content tt.download .nav span.fa-spin:first-child,.wy-menu-vertical li .btn button.fa-spin.toctree-expand,.wy-menu-vertical li .nav button.fa-spin.toctree-expand{display:inline-block}.btn.fa:before,.btn.icon:before,.rst-content .btn.admonition-title:before,.rst-content .code-block-caption .btn.headerlink:before,.rst-content .eqno .btn.headerlink:before,.rst-content code.download span.btn:first-child:before,.rst-content dl dt .btn.headerlink:before,.rst-content h1 .btn.headerlink:before,.rst-content h2 .btn.headerlink:before,.rst-content h3 .btn.headerlink:before,.rst-content h4 .btn.headerlink:before,.rst-content h5 .btn.headerlink:before,.rst-content h6 .btn.headerlink:before,.rst-content p .btn.headerlink:before,.rst-content table>caption .btn.headerlink:before,.rst-content tt.download span.btn:first-child:before,.wy-menu-vertical li button.btn.toctree-expand:before{opacity:.5;-webkit-transition:opacity .05s ease-in;-moz-transition:opacity .05s ease-in;transition:opacity .05s ease-in}.btn.fa:hover:before,.btn.icon:hover:before,.rst-content .btn.admonition-title:hover:before,.rst-content .code-block-caption .btn.headerlink:hover:before,.rst-content .eqno .btn.headerlink:hover:before,.rst-content code.download span.btn:first-child:hover:before,.rst-content dl dt .btn.headerlink:hover:before,.rst-content h1 .btn.headerlink:hover:before,.rst-content h2 .btn.headerlink:hover:before,.rst-content h3 .btn.headerlink:hover:before,.rst-content h4 .btn.headerlink:hover:before,.rst-content h5 .btn.headerlink:hover:before,.rst-content h6 .btn.headerlink:hover:before,.rst-content p .btn.headerlink:hover:before,.rst-content table>caption .btn.headerlink:hover:before,.rst-content tt.download span.btn:first-child:hover:before,.wy-menu-vertical li button.btn.toctree-expand:hover:before{opacity:1}.btn-mini .fa:before,.btn-mini .icon:before,.btn-mini .rst-content .admonition-title:before,.btn-mini .rst-content .code-block-caption .headerlink:before,.btn-mini .rst-content .eqno .headerlink:before,.btn-mini .rst-content code.download span:first-child:before,.btn-mini .rst-content dl dt .headerlink:before,.btn-mini .rst-content h1 .headerlink:before,.btn-mini .rst-content h2 .headerlink:before,.btn-mini .rst-content h3 .headerlink:before,.btn-mini .rst-content h4 .headerlink:before,.btn-mini .rst-content h5 .headerlink:before,.btn-mini .rst-content h6 .headerlink:before,.btn-mini .rst-content p .headerlink:before,.btn-mini .rst-content table>caption .headerlink:before,.btn-mini .rst-content tt.download span:first-child:before,.btn-mini .wy-menu-vertical li button.toctree-expand:before,.rst-content .btn-mini .admonition-title:before,.rst-content .code-block-caption .btn-mini .headerlink:before,.rst-content .eqno .btn-mini .headerlink:before,.rst-content code.download .btn-mini span:first-child:before,.rst-content dl dt .btn-mini .headerlink:before,.rst-content h1 .btn-mini .headerlink:before,.rst-content h2 .btn-mini .headerlink:before,.rst-content h3 .btn-mini .headerlink:before,.rst-content h4 .btn-mini .headerlink:before,.rst-content h5 .btn-mini .headerlink:before,.rst-content h6 .btn-mini .headerlink:before,.rst-content p .btn-mini .headerlink:before,.rst-content table>caption .btn-mini .headerlink:before,.rst-content tt.download .btn-mini span:first-child:before,.wy-menu-vertical li .btn-mini button.toctree-expand:before{font-size:14px;vertical-align:-15%}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.wy-alert{padding:12px;line-height:24px;margin-bottom:24px;background:#e7f2fa}.rst-content .admonition-title,.wy-alert-title{font-weight:700;display:block;color:#fff;background:#6ab0de;padding:6px 12px;margin:-12px -12px 12px}.rst-content .danger,.rst-content .error,.rst-content .wy-alert-danger.admonition,.rst-content .wy-alert-danger.admonition-todo,.rst-content .wy-alert-danger.attention,.rst-content .wy-alert-danger.caution,.rst-content .wy-alert-danger.hint,.rst-content .wy-alert-danger.important,.rst-content .wy-alert-danger.note,.rst-content .wy-alert-danger.seealso,.rst-content .wy-alert-danger.tip,.rst-content .wy-alert-danger.warning,.wy-alert.wy-alert-danger{background:#fdf3f2}.rst-content .danger .admonition-title,.rst-content .danger .wy-alert-title,.rst-content .error .admonition-title,.rst-content .error .wy-alert-title,.rst-content .wy-alert-danger.admonition-todo .admonition-title,.rst-content .wy-alert-danger.admonition-todo .wy-alert-title,.rst-content .wy-alert-danger.admonition .admonition-title,.rst-content .wy-alert-danger.admonition .wy-alert-title,.rst-content .wy-alert-danger.attention .admonition-title,.rst-content .wy-alert-danger.attention .wy-alert-title,.rst-content .wy-alert-danger.caution .admonition-title,.rst-content .wy-alert-danger.caution .wy-alert-title,.rst-content .wy-alert-danger.hint .admonition-title,.rst-content .wy-alert-danger.hint .wy-alert-title,.rst-content .wy-alert-danger.important .admonition-title,.rst-content .wy-alert-danger.important .wy-alert-title,.rst-content .wy-alert-danger.note .admonition-title,.rst-content .wy-alert-danger.note .wy-alert-title,.rst-content .wy-alert-danger.seealso .admonition-title,.rst-content .wy-alert-danger.seealso .wy-alert-title,.rst-content .wy-alert-danger.tip .admonition-title,.rst-content .wy-alert-danger.tip .wy-alert-title,.rst-content .wy-alert-danger.warning .admonition-title,.rst-content .wy-alert-danger.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-danger .admonition-title,.wy-alert.wy-alert-danger .rst-content .admonition-title,.wy-alert.wy-alert-danger .wy-alert-title{background:#f29f97}.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .warning,.rst-content .wy-alert-warning.admonition,.rst-content .wy-alert-warning.danger,.rst-content .wy-alert-warning.error,.rst-content .wy-alert-warning.hint,.rst-content .wy-alert-warning.important,.rst-content .wy-alert-warning.note,.rst-content .wy-alert-warning.seealso,.rst-content .wy-alert-warning.tip,.wy-alert.wy-alert-warning{background:#ffedcc}.rst-content .admonition-todo .admonition-title,.rst-content .admonition-todo .wy-alert-title,.rst-content .attention .admonition-title,.rst-content .attention .wy-alert-title,.rst-content .caution .admonition-title,.rst-content .caution .wy-alert-title,.rst-content .warning .admonition-title,.rst-content .warning .wy-alert-title,.rst-content .wy-alert-warning.admonition .admonition-title,.rst-content .wy-alert-warning.admonition .wy-alert-title,.rst-content .wy-alert-warning.danger .admonition-title,.rst-content .wy-alert-warning.danger .wy-alert-title,.rst-content .wy-alert-warning.error .admonition-title,.rst-content .wy-alert-warning.error .wy-alert-title,.rst-content .wy-alert-warning.hint .admonition-title,.rst-content .wy-alert-warning.hint .wy-alert-title,.rst-content .wy-alert-warning.important .admonition-title,.rst-content .wy-alert-warning.important .wy-alert-title,.rst-content .wy-alert-warning.note .admonition-title,.rst-content .wy-alert-warning.note .wy-alert-title,.rst-content .wy-alert-warning.seealso .admonition-title,.rst-content .wy-alert-warning.seealso .wy-alert-title,.rst-content .wy-alert-warning.tip .admonition-title,.rst-content .wy-alert-warning.tip .wy-alert-title,.rst-content .wy-alert.wy-alert-warning .admonition-title,.wy-alert.wy-alert-warning .rst-content .admonition-title,.wy-alert.wy-alert-warning .wy-alert-title{background:#f0b37e}.rst-content .note,.rst-content .seealso,.rst-content .wy-alert-info.admonition,.rst-content .wy-alert-info.admonition-todo,.rst-content .wy-alert-info.attention,.rst-content .wy-alert-info.caution,.rst-content .wy-alert-info.danger,.rst-content .wy-alert-info.error,.rst-content .wy-alert-info.hint,.rst-content .wy-alert-info.important,.rst-content .wy-alert-info.tip,.rst-content .wy-alert-info.warning,.wy-alert.wy-alert-info{background:#e7f2fa}.rst-content .note .admonition-title,.rst-content .note .wy-alert-title,.rst-content .seealso .admonition-title,.rst-content .seealso .wy-alert-title,.rst-content .wy-alert-info.admonition-todo .admonition-title,.rst-content .wy-alert-info.admonition-todo .wy-alert-title,.rst-content .wy-alert-info.admonition .admonition-title,.rst-content .wy-alert-info.admonition .wy-alert-title,.rst-content .wy-alert-info.attention .admonition-title,.rst-content .wy-alert-info.attention .wy-alert-title,.rst-content .wy-alert-info.caution .admonition-title,.rst-content .wy-alert-info.caution .wy-alert-title,.rst-content .wy-alert-info.danger .admonition-title,.rst-content .wy-alert-info.danger .wy-alert-title,.rst-content .wy-alert-info.error .admonition-title,.rst-content .wy-alert-info.error .wy-alert-title,.rst-content .wy-alert-info.hint .admonition-title,.rst-content .wy-alert-info.hint .wy-alert-title,.rst-content .wy-alert-info.important .admonition-title,.rst-content .wy-alert-info.important .wy-alert-title,.rst-content .wy-alert-info.tip .admonition-title,.rst-content .wy-alert-info.tip .wy-alert-title,.rst-content .wy-alert-info.warning .admonition-title,.rst-content .wy-alert-info.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-info .admonition-title,.wy-alert.wy-alert-info .rst-content .admonition-title,.wy-alert.wy-alert-info .wy-alert-title{background:#6ab0de}.rst-content .hint,.rst-content .important,.rst-content .tip,.rst-content .wy-alert-success.admonition,.rst-content .wy-alert-success.admonition-todo,.rst-content .wy-alert-success.attention,.rst-content .wy-alert-success.caution,.rst-content .wy-alert-success.danger,.rst-content .wy-alert-success.error,.rst-content .wy-alert-success.note,.rst-content .wy-alert-success.seealso,.rst-content .wy-alert-success.warning,.wy-alert.wy-alert-success{background:#dbfaf4}.rst-content .hint .admonition-title,.rst-content .hint .wy-alert-title,.rst-content .important .admonition-title,.rst-content .important .wy-alert-title,.rst-content .tip .admonition-title,.rst-content .tip .wy-alert-title,.rst-content .wy-alert-success.admonition-todo .admonition-title,.rst-content .wy-alert-success.admonition-todo .wy-alert-title,.rst-content .wy-alert-success.admonition .admonition-title,.rst-content .wy-alert-success.admonition .wy-alert-title,.rst-content .wy-alert-success.attention .admonition-title,.rst-content .wy-alert-success.attention .wy-alert-title,.rst-content .wy-alert-success.caution .admonition-title,.rst-content .wy-alert-success.caution .wy-alert-title,.rst-content .wy-alert-success.danger .admonition-title,.rst-content .wy-alert-success.danger .wy-alert-title,.rst-content .wy-alert-success.error .admonition-title,.rst-content .wy-alert-success.error .wy-alert-title,.rst-content .wy-alert-success.note .admonition-title,.rst-content .wy-alert-success.note .wy-alert-title,.rst-content .wy-alert-success.seealso .admonition-title,.rst-content .wy-alert-success.seealso .wy-alert-title,.rst-content .wy-alert-success.warning .admonition-title,.rst-content .wy-alert-success.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-success .admonition-title,.wy-alert.wy-alert-success .rst-content .admonition-title,.wy-alert.wy-alert-success .wy-alert-title{background:#1abc9c}.rst-content .wy-alert-neutral.admonition,.rst-content .wy-alert-neutral.admonition-todo,.rst-content .wy-alert-neutral.attention,.rst-content .wy-alert-neutral.caution,.rst-content .wy-alert-neutral.danger,.rst-content .wy-alert-neutral.error,.rst-content .wy-alert-neutral.hint,.rst-content .wy-alert-neutral.important,.rst-content .wy-alert-neutral.note,.rst-content .wy-alert-neutral.seealso,.rst-content .wy-alert-neutral.tip,.rst-content .wy-alert-neutral.warning,.wy-alert.wy-alert-neutral{background:#f3f6f6}.rst-content .wy-alert-neutral.admonition-todo .admonition-title,.rst-content .wy-alert-neutral.admonition-todo .wy-alert-title,.rst-content .wy-alert-neutral.admonition .admonition-title,.rst-content .wy-alert-neutral.admonition .wy-alert-title,.rst-content .wy-alert-neutral.attention .admonition-title,.rst-content .wy-alert-neutral.attention .wy-alert-title,.rst-content .wy-alert-neutral.caution .admonition-title,.rst-content .wy-alert-neutral.caution .wy-alert-title,.rst-content .wy-alert-neutral.danger .admonition-title,.rst-content .wy-alert-neutral.danger .wy-alert-title,.rst-content .wy-alert-neutral.error .admonition-title,.rst-content .wy-alert-neutral.error .wy-alert-title,.rst-content .wy-alert-neutral.hint .admonition-title,.rst-content .wy-alert-neutral.hint .wy-alert-title,.rst-content .wy-alert-neutral.important .admonition-title,.rst-content .wy-alert-neutral.important .wy-alert-title,.rst-content .wy-alert-neutral.note .admonition-title,.rst-content .wy-alert-neutral.note .wy-alert-title,.rst-content .wy-alert-neutral.seealso .admonition-title,.rst-content .wy-alert-neutral.seealso .wy-alert-title,.rst-content .wy-alert-neutral.tip .admonition-title,.rst-content .wy-alert-neutral.tip .wy-alert-title,.rst-content .wy-alert-neutral.warning .admonition-title,.rst-content .wy-alert-neutral.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-neutral .admonition-title,.wy-alert.wy-alert-neutral .rst-content .admonition-title,.wy-alert.wy-alert-neutral .wy-alert-title{color:#404040;background:#e1e4e5}.rst-content .wy-alert-neutral.admonition-todo a,.rst-content .wy-alert-neutral.admonition a,.rst-content .wy-alert-neutral.attention a,.rst-content .wy-alert-neutral.caution a,.rst-content .wy-alert-neutral.danger a,.rst-content .wy-alert-neutral.error a,.rst-content .wy-alert-neutral.hint a,.rst-content .wy-alert-neutral.important a,.rst-content .wy-alert-neutral.note a,.rst-content .wy-alert-neutral.seealso a,.rst-content .wy-alert-neutral.tip a,.rst-content .wy-alert-neutral.warning a,.wy-alert.wy-alert-neutral a{color:#2980b9}.rst-content .admonition-todo p:last-child,.rst-content .admonition p:last-child,.rst-content .attention p:last-child,.rst-content .caution p:last-child,.rst-content .danger p:last-child,.rst-content .error p:last-child,.rst-content .hint p:last-child,.rst-content .important p:last-child,.rst-content .note p:last-child,.rst-content .seealso p:last-child,.rst-content .tip p:last-child,.rst-content .warning p:last-child,.wy-alert p:last-child{margin-bottom:0}.wy-tray-container{position:fixed;bottom:0;left:0;z-index:600}.wy-tray-container li{display:block;width:300px;background:transparent;color:#fff;text-align:center;box-shadow:0 5px 5px 0 rgba(0,0,0,.1);padding:0 24px;min-width:20%;opacity:0;height:0;line-height:56px;overflow:hidden;-webkit-transition:all .3s ease-in;-moz-transition:all .3s ease-in;transition:all .3s ease-in}.wy-tray-container li.wy-tray-item-success{background:#27ae60}.wy-tray-container li.wy-tray-item-info{background:#2980b9}.wy-tray-container li.wy-tray-item-warning{background:#e67e22}.wy-tray-container li.wy-tray-item-danger{background:#e74c3c}.wy-tray-container li.on{opacity:1;height:56px}@media screen and (max-width:768px){.wy-tray-container{bottom:auto;top:0;width:100%}.wy-tray-container li{width:100%}}button{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle;cursor:pointer;line-height:normal;-webkit-appearance:button;*overflow:visible}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}button[disabled]{cursor:default}.btn{display:inline-block;border-radius:2px;line-height:normal;white-space:nowrap;text-align:center;cursor:pointer;font-size:100%;padding:6px 12px 8px;color:#fff;border:1px solid rgba(0,0,0,.1);background-color:#27ae60;text-decoration:none;font-weight:400;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 2px -1px hsla(0,0%,100%,.5),inset 0 -2px 0 0 rgba(0,0,0,.1);outline-none:false;vertical-align:middle;*display:inline;zoom:1;-webkit-user-drag:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-transition:all .1s linear;-moz-transition:all .1s linear;transition:all .1s linear}.btn-hover{background:#2e8ece;color:#fff}.btn:hover{background:#2cc36b;color:#fff}.btn:focus{background:#2cc36b;outline:0}.btn:active{box-shadow:inset 0 -1px 0 0 rgba(0,0,0,.05),inset 0 2px 0 0 rgba(0,0,0,.1);padding:8px 12px 6px}.btn:visited{color:#fff}.btn-disabled,.btn-disabled:active,.btn-disabled:focus,.btn-disabled:hover,.btn:disabled{background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);filter:alpha(opacity=40);opacity:.4;cursor:not-allowed;box-shadow:none}.btn::-moz-focus-inner{padding:0;border:0}.btn-small{font-size:80%}.btn-info{background-color:#2980b9!important}.btn-info:hover{background-color:#2e8ece!important}.btn-neutral{background-color:#f3f6f6!important;color:#404040!important}.btn-neutral:hover{background-color:#e5ebeb!important;color:#404040}.btn-neutral:visited{color:#404040!important}.btn-success{background-color:#27ae60!important}.btn-success:hover{background-color:#295!important}.btn-danger{background-color:#e74c3c!important}.btn-danger:hover{background-color:#ea6153!important}.btn-warning{background-color:#e67e22!important}.btn-warning:hover{background-color:#e98b39!important}.btn-invert{background-color:#222}.btn-invert:hover{background-color:#2f2f2f!important}.btn-link{background-color:transparent!important;color:#2980b9;box-shadow:none;border-color:transparent!important}.btn-link:active,.btn-link:hover{background-color:transparent!important;color:#409ad5!important;box-shadow:none}.btn-link:visited{color:#9b59b6}.wy-btn-group .btn,.wy-control .btn{vertical-align:middle}.wy-btn-group{margin-bottom:24px;*zoom:1}.wy-btn-group:after,.wy-btn-group:before{display:table;content:""}.wy-btn-group:after{clear:both}.wy-dropdown{position:relative;display:inline-block}.wy-dropdown-active .wy-dropdown-menu{display:block}.wy-dropdown-menu{position:absolute;left:0;display:none;float:left;top:100%;min-width:100%;background:#fcfcfc;z-index:100;border:1px solid #cfd7dd;box-shadow:0 2px 2px 0 rgba(0,0,0,.1);padding:12px}.wy-dropdown-menu>dd>a{display:block;clear:both;color:#404040;white-space:nowrap;font-size:90%;padding:0 12px;cursor:pointer}.wy-dropdown-menu>dd>a:hover{background:#2980b9;color:#fff}.wy-dropdown-menu>dd.divider{border-top:1px solid #cfd7dd;margin:6px 0}.wy-dropdown-menu>dd.search{padding-bottom:12px}.wy-dropdown-menu>dd.search input[type=search]{width:100%}.wy-dropdown-menu>dd.call-to-action{background:#e3e3e3;text-transform:uppercase;font-weight:500;font-size:80%}.wy-dropdown-menu>dd.call-to-action:hover{background:#e3e3e3}.wy-dropdown-menu>dd.call-to-action .btn{color:#fff}.wy-dropdown.wy-dropdown-up .wy-dropdown-menu{bottom:100%;top:auto;left:auto;right:0}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu{background:#fcfcfc;margin-top:2px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a{padding:6px 12px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a:hover{background:#2980b9;color:#fff}.wy-dropdown.wy-dropdown-left .wy-dropdown-menu{right:0;left:auto;text-align:right}.wy-dropdown-arrow:before{content:" ";border-bottom:5px solid #f5f5f5;border-left:5px solid transparent;border-right:5px solid transparent;position:absolute;display:block;top:-4px;left:50%;margin-left:-3px}.wy-dropdown-arrow.wy-dropdown-arrow-left:before{left:11px}.wy-form-stacked select{display:block}.wy-form-aligned .wy-help-inline,.wy-form-aligned input,.wy-form-aligned label,.wy-form-aligned select,.wy-form-aligned textarea{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-form-aligned .wy-control-group>label{display:inline-block;vertical-align:middle;width:10em;margin:6px 12px 0 0;float:left}.wy-form-aligned .wy-control{float:left}.wy-form-aligned .wy-control label{display:block}.wy-form-aligned .wy-control select{margin-top:6px}fieldset{margin:0}fieldset,legend{border:0;padding:0}legend{width:100%;white-space:normal;margin-bottom:24px;font-size:150%;*margin-left:-7px}label,legend{display:block}label{margin:0 0 .3125em;color:#333;font-size:90%}input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}.wy-control-group{margin-bottom:24px;max-width:1200px;margin-left:auto;margin-right:auto;*zoom:1}.wy-control-group:after,.wy-control-group:before{display:table;content:""}.wy-control-group:after{clear:both}.wy-control-group.wy-control-group-required>label:after{content:" *";color:#e74c3c}.wy-control-group .wy-form-full,.wy-control-group .wy-form-halves,.wy-control-group .wy-form-thirds{padding-bottom:12px}.wy-control-group .wy-form-full input[type=color],.wy-control-group .wy-form-full input[type=date],.wy-control-group .wy-form-full input[type=datetime-local],.wy-control-group .wy-form-full input[type=datetime],.wy-control-group .wy-form-full input[type=email],.wy-control-group .wy-form-full input[type=month],.wy-control-group .wy-form-full input[type=number],.wy-control-group .wy-form-full input[type=password],.wy-control-group .wy-form-full input[type=search],.wy-control-group .wy-form-full input[type=tel],.wy-control-group .wy-form-full input[type=text],.wy-control-group .wy-form-full input[type=time],.wy-control-group .wy-form-full input[type=url],.wy-control-group .wy-form-full input[type=week],.wy-control-group .wy-form-full select,.wy-control-group .wy-form-halves input[type=color],.wy-control-group .wy-form-halves input[type=date],.wy-control-group .wy-form-halves input[type=datetime-local],.wy-control-group .wy-form-halves input[type=datetime],.wy-control-group .wy-form-halves input[type=email],.wy-control-group .wy-form-halves input[type=month],.wy-control-group .wy-form-halves input[type=number],.wy-control-group .wy-form-halves input[type=password],.wy-control-group .wy-form-halves input[type=search],.wy-control-group .wy-form-halves input[type=tel],.wy-control-group .wy-form-halves input[type=text],.wy-control-group .wy-form-halves input[type=time],.wy-control-group .wy-form-halves input[type=url],.wy-control-group .wy-form-halves input[type=week],.wy-control-group .wy-form-halves select,.wy-control-group .wy-form-thirds input[type=color],.wy-control-group .wy-form-thirds input[type=date],.wy-control-group .wy-form-thirds input[type=datetime-local],.wy-control-group .wy-form-thirds input[type=datetime],.wy-control-group .wy-form-thirds input[type=email],.wy-control-group .wy-form-thirds input[type=month],.wy-control-group .wy-form-thirds input[type=number],.wy-control-group .wy-form-thirds input[type=password],.wy-control-group .wy-form-thirds input[type=search],.wy-control-group .wy-form-thirds input[type=tel],.wy-control-group .wy-form-thirds input[type=text],.wy-control-group .wy-form-thirds input[type=time],.wy-control-group .wy-form-thirds input[type=url],.wy-control-group .wy-form-thirds input[type=week],.wy-control-group .wy-form-thirds select{width:100%}.wy-control-group .wy-form-full{float:left;display:block;width:100%;margin-right:0}.wy-control-group .wy-form-full:last-child{margin-right:0}.wy-control-group .wy-form-halves{float:left;display:block;margin-right:2.35765%;width:48.82117%}.wy-control-group .wy-form-halves:last-child,.wy-control-group .wy-form-halves:nth-of-type(2n){margin-right:0}.wy-control-group .wy-form-halves:nth-of-type(odd){clear:left}.wy-control-group .wy-form-thirds{float:left;display:block;margin-right:2.35765%;width:31.76157%}.wy-control-group .wy-form-thirds:last-child,.wy-control-group .wy-form-thirds:nth-of-type(3n){margin-right:0}.wy-control-group .wy-form-thirds:nth-of-type(3n+1){clear:left}.wy-control-group.wy-control-group-no-input .wy-control,.wy-control-no-input{margin:6px 0 0;font-size:90%}.wy-control-no-input{display:inline-block}.wy-control-group.fluid-input input[type=color],.wy-control-group.fluid-input input[type=date],.wy-control-group.fluid-input input[type=datetime-local],.wy-control-group.fluid-input input[type=datetime],.wy-control-group.fluid-input input[type=email],.wy-control-group.fluid-input input[type=month],.wy-control-group.fluid-input input[type=number],.wy-control-group.fluid-input input[type=password],.wy-control-group.fluid-input input[type=search],.wy-control-group.fluid-input input[type=tel],.wy-control-group.fluid-input input[type=text],.wy-control-group.fluid-input input[type=time],.wy-control-group.fluid-input input[type=url],.wy-control-group.fluid-input input[type=week]{width:100%}.wy-form-message-inline{padding-left:.3em;color:#666;font-size:90%}.wy-form-message{display:block;color:#999;font-size:70%;margin-top:.3125em;font-style:italic}.wy-form-message p{font-size:inherit;font-style:italic;margin-bottom:6px}.wy-form-message p:last-child{margin-bottom:0}input{line-height:normal}input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;*overflow:visible}input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week]{-webkit-appearance:none;padding:6px;display:inline-block;border:1px solid #ccc;font-size:80%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 3px #ddd;border-radius:0;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}input[type=datetime-local]{padding:.34375em .625em}input[disabled]{cursor:default}input[type=checkbox],input[type=radio]{padding:0;margin-right:.3125em;*height:13px;*width:13px}input[type=checkbox],input[type=radio],input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}input[type=color]:focus,input[type=date]:focus,input[type=datetime-local]:focus,input[type=datetime]:focus,input[type=email]:focus,input[type=month]:focus,input[type=number]:focus,input[type=password]:focus,input[type=search]:focus,input[type=tel]:focus,input[type=text]:focus,input[type=time]:focus,input[type=url]:focus,input[type=week]:focus{outline:0;outline:thin dotted\9;border-color:#333}input.no-focus:focus{border-color:#ccc!important}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:thin dotted #333;outline:1px auto #129fea}input[type=color][disabled],input[type=date][disabled],input[type=datetime-local][disabled],input[type=datetime][disabled],input[type=email][disabled],input[type=month][disabled],input[type=number][disabled],input[type=password][disabled],input[type=search][disabled],input[type=tel][disabled],input[type=text][disabled],input[type=time][disabled],input[type=url][disabled],input[type=week][disabled]{cursor:not-allowed;background-color:#fafafa}input:focus:invalid,select:focus:invalid,textarea:focus:invalid{color:#e74c3c;border:1px solid #e74c3c}input:focus:invalid:focus,select:focus:invalid:focus,textarea:focus:invalid:focus{border-color:#e74c3c}input[type=checkbox]:focus:invalid:focus,input[type=file]:focus:invalid:focus,input[type=radio]:focus:invalid:focus{outline-color:#e74c3c}input.wy-input-large{padding:12px;font-size:100%}textarea{overflow:auto;vertical-align:top;width:100%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif}select,textarea{padding:.5em .625em;display:inline-block;border:1px solid #ccc;font-size:80%;box-shadow:inset 0 1px 3px #ddd;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}select{border:1px solid #ccc;background-color:#fff}select[multiple]{height:auto}select:focus,textarea:focus{outline:0}input[readonly],select[disabled],select[readonly],textarea[disabled],textarea[readonly]{cursor:not-allowed;background-color:#fafafa}input[type=checkbox][disabled],input[type=radio][disabled]{cursor:not-allowed}.wy-checkbox,.wy-radio{margin:6px 0;color:#404040;display:block}.wy-checkbox input,.wy-radio input{vertical-align:baseline}.wy-form-message-inline{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-input-prefix,.wy-input-suffix{white-space:nowrap;padding:6px}.wy-input-prefix .wy-input-context,.wy-input-suffix .wy-input-context{line-height:27px;padding:0 8px;display:inline-block;font-size:80%;background-color:#f3f6f6;border:1px solid #ccc;color:#999}.wy-input-suffix .wy-input-context{border-left:0}.wy-input-prefix .wy-input-context{border-right:0}.wy-switch{position:relative;display:block;height:24px;margin-top:12px;cursor:pointer}.wy-switch:before{left:0;top:0;width:36px;height:12px;background:#ccc}.wy-switch:after,.wy-switch:before{position:absolute;content:"";display:block;border-radius:4px;-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.wy-switch:after{width:18px;height:18px;background:#999;left:-3px;top:-3px}.wy-switch span{position:absolute;left:48px;display:block;font-size:12px;color:#ccc;line-height:1}.wy-switch.active:before{background:#1e8449}.wy-switch.active:after{left:24px;background:#27ae60}.wy-switch.disabled{cursor:not-allowed;opacity:.8}.wy-control-group.wy-control-group-error .wy-form-message,.wy-control-group.wy-control-group-error>label{color:#e74c3c}.wy-control-group.wy-control-group-error input[type=color],.wy-control-group.wy-control-group-error input[type=date],.wy-control-group.wy-control-group-error input[type=datetime-local],.wy-control-group.wy-control-group-error input[type=datetime],.wy-control-group.wy-control-group-error input[type=email],.wy-control-group.wy-control-group-error input[type=month],.wy-control-group.wy-control-group-error input[type=number],.wy-control-group.wy-control-group-error input[type=password],.wy-control-group.wy-control-group-error input[type=search],.wy-control-group.wy-control-group-error input[type=tel],.wy-control-group.wy-control-group-error input[type=text],.wy-control-group.wy-control-group-error input[type=time],.wy-control-group.wy-control-group-error input[type=url],.wy-control-group.wy-control-group-error input[type=week],.wy-control-group.wy-control-group-error textarea{border:1px solid #e74c3c}.wy-inline-validate{white-space:nowrap}.wy-inline-validate .wy-input-context{padding:.5em .625em;display:inline-block;font-size:80%}.wy-inline-validate.wy-inline-validate-success .wy-input-context{color:#27ae60}.wy-inline-validate.wy-inline-validate-danger .wy-input-context{color:#e74c3c}.wy-inline-validate.wy-inline-validate-warning .wy-input-context{color:#e67e22}.wy-inline-validate.wy-inline-validate-info .wy-input-context{color:#2980b9}.rotate-90{-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.rotate-180{-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.rotate-270{-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.mirror{-webkit-transform:scaleX(-1);-moz-transform:scaleX(-1);-ms-transform:scaleX(-1);-o-transform:scaleX(-1);transform:scaleX(-1)}.mirror.rotate-90{-webkit-transform:scaleX(-1) rotate(90deg);-moz-transform:scaleX(-1) rotate(90deg);-ms-transform:scaleX(-1) rotate(90deg);-o-transform:scaleX(-1) rotate(90deg);transform:scaleX(-1) rotate(90deg)}.mirror.rotate-180{-webkit-transform:scaleX(-1) rotate(180deg);-moz-transform:scaleX(-1) rotate(180deg);-ms-transform:scaleX(-1) rotate(180deg);-o-transform:scaleX(-1) rotate(180deg);transform:scaleX(-1) rotate(180deg)}.mirror.rotate-270{-webkit-transform:scaleX(-1) rotate(270deg);-moz-transform:scaleX(-1) rotate(270deg);-ms-transform:scaleX(-1) rotate(270deg);-o-transform:scaleX(-1) rotate(270deg);transform:scaleX(-1) rotate(270deg)}@media only screen and (max-width:480px){.wy-form button[type=submit]{margin:.7em 0 0}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=text],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week],.wy-form label{margin-bottom:.3em;display:block}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week]{margin-bottom:0}.wy-form-aligned .wy-control-group label{margin-bottom:.3em;text-align:left;display:block;width:100%}.wy-form-aligned .wy-control{margin:1.5em 0 0}.wy-form-message,.wy-form-message-inline,.wy-form .wy-help-inline{display:block;font-size:80%;padding:6px 0}}@media screen and (max-width:768px){.tablet-hide{display:none}}@media screen and (max-width:480px){.mobile-hide{display:none}}.float-left{float:left}.float-right{float:right}.full-width{width:100%}.rst-content table.docutils,.rst-content table.field-list,.wy-table{border-collapse:collapse;border-spacing:0;empty-cells:show;margin-bottom:24px}.rst-content table.docutils caption,.rst-content table.field-list caption,.wy-table caption{color:#000;font:italic 85%/1 arial,sans-serif;padding:1em 0;text-align:center}.rst-content table.docutils td,.rst-content table.docutils th,.rst-content table.field-list td,.rst-content table.field-list th,.wy-table td,.wy-table th{font-size:90%;margin:0;overflow:visible;padding:8px 16px}.rst-content table.docutils td:first-child,.rst-content table.docutils th:first-child,.rst-content table.field-list td:first-child,.rst-content table.field-list th:first-child,.wy-table td:first-child,.wy-table th:first-child{border-left-width:0}.rst-content table.docutils thead,.rst-content table.field-list thead,.wy-table thead{color:#000;text-align:left;vertical-align:bottom;white-space:nowrap}.rst-content table.docutils thead th,.rst-content table.field-list thead th,.wy-table thead th{font-weight:700;border-bottom:2px solid #e1e4e5}.rst-content table.docutils td,.rst-content table.field-list td,.wy-table td{background-color:transparent;vertical-align:middle}.rst-content table.docutils td p,.rst-content table.field-list td p,.wy-table td p{line-height:18px}.rst-content table.docutils td p:last-child,.rst-content table.field-list td p:last-child,.wy-table td p:last-child{margin-bottom:0}.rst-content table.docutils .wy-table-cell-min,.rst-content table.field-list .wy-table-cell-min,.wy-table .wy-table-cell-min{width:1%;padding-right:0}.rst-content table.docutils .wy-table-cell-min input[type=checkbox],.rst-content table.field-list .wy-table-cell-min input[type=checkbox],.wy-table .wy-table-cell-min input[type=checkbox]{margin:0}.wy-table-secondary{color:grey;font-size:90%}.wy-table-tertiary{color:grey;font-size:80%}.rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td,.wy-table-backed,.wy-table-odd td,.wy-table-striped tr:nth-child(2n-1) td{background-color:#f3f6f6}.rst-content table.docutils,.wy-table-bordered-all{border:1px solid #e1e4e5}.rst-content table.docutils td,.wy-table-bordered-all td{border-bottom:1px solid #e1e4e5;border-left:1px solid #e1e4e5}.rst-content table.docutils tbody>tr:last-child td,.wy-table-bordered-all tbody>tr:last-child td{border-bottom-width:0}.wy-table-bordered{border:1px solid #e1e4e5}.wy-table-bordered-rows td{border-bottom:1px solid #e1e4e5}.wy-table-bordered-rows tbody>tr:last-child td{border-bottom-width:0}.wy-table-horizontal td,.wy-table-horizontal th{border-width:0 0 1px;border-bottom:1px solid #e1e4e5}.wy-table-horizontal tbody>tr:last-child td{border-bottom-width:0}.wy-table-responsive{margin-bottom:24px;max-width:100%;overflow:auto}.wy-table-responsive table{margin-bottom:0!important}.wy-table-responsive table td,.wy-table-responsive table th{white-space:nowrap}a{color:#2980b9;text-decoration:none;cursor:pointer}a:hover{color:#3091d1}a:visited{color:#9b59b6}html{height:100%}body,html{overflow-x:hidden}body{font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;font-weight:400;color:#404040;min-height:100%;background:#edf0f2}.wy-text-left{text-align:left}.wy-text-center{text-align:center}.wy-text-right{text-align:right}.wy-text-large{font-size:120%}.wy-text-normal{font-size:100%}.wy-text-small,small{font-size:80%}.wy-text-strike{text-decoration:line-through}.wy-text-warning{color:#e67e22!important}a.wy-text-warning:hover{color:#eb9950!important}.wy-text-info{color:#2980b9!important}a.wy-text-info:hover{color:#409ad5!important}.wy-text-success{color:#27ae60!important}a.wy-text-success:hover{color:#36d278!important}.wy-text-danger{color:#e74c3c!important}a.wy-text-danger:hover{color:#ed7669!important}.wy-text-neutral{color:#404040!important}a.wy-text-neutral:hover{color:#595959!important}.rst-content .toctree-wrapper>p.caption,h1,h2,h3,h4,h5,h6,legend{margin-top:0;font-weight:700;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif}p{line-height:24px;font-size:16px;margin:0 0 24px}h1{font-size:175%}.rst-content .toctree-wrapper>p.caption,h2{font-size:150%}h3{font-size:125%}h4{font-size:115%}h5{font-size:110%}h6{font-size:100%}hr{display:block;height:1px;border:0;border-top:1px solid #e1e4e5;margin:24px 0;padding:0}.rst-content code,.rst-content tt,code{white-space:nowrap;max-width:100%;background:#fff;border:1px solid #e1e4e5;font-size:75%;padding:0 5px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#e74c3c;overflow-x:auto}.rst-content tt.code-large,code.code-large{font-size:90%}.rst-content .section ul,.rst-content .toctree-wrapper ul,.rst-content section ul,.wy-plain-list-disc,article ul{list-style:disc;line-height:24px;margin-bottom:24px}.rst-content .section ul li,.rst-content .toctree-wrapper ul li,.rst-content section ul li,.wy-plain-list-disc li,article ul li{list-style:disc;margin-left:24px}.rst-content .section ul li p:last-child,.rst-content .section ul li ul,.rst-content .toctree-wrapper ul li p:last-child,.rst-content .toctree-wrapper ul li ul,.rst-content section ul li p:last-child,.rst-content section ul li ul,.wy-plain-list-disc li p:last-child,.wy-plain-list-disc li ul,article ul li p:last-child,article ul li ul{margin-bottom:0}.rst-content .section ul li li,.rst-content .toctree-wrapper ul li li,.rst-content section ul li li,.wy-plain-list-disc li li,article ul li li{list-style:circle}.rst-content .section ul li li li,.rst-content .toctree-wrapper ul li li li,.rst-content section ul li li li,.wy-plain-list-disc li li li,article ul li li li{list-style:square}.rst-content .section ul li ol li,.rst-content .toctree-wrapper ul li ol li,.rst-content section ul li ol li,.wy-plain-list-disc li ol li,article ul li ol li{list-style:decimal}.rst-content .section ol,.rst-content .section ol.arabic,.rst-content .toctree-wrapper ol,.rst-content .toctree-wrapper ol.arabic,.rst-content section ol,.rst-content section ol.arabic,.wy-plain-list-decimal,article ol{list-style:decimal;line-height:24px;margin-bottom:24px}.rst-content .section ol.arabic li,.rst-content .section ol li,.rst-content .toctree-wrapper ol.arabic li,.rst-content .toctree-wrapper ol li,.rst-content section ol.arabic li,.rst-content section ol li,.wy-plain-list-decimal li,article ol li{list-style:decimal;margin-left:24px}.rst-content .section ol.arabic li ul,.rst-content .section ol li p:last-child,.rst-content .section ol li ul,.rst-content .toctree-wrapper ol.arabic li ul,.rst-content .toctree-wrapper ol li p:last-child,.rst-content .toctree-wrapper ol li ul,.rst-content section ol.arabic li ul,.rst-content section ol li p:last-child,.rst-content section ol li ul,.wy-plain-list-decimal li p:last-child,.wy-plain-list-decimal li ul,article ol li p:last-child,article ol li ul{margin-bottom:0}.rst-content .section ol.arabic li ul li,.rst-content .section ol li ul li,.rst-content .toctree-wrapper ol.arabic li ul li,.rst-content .toctree-wrapper ol li ul li,.rst-content section ol.arabic li ul li,.rst-content section ol li ul li,.wy-plain-list-decimal li ul li,article ol li ul li{list-style:disc}.wy-breadcrumbs{*zoom:1}.wy-breadcrumbs:after,.wy-breadcrumbs:before{display:table;content:""}.wy-breadcrumbs:after{clear:both}.wy-breadcrumbs>li{display:inline-block;padding-top:5px}.wy-breadcrumbs>li.wy-breadcrumbs-aside{float:right}.rst-content .wy-breadcrumbs>li code,.rst-content .wy-breadcrumbs>li tt,.wy-breadcrumbs>li .rst-content tt,.wy-breadcrumbs>li code{all:inherit;color:inherit}.breadcrumb-item:before{content:"/";color:#bbb;font-size:13px;padding:0 6px 0 3px}.wy-breadcrumbs-extra{margin-bottom:0;color:#b3b3b3;font-size:80%;display:inline-block}@media screen and (max-width:480px){.wy-breadcrumbs-extra,.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}@media print{.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}html{font-size:16px}.wy-affix{position:fixed;top:1.618em}.wy-menu a:hover{text-decoration:none}.wy-menu-horiz{*zoom:1}.wy-menu-horiz:after,.wy-menu-horiz:before{display:table;content:""}.wy-menu-horiz:after{clear:both}.wy-menu-horiz li,.wy-menu-horiz ul{display:inline-block}.wy-menu-horiz li:hover{background:hsla(0,0%,100%,.1)}.wy-menu-horiz li.divide-left{border-left:1px solid #404040}.wy-menu-horiz li.divide-right{border-right:1px solid #404040}.wy-menu-horiz a{height:32px;display:inline-block;line-height:32px;padding:0 16px}.wy-menu-vertical{width:300px}.wy-menu-vertical header,.wy-menu-vertical p.caption{color:#55a5d9;height:32px;line-height:32px;padding:0 1.618em;margin:12px 0 0;display:block;font-weight:700;text-transform:uppercase;font-size:85%;white-space:nowrap}.wy-menu-vertical ul{margin-bottom:0}.wy-menu-vertical li.divide-top{border-top:1px solid #404040}.wy-menu-vertical li.divide-bottom{border-bottom:1px solid #404040}.wy-menu-vertical li.current{background:#e3e3e3}.wy-menu-vertical li.current a{color:grey;border-right:1px solid #c9c9c9;padding:.4045em 2.427em}.wy-menu-vertical li.current a:hover{background:#d6d6d6}.rst-content .wy-menu-vertical li tt,.wy-menu-vertical li .rst-content tt,.wy-menu-vertical li code{border:none;background:inherit;color:inherit;padding-left:0;padding-right:0}.wy-menu-vertical li button.toctree-expand{display:block;float:left;margin-left:-1.2em;line-height:18px;color:#4d4d4d;border:none;background:none;padding:0}.wy-menu-vertical li.current>a,.wy-menu-vertical li.on a{color:#404040;font-weight:700;position:relative;background:#fcfcfc;border:none;padding:.4045em 1.618em}.wy-menu-vertical li.current>a:hover,.wy-menu-vertical li.on a:hover{background:#fcfcfc}.wy-menu-vertical li.current>a:hover button.toctree-expand,.wy-menu-vertical li.on a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand{display:block;line-height:18px;color:#333}.wy-menu-vertical li.toctree-l1.current>a{border-bottom:1px solid #c9c9c9;border-top:1px solid #c9c9c9}.wy-menu-vertical .toctree-l1.current .toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .toctree-l11>ul{display:none}.wy-menu-vertical .toctree-l1.current .current.toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .current.toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .current.toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .current.toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .current.toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .current.toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .current.toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .current.toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .current.toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .current.toctree-l11>ul{display:block}.wy-menu-vertical li.toctree-l3,.wy-menu-vertical li.toctree-l4{font-size:.9em}.wy-menu-vertical li.toctree-l2 a,.wy-menu-vertical li.toctree-l3 a,.wy-menu-vertical li.toctree-l4 a,.wy-menu-vertical li.toctree-l5 a,.wy-menu-vertical li.toctree-l6 a,.wy-menu-vertical li.toctree-l7 a,.wy-menu-vertical li.toctree-l8 a,.wy-menu-vertical li.toctree-l9 a,.wy-menu-vertical li.toctree-l10 a{color:#404040}.wy-menu-vertical li.toctree-l2 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l3 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l4 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l5 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l6 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l7 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l8 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l9 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l10 a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a,.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a,.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a,.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a,.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a,.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a,.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a,.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{display:block}.wy-menu-vertical li.toctree-l2.current>a{padding:.4045em 2.427em}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{padding:.4045em 1.618em .4045em 4.045em}.wy-menu-vertical li.toctree-l3.current>a{padding:.4045em 4.045em}.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{padding:.4045em 1.618em .4045em 5.663em}.wy-menu-vertical li.toctree-l4.current>a{padding:.4045em 5.663em}.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a{padding:.4045em 1.618em .4045em 7.281em}.wy-menu-vertical li.toctree-l5.current>a{padding:.4045em 7.281em}.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a{padding:.4045em 1.618em .4045em 8.899em}.wy-menu-vertical li.toctree-l6.current>a{padding:.4045em 8.899em}.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a{padding:.4045em 1.618em .4045em 10.517em}.wy-menu-vertical li.toctree-l7.current>a{padding:.4045em 10.517em}.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a{padding:.4045em 1.618em .4045em 12.135em}.wy-menu-vertical li.toctree-l8.current>a{padding:.4045em 12.135em}.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a{padding:.4045em 1.618em .4045em 13.753em}.wy-menu-vertical li.toctree-l9.current>a{padding:.4045em 13.753em}.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a{padding:.4045em 1.618em .4045em 15.371em}.wy-menu-vertical li.toctree-l10.current>a{padding:.4045em 15.371em}.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{padding:.4045em 1.618em .4045em 16.989em}.wy-menu-vertical li.toctree-l2.current>a,.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{background:#c9c9c9}.wy-menu-vertical li.toctree-l2 button.toctree-expand{color:#a3a3a3}.wy-menu-vertical li.toctree-l3.current>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{background:#bdbdbd}.wy-menu-vertical li.toctree-l3 button.toctree-expand{color:#969696}.wy-menu-vertical li.current ul{display:block}.wy-menu-vertical li ul{margin-bottom:0;display:none}.wy-menu-vertical li ul li a{margin-bottom:0;color:#d9d9d9;font-weight:400}.wy-menu-vertical a{line-height:18px;padding:.4045em 1.618em;display:block;position:relative;font-size:90%;color:#d9d9d9}.wy-menu-vertical a:hover{background-color:#4e4a4a;cursor:pointer}.wy-menu-vertical a:hover button.toctree-expand{color:#d9d9d9}.wy-menu-vertical a:active{background-color:#2980b9;cursor:pointer;color:#fff}.wy-menu-vertical a:active button.toctree-expand{color:#fff}.wy-side-nav-search{display:block;width:300px;padding:.809em;margin-bottom:.809em;z-index:200;background-color:#2980b9;text-align:center;color:#fcfcfc}.wy-side-nav-search input[type=text]{width:100%;border-radius:50px;padding:6px 12px;border-color:#2472a4}.wy-side-nav-search img{display:block;margin:auto auto .809em;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-side-nav-search .wy-dropdown>a,.wy-side-nav-search>a{color:#fcfcfc;font-size:100%;font-weight:700;display:inline-block;padding:4px 6px;margin-bottom:.809em;max-width:100%}.wy-side-nav-search .wy-dropdown>a:hover,.wy-side-nav-search>a:hover{background:hsla(0,0%,100%,.1)}.wy-side-nav-search .wy-dropdown>a img.logo,.wy-side-nav-search>a img.logo{display:block;margin:0 auto;height:auto;width:auto;border-radius:0;max-width:100%;background:transparent}.wy-side-nav-search .wy-dropdown>a.icon img.logo,.wy-side-nav-search>a.icon img.logo{margin-top:.85em}.wy-side-nav-search>div.version{margin-top:-.4045em;margin-bottom:.809em;font-weight:400;color:hsla(0,0%,100%,.3)}.wy-nav .wy-menu-vertical header{color:#2980b9}.wy-nav .wy-menu-vertical a{color:#b3b3b3}.wy-nav .wy-menu-vertical a:hover{background-color:#2980b9;color:#fff}[data-menu-wrap]{-webkit-transition:all .2s ease-in;-moz-transition:all .2s ease-in;transition:all .2s ease-in;position:absolute;opacity:1;width:100%;opacity:0}[data-menu-wrap].move-center{left:0;right:auto;opacity:1}[data-menu-wrap].move-left{right:auto;left:-100%;opacity:0}[data-menu-wrap].move-right{right:-100%;left:auto;opacity:0}.wy-body-for-nav{background:#fcfcfc}.wy-grid-for-nav{position:absolute;width:100%;height:100%}.wy-nav-side{position:fixed;top:0;bottom:0;left:0;padding-bottom:2em;width:300px;overflow-x:hidden;overflow-y:hidden;min-height:100%;color:#9b9b9b;background:#343131;z-index:200}.wy-side-scroll{width:320px;position:relative;overflow-x:hidden;overflow-y:scroll;height:100%}.wy-nav-top{display:none;background:#2980b9;color:#fff;padding:.4045em .809em;position:relative;line-height:50px;text-align:center;font-size:100%;*zoom:1}.wy-nav-top:after,.wy-nav-top:before{display:table;content:""}.wy-nav-top:after{clear:both}.wy-nav-top a{color:#fff;font-weight:700}.wy-nav-top img{margin-right:12px;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-nav-top i{font-size:30px;float:left;cursor:pointer;padding-top:inherit}.wy-nav-content-wrap{margin-left:300px;background:#fcfcfc;min-height:100%}.wy-nav-content{padding:1.618em 3.236em;height:100%;max-width:800px;margin:auto}.wy-body-mask{position:fixed;width:100%;height:100%;background:rgba(0,0,0,.2);display:none;z-index:499}.wy-body-mask.on{display:block}footer{color:grey}footer p{margin-bottom:12px}.rst-content footer span.commit tt,footer span.commit .rst-content tt,footer span.commit code{padding:0;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:1em;background:none;border:none;color:grey}.rst-footer-buttons{*zoom:1}.rst-footer-buttons:after,.rst-footer-buttons:before{width:100%;display:table;content:""}.rst-footer-buttons:after{clear:both}.rst-breadcrumbs-buttons{margin-top:12px;*zoom:1}.rst-breadcrumbs-buttons:after,.rst-breadcrumbs-buttons:before{display:table;content:""}.rst-breadcrumbs-buttons:after{clear:both}#search-results .search li{margin-bottom:24px;border-bottom:1px solid #e1e4e5;padding-bottom:24px}#search-results .search li:first-child{border-top:1px solid #e1e4e5;padding-top:24px}#search-results .search li a{font-size:120%;margin-bottom:12px;display:inline-block}#search-results .context{color:grey;font-size:90%}.genindextable li>ul{margin-left:24px}@media screen and (max-width:768px){.wy-body-for-nav{background:#fcfcfc}.wy-nav-top{display:block}.wy-nav-side{left:-300px}.wy-nav-side.shift{width:85%;left:0}.wy-menu.wy-menu-vertical,.wy-side-nav-search,.wy-side-scroll{width:auto}.wy-nav-content-wrap{margin-left:0}.wy-nav-content-wrap .wy-nav-content{padding:1.618em}.wy-nav-content-wrap.shift{position:fixed;min-width:100%;left:85%;top:0;height:100%;overflow:hidden}}@media screen and (min-width:1100px){.wy-nav-content-wrap{background:rgba(0,0,0,.05)}.wy-nav-content{margin:0;background:#fcfcfc}}@media print{.rst-versions,.wy-nav-side,footer{display:none}.wy-nav-content-wrap{margin-left:0}}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60;*zoom:1}.rst-versions .rst-current-version:after,.rst-versions .rst-current-version:before{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-content .code-block-caption .rst-versions .rst-current-version .headerlink,.rst-content .eqno .rst-versions .rst-current-version .headerlink,.rst-content .rst-versions .rst-current-version .admonition-title,.rst-content code.download .rst-versions .rst-current-version span:first-child,.rst-content dl dt .rst-versions .rst-current-version .headerlink,.rst-content h1 .rst-versions .rst-current-version .headerlink,.rst-content h2 .rst-versions .rst-current-version .headerlink,.rst-content h3 .rst-versions .rst-current-version .headerlink,.rst-content h4 .rst-versions .rst-current-version .headerlink,.rst-content h5 .rst-versions .rst-current-version .headerlink,.rst-content h6 .rst-versions .rst-current-version .headerlink,.rst-content p .rst-versions .rst-current-version .headerlink,.rst-content table>caption .rst-versions .rst-current-version .headerlink,.rst-content tt.download .rst-versions .rst-current-version span:first-child,.rst-versions .rst-current-version .fa,.rst-versions .rst-current-version .icon,.rst-versions .rst-current-version .rst-content .admonition-title,.rst-versions .rst-current-version .rst-content .code-block-caption .headerlink,.rst-versions .rst-current-version .rst-content .eqno .headerlink,.rst-versions .rst-current-version .rst-content code.download span:first-child,.rst-versions .rst-current-version .rst-content dl dt .headerlink,.rst-versions .rst-current-version .rst-content h1 .headerlink,.rst-versions .rst-current-version .rst-content h2 .headerlink,.rst-versions .rst-current-version .rst-content h3 .headerlink,.rst-versions .rst-current-version .rst-content h4 .headerlink,.rst-versions .rst-current-version .rst-content h5 .headerlink,.rst-versions .rst-current-version .rst-content h6 .headerlink,.rst-versions .rst-current-version .rst-content p .headerlink,.rst-versions .rst-current-version .rst-content table>caption .headerlink,.rst-versions .rst-current-version .rst-content tt.download span:first-child,.rst-versions .rst-current-version .wy-menu-vertical li button.toctree-expand,.wy-menu-vertical li .rst-versions .rst-current-version button.toctree-expand{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}.rst-content .toctree-wrapper>p.caption,.rst-content h1,.rst-content h2,.rst-content h3,.rst-content h4,.rst-content h5,.rst-content h6{margin-bottom:24px}.rst-content img{max-width:100%;height:auto}.rst-content div.figure,.rst-content figure{margin-bottom:24px}.rst-content div.figure .caption-text,.rst-content figure .caption-text{font-style:italic}.rst-content div.figure p:last-child.caption,.rst-content figure p:last-child.caption{margin-bottom:0}.rst-content div.figure.align-center,.rst-content figure.align-center{text-align:center}.rst-content .section>a>img,.rst-content .section>img,.rst-content section>a>img,.rst-content section>img{margin-bottom:24px}.rst-content abbr[title]{text-decoration:none}.rst-content.style-external-links a.reference.external:after{font-family:FontAwesome;content:"\f08e";color:#b3b3b3;vertical-align:super;font-size:60%;margin:0 .2em}.rst-content blockquote{margin-left:24px;line-height:24px;margin-bottom:24px}.rst-content pre.literal-block{white-space:pre;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;display:block;overflow:auto}.rst-content div[class^=highlight],.rst-content pre.literal-block{border:1px solid #e1e4e5;overflow-x:auto;margin:1px 0 24px}.rst-content div[class^=highlight] div[class^=highlight],.rst-content pre.literal-block div[class^=highlight]{padding:0;border:none;margin:0}.rst-content div[class^=highlight] td.code{width:100%}.rst-content .linenodiv pre{border-right:1px solid #e6e9ea;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;user-select:none;pointer-events:none}.rst-content div[class^=highlight] pre{white-space:pre;margin:0;padding:12px;display:block;overflow:auto}.rst-content div[class^=highlight] pre .hll{display:block;margin:0 -12px;padding:0 12px}.rst-content .linenodiv pre,.rst-content div[class^=highlight] pre,.rst-content pre.literal-block{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:12px;line-height:1.4}.rst-content div.highlight .gp,.rst-content div.highlight span.linenos{user-select:none;pointer-events:none}.rst-content div.highlight span.linenos{display:inline-block;padding-left:0;padding-right:12px;margin-right:12px;border-right:1px solid #e6e9ea}.rst-content .code-block-caption{font-style:italic;font-size:85%;line-height:1;padding:1em 0;text-align:center}@media print{.rst-content .codeblock,.rst-content div[class^=highlight],.rst-content div[class^=highlight] pre{white-space:pre-wrap}}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning{clear:both}.rst-content .admonition-todo .last,.rst-content .admonition-todo>:last-child,.rst-content .admonition .last,.rst-content .admonition>:last-child,.rst-content .attention .last,.rst-content .attention>:last-child,.rst-content .caution .last,.rst-content .caution>:last-child,.rst-content .danger .last,.rst-content .danger>:last-child,.rst-content .error .last,.rst-content .error>:last-child,.rst-content .hint .last,.rst-content .hint>:last-child,.rst-content .important .last,.rst-content .important>:last-child,.rst-content .note .last,.rst-content .note>:last-child,.rst-content .seealso .last,.rst-content .seealso>:last-child,.rst-content .tip .last,.rst-content .tip>:last-child,.rst-content .warning .last,.rst-content .warning>:last-child{margin-bottom:0}.rst-content .admonition-title:before{margin-right:4px}.rst-content .admonition table{border-color:rgba(0,0,0,.1)}.rst-content .admonition table td,.rst-content .admonition table th{background:transparent!important;border-color:rgba(0,0,0,.1)!important}.rst-content .section ol.loweralpha,.rst-content .section ol.loweralpha>li,.rst-content .toctree-wrapper ol.loweralpha,.rst-content .toctree-wrapper ol.loweralpha>li,.rst-content section ol.loweralpha,.rst-content section ol.loweralpha>li{list-style:lower-alpha}.rst-content .section ol.upperalpha,.rst-content .section ol.upperalpha>li,.rst-content .toctree-wrapper ol.upperalpha,.rst-content .toctree-wrapper ol.upperalpha>li,.rst-content section ol.upperalpha,.rst-content section ol.upperalpha>li{list-style:upper-alpha}.rst-content .section ol li>*,.rst-content .section ul li>*,.rst-content .toctree-wrapper ol li>*,.rst-content .toctree-wrapper ul li>*,.rst-content section ol li>*,.rst-content section ul li>*{margin-top:12px;margin-bottom:12px}.rst-content .section ol li>:first-child,.rst-content .section ul li>:first-child,.rst-content .toctree-wrapper ol li>:first-child,.rst-content .toctree-wrapper ul li>:first-child,.rst-content section ol li>:first-child,.rst-content section ul li>:first-child{margin-top:0}.rst-content .section ol li>p,.rst-content .section ol li>p:last-child,.rst-content .section ul li>p,.rst-content .section ul li>p:last-child,.rst-content .toctree-wrapper ol li>p,.rst-content .toctree-wrapper ol li>p:last-child,.rst-content .toctree-wrapper ul li>p,.rst-content .toctree-wrapper ul li>p:last-child,.rst-content section ol li>p,.rst-content section ol li>p:last-child,.rst-content section ul li>p,.rst-content section ul li>p:last-child{margin-bottom:12px}.rst-content .section ol li>p:only-child,.rst-content .section ol li>p:only-child:last-child,.rst-content .section ul li>p:only-child,.rst-content .section ul li>p:only-child:last-child,.rst-content .toctree-wrapper ol li>p:only-child,.rst-content .toctree-wrapper ol li>p:only-child:last-child,.rst-content .toctree-wrapper ul li>p:only-child,.rst-content .toctree-wrapper ul li>p:only-child:last-child,.rst-content section ol li>p:only-child,.rst-content section ol li>p:only-child:last-child,.rst-content section ul li>p:only-child,.rst-content section ul li>p:only-child:last-child{margin-bottom:0}.rst-content .section ol li>ol,.rst-content .section ol li>ul,.rst-content .section ul li>ol,.rst-content .section ul li>ul,.rst-content .toctree-wrapper ol li>ol,.rst-content .toctree-wrapper ol li>ul,.rst-content .toctree-wrapper ul li>ol,.rst-content .toctree-wrapper ul li>ul,.rst-content section ol li>ol,.rst-content section ol li>ul,.rst-content section ul li>ol,.rst-content section ul li>ul{margin-bottom:12px}.rst-content .section ol.simple li>*,.rst-content .section ol.simple li ol,.rst-content .section ol.simple li ul,.rst-content .section ul.simple li>*,.rst-content .section ul.simple li ol,.rst-content .section ul.simple li ul,.rst-content .toctree-wrapper ol.simple li>*,.rst-content .toctree-wrapper ol.simple li ol,.rst-content .toctree-wrapper ol.simple li ul,.rst-content .toctree-wrapper ul.simple li>*,.rst-content .toctree-wrapper ul.simple li ol,.rst-content .toctree-wrapper ul.simple li ul,.rst-content section ol.simple li>*,.rst-content section ol.simple li ol,.rst-content section ol.simple li ul,.rst-content section ul.simple li>*,.rst-content section ul.simple li ol,.rst-content section ul.simple li ul{margin-top:0;margin-bottom:0}.rst-content .line-block{margin-left:0;margin-bottom:24px;line-height:24px}.rst-content .line-block .line-block{margin-left:24px;margin-bottom:0}.rst-content .topic-title{font-weight:700;margin-bottom:12px}.rst-content .toc-backref{color:#404040}.rst-content .align-right{float:right;margin:0 0 24px 24px}.rst-content .align-left{float:left;margin:0 24px 24px 0}.rst-content .align-center{margin:auto}.rst-content .align-center:not(table){display:block}.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink{opacity:0;font-size:14px;font-family:FontAwesome;margin-left:.5em}.rst-content .code-block-caption .headerlink:focus,.rst-content .code-block-caption:hover .headerlink,.rst-content .eqno .headerlink:focus,.rst-content .eqno:hover .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink:focus,.rst-content .toctree-wrapper>p.caption:hover .headerlink,.rst-content dl dt .headerlink:focus,.rst-content dl dt:hover .headerlink,.rst-content h1 .headerlink:focus,.rst-content h1:hover .headerlink,.rst-content h2 .headerlink:focus,.rst-content h2:hover .headerlink,.rst-content h3 .headerlink:focus,.rst-content h3:hover .headerlink,.rst-content h4 .headerlink:focus,.rst-content h4:hover .headerlink,.rst-content h5 .headerlink:focus,.rst-content h5:hover .headerlink,.rst-content h6 .headerlink:focus,.rst-content h6:hover .headerlink,.rst-content p.caption .headerlink:focus,.rst-content p.caption:hover .headerlink,.rst-content p .headerlink:focus,.rst-content p:hover .headerlink,.rst-content table>caption .headerlink:focus,.rst-content table>caption:hover .headerlink{opacity:1}.rst-content p a{overflow-wrap:anywhere}.rst-content .wy-table td p,.rst-content .wy-table td ul,.rst-content .wy-table th p,.rst-content .wy-table th ul,.rst-content table.docutils td p,.rst-content table.docutils td ul,.rst-content table.docutils th p,.rst-content table.docutils th ul,.rst-content table.field-list td p,.rst-content table.field-list td ul,.rst-content table.field-list th p,.rst-content table.field-list th ul{font-size:inherit}.rst-content .btn:focus{outline:2px solid}.rst-content table>caption .headerlink:after{font-size:12px}.rst-content .centered{text-align:center}.rst-content .sidebar{float:right;width:40%;display:block;margin:0 0 24px 24px;padding:24px;background:#f3f6f6;border:1px solid #e1e4e5}.rst-content .sidebar dl,.rst-content .sidebar p,.rst-content .sidebar ul{font-size:90%}.rst-content .sidebar .last,.rst-content .sidebar>:last-child{margin-bottom:0}.rst-content .sidebar .sidebar-title{display:block;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif;font-weight:700;background:#e1e4e5;padding:6px 12px;margin:-24px -24px 24px;font-size:100%}.rst-content .highlighted{background:#f1c40f;box-shadow:0 0 0 2px #f1c40f;display:inline;font-weight:700}.rst-content .citation-reference,.rst-content .footnote-reference{vertical-align:baseline;position:relative;top:-.4em;line-height:0;font-size:90%}.rst-content .citation-reference>span.fn-bracket,.rst-content .footnote-reference>span.fn-bracket{display:none}.rst-content .hlist{width:100%}.rst-content dl dt span.classifier:before{content:" : "}.rst-content dl dt span.classifier-delimiter{display:none!important}html.writer-html4 .rst-content table.docutils.citation,html.writer-html4 .rst-content table.docutils.footnote{background:none;border:none}html.writer-html4 .rst-content table.docutils.citation td,html.writer-html4 .rst-content table.docutils.citation tr,html.writer-html4 .rst-content table.docutils.footnote td,html.writer-html4 .rst-content table.docutils.footnote tr{border:none;background-color:transparent!important;white-space:normal}html.writer-html4 .rst-content table.docutils.citation td.label,html.writer-html4 .rst-content table.docutils.footnote td.label{padding-left:0;padding-right:0;vertical-align:top}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{display:grid;grid-template-columns:auto minmax(80%,95%)}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{display:inline-grid;grid-template-columns:max-content auto}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{display:grid;grid-template-columns:auto auto minmax(.65rem,auto) minmax(40%,95%)}html.writer-html5 .rst-content aside.citation>span.label,html.writer-html5 .rst-content aside.footnote>span.label,html.writer-html5 .rst-content div.citation>span.label{grid-column-start:1;grid-column-end:2}html.writer-html5 .rst-content aside.citation>span.backrefs,html.writer-html5 .rst-content aside.footnote>span.backrefs,html.writer-html5 .rst-content div.citation>span.backrefs{grid-column-start:2;grid-column-end:3;grid-row-start:1;grid-row-end:3}html.writer-html5 .rst-content aside.citation>p,html.writer-html5 .rst-content aside.footnote>p,html.writer-html5 .rst-content div.citation>p{grid-column-start:4;grid-column-end:5}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{margin-bottom:24px}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{padding-left:1rem}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dd,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dd,html.writer-html5 .rst-content dl.footnote>dt{margin-bottom:0}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{font-size:.9rem}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.footnote>dt{margin:0 .5rem .5rem 0;line-height:1.2rem;word-break:break-all;font-weight:400}html.writer-html5 .rst-content dl.citation>dt>span.brackets:before,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:before{content:"["}html.writer-html5 .rst-content dl.citation>dt>span.brackets:after,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:after{content:"]"}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a{word-break:keep-all}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a:not(:first-child):before,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.footnote>dd{margin:0 0 .5rem;line-height:1.2rem}html.writer-html5 .rst-content dl.citation>dd p,html.writer-html5 .rst-content dl.footnote>dd p{font-size:.9rem}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{padding-left:1rem;padding-right:1rem;font-size:.9rem;line-height:1.2rem}html.writer-html5 .rst-content aside.citation p,html.writer-html5 .rst-content aside.footnote p,html.writer-html5 .rst-content div.citation p{font-size:.9rem;line-height:1.2rem;margin-bottom:12px}html.writer-html5 .rst-content aside.citation span.backrefs,html.writer-html5 .rst-content aside.footnote span.backrefs,html.writer-html5 .rst-content div.citation span.backrefs{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content aside.citation span.backrefs>a,html.writer-html5 .rst-content aside.footnote span.backrefs>a,html.writer-html5 .rst-content div.citation span.backrefs>a{word-break:keep-all}html.writer-html5 .rst-content aside.citation span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content aside.footnote span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content div.citation span.backrefs>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content aside.citation span.label,html.writer-html5 .rst-content aside.footnote span.label,html.writer-html5 .rst-content div.citation span.label{line-height:1.2rem}html.writer-html5 .rst-content aside.citation-list,html.writer-html5 .rst-content aside.footnote-list,html.writer-html5 .rst-content div.citation-list{margin-bottom:24px}html.writer-html5 .rst-content dl.option-list kbd{font-size:.9rem}.rst-content table.docutils.footnote,html.writer-html4 .rst-content table.docutils.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content aside.footnote-list aside.footnote,html.writer-html5 .rst-content div.citation-list>div.citation,html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{color:grey}.rst-content table.docutils.footnote code,.rst-content table.docutils.footnote tt,html.writer-html4 .rst-content table.docutils.citation code,html.writer-html4 .rst-content table.docutils.citation tt,html.writer-html5 .rst-content aside.footnote-list aside.footnote code,html.writer-html5 .rst-content aside.footnote-list aside.footnote tt,html.writer-html5 .rst-content aside.footnote code,html.writer-html5 .rst-content aside.footnote tt,html.writer-html5 .rst-content div.citation-list>div.citation code,html.writer-html5 .rst-content div.citation-list>div.citation tt,html.writer-html5 .rst-content dl.citation code,html.writer-html5 .rst-content dl.citation tt,html.writer-html5 .rst-content dl.footnote code,html.writer-html5 .rst-content dl.footnote tt{color:#555}.rst-content .wy-table-responsive.citation,.rst-content .wy-table-responsive.footnote{margin-bottom:0}.rst-content .wy-table-responsive.citation+:not(.citation),.rst-content .wy-table-responsive.footnote+:not(.footnote){margin-top:24px}.rst-content .wy-table-responsive.citation:last-child,.rst-content .wy-table-responsive.footnote:last-child{margin-bottom:24px}.rst-content table.docutils th{border-color:#e1e4e5}html.writer-html5 .rst-content table.docutils th{border:1px solid #e1e4e5}html.writer-html5 .rst-content table.docutils td>p,html.writer-html5 .rst-content table.docutils th>p{line-height:1rem;margin-bottom:0;font-size:.9rem}.rst-content table.docutils td .last,.rst-content table.docutils td .last>:last-child{margin-bottom:0}.rst-content table.field-list,.rst-content table.field-list td{border:none}.rst-content table.field-list td p{line-height:inherit}.rst-content table.field-list td>strong{display:inline-block}.rst-content table.field-list .field-name{padding-right:10px;text-align:left;white-space:nowrap}.rst-content table.field-list .field-body{text-align:left}.rst-content code,.rst-content tt{color:#000;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;padding:2px 5px}.rst-content code big,.rst-content code em,.rst-content tt big,.rst-content tt em{font-size:100%!important;line-height:normal}.rst-content code.literal,.rst-content tt.literal{color:#e74c3c;white-space:normal}.rst-content code.xref,.rst-content tt.xref,a .rst-content code,a .rst-content tt{font-weight:700;color:#404040;overflow-wrap:normal}.rst-content kbd,.rst-content pre,.rst-content samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace}.rst-content a code,.rst-content a tt{color:#2980b9}.rst-content dl{margin-bottom:24px}.rst-content dl dt{font-weight:700;margin-bottom:12px}.rst-content dl ol,.rst-content dl p,.rst-content dl table,.rst-content dl ul{margin-bottom:12px}.rst-content dl dd{margin:0 0 12px 24px;line-height:24px}.rst-content dl dd>ol:last-child,.rst-content dl dd>p:last-child,.rst-content dl dd>table:last-child,.rst-content dl dd>ul:last-child{margin-bottom:0}html.writer-html4 .rst-content dl:not(.docutils),html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple){margin-bottom:24px}html.writer-html4 .rst-content dl:not(.docutils)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{display:table;margin:6px 0;font-size:90%;line-height:normal;background:#e7f2fa;color:#2980b9;border-top:3px solid #6ab0de;padding:6px;position:relative}html.writer-html4 .rst-content dl:not(.docutils)>dt:before,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:before{color:#6ab0de}html.writer-html4 .rst-content dl:not(.docutils)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{margin-bottom:6px;border:none;border-left:3px solid #ccc;background:#f0f0f0;color:#555}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils)>dt:first-child,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:first-child{margin-top:0}html.writer-html4 .rst-content dl:not(.docutils) code.descclassname,html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descclassname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{background-color:transparent;border:none;padding:0;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .optional,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .optional{display:inline-block;padding:0 4px;color:#000;font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .property,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .property{display:inline-block;padding-right:8px;max-width:100%}html.writer-html4 .rst-content dl:not(.docutils) .k,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .k{font-style:italic}html.writer-html4 .rst-content dl:not(.docutils) .descclassname,html.writer-html4 .rst-content dl:not(.docutils) .descname,html.writer-html4 .rst-content dl:not(.docutils) .sig-name,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .sig-name{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#000}.rst-content .viewcode-back,.rst-content .viewcode-link{display:inline-block;color:#27ae60;font-size:80%;padding-left:24px}.rst-content .viewcode-back{display:block;float:right}.rst-content p.rubric{margin-bottom:12px;font-weight:700}.rst-content code.download,.rst-content tt.download{background:inherit;padding:inherit;font-weight:400;font-family:inherit;font-size:inherit;color:inherit;border:inherit;white-space:inherit}.rst-content code.download span:first-child,.rst-content tt.download span:first-child{-webkit-font-smoothing:subpixel-antialiased}.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{margin-right:4px}.rst-content .guilabel,.rst-content .menuselection{font-size:80%;font-weight:700;border-radius:4px;padding:2.4px 6px;margin:auto 2px}.rst-content .guilabel,.rst-content .menuselection{border:1px solid #7fbbe3;background:#e7f2fa}.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>.kbd,.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>kbd{color:inherit;font-size:80%;background-color:#fff;border:1px solid #a6a6a6;border-radius:4px;box-shadow:0 2px grey;padding:2.4px 6px;margin:auto 0}.rst-content .versionmodified{font-style:italic}@media screen and (max-width:480px){.rst-content .sidebar{width:100%}}span[id*=MathJax-Span]{color:#404040}.math{text-align:center}@font-face{font-family:Lato;src:url(fonts/lato-normal.woff2?bd03a2cc277bbbc338d464e679fe9942) format("woff2"),url(fonts/lato-normal.woff?27bd77b9162d388cb8d4c4217c7c5e2a) format("woff");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold.woff2?cccb897485813c7c256901dbca54ecf2) format("woff2"),url(fonts/lato-bold.woff?d878b6c29b10beca227e9eef4246111b) format("woff");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold-italic.woff2?0b6bb6725576b072c5d0b02ecdd1900d) format("woff2"),url(fonts/lato-bold-italic.woff?9c7e4e9eb485b4a121c760e61bc3707c) format("woff");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-normal-italic.woff2?4eb103b4d12be57cb1d040ed5e162e9d) format("woff2"),url(fonts/lato-normal-italic.woff?f28f2d6482446544ef1ea1ccc6dd5892) format("woff");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:400;src:url(fonts/Roboto-Slab-Regular.woff2?7abf5b8d04d26a2cafea937019bca958) format("woff2"),url(fonts/Roboto-Slab-Regular.woff?c1be9284088d487c5e3ff0a10a92e58c) format("woff");font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:700;src:url(fonts/Roboto-Slab-Bold.woff2?9984f4a9bda09be08e83f2506954adbe) format("woff2"),url(fonts/Roboto-Slab-Bold.woff?bed5564a116b05148e3b3bea6fb1162a) format("woff");font-display:block} \ No newline at end of file diff --git a/isofit-tutorials/build/html/_static/doctools.js b/isofit-tutorials/build/html/_static/doctools.js new file mode 100644 index 0000000..4d67807 --- /dev/null +++ b/isofit-tutorials/build/html/_static/doctools.js @@ -0,0 +1,156 @@ +/* + * doctools.js + * ~~~~~~~~~~~ + * + * Base JavaScript utilities for all Sphinx HTML documentation. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ +"use strict"; + +const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([ + "TEXTAREA", + "INPUT", + "SELECT", + "BUTTON", +]); + +const _ready = (callback) => { + if (document.readyState !== "loading") { + callback(); + } else { + document.addEventListener("DOMContentLoaded", callback); + } +}; + +/** + * Small JavaScript module for the documentation. + */ +const Documentation = { + init: () => { + Documentation.initDomainIndexTable(); + Documentation.initOnKeyListeners(); + }, + + /** + * i18n support + */ + TRANSLATIONS: {}, + PLURAL_EXPR: (n) => (n === 1 ? 0 : 1), + LOCALE: "unknown", + + // gettext and ngettext don't access this so that the functions + // can safely bound to a different name (_ = Documentation.gettext) + gettext: (string) => { + const translated = Documentation.TRANSLATIONS[string]; + switch (typeof translated) { + case "undefined": + return string; // no translation + case "string": + return translated; // translation exists + default: + return translated[0]; // (singular, plural) translation tuple exists + } + }, + + ngettext: (singular, plural, n) => { + const translated = Documentation.TRANSLATIONS[singular]; + if (typeof translated !== "undefined") + return translated[Documentation.PLURAL_EXPR(n)]; + return n === 1 ? singular : plural; + }, + + addTranslations: (catalog) => { + Object.assign(Documentation.TRANSLATIONS, catalog.messages); + Documentation.PLURAL_EXPR = new Function( + "n", + `return (${catalog.plural_expr})` + ); + Documentation.LOCALE = catalog.locale; + }, + + /** + * helper function to focus on search bar + */ + focusSearchBar: () => { + document.querySelectorAll("input[name=q]")[0]?.focus(); + }, + + /** + * Initialise the domain index toggle buttons + */ + initDomainIndexTable: () => { + const toggler = (el) => { + const idNumber = el.id.substr(7); + const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`); + if (el.src.substr(-9) === "minus.png") { + el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`; + toggledRows.forEach((el) => (el.style.display = "none")); + } else { + el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`; + toggledRows.forEach((el) => (el.style.display = "")); + } + }; + + const togglerElements = document.querySelectorAll("img.toggler"); + togglerElements.forEach((el) => + el.addEventListener("click", (event) => toggler(event.currentTarget)) + ); + togglerElements.forEach((el) => (el.style.display = "")); + if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler); + }, + + initOnKeyListeners: () => { + // only install a listener if it is really needed + if ( + !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS && + !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS + ) + return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.altKey || event.ctrlKey || event.metaKey) return; + + if (!event.shiftKey) { + switch (event.key) { + case "ArrowLeft": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const prevLink = document.querySelector('link[rel="prev"]'); + if (prevLink && prevLink.href) { + window.location.href = prevLink.href; + event.preventDefault(); + } + break; + case "ArrowRight": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const nextLink = document.querySelector('link[rel="next"]'); + if (nextLink && nextLink.href) { + window.location.href = nextLink.href; + event.preventDefault(); + } + break; + } + } + + // some keyboard layouts may need Shift to get / + switch (event.key) { + case "/": + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break; + Documentation.focusSearchBar(); + event.preventDefault(); + } + }); + }, +}; + +// quick alias for translations +const _ = Documentation.gettext; + +_ready(Documentation.init); diff --git a/isofit-tutorials/build/html/_static/documentation_options.js b/isofit-tutorials/build/html/_static/documentation_options.js new file mode 100644 index 0000000..7e4c114 --- /dev/null +++ b/isofit-tutorials/build/html/_static/documentation_options.js @@ -0,0 +1,13 @@ +const DOCUMENTATION_OPTIONS = { + VERSION: '', + LANGUAGE: 'en', + COLLAPSE_INDEX: false, + BUILDER: 'html', + FILE_SUFFIX: '.html', + LINK_SUFFIX: '.html', + HAS_SOURCE: true, + SOURCELINK_SUFFIX: '.txt', + NAVIGATION_WITH_KEYS: false, + SHOW_SEARCH_SUMMARY: true, + ENABLE_SEARCH_SHORTCUTS: true, +}; \ No newline at end of file diff --git a/isofit-tutorials/build/html/_static/file.png b/isofit-tutorials/build/html/_static/file.png new file mode 100644 index 0000000..a858a41 Binary files /dev/null and b/isofit-tutorials/build/html/_static/file.png differ diff --git a/isofit-tutorials/build/html/_static/jquery.js b/isofit-tutorials/build/html/_static/jquery.js new file mode 100644 index 0000000..c4c6022 --- /dev/null +++ b/isofit-tutorials/build/html/_static/jquery.js @@ -0,0 +1,2 @@ +/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */ +!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="",y.option=!!ce.lastChild;var ge={thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n",""]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="
",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=y.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=y.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),y.elements=c+" "+a,j(b)}function f(a){var b=x[a[v]];return b||(b={},w++,a[v]=w,x[w]=b),b}function g(a,c,d){if(c||(c=b),q)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():u.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||t.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),q)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return y.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(y,b.frag)}function j(a){a||(a=b);var d=f(a);return!y.shivCSS||p||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),q||i(a,d),a}function k(a){for(var b,c=a.getElementsByTagName("*"),e=c.length,f=RegExp("^(?:"+d().join("|")+")$","i"),g=[];e--;)b=c[e],f.test(b.nodeName)&&g.push(b.applyElement(l(b)));return g}function l(a){for(var b,c=a.attributes,d=c.length,e=a.ownerDocument.createElement(A+":"+a.nodeName);d--;)b=c[d],b.specified&&e.setAttribute(b.nodeName,b.nodeValue);return e.style.cssText=a.style.cssText,e}function m(a){for(var b,c=a.split("{"),e=c.length,f=RegExp("(^|[\\s,>+~])("+d().join("|")+")(?=[[\\s,>+~#.:]|$)","gi"),g="$1"+A+"\\:$2";e--;)b=c[e]=c[e].split("}"),b[b.length-1]=b[b.length-1].replace(f,g),c[e]=b.join("}");return c.join("{")}function n(a){for(var b=a.length;b--;)a[b].removeNode()}function o(a){function b(){clearTimeout(g._removeSheetTimer),d&&d.removeNode(!0),d=null}var d,e,g=f(a),h=a.namespaces,i=a.parentWindow;return!B||a.printShived?a:("undefined"==typeof h[A]&&h.add(A),i.attachEvent("onbeforeprint",function(){b();for(var f,g,h,i=a.styleSheets,j=[],l=i.length,n=Array(l);l--;)n[l]=i[l];for(;h=n.pop();)if(!h.disabled&&z.test(h.media)){try{f=h.imports,g=f.length}catch(o){g=0}for(l=0;g>l;l++)n.push(f[l]);try{j.push(h.cssText)}catch(o){}}j=m(j.reverse().join("")),e=k(a),d=c(a,j)}),i.attachEvent("onafterprint",function(){n(e),clearTimeout(g._removeSheetTimer),g._removeSheetTimer=setTimeout(b,500)}),a.printShived=!0,a)}var p,q,r="3.7.3",s=a.html5||{},t=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,u=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,v="_html5shiv",w=0,x={};!function(){try{var a=b.createElement("a");a.innerHTML="",p="hidden"in a,q=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){p=!0,q=!0}}();var y={elements:s.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:r,shivCSS:s.shivCSS!==!1,supportsUnknownElements:q,shivMethods:s.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=y,j(b);var z=/^$|\b(?:all|print)\b/,A="html5shiv",B=!q&&function(){var c=b.documentElement;return!("undefined"==typeof b.namespaces||"undefined"==typeof b.parentWindow||"undefined"==typeof c.applyElement||"undefined"==typeof c.removeNode||"undefined"==typeof a.attachEvent)}();y.type+=" print",y.shivPrint=o,o(b),"object"==typeof module&&module.exports&&(module.exports=y)}("undefined"!=typeof window?window:this,document); \ No newline at end of file diff --git a/isofit-tutorials/build/html/_static/js/html5shiv.min.js b/isofit-tutorials/build/html/_static/js/html5shiv.min.js new file mode 100644 index 0000000..cd1c674 --- /dev/null +++ b/isofit-tutorials/build/html/_static/js/html5shiv.min.js @@ -0,0 +1,4 @@ +/** +* @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed +*/ +!function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=t.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=t.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),t.elements=c+" "+a,j(b)}function f(a){var b=s[a[q]];return b||(b={},r++,a[q]=r,s[r]=b),b}function g(a,c,d){if(c||(c=b),l)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():p.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||o.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),l)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return t.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(t,b.frag)}function j(a){a||(a=b);var d=f(a);return!t.shivCSS||k||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),l||i(a,d),a}var k,l,m="3.7.3-pre",n=a.html5||{},o=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,p=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,q="_html5shiv",r=0,s={};!function(){try{var a=b.createElement("a");a.innerHTML="",k="hidden"in a,l=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){k=!0,l=!0}}();var t={elements:n.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:m,shivCSS:n.shivCSS!==!1,supportsUnknownElements:l,shivMethods:n.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=t,j(b),"object"==typeof module&&module.exports&&(module.exports=t)}("undefined"!=typeof window?window:this,document); \ No newline at end of file diff --git a/isofit-tutorials/build/html/_static/js/theme.js b/isofit-tutorials/build/html/_static/js/theme.js new file mode 100644 index 0000000..1fddb6e --- /dev/null +++ b/isofit-tutorials/build/html/_static/js/theme.js @@ -0,0 +1 @@ +!function(n){var e={};function t(i){if(e[i])return e[i].exports;var o=e[i]={i:i,l:!1,exports:{}};return n[i].call(o.exports,o,o.exports,t),o.l=!0,o.exports}t.m=n,t.c=e,t.d=function(n,e,i){t.o(n,e)||Object.defineProperty(n,e,{enumerable:!0,get:i})},t.r=function(n){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(n,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(n,"__esModule",{value:!0})},t.t=function(n,e){if(1&e&&(n=t(n)),8&e)return n;if(4&e&&"object"==typeof n&&n&&n.__esModule)return n;var i=Object.create(null);if(t.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:n}),2&e&&"string"!=typeof n)for(var o in n)t.d(i,o,function(e){return n[e]}.bind(null,o));return i},t.n=function(n){var e=n&&n.__esModule?function(){return n.default}:function(){return n};return t.d(e,"a",e),e},t.o=function(n,e){return Object.prototype.hasOwnProperty.call(n,e)},t.p="",t(t.s=0)}([function(n,e,t){t(1),n.exports=t(3)},function(n,e,t){(function(){var e="undefined"!=typeof window?window.jQuery:t(2);n.exports.ThemeNav={navBar:null,win:null,winScroll:!1,winResize:!1,linkScroll:!1,winPosition:0,winHeight:null,docHeight:null,isRunning:!1,enable:function(n){var t=this;void 0===n&&(n=!0),t.isRunning||(t.isRunning=!0,e((function(e){t.init(e),t.reset(),t.win.on("hashchange",t.reset),n&&t.win.on("scroll",(function(){t.linkScroll||t.winScroll||(t.winScroll=!0,requestAnimationFrame((function(){t.onScroll()})))})),t.win.on("resize",(function(){t.winResize||(t.winResize=!0,requestAnimationFrame((function(){t.onResize()})))})),t.onResize()})))},enableSticky:function(){this.enable(!0)},init:function(n){n(document);var e=this;this.navBar=n("div.wy-side-scroll:first"),this.win=n(window),n(document).on("click","[data-toggle='wy-nav-top']",(function(){n("[data-toggle='wy-nav-shift']").toggleClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift")})).on("click",".wy-menu-vertical .current ul li a",(function(){var t=n(this);n("[data-toggle='wy-nav-shift']").removeClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift"),e.toggleCurrent(t),e.hashChange()})).on("click","[data-toggle='rst-current-version']",(function(){n("[data-toggle='rst-versions']").toggleClass("shift-up")})),n("table.docutils:not(.field-list,.footnote,.citation)").wrap("
"),n("table.docutils.footnote").wrap("
"),n("table.docutils.citation").wrap("
"),n(".wy-menu-vertical ul").not(".simple").siblings("a").each((function(){var t=n(this);expand=n(''),expand.on("click",(function(n){return e.toggleCurrent(t),n.stopPropagation(),!1})),t.prepend(expand)}))},reset:function(){var n=encodeURI(window.location.hash)||"#";try{var e=$(".wy-menu-vertical"),t=e.find('[href="'+n+'"]');if(0===t.length){var i=$('.document [id="'+n.substring(1)+'"]').closest("div.section");0===(t=e.find('[href="#'+i.attr("id")+'"]')).length&&(t=e.find('[href="#"]'))}if(t.length>0){$(".wy-menu-vertical .current").removeClass("current").attr("aria-expanded","false"),t.addClass("current").attr("aria-expanded","true"),t.closest("li.toctree-l1").parent().addClass("current").attr("aria-expanded","true");for(let n=1;n<=10;n++)t.closest("li.toctree-l"+n).addClass("current").attr("aria-expanded","true");t[0].scrollIntoView()}}catch(n){console.log("Error expanding nav for anchor",n)}},onScroll:function(){this.winScroll=!1;var n=this.win.scrollTop(),e=n+this.winHeight,t=this.navBar.scrollTop()+(n-this.winPosition);n<0||e>this.docHeight||(this.navBar.scrollTop(t),this.winPosition=n)},onResize:function(){this.winResize=!1,this.winHeight=this.win.height(),this.docHeight=$(document).height()},hashChange:function(){this.linkScroll=!0,this.win.one("hashchange",(function(){this.linkScroll=!1}))},toggleCurrent:function(n){var e=n.closest("li");e.siblings("li.current").removeClass("current").attr("aria-expanded","false"),e.siblings().find("li.current").removeClass("current").attr("aria-expanded","false");var t=e.find("> ul li");t.length&&(t.removeClass("current").attr("aria-expanded","false"),e.toggleClass("current").attr("aria-expanded",(function(n,e){return"true"==e?"false":"true"})))}},"undefined"!=typeof window&&(window.SphinxRtdTheme={Navigation:n.exports.ThemeNav,StickyNav:n.exports.ThemeNav}),function(){for(var n=0,e=["ms","moz","webkit","o"],t=0;t0 + var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1 + var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1 + var s_v = "^(" + C + ")?" + v; // vowel in stem + + this.stemWord = function (w) { + var stem; + var suffix; + var firstch; + var origword = w; + + if (w.length < 3) + return w; + + var re; + var re2; + var re3; + var re4; + + firstch = w.substr(0,1); + if (firstch == "y") + w = firstch.toUpperCase() + w.substr(1); + + // Step 1a + re = /^(.+?)(ss|i)es$/; + re2 = /^(.+?)([^s])s$/; + + if (re.test(w)) + w = w.replace(re,"$1$2"); + else if (re2.test(w)) + w = w.replace(re2,"$1$2"); + + // Step 1b + re = /^(.+?)eed$/; + re2 = /^(.+?)(ed|ing)$/; + if (re.test(w)) { + var fp = re.exec(w); + re = new RegExp(mgr0); + if (re.test(fp[1])) { + re = /.$/; + w = w.replace(re,""); + } + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1]; + re2 = new RegExp(s_v); + if (re2.test(stem)) { + w = stem; + re2 = /(at|bl|iz)$/; + re3 = new RegExp("([^aeiouylsz])\\1$"); + re4 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re2.test(w)) + w = w + "e"; + else if (re3.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + else if (re4.test(w)) + w = w + "e"; + } + } + + // Step 1c + re = /^(.+?)y$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(s_v); + if (re.test(stem)) + w = stem + "i"; + } + + // Step 2 + re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step2list[suffix]; + } + + // Step 3 + re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step3list[suffix]; + } + + // Step 4 + re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/; + re2 = /^(.+?)(s|t)(ion)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + if (re.test(stem)) + w = stem; + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1] + fp[2]; + re2 = new RegExp(mgr1); + if (re2.test(stem)) + w = stem; + } + + // Step 5 + re = /^(.+?)e$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + re2 = new RegExp(meq1); + re3 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re.test(stem) || (re2.test(stem) && !(re3.test(stem)))) + w = stem; + } + re = /ll$/; + re2 = new RegExp(mgr1); + if (re.test(w) && re2.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + + // and turn initial Y back to y + if (firstch == "y") + w = firstch.toLowerCase() + w.substr(1); + return w; + } +} + diff --git a/isofit-tutorials/build/html/_static/minus.png b/isofit-tutorials/build/html/_static/minus.png new file mode 100644 index 0000000..d96755f Binary files /dev/null and b/isofit-tutorials/build/html/_static/minus.png differ diff --git a/isofit-tutorials/build/html/_static/nbsphinx-broken-thumbnail.svg b/isofit-tutorials/build/html/_static/nbsphinx-broken-thumbnail.svg new file mode 100644 index 0000000..4919ca8 --- /dev/null +++ b/isofit-tutorials/build/html/_static/nbsphinx-broken-thumbnail.svg @@ -0,0 +1,9 @@ + + + + diff --git a/isofit-tutorials/build/html/_static/nbsphinx-code-cells.css b/isofit-tutorials/build/html/_static/nbsphinx-code-cells.css new file mode 100644 index 0000000..a3fb27c --- /dev/null +++ b/isofit-tutorials/build/html/_static/nbsphinx-code-cells.css @@ -0,0 +1,259 @@ +/* remove conflicting styling from Sphinx themes */ +div.nbinput.container div.prompt *, +div.nboutput.container div.prompt *, +div.nbinput.container div.input_area pre, +div.nboutput.container div.output_area pre, +div.nbinput.container div.input_area .highlight, +div.nboutput.container div.output_area .highlight { + border: none; + padding: 0; + margin: 0; + box-shadow: none; +} + +div.nbinput.container > div[class*=highlight], +div.nboutput.container > div[class*=highlight] { + margin: 0; +} + +div.nbinput.container div.prompt *, +div.nboutput.container div.prompt * { + background: none; +} + +div.nboutput.container div.output_area .highlight, +div.nboutput.container div.output_area pre { + background: unset; +} + +div.nboutput.container div.output_area div.highlight { + color: unset; /* override Pygments text color */ +} + +/* avoid gaps between output lines */ +div.nboutput.container div[class*=highlight] pre { + line-height: normal; +} + +/* input/output containers */ +div.nbinput.container, +div.nboutput.container { + display: -webkit-flex; + display: flex; + align-items: flex-start; + margin: 0; + width: 100%; +} +@media (max-width: 540px) { + div.nbinput.container, + div.nboutput.container { + flex-direction: column; + } +} + +/* input container */ +div.nbinput.container { + padding-top: 5px; +} + +/* last container */ +div.nblast.container { + padding-bottom: 5px; +} + +/* input prompt */ +div.nbinput.container div.prompt pre, +/* for sphinx_immaterial theme: */ +div.nbinput.container div.prompt pre > code { + color: #307FC1; +} + +/* output prompt */ +div.nboutput.container div.prompt pre, +/* for sphinx_immaterial theme: */ +div.nboutput.container div.prompt pre > code { + color: #BF5B3D; +} + +/* all prompts */ +div.nbinput.container div.prompt, +div.nboutput.container div.prompt { + width: 4.5ex; + padding-top: 5px; + position: relative; + user-select: none; +} + +div.nbinput.container div.prompt > div, +div.nboutput.container div.prompt > div { + position: absolute; + right: 0; + margin-right: 0.3ex; +} + +@media (max-width: 540px) { + div.nbinput.container div.prompt, + div.nboutput.container div.prompt { + width: unset; + text-align: left; + padding: 0.4em; + } + div.nboutput.container div.prompt.empty { + padding: 0; + } + + div.nbinput.container div.prompt > div, + div.nboutput.container div.prompt > div { + position: unset; + } +} + +/* disable scrollbars and line breaks on prompts */ +div.nbinput.container div.prompt pre, +div.nboutput.container div.prompt pre { + overflow: hidden; + white-space: pre; +} + +/* input/output area */ +div.nbinput.container div.input_area, +div.nboutput.container div.output_area { + -webkit-flex: 1; + flex: 1; + overflow: auto; +} +@media (max-width: 540px) { + div.nbinput.container div.input_area, + div.nboutput.container div.output_area { + width: 100%; + } +} + +/* input area */ +div.nbinput.container div.input_area { + border: 1px solid #e0e0e0; + border-radius: 2px; + /*background: #f5f5f5;*/ +} + +/* override MathJax center alignment in output cells */ +div.nboutput.container div[class*=MathJax] { + text-align: left !important; +} + +/* override sphinx.ext.imgmath center alignment in output cells */ +div.nboutput.container div.math p { + text-align: left; +} + +/* standard error */ +div.nboutput.container div.output_area.stderr { + background: #fdd; +} + +/* ANSI colors */ +.ansi-black-fg { color: #3E424D; } +.ansi-black-bg { background-color: #3E424D; } +.ansi-black-intense-fg { color: #282C36; } +.ansi-black-intense-bg { background-color: #282C36; } +.ansi-red-fg { color: #E75C58; } +.ansi-red-bg { background-color: #E75C58; } +.ansi-red-intense-fg { color: #B22B31; } +.ansi-red-intense-bg { background-color: #B22B31; } +.ansi-green-fg { color: #00A250; } +.ansi-green-bg { background-color: #00A250; } +.ansi-green-intense-fg { color: #007427; } +.ansi-green-intense-bg { background-color: #007427; } +.ansi-yellow-fg { color: #DDB62B; } +.ansi-yellow-bg { background-color: #DDB62B; } +.ansi-yellow-intense-fg { color: #B27D12; } +.ansi-yellow-intense-bg { background-color: #B27D12; } +.ansi-blue-fg { color: #208FFB; } +.ansi-blue-bg { background-color: #208FFB; } +.ansi-blue-intense-fg { color: #0065CA; } +.ansi-blue-intense-bg { background-color: #0065CA; } +.ansi-magenta-fg { color: #D160C4; } +.ansi-magenta-bg { background-color: #D160C4; } +.ansi-magenta-intense-fg { color: #A03196; } +.ansi-magenta-intense-bg { background-color: #A03196; } +.ansi-cyan-fg { color: #60C6C8; } +.ansi-cyan-bg { background-color: #60C6C8; } +.ansi-cyan-intense-fg { color: #258F8F; } +.ansi-cyan-intense-bg { background-color: #258F8F; } +.ansi-white-fg { color: #C5C1B4; } +.ansi-white-bg { background-color: #C5C1B4; } +.ansi-white-intense-fg { color: #A1A6B2; } +.ansi-white-intense-bg { background-color: #A1A6B2; } + +.ansi-default-inverse-fg { color: #FFFFFF; } +.ansi-default-inverse-bg { background-color: #000000; } + +.ansi-bold { font-weight: bold; } +.ansi-underline { text-decoration: underline; } + + +div.nbinput.container div.input_area div[class*=highlight] > pre, +div.nboutput.container div.output_area div[class*=highlight] > pre, +div.nboutput.container div.output_area div[class*=highlight].math, +div.nboutput.container div.output_area.rendered_html, +div.nboutput.container div.output_area > div.output_javascript, +div.nboutput.container div.output_area:not(.rendered_html) > img{ + padding: 5px; + margin: 0; +} + +/* fix copybtn overflow problem in chromium (needed for 'sphinx_copybutton') */ +div.nbinput.container div.input_area > div[class^='highlight'], +div.nboutput.container div.output_area > div[class^='highlight']{ + overflow-y: hidden; +} + +/* hide copy button on prompts for 'sphinx_copybutton' extension ... */ +.prompt .copybtn, +/* ... and 'sphinx_immaterial' theme */ +.prompt .md-clipboard.md-icon { + display: none; +} + +/* Some additional styling taken form the Jupyter notebook CSS */ +.jp-RenderedHTMLCommon table, +div.rendered_html table { + border: none; + border-collapse: collapse; + border-spacing: 0; + color: black; + font-size: 12px; + table-layout: fixed; +} +.jp-RenderedHTMLCommon thead, +div.rendered_html thead { + border-bottom: 1px solid black; + vertical-align: bottom; +} +.jp-RenderedHTMLCommon tr, +.jp-RenderedHTMLCommon th, +.jp-RenderedHTMLCommon td, +div.rendered_html tr, +div.rendered_html th, +div.rendered_html td { + text-align: right; + vertical-align: middle; + padding: 0.5em 0.5em; + line-height: normal; + white-space: normal; + max-width: none; + border: none; +} +.jp-RenderedHTMLCommon th, +div.rendered_html th { + font-weight: bold; +} +.jp-RenderedHTMLCommon tbody tr:nth-child(odd), +div.rendered_html tbody tr:nth-child(odd) { + background: #f5f5f5; +} +.jp-RenderedHTMLCommon tbody tr:hover, +div.rendered_html tbody tr:hover { + background: rgba(66, 165, 245, 0.2); +} + diff --git a/isofit-tutorials/build/html/_static/nbsphinx-gallery.css b/isofit-tutorials/build/html/_static/nbsphinx-gallery.css new file mode 100644 index 0000000..365c27a --- /dev/null +++ b/isofit-tutorials/build/html/_static/nbsphinx-gallery.css @@ -0,0 +1,31 @@ +.nbsphinx-gallery { + display: grid; + grid-template-columns: repeat(auto-fill, minmax(160px, 1fr)); + gap: 5px; + margin-top: 1em; + margin-bottom: 1em; +} + +.nbsphinx-gallery > a { + padding: 5px; + border: 1px dotted currentColor; + border-radius: 2px; + text-align: center; +} + +.nbsphinx-gallery > a:hover { + border-style: solid; +} + +.nbsphinx-gallery img { + max-width: 100%; + max-height: 100%; +} + +.nbsphinx-gallery > a > div:first-child { + display: flex; + align-items: start; + justify-content: center; + height: 120px; + margin-bottom: 5px; +} diff --git a/isofit-tutorials/build/html/_static/nbsphinx-no-thumbnail.svg b/isofit-tutorials/build/html/_static/nbsphinx-no-thumbnail.svg new file mode 100644 index 0000000..9dca758 --- /dev/null +++ b/isofit-tutorials/build/html/_static/nbsphinx-no-thumbnail.svg @@ -0,0 +1,9 @@ + + + + diff --git a/isofit-tutorials/build/html/_static/plus.png b/isofit-tutorials/build/html/_static/plus.png new file mode 100644 index 0000000..7107cec Binary files /dev/null and b/isofit-tutorials/build/html/_static/plus.png differ diff --git a/isofit-tutorials/build/html/_static/pygments.css b/isofit-tutorials/build/html/_static/pygments.css new file mode 100644 index 0000000..6f8b210 --- /dev/null +++ b/isofit-tutorials/build/html/_static/pygments.css @@ -0,0 +1,75 @@ +pre { line-height: 125%; } +td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +.highlight .hll { background-color: #ffffcc } +.highlight { background: #f8f8f8; } +.highlight .c { color: #3D7B7B; font-style: italic } /* Comment */ +.highlight .err { border: 1px solid #F00 } /* Error */ +.highlight .k { color: #008000; font-weight: bold } /* Keyword */ +.highlight .o { color: #666 } /* Operator */ +.highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */ +.highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */ +.highlight .cp { color: #9C6500 } /* Comment.Preproc */ +.highlight .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */ +.highlight .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */ +.highlight .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */ +.highlight .gd { color: #A00000 } /* Generic.Deleted */ +.highlight .ge { font-style: italic } /* Generic.Emph */ +.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */ +.highlight .gr { color: #E40000 } /* Generic.Error */ +.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */ +.highlight .gi { color: #008400 } /* Generic.Inserted */ +.highlight .go { color: #717171 } /* Generic.Output */ +.highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */ +.highlight .gs { font-weight: bold } /* Generic.Strong */ +.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */ +.highlight .gt { color: #04D } /* Generic.Traceback */ +.highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */ +.highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */ +.highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */ +.highlight .kp { color: #008000 } /* Keyword.Pseudo */ +.highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */ +.highlight .kt { color: #B00040 } /* Keyword.Type */ +.highlight .m { color: #666 } /* Literal.Number */ +.highlight .s { color: #BA2121 } /* Literal.String */ +.highlight .na { color: #687822 } /* Name.Attribute */ +.highlight .nb { color: #008000 } /* Name.Builtin */ +.highlight .nc { color: #00F; font-weight: bold } /* Name.Class */ +.highlight .no { color: #800 } /* Name.Constant */ +.highlight .nd { color: #A2F } /* Name.Decorator */ +.highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */ +.highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */ +.highlight .nf { color: #00F } /* Name.Function */ +.highlight .nl { color: #767600 } /* Name.Label */ +.highlight .nn { color: #00F; font-weight: bold } /* Name.Namespace */ +.highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */ +.highlight .nv { color: #19177C } /* Name.Variable */ +.highlight .ow { color: #A2F; font-weight: bold } /* Operator.Word */ +.highlight .w { color: #BBB } /* Text.Whitespace */ +.highlight .mb { color: #666 } /* Literal.Number.Bin */ +.highlight .mf { color: #666 } /* Literal.Number.Float */ +.highlight .mh { color: #666 } /* Literal.Number.Hex */ +.highlight .mi { color: #666 } /* Literal.Number.Integer */ +.highlight .mo { color: #666 } /* Literal.Number.Oct */ +.highlight .sa { color: #BA2121 } /* Literal.String.Affix */ +.highlight .sb { color: #BA2121 } /* Literal.String.Backtick */ +.highlight .sc { color: #BA2121 } /* Literal.String.Char */ +.highlight .dl { color: #BA2121 } /* Literal.String.Delimiter */ +.highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */ +.highlight .s2 { color: #BA2121 } /* Literal.String.Double */ +.highlight .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */ +.highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */ +.highlight .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */ +.highlight .sx { color: #008000 } /* Literal.String.Other */ +.highlight .sr { color: #A45A77 } /* Literal.String.Regex */ +.highlight .s1 { color: #BA2121 } /* Literal.String.Single */ +.highlight .ss { color: #19177C } /* Literal.String.Symbol */ +.highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */ +.highlight .fm { color: #00F } /* Name.Function.Magic */ +.highlight .vc { color: #19177C } /* Name.Variable.Class */ +.highlight .vg { color: #19177C } /* Name.Variable.Global */ +.highlight .vi { color: #19177C } /* Name.Variable.Instance */ +.highlight .vm { color: #19177C } /* Name.Variable.Magic */ +.highlight .il { color: #666 } /* Literal.Number.Integer.Long */ \ No newline at end of file diff --git a/isofit-tutorials/build/html/_static/searchtools.js b/isofit-tutorials/build/html/_static/searchtools.js new file mode 100644 index 0000000..b08d58c --- /dev/null +++ b/isofit-tutorials/build/html/_static/searchtools.js @@ -0,0 +1,620 @@ +/* + * searchtools.js + * ~~~~~~~~~~~~~~~~ + * + * Sphinx JavaScript utilities for the full-text search. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ +"use strict"; + +/** + * Simple result scoring code. + */ +if (typeof Scorer === "undefined") { + var Scorer = { + // Implement the following function to further tweak the score for each result + // The function takes a result array [docname, title, anchor, descr, score, filename] + // and returns the new score. + /* + score: result => { + const [docname, title, anchor, descr, score, filename] = result + return score + }, + */ + + // query matches the full name of an object + objNameMatch: 11, + // or matches in the last dotted part of the object name + objPartialMatch: 6, + // Additive scores depending on the priority of the object + objPrio: { + 0: 15, // used to be importantResults + 1: 5, // used to be objectResults + 2: -5, // used to be unimportantResults + }, + // Used when the priority is not in the mapping. + objPrioDefault: 0, + + // query found in title + title: 15, + partialTitle: 7, + // query found in terms + term: 5, + partialTerm: 2, + }; +} + +const _removeChildren = (element) => { + while (element && element.lastChild) element.removeChild(element.lastChild); +}; + +/** + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping + */ +const _escapeRegExp = (string) => + string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string + +const _displayItem = (item, searchTerms, highlightTerms) => { + const docBuilder = DOCUMENTATION_OPTIONS.BUILDER; + const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX; + const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX; + const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY; + const contentRoot = document.documentElement.dataset.content_root; + + const [docName, title, anchor, descr, score, _filename] = item; + + let listItem = document.createElement("li"); + let requestUrl; + let linkUrl; + if (docBuilder === "dirhtml") { + // dirhtml builder + let dirname = docName + "/"; + if (dirname.match(/\/index\/$/)) + dirname = dirname.substring(0, dirname.length - 6); + else if (dirname === "index/") dirname = ""; + requestUrl = contentRoot + dirname; + linkUrl = requestUrl; + } else { + // normal html builders + requestUrl = contentRoot + docName + docFileSuffix; + linkUrl = docName + docLinkSuffix; + } + let linkEl = listItem.appendChild(document.createElement("a")); + linkEl.href = linkUrl + anchor; + linkEl.dataset.score = score; + linkEl.innerHTML = title; + if (descr) { + listItem.appendChild(document.createElement("span")).innerHTML = + " (" + descr + ")"; + // highlight search terms in the description + if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js + highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted")); + } + else if (showSearchSummary) + fetch(requestUrl) + .then((responseData) => responseData.text()) + .then((data) => { + if (data) + listItem.appendChild( + Search.makeSearchSummary(data, searchTerms, anchor) + ); + // highlight search terms in the summary + if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js + highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted")); + }); + Search.output.appendChild(listItem); +}; +const _finishSearch = (resultCount) => { + Search.stopPulse(); + Search.title.innerText = _("Search Results"); + if (!resultCount) + Search.status.innerText = Documentation.gettext( + "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories." + ); + else + Search.status.innerText = _( + "Search finished, found ${resultCount} page(s) matching the search query." + ).replace('${resultCount}', resultCount); +}; +const _displayNextItem = ( + results, + resultCount, + searchTerms, + highlightTerms, +) => { + // results left, load the summary and display it + // this is intended to be dynamic (don't sub resultsCount) + if (results.length) { + _displayItem(results.pop(), searchTerms, highlightTerms); + setTimeout( + () => _displayNextItem(results, resultCount, searchTerms, highlightTerms), + 5 + ); + } + // search finished, update title and status message + else _finishSearch(resultCount); +}; +// Helper function used by query() to order search results. +// Each input is an array of [docname, title, anchor, descr, score, filename]. +// Order the results by score (in opposite order of appearance, since the +// `_displayNextItem` function uses pop() to retrieve items) and then alphabetically. +const _orderResultsByScoreThenName = (a, b) => { + const leftScore = a[4]; + const rightScore = b[4]; + if (leftScore === rightScore) { + // same score: sort alphabetically + const leftTitle = a[1].toLowerCase(); + const rightTitle = b[1].toLowerCase(); + if (leftTitle === rightTitle) return 0; + return leftTitle > rightTitle ? -1 : 1; // inverted is intentional + } + return leftScore > rightScore ? 1 : -1; +}; + +/** + * Default splitQuery function. Can be overridden in ``sphinx.search`` with a + * custom function per language. + * + * The regular expression works by splitting the string on consecutive characters + * that are not Unicode letters, numbers, underscores, or emoji characters. + * This is the same as ``\W+`` in Python, preserving the surrogate pair area. + */ +if (typeof splitQuery === "undefined") { + var splitQuery = (query) => query + .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu) + .filter(term => term) // remove remaining empty strings +} + +/** + * Search Module + */ +const Search = { + _index: null, + _queued_query: null, + _pulse_status: -1, + + htmlToText: (htmlString, anchor) => { + const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html'); + for (const removalQuery of [".headerlink", "script", "style"]) { + htmlElement.querySelectorAll(removalQuery).forEach((el) => { el.remove() }); + } + if (anchor) { + const anchorContent = htmlElement.querySelector(`[role="main"] ${anchor}`); + if (anchorContent) return anchorContent.textContent; + + console.warn( + `Anchored content block not found. Sphinx search tries to obtain it via DOM query '[role=main] ${anchor}'. Check your theme or template.` + ); + } + + // if anchor not specified or not found, fall back to main content + const docContent = htmlElement.querySelector('[role="main"]'); + if (docContent) return docContent.textContent; + + console.warn( + "Content block not found. Sphinx search tries to obtain it via DOM query '[role=main]'. Check your theme or template." + ); + return ""; + }, + + init: () => { + const query = new URLSearchParams(window.location.search).get("q"); + document + .querySelectorAll('input[name="q"]') + .forEach((el) => (el.value = query)); + if (query) Search.performSearch(query); + }, + + loadIndex: (url) => + (document.body.appendChild(document.createElement("script")).src = url), + + setIndex: (index) => { + Search._index = index; + if (Search._queued_query !== null) { + const query = Search._queued_query; + Search._queued_query = null; + Search.query(query); + } + }, + + hasIndex: () => Search._index !== null, + + deferQuery: (query) => (Search._queued_query = query), + + stopPulse: () => (Search._pulse_status = -1), + + startPulse: () => { + if (Search._pulse_status >= 0) return; + + const pulse = () => { + Search._pulse_status = (Search._pulse_status + 1) % 4; + Search.dots.innerText = ".".repeat(Search._pulse_status); + if (Search._pulse_status >= 0) window.setTimeout(pulse, 500); + }; + pulse(); + }, + + /** + * perform a search for something (or wait until index is loaded) + */ + performSearch: (query) => { + // create the required interface elements + const searchText = document.createElement("h2"); + searchText.textContent = _("Searching"); + const searchSummary = document.createElement("p"); + searchSummary.classList.add("search-summary"); + searchSummary.innerText = ""; + const searchList = document.createElement("ul"); + searchList.classList.add("search"); + + const out = document.getElementById("search-results"); + Search.title = out.appendChild(searchText); + Search.dots = Search.title.appendChild(document.createElement("span")); + Search.status = out.appendChild(searchSummary); + Search.output = out.appendChild(searchList); + + const searchProgress = document.getElementById("search-progress"); + // Some themes don't use the search progress node + if (searchProgress) { + searchProgress.innerText = _("Preparing search..."); + } + Search.startPulse(); + + // index already loaded, the browser was quick! + if (Search.hasIndex()) Search.query(query); + else Search.deferQuery(query); + }, + + _parseQuery: (query) => { + // stem the search terms and add them to the correct list + const stemmer = new Stemmer(); + const searchTerms = new Set(); + const excludedTerms = new Set(); + const highlightTerms = new Set(); + const objectTerms = new Set(splitQuery(query.toLowerCase().trim())); + splitQuery(query.trim()).forEach((queryTerm) => { + const queryTermLower = queryTerm.toLowerCase(); + + // maybe skip this "word" + // stopwords array is from language_data.js + if ( + stopwords.indexOf(queryTermLower) !== -1 || + queryTerm.match(/^\d+$/) + ) + return; + + // stem the word + let word = stemmer.stemWord(queryTermLower); + // select the correct list + if (word[0] === "-") excludedTerms.add(word.substr(1)); + else { + searchTerms.add(word); + highlightTerms.add(queryTermLower); + } + }); + + if (SPHINX_HIGHLIGHT_ENABLED) { // set in sphinx_highlight.js + localStorage.setItem("sphinx_highlight_terms", [...highlightTerms].join(" ")) + } + + // console.debug("SEARCH: searching for:"); + // console.info("required: ", [...searchTerms]); + // console.info("excluded: ", [...excludedTerms]); + + return [query, searchTerms, excludedTerms, highlightTerms, objectTerms]; + }, + + /** + * execute search (requires search index to be loaded) + */ + _performSearch: (query, searchTerms, excludedTerms, highlightTerms, objectTerms) => { + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const titles = Search._index.titles; + const allTitles = Search._index.alltitles; + const indexEntries = Search._index.indexentries; + + // Collect multiple result groups to be sorted separately and then ordered. + // Each is an array of [docname, title, anchor, descr, score, filename]. + const normalResults = []; + const nonMainIndexResults = []; + + _removeChildren(document.getElementById("search-progress")); + + const queryLower = query.toLowerCase().trim(); + for (const [title, foundTitles] of Object.entries(allTitles)) { + if (title.toLowerCase().trim().includes(queryLower) && (queryLower.length >= title.length/2)) { + for (const [file, id] of foundTitles) { + const score = Math.round(Scorer.title * queryLower.length / title.length); + const boost = titles[file] === title ? 1 : 0; // add a boost for document titles + normalResults.push([ + docNames[file], + titles[file] !== title ? `${titles[file]} > ${title}` : title, + id !== null ? "#" + id : "", + null, + score + boost, + filenames[file], + ]); + } + } + } + + // search for explicit entries in index directives + for (const [entry, foundEntries] of Object.entries(indexEntries)) { + if (entry.includes(queryLower) && (queryLower.length >= entry.length/2)) { + for (const [file, id, isMain] of foundEntries) { + const score = Math.round(100 * queryLower.length / entry.length); + const result = [ + docNames[file], + titles[file], + id ? "#" + id : "", + null, + score, + filenames[file], + ]; + if (isMain) { + normalResults.push(result); + } else { + nonMainIndexResults.push(result); + } + } + } + } + + // lookup as object + objectTerms.forEach((term) => + normalResults.push(...Search.performObjectSearch(term, objectTerms)) + ); + + // lookup as search terms in fulltext + normalResults.push(...Search.performTermsSearch(searchTerms, excludedTerms)); + + // let the scorer override scores with a custom scoring function + if (Scorer.score) { + normalResults.forEach((item) => (item[4] = Scorer.score(item))); + nonMainIndexResults.forEach((item) => (item[4] = Scorer.score(item))); + } + + // Sort each group of results by score and then alphabetically by name. + normalResults.sort(_orderResultsByScoreThenName); + nonMainIndexResults.sort(_orderResultsByScoreThenName); + + // Combine the result groups in (reverse) order. + // Non-main index entries are typically arbitrary cross-references, + // so display them after other results. + let results = [...nonMainIndexResults, ...normalResults]; + + // remove duplicate search results + // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept + let seen = new Set(); + results = results.reverse().reduce((acc, result) => { + let resultStr = result.slice(0, 4).concat([result[5]]).map(v => String(v)).join(','); + if (!seen.has(resultStr)) { + acc.push(result); + seen.add(resultStr); + } + return acc; + }, []); + + return results.reverse(); + }, + + query: (query) => { + const [searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms] = Search._parseQuery(query); + const results = Search._performSearch(searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms); + + // for debugging + //Search.lastresults = results.slice(); // a copy + // console.info("search results:", Search.lastresults); + + // print the results + _displayNextItem(results, results.length, searchTerms, highlightTerms); + }, + + /** + * search for object names + */ + performObjectSearch: (object, objectTerms) => { + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const objects = Search._index.objects; + const objNames = Search._index.objnames; + const titles = Search._index.titles; + + const results = []; + + const objectSearchCallback = (prefix, match) => { + const name = match[4] + const fullname = (prefix ? prefix + "." : "") + name; + const fullnameLower = fullname.toLowerCase(); + if (fullnameLower.indexOf(object) < 0) return; + + let score = 0; + const parts = fullnameLower.split("."); + + // check for different match types: exact matches of full name or + // "last name" (i.e. last dotted part) + if (fullnameLower === object || parts.slice(-1)[0] === object) + score += Scorer.objNameMatch; + else if (parts.slice(-1)[0].indexOf(object) > -1) + score += Scorer.objPartialMatch; // matches in last name + + const objName = objNames[match[1]][2]; + const title = titles[match[0]]; + + // If more than one term searched for, we require other words to be + // found in the name/title/description + const otherTerms = new Set(objectTerms); + otherTerms.delete(object); + if (otherTerms.size > 0) { + const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase(); + if ( + [...otherTerms].some((otherTerm) => haystack.indexOf(otherTerm) < 0) + ) + return; + } + + let anchor = match[3]; + if (anchor === "") anchor = fullname; + else if (anchor === "-") anchor = objNames[match[1]][1] + "-" + fullname; + + const descr = objName + _(", in ") + title; + + // add custom score for some objects according to scorer + if (Scorer.objPrio.hasOwnProperty(match[2])) + score += Scorer.objPrio[match[2]]; + else score += Scorer.objPrioDefault; + + results.push([ + docNames[match[0]], + fullname, + "#" + anchor, + descr, + score, + filenames[match[0]], + ]); + }; + Object.keys(objects).forEach((prefix) => + objects[prefix].forEach((array) => + objectSearchCallback(prefix, array) + ) + ); + return results; + }, + + /** + * search for full-text terms in the index + */ + performTermsSearch: (searchTerms, excludedTerms) => { + // prepare search + const terms = Search._index.terms; + const titleTerms = Search._index.titleterms; + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const titles = Search._index.titles; + + const scoreMap = new Map(); + const fileMap = new Map(); + + // perform the search on the required terms + searchTerms.forEach((word) => { + const files = []; + const arr = [ + { files: terms[word], score: Scorer.term }, + { files: titleTerms[word], score: Scorer.title }, + ]; + // add support for partial matches + if (word.length > 2) { + const escapedWord = _escapeRegExp(word); + if (!terms.hasOwnProperty(word)) { + Object.keys(terms).forEach((term) => { + if (term.match(escapedWord)) + arr.push({ files: terms[term], score: Scorer.partialTerm }); + }); + } + if (!titleTerms.hasOwnProperty(word)) { + Object.keys(titleTerms).forEach((term) => { + if (term.match(escapedWord)) + arr.push({ files: titleTerms[term], score: Scorer.partialTitle }); + }); + } + } + + // no match but word was a required one + if (arr.every((record) => record.files === undefined)) return; + + // found search word in contents + arr.forEach((record) => { + if (record.files === undefined) return; + + let recordFiles = record.files; + if (recordFiles.length === undefined) recordFiles = [recordFiles]; + files.push(...recordFiles); + + // set score for the word in each file + recordFiles.forEach((file) => { + if (!scoreMap.has(file)) scoreMap.set(file, {}); + scoreMap.get(file)[word] = record.score; + }); + }); + + // create the mapping + files.forEach((file) => { + if (!fileMap.has(file)) fileMap.set(file, [word]); + else if (fileMap.get(file).indexOf(word) === -1) fileMap.get(file).push(word); + }); + }); + + // now check if the files don't contain excluded terms + const results = []; + for (const [file, wordList] of fileMap) { + // check if all requirements are matched + + // as search terms with length < 3 are discarded + const filteredTermCount = [...searchTerms].filter( + (term) => term.length > 2 + ).length; + if ( + wordList.length !== searchTerms.size && + wordList.length !== filteredTermCount + ) + continue; + + // ensure that none of the excluded terms is in the search result + if ( + [...excludedTerms].some( + (term) => + terms[term] === file || + titleTerms[term] === file || + (terms[term] || []).includes(file) || + (titleTerms[term] || []).includes(file) + ) + ) + break; + + // select one (max) score for the file. + const score = Math.max(...wordList.map((w) => scoreMap.get(file)[w])); + // add result to the result list + results.push([ + docNames[file], + titles[file], + "", + null, + score, + filenames[file], + ]); + } + return results; + }, + + /** + * helper function to return a node containing the + * search summary for a given text. keywords is a list + * of stemmed words. + */ + makeSearchSummary: (htmlText, keywords, anchor) => { + const text = Search.htmlToText(htmlText, anchor); + if (text === "") return null; + + const textLower = text.toLowerCase(); + const actualStartPosition = [...keywords] + .map((k) => textLower.indexOf(k.toLowerCase())) + .filter((i) => i > -1) + .slice(-1)[0]; + const startWithContext = Math.max(actualStartPosition - 120, 0); + + const top = startWithContext === 0 ? "" : "..."; + const tail = startWithContext + 240 < text.length ? "..." : ""; + + let summary = document.createElement("p"); + summary.classList.add("context"); + summary.textContent = top + text.substr(startWithContext, 240).trim() + tail; + + return summary; + }, +}; + +_ready(Search.init); diff --git a/isofit-tutorials/build/html/_static/sphinx_highlight.js b/isofit-tutorials/build/html/_static/sphinx_highlight.js new file mode 100644 index 0000000..8a96c69 --- /dev/null +++ b/isofit-tutorials/build/html/_static/sphinx_highlight.js @@ -0,0 +1,154 @@ +/* Highlighting utilities for Sphinx HTML documentation. */ +"use strict"; + +const SPHINX_HIGHLIGHT_ENABLED = true + +/** + * highlight a given string on a node by wrapping it in + * span elements with the given class name. + */ +const _highlight = (node, addItems, text, className) => { + if (node.nodeType === Node.TEXT_NODE) { + const val = node.nodeValue; + const parent = node.parentNode; + const pos = val.toLowerCase().indexOf(text); + if ( + pos >= 0 && + !parent.classList.contains(className) && + !parent.classList.contains("nohighlight") + ) { + let span; + + const closestNode = parent.closest("body, svg, foreignObject"); + const isInSVG = closestNode && closestNode.matches("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.classList.add(className); + } + + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + const rest = document.createTextNode(val.substr(pos + text.length)); + parent.insertBefore( + span, + parent.insertBefore( + rest, + node.nextSibling + ) + ); + node.nodeValue = val.substr(0, pos); + /* There may be more occurrences of search term in this node. So call this + * function recursively on the remaining fragment. + */ + _highlight(rest, addItems, text, className); + + if (isInSVG) { + const rect = document.createElementNS( + "http://www.w3.org/2000/svg", + "rect" + ); + const bbox = parent.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute("class", className); + addItems.push({ parent: parent, target: rect }); + } + } + } else if (node.matches && !node.matches("button, select, textarea")) { + node.childNodes.forEach((el) => _highlight(el, addItems, text, className)); + } +}; +const _highlightText = (thisNode, text, className) => { + let addItems = []; + _highlight(thisNode, addItems, text, className); + addItems.forEach((obj) => + obj.parent.insertAdjacentElement("beforebegin", obj.target) + ); +}; + +/** + * Small JavaScript module for the documentation. + */ +const SphinxHighlight = { + + /** + * highlight the search words provided in localstorage in the text + */ + highlightSearchWords: () => { + if (!SPHINX_HIGHLIGHT_ENABLED) return; // bail if no highlight + + // get and clear terms from localstorage + const url = new URL(window.location); + const highlight = + localStorage.getItem("sphinx_highlight_terms") + || url.searchParams.get("highlight") + || ""; + localStorage.removeItem("sphinx_highlight_terms") + url.searchParams.delete("highlight"); + window.history.replaceState({}, "", url); + + // get individual terms from highlight string + const terms = highlight.toLowerCase().split(/\s+/).filter(x => x); + if (terms.length === 0) return; // nothing to do + + // There should never be more than one element matching "div.body" + const divBody = document.querySelectorAll("div.body"); + const body = divBody.length ? divBody[0] : document.querySelector("body"); + window.setTimeout(() => { + terms.forEach((term) => _highlightText(body, term, "highlighted")); + }, 10); + + const searchBox = document.getElementById("searchbox"); + if (searchBox === null) return; + searchBox.appendChild( + document + .createRange() + .createContextualFragment( + '

' + + '' + + _("Hide Search Matches") + + "

" + ) + ); + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords: () => { + document + .querySelectorAll("#searchbox .highlight-link") + .forEach((el) => el.remove()); + document + .querySelectorAll("span.highlighted") + .forEach((el) => el.classList.remove("highlighted")); + localStorage.removeItem("sphinx_highlight_terms") + }, + + initEscapeListener: () => { + // only install a listener if it is really needed + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return; + if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) { + SphinxHighlight.hideSearchWords(); + event.preventDefault(); + } + }); + }, +}; + +_ready(() => { + /* Do not call highlightSearchWords() when we are on the search page. + * It will highlight words from the *previous* search query. + */ + if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords(); + SphinxHighlight.initEscapeListener(); +}); diff --git a/isofit-tutorials/build/html/genindex.html b/isofit-tutorials/build/html/genindex.html new file mode 100644 index 0000000..be9fcf3 --- /dev/null +++ b/isofit-tutorials/build/html/genindex.html @@ -0,0 +1,119 @@ + + + + + + Index — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Index
    • +
  • +
    • +
+
+
+
+
+ + +

Index

+ +
+ +
+ + +
+
+
+ +
+ +
+

© Copyright Copyright 2018 California Institute of Technology.

+
+ + Built with Sphinx using a + theme + provided by Read the Docs. + + +
+
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/how_to_run/about.html b/isofit-tutorials/build/html/how_to_run/about.html new file mode 100644 index 0000000..bb73939 --- /dev/null +++ b/isofit-tutorials/build/html/how_to_run/about.html @@ -0,0 +1,137 @@ + + + + + + + About — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

About

+

ISOFIT contains a set of routines and utilities for fitting surface, atmosphere and instrument models to imaging +spectrometer data. It is written primarily in Python, with JSON format configuration files and some dependencies on +widely-available numerical and scientific libraries such as scipy, numpy, and scikit-learn. It is designed for maximum +flexibility, so that users can swap in and evaluate model components based on different radiative transfer models (RTMs) +and various statistical descriptions of surface, instrument, and atmosphere. It can run on individual radiance spectra +in text format, or imaging spectrometer data cubes.

+
+

Feature overview

+
    +

  • utilities for fitting surface, atmosphere and instrument models to imaging spectrometer data

    • +

  • a selection of radiative transfer models (RTMs) incl. MODTRAN, LibRadTran, and 6S

    • +

  • sRTMnet emulator for MODTRAN 6 by coupling a neural network with a surrogate RTM (6S v2.1)

    • +

  • various statistical descriptions of surface, instrument, and atmosphere

    • +

  • application to both individual radiance spectra and imaging spectrometer data cubes

    • +

  • custom instrument models to handle new sensors

    • +

  • observation uncertanities to account for model discrepancy errors

    • +

  • prior distribution based on background knowledge of the state vector

    • +
+
+
+ + +
+
+
+ +
+ +
+

© Copyright Copyright 2018 California Institute of Technology.

+
+ + Built with Sphinx using a + theme + provided by Read the Docs. + + +
+
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/how_to_run/apply_oe.html b/isofit-tutorials/build/html/how_to_run/apply_oe.html new file mode 100644 index 0000000..9f43cc5 --- /dev/null +++ b/isofit-tutorials/build/html/how_to_run/apply_oe.html @@ -0,0 +1,706 @@ + + + + + + + Apply OE — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Apply OE

+
+

What is Apply OE?

+

Apply OE is the built-in end-to-end atmospheric correction pipeline, and is the easiest way to run Isofit. Apply OE is run via a command line interface (CLI) tool accessed with a terminal call:

+

isofit apply_oe --help

+

The function docstring is printed when this command is run within a terminal window, and acts as a guide for how to run the function.

+
isofit apply_oe --help
+
+Usage: isofit apply_oe [OPTIONS] INPUT_RADIANCE INPUT_LOC INPUT_OBS
+                      WORKING_DIRECTORY SENSOR
+
+ Applies OE over a flightline using a radiative transfer engine. This
+ executes ISOFIT in a generalized way, accounting for the types of variation
+ that might be considered typical.
+
+ Observation (obs) and location (loc) files are used to determine appropriate
+ geometry lookup tables and provide a heuristic means of determining
+ atmospheric water ranges.
+
+ Parameters
+ ----------
+ input_radiance : str
+     Radiance data cube. Expected to be ENVI format
+ input_loc : str
+     Location data cube of shape (Lon, Lat, Elevation). Expected to be ENVI format
+ input_obs : str
+     Observation data cube of shape:
+         (path length, to-sensor azimuth, to-sensor zenith,
+         to-sun azimuth, to-sun zenith, phase,
+         slope, aspect, cosine i, UTC time)
+     Expected to be ENVI format
+ working_directory : str
+     Directory to stage multiple outputs, will contain subdirectories
+ sensor : str
+     The sensor used for acquisition, will be used to set noise and datetime
+     settings
+ surface_path : str
+     Path to surface model or json dict of surface model configuration
+ copy_input_files : bool, default=False
+     Flag to choose to copy input_radiance, input_loc, and input_obs locally into
+     the working_directory
+ modtran_path : str, default=None
+     Location of MODTRAN utility. Alternately set with `MODTRAN_DIR` environment
+     variable
+ wavelength_path : str, default=None
+     Location to get wavelength information from, if not specified the radiance
+     header will be used
+ surface_category : str, default="multicomponent_surface"
+     The type of ISOFIT surface priors to use.  Default is multicomponent_surface
+ aerosol_climatology_path : str, default=None
+     Specific aerosol climatology information to use in MODTRAN
+ rdn_factors_path : str, default=None
+     Specify a radiometric correction factor, if desired
+ atmosphere_type : str, default="ATM_MIDLAT_SUMMER"
+     Atmospheric profile to be used for MODTRAN simulations.  Unused for other
+     radiative transfer models.
+ channelized_uncertainty_path : str, default=None
+     Path to a channelized uncertainty file
+ model_discrepancy_path : str, default=None
+     Modifies S_eps in the OE formalism as the Gamma additive term, as:
+     S_eps = Sy + Kb.dot(self.Sb).dot(Kb.T) + Gamma
+ lut_config_file : str, default=None
+     Path to a look up table configuration file, which will override defaults
+     choices
+ multiple_restarts : bool, default=False
+     Use multiple initial starting poitns for each OE ptimization run, using
+     the corners of the atmospheric variables as starting points.  This gives
+     a more robust, albeit more expensive, solution.
+ logging_level : str, default="INFO"
+     Logging level with which to run ISOFIT
+ log_file : str, default=None
+     File path to write ISOFIT logs to
+ n_cores : int, default=1
+     Number of cores to run ISOFIT with. Substantial parallelism is available, and
+     full runs will be very slow in serial. Suggested to max this out on the
+     available system
+ presolve : int, default=False
+     Flag to use a presolve mode to estimate the available atmospheric water range.
+     Runs a preliminary inversion over the image with a 1-D LUT of water vapor, and
+     uses the resulting range (slightly expanded) to bound determine the full LUT.
+     Advisable to only use with small cubes or in concert with the empirical_line
+     setting, or a significant speed penalty will be incurred
+ empirical_line : bool, default=False
+     Use an empirical line interpolation to run full inversions over only a subset
+     of pixels, determined using a SLIC superpixel segmentation, and use a KDTREE of
+     local solutions to interpolate radiance->reflectance. Generally a good option
+     if not trying to analyze the atmospheric state at fine scale resolution.
+     Mutually exclusive with analytical_line
+ analytical_line : bool, default=False
+     Use an analytical solution to the fixed atmospheric state to solve for each
+     pixel.  Starts by running a full OE retrieval on each SLIC superpixel, then
+     interpolates the atmospheric state to each pixel, and closes with the
+     analytical solution.
+     Mutually exclusive with empirical_line
+ ray_temp_dir : str, default="/tmp/ray"
+     Location of temporary directory for ray parallelization engine
+ emulator_base : str, default=None
+     Location of emulator base path. Point this at the model folder (or h5 file) of
+     sRTMnet to use the emulator instead of MODTRAN. An additional file with the
+     same basename and the extention _aux.npz must accompany
+     e.g. /path/to/emulator.h5 /path/to/emulator_aux.npz
+ segmentation_size : int, default=40
+     If empirical_line is enabled, sets the size of segments to construct
+ num_neighbors : list[int], default=[]
+     Forced number of neighbors for empirical line extrapolation - overides default
+     set from segmentation_size parameter
+ atm_sigma : list[int], default=[2]
+     A list of smoothing factors to use during the atmospheric interpolation, one
+     for each atmospheric parameter (or broadcast to all if only one is provided).
+     Only used with the analytical line.
+ pressure_elevation : bool, default=False
+     Flag to retrieve elevation
+ prebuilt_lut : str, default=None
+     Use this pre-constructed look up table for all retrievals. Must be an
+     ISOFIT-compatible RTE NetCDF
+ no_min_lut_spacing : bool, default=False
+     Don't allow the LUTConfig to remove a LUT dimension because of minimal spacing.
+ inversion_windows : list[float], default=None
+     Override the default inversion windows.  Will supercede any sensor specific
+     defaults that are in place.
+     Must be in 2-item tuples
+ config_only : bool, default=False
+     Generates the configuration then exits before execution. If presolve is
+     enabled, that run will still occur.
+ interpolate_bad_rdn : bool, default=False
+     Flag to perform a per-pixel interpolation across no-data and NaN data bands.
+     Does not interpolate vectors that are entire no-data or NaN, only partial.
+     Currently only designed for wavelength interpolation on spectra.
+     Does NOT do any spatial interpolation
+ interpolate_inplace : bool, default=False
+     Flag to tell interpolation to work on the file in place, or generate a
+     new interpolated rdn file. The location of the new file will be in the
+     "input" directory within the working directory.
+
+ References
+ ----------
+ D.R. Thompson, A. Braverman,P.G. Brodrick, A. Candela, N. Carbon, R.N. Clark,D. Connelly, R.O. Green, R.F.
+ Kokaly, L. Li, N. Mahowald, R.L. Miller, G.S. Okin, T.H.Painter, G.A. Swayze, M. Turmon, J. Susilouto, and
+ D.S. Wettergreen. Quantifying Uncertainty for Remote Spectroscopy of Surface Composition. Remote Sensing of
+ Environment, 2020. doi: https://doi.org/10.1016/j.rse.2020.111898.
+
+ sRTMnet emulator:
+ P.G. Brodrick, D.R. Thompson, J.E. Fahlen, M.L. Eastwood, C.M. Sarture, S.R. Lundeen, W. Olson-Duvall,
+ N. Carmon, and R.O. Green. Generalized radiative transfer emulation for imaging spectroscopy reflectance
+ retrievals. Remote Sensing of Environment, 261:112476, 2021.doi: 10.1016/j.rse.2021.112476.
+
+Options:
+ -sp, --surface_path TEXT        [required]
+ --copy_input_files
+ --modtran_path TEXT
+ --wavelength_path TEXT
+ --surface_category TEXT
+ --aerosol_climatology_path TEXT
+ --rdn_factors_path TEXT
+ --atmosphere_type TEXT
+ --channelized_uncertainty_path TEXT
+ --model_discrepancy_path TEXT
+ --lut_config_file TEXT
+ --multiple_restarts
+ --logging_level TEXT
+ --log_file TEXT
+ --n_cores INTEGER
+ --presolve
+ --empirical_line
+ --analytical_line
+ --ray_temp_dir TEXT
+ --emulator_base TEXT
+ --segmentation_size INTEGER
+ -nn, --num_neighbors INTEGER
+ -as, --atm_sigma FLOAT
+ --pressure_elevation
+ --prebuilt_lut TEXT
+ --no_min_lut_spacing
+ --inversion_windows FLOAT...
+ --config_only
+ --interpolate_bad_rdn
+ --interpolate_inplace
+ --debug-args                    Prints the arguments list without executing
+                                 the command
+ --profile TEXT
+ --help                          Show this message and exit.
+
+
+

The Apply OE function can leverage a large number of input parameters, but most are optional. The important inputs are the non-optional arguments:

+

INPUT_RADIANCE INPUT_LOC INPUT_OBS WORKING_DIRECTORY SENSOR and --surface_path.

+

which must be entered in the specified order. Descriptions of each are found in the docstring printed above. It is important to note that the INPUT_RADIANCE, INPUT_LOC, and INPUT_OBS are ENVI raster data formats that must be at the same row-column dimensions. The --surface_path points Isofit torwards the constructed prior distribution file for surface reflectance. Optional arguments are denoted by the ‘–’ in their name, e.g. --modtran_path, --pressure_elevation. The +default radiative transfer engine (RTE) is currently set to Modtran. Most new users will use the sRTMnet emulator for which you must specify an --emulator_path.

+
+
+

How do you run Apply OE?

+

The script is run via the CLI. For example:

+
isofit apply_oe \
+  ~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010 \
+  ~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010 \
+  ~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010 \
+  ~/.isofit/examples/image_cube/small \
+  ang \
+  --surface_path ~/.isofit/imagecube/small/data/surface.mat \
+  --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \
+  --n_cores 10 \
+  --presolve \
+
+
+

Here,

+
~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010
+~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010
+~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010
+
+
+

are the radiance, location, and observational geometry files respectively. The \ tells the CLI call to expect a multi-line input. The remaining two requried parameters are ang, the sensor designation (AVIRIS-NG), and the --surface_path pointing to the surface prior file at ~/.isofit/imagecube/small/data/surface.mat.

+

The remaining arguments set Apply OE to run with:

+
    +

  1. --emulator_base points isofit to the location of the sRTMnet emulator to use as the radiative transfer engine (RTE)

    2. +

  2. --n_cores = 10 CPU cores

    3. +

  3. The --presolve algorithm to narrow down the water vapor retrievals, which leads to faster total processing time

    4. +
+

We can examine both the inputs and outputs of Apply OE with this run call:

+
+
[1]:
+
+
+
# Common imports
+import os
+from pathlib import Path
+
+from spectral import envi
+from matplotlib import pyplot as plt
+import numpy as np
+
+from isofit.core.common import envi_header
+
+
+
+
+
[2]:
+
+
+
# Load the input files
+rdn_path = Path('~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010')
+loc_path = Path('~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010')
+obs_path = Path('~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010')
+
+rdn = envi.open(envi_header(str(rdn_path.expanduser())))
+loc =  envi.open(envi_header(str(loc_path.expanduser())))
+obs =  envi.open(envi_header(str(obs_path.expanduser())))
+
+rdn_im = rdn.open_memmap(interleave='bip')
+loc_im = loc.open_memmap(interleave='bip')
+obs_im = obs.open_memmap(interleave='bip')
+
+
+
+
+
[3]:
+
+
+
# Print the bands of the input files
+print('Band names in the location file:')
+[print(f"{i}") for i in loc.metadata['band names']]
+
+print()
+print('Band names in the observational geometry file:')
+temp = [print(f"{i}") for i in obs.metadata['band names']]
+
+
+
+
+
+
+
+
+Band names in the location file:
+Longitude (WGS-84)
+Latitude (WGS-84)
+Elevation (m)
+
+Band names in the observational geometry file:
+Path length (m)
+To-sensor azimuth (0 to 360 degrees cw from N)
+To-sensor zenith (0 to 90 degrees from zenith)
+To-sun azimuth (0 to 360 degrees cw from N)
+To-sun zenith (0 to 90 degrees from zenith)
+Solar phase
+Slope
+Aspect
+Cosine(i)
+UTC Time
+Earth-sun distance (AU)
+
+
+
+
[4]:
+
+
+
# Plot the input data
+normalize = lambda x, vmin, vmax:  (x - vmin) / (vmax - vmin)
+bands = [55, 35, 15]
+
+fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(13, 4))
+plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))
+plot = axs[1].imshow(loc_im[..., 0])
+plot = axs[2].imshow(obs_im[..., 4])
+
+title = axs[0].set_title('Radiance (RGB)')
+title = axs[1].set_title('Longitude (WGS-84)')
+title = axs[2].set_title('Solar zenith angle (Deg)')
+
+
+
+
+
+
+
+../_images/how_to_run_apply_oe_12_0.png +
+
+

The input image doesn’t look like much because this is just a 10x10 pixel example. However we see per-pixel spectral variation in the radiance RGB, and systematic variation in the location and geometric variables.

+

Looking at the output data:

+
+
[ ]:
+
+
+
# Load the output files
+rfl_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_rfl')
+state_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_state')
+uncert_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_uncert')
+
+rfl = envi.open(envi_header(str(rfl_path.expanduser())))
+state = envi.open(envi_header(str(state_path.expanduser())))
+uncert = envi.open(envi_header(str(uncert_path.expanduser())))
+
+rfl_im = rfl.open_memmap(interleave='bip')
+state_im = state.open_memmap(interleave='bip')
+uncert_im = uncert.open_memmap(interleave='bip')
+
+print(f'Shape of the _rfl file: {rfl_im.shape}')
+print(f'Shape of the _state file: {state_im.shape}')
+print(f'Shape of the _uncert file: {uncert_im.shape}')
+
+
+
+
+
+
+
+
+Shape of the _rfl file: (10, 10, 425)
+Shape of the _state file: (10, 10, 427)
+Shape of the _uncert file: (10, 10, 427)
+
+
+

The difference between the _rfl file and the _state file is that the _rfl file only contains the solutions for surface reflectance variables. Here, the AVIRIS-NG image contains 425 wavelength bands. As a result, the _rfl contains 425 bands. The _state and _uncert files contain the surface reflectance solutions and uncertainty calculated as the standard deviation of the posterior distributions for the 425 wavelength bands and for non-reflectance statevector elements; here, +aerosol optical depth (AOD) and water vapor (H2O).

+
+
[6]:
+
+
+
# Plot the output data
+normalize = lambda x, vmin, vmax:  (x - vmin) / (vmax - vmin)
+bands = [55, 35, 15]
+
+fig, axs = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(8, 8))
+axs = np.ravel(axs)
+plot = axs[0].imshow(normalize(rfl_im[..., bands], 0, 0.3))
+uncert = axs[1].imshow(uncert_im[..., 55])
+aod = axs[2].imshow(state_im[..., -2])
+h2o = axs[3].imshow(state_im[..., -1])
+
+plt.colorbar(uncert)
+plt.colorbar(aod)
+plt.colorbar(h2o)
+
+title = axs[0].set_title('Reflectance')
+title = axs[1].set_title('Uncertainty (at 650 nm)')
+title = axs[2].set_title('AOD')
+title = axs[3].set_title('H2O')
+
+
+
+
+
+
+
+../_images/how_to_run_apply_oe_16_0.png +
+
+
+
+

The Analytical Line

+

In the example above, we ran Isofit using the full optimal estimation (OE) on each pixel independently. Computationally, this amounts to iterating through each row-column pair to solve for the full state-vector (427 variables in the above case). However for large images, this demands long run-times, and ignores the principle that some state-vector elements, namely the atmospheric variables like AOD and H2O, should not vary from one pixel to the next, but rather should be spatially smooth, and +only vary over multi-pixel length scales Link to the relevent paper.

+

The analytical line and empirical line algorithms leverage the assumption of a spatially smooth atmosphere to decrease run times by a factor of 10. Currently, we suggest using the analytical line algorithm and not the empirical line algorithm.

+

See the following CLI call to run Apply OE with the analytical line algorithm:

+
isofit apply_oe \
+  ~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k \
+  ~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k \
+  ~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k \
+  ~/.isofit/imagecube/medium \
+  ang \
+  --surface_path ~/.isofit/imagecube/small/data/surface.mat \
+  --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \
+  --n_cores 10 \
+  --presolve \
+  --log_file ~/.isofit/imagecube/medium/log.txt \
+  --analytical_line \
+  --segmentation_size 50
+
+
+

Most of the input parameters are identical to the per-pixel application above. However, we’ve added a --log_file, the --analytical_line flag, and a --segmentation_size. The --log_file points the program to write a text file to print logging statements during run time. The --analytical_line flag tells Isofit to use the analytical line algorithm.

+

A simple overview for the anylitical line algorithm:

+
    +

  1. All three input files are “segmented” into superpixel blocks using the SLIC algorithm. The --segmentation_size value sets the number of pixels that each superpixel contains.

    2. +

  2. At the superpixel resolution, Isofit solves for the OE solutions, which provides both surface and atmospheric state variables.

    3. +

  3. Atmospheric state variables are spatially interpolated to full image resolution. The spatial interpolation uses the Apply OE parameters --num_neighbors and --atm_sigma.

    4. +

  4. With a fixed atmosphere, we leverage a closed form solution for surface state elements that allows for a solution convergence in a single iteration.

    5. +
+

We can visualize what the segmentation is doing by leveraging the isofit reconstruct_subs CLI command.

+

Visualizing the input data:

+
+
[8]:
+
+
+
# Plotting the input data
+rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')
+loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')
+obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')
+
+subs_rdn_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_rdn')
+subs_loc_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_loc')
+subs_obs_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_obs')
+
+rdn = envi.open(envi_header(str(rdn_path.expanduser())))
+loc = envi.open(envi_header(str(loc_path.expanduser())))
+obs = envi.open(envi_header(str(obs_path.expanduser())))
+
+subs_rdn = envi.open(envi_header(str(subs_rdn_path.expanduser())))
+subs_loc = envi.open(envi_header(str(subs_loc_path.expanduser())))
+subs_obs = envi.open(envi_header(str(subs_obs_path.expanduser())))
+
+rdn_im = rdn.open_memmap(interleave='bip')
+loc_im = loc.open_memmap(interleave='bip')
+obs_im = obs.open_memmap(interleave='bip')
+
+subs_rdn_im = subs_rdn.open_memmap(interleave='bip')
+subs_loc_im = subs_loc.open_memmap(interleave='bip')
+subs_obs_im = subs_obs.open_memmap(interleave='bip')
+
+fig, axs = plt.subplots(2, 3, sharex=True, sharey=True, figsize=(5, 10))
+axs = np.ravel(axs)
+
+axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))
+axs[1].imshow(loc[0:400, :, 0])
+axs[2].imshow(obs[0:400, :, 4])
+
+axs[3].imshow(normalize(subs_rdn_im[0:400, :, bands], 0, 15))
+axs[4].imshow(subs_loc[0:400, :, 0])
+axs[5].imshow(subs_obs[0:400, :, 4])
+
+axs[0].set_title('Radiance')
+axs[1].set_title('Longitude')
+axs[2].set_title('Elevation')
+
+axs[0].set_ylabel('Full resolution')
+axs[3].set_ylabel('Superpixel resolution')
+plt.show()
+
+
+
+
+
+
+
+
+Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].
+
+
+
+
+
+
+../_images/how_to_run_apply_oe_20_1.png +
+
+

We can examine the results from Apply OE after the OE solutions on the superpixels:

+
+
[ ]:
+
+
+
wl = np.array(rdn.metadata['wavelength']).astype(float)
+
+state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_recon_subs_state')
+state  = envi.open(envi_header(str(state_path.expanduser())))
+state_im = state.open_memmap(interleave='bip')
+
+fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)
+axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))
+axs[1].imshow(normalize(state_im[0:400, :, bands], 0, 0.25))
+aod = axs[2].imshow(state_im[0:400, :, -2])
+h2o = axs[3].imshow(state_im[0:400, :, -1])
+
+plt.colorbar(aod)
+plt.colorbar(h2o)
+
+axs[0].set_title('Radiance')
+axs[1].set_title('Reflectance')
+axs[2].set_title('AOD')
+axs[3].set_title('H2O')
+plt.show()
+
+
+
+
+
+
+
+
+Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].
+Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.12389879..1.5404001].
+
+
+
+
+
+
+../_images/how_to_run_apply_oe_22_1.png +
+
+

Finally, we can examine the final results at the end of the anlaytical line algorithm:

+
+
[ ]:
+
+
+
rfl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_rfl')
+atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')
+
+rfl  = envi.open(envi_header(str(rfl_path.expanduser())))
+atm  = envi.open(envi_header(str(atm_path.expanduser())))
+
+rfl_im = rfl.open_memmap(interleave='bip')
+atm_im = atm.open_memmap(interleave='bip')
+
+
+fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)
+axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))
+axs[1].imshow(normalize(rfl_im[0:400, :, bands], 0, 0.25))
+aod = axs[2].imshow(atm_im[0:400, :, -2])
+h2o = axs[3].imshow(atm_im[0:400, :, -1])
+
+plt.colorbar(aod)
+plt.colorbar(h2o)
+
+axs[0].set_title('Radiance')
+axs[1].set_title('Reflectance')
+axs[2].set_title('AOD')
+axs[3].set_title('H2O')
+plt.show()
+
+
+
+
+
+
+
+
+Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].
+Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.11736042..1.7135264].
+
+
+
+
+
+
+../_images/how_to_run_apply_oe_24_1.png +
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/how_to_run/apply_oe.ipynb b/isofit-tutorials/build/html/how_to_run/apply_oe.ipynb new file mode 100644 index 0000000..24edbdd --- /dev/null +++ b/isofit-tutorials/build/html/how_to_run/apply_oe.ipynb @@ -0,0 +1,754 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1be88697", + "metadata": {}, + "source": [ + "# Apply OE" + ] + }, + { + "cell_type": "markdown", + "id": "94f3598f", + "metadata": {}, + "source": [ + "#### What is Apply OE?" + ] + }, + { + "cell_type": "markdown", + "id": "c0421619", + "metadata": {}, + "source": [ + "Apply OE is the built-in end-to-end atmospheric correction pipeline, and is the easiest way to run Isofit. Apply OE is run via a command line interface (CLI) tool accessed with a terminal call:\n", + "\n", + " `isofit apply_oe --help`\n", + "\n", + " The function docstring is printed when this command is run within a terminal window, and acts as a guide for how to run the function.\n", + "\n", + " ```\n", + "isofit apply_oe --help\n", + "\n", + "Usage: isofit apply_oe [OPTIONS] INPUT_RADIANCE INPUT_LOC INPUT_OBS\n", + " WORKING_DIRECTORY SENSOR\n", + "\n", + " Applies OE over a flightline using a radiative transfer engine. This\n", + " executes ISOFIT in a generalized way, accounting for the types of variation\n", + " that might be considered typical.\n", + "\n", + " Observation (obs) and location (loc) files are used to determine appropriate\n", + " geometry lookup tables and provide a heuristic means of determining\n", + " atmospheric water ranges.\n", + "\n", + " Parameters\n", + " ----------\n", + " input_radiance : str\n", + " Radiance data cube. Expected to be ENVI format\n", + " input_loc : str\n", + " Location data cube of shape (Lon, Lat, Elevation). Expected to be ENVI format\n", + " input_obs : str\n", + " Observation data cube of shape:\n", + " (path length, to-sensor azimuth, to-sensor zenith,\n", + " to-sun azimuth, to-sun zenith, phase,\n", + " slope, aspect, cosine i, UTC time)\n", + " Expected to be ENVI format\n", + " working_directory : str\n", + " Directory to stage multiple outputs, will contain subdirectories\n", + " sensor : str\n", + " The sensor used for acquisition, will be used to set noise and datetime\n", + " settings\n", + " surface_path : str\n", + " Path to surface model or json dict of surface model configuration\n", + " copy_input_files : bool, default=False\n", + " Flag to choose to copy input_radiance, input_loc, and input_obs locally into\n", + " the working_directory\n", + " modtran_path : str, default=None\n", + " Location of MODTRAN utility. Alternately set with `MODTRAN_DIR` environment\n", + " variable\n", + " wavelength_path : str, default=None\n", + " Location to get wavelength information from, if not specified the radiance\n", + " header will be used\n", + " surface_category : str, default=\"multicomponent_surface\"\n", + " The type of ISOFIT surface priors to use. Default is multicomponent_surface\n", + " aerosol_climatology_path : str, default=None\n", + " Specific aerosol climatology information to use in MODTRAN\n", + " rdn_factors_path : str, default=None\n", + " Specify a radiometric correction factor, if desired\n", + " atmosphere_type : str, default=\"ATM_MIDLAT_SUMMER\"\n", + " Atmospheric profile to be used for MODTRAN simulations. Unused for other\n", + " radiative transfer models.\n", + " channelized_uncertainty_path : str, default=None\n", + " Path to a channelized uncertainty file\n", + " model_discrepancy_path : str, default=None\n", + " Modifies S_eps in the OE formalism as the Gamma additive term, as:\n", + " S_eps = Sy + Kb.dot(self.Sb).dot(Kb.T) + Gamma\n", + " lut_config_file : str, default=None\n", + " Path to a look up table configuration file, which will override defaults\n", + " choices\n", + " multiple_restarts : bool, default=False\n", + " Use multiple initial starting poitns for each OE ptimization run, using\n", + " the corners of the atmospheric variables as starting points. This gives\n", + " a more robust, albeit more expensive, solution.\n", + " logging_level : str, default=\"INFO\"\n", + " Logging level with which to run ISOFIT\n", + " log_file : str, default=None\n", + " File path to write ISOFIT logs to\n", + " n_cores : int, default=1\n", + " Number of cores to run ISOFIT with. Substantial parallelism is available, and\n", + " full runs will be very slow in serial. Suggested to max this out on the\n", + " available system\n", + " presolve : int, default=False\n", + " Flag to use a presolve mode to estimate the available atmospheric water range.\n", + " Runs a preliminary inversion over the image with a 1-D LUT of water vapor, and\n", + " uses the resulting range (slightly expanded) to bound determine the full LUT.\n", + " Advisable to only use with small cubes or in concert with the empirical_line\n", + " setting, or a significant speed penalty will be incurred\n", + " empirical_line : bool, default=False\n", + " Use an empirical line interpolation to run full inversions over only a subset\n", + " of pixels, determined using a SLIC superpixel segmentation, and use a KDTREE of\n", + " local solutions to interpolate radiance->reflectance. Generally a good option\n", + " if not trying to analyze the atmospheric state at fine scale resolution.\n", + " Mutually exclusive with analytical_line\n", + " analytical_line : bool, default=False\n", + " Use an analytical solution to the fixed atmospheric state to solve for each\n", + " pixel. Starts by running a full OE retrieval on each SLIC superpixel, then\n", + " interpolates the atmospheric state to each pixel, and closes with the\n", + " analytical solution.\n", + " Mutually exclusive with empirical_line\n", + " ray_temp_dir : str, default=\"/tmp/ray\"\n", + " Location of temporary directory for ray parallelization engine\n", + " emulator_base : str, default=None\n", + " Location of emulator base path. Point this at the model folder (or h5 file) of\n", + " sRTMnet to use the emulator instead of MODTRAN. An additional file with the\n", + " same basename and the extention _aux.npz must accompany\n", + " e.g. /path/to/emulator.h5 /path/to/emulator_aux.npz\n", + " segmentation_size : int, default=40\n", + " If empirical_line is enabled, sets the size of segments to construct\n", + " num_neighbors : list[int], default=[]\n", + " Forced number of neighbors for empirical line extrapolation - overides default\n", + " set from segmentation_size parameter\n", + " atm_sigma : list[int], default=[2]\n", + " A list of smoothing factors to use during the atmospheric interpolation, one\n", + " for each atmospheric parameter (or broadcast to all if only one is provided).\n", + " Only used with the analytical line.\n", + " pressure_elevation : bool, default=False\n", + " Flag to retrieve elevation\n", + " prebuilt_lut : str, default=None\n", + " Use this pre-constructed look up table for all retrievals. Must be an\n", + " ISOFIT-compatible RTE NetCDF\n", + " no_min_lut_spacing : bool, default=False\n", + " Don't allow the LUTConfig to remove a LUT dimension because of minimal spacing.\n", + " inversion_windows : list[float], default=None\n", + " Override the default inversion windows. Will supercede any sensor specific\n", + " defaults that are in place.\n", + " Must be in 2-item tuples\n", + " config_only : bool, default=False\n", + " Generates the configuration then exits before execution. If presolve is\n", + " enabled, that run will still occur.\n", + " interpolate_bad_rdn : bool, default=False\n", + " Flag to perform a per-pixel interpolation across no-data and NaN data bands.\n", + " Does not interpolate vectors that are entire no-data or NaN, only partial.\n", + " Currently only designed for wavelength interpolation on spectra.\n", + " Does NOT do any spatial interpolation\n", + " interpolate_inplace : bool, default=False\n", + " Flag to tell interpolation to work on the file in place, or generate a\n", + " new interpolated rdn file. The location of the new file will be in the\n", + " \"input\" directory within the working directory.\n", + "\n", + " References\n", + " ----------\n", + " D.R. Thompson, A. Braverman,P.G. Brodrick, A. Candela, N. Carbon, R.N. Clark,D. Connelly, R.O. Green, R.F.\n", + " Kokaly, L. Li, N. Mahowald, R.L. Miller, G.S. Okin, T.H.Painter, G.A. Swayze, M. Turmon, J. Susilouto, and\n", + " D.S. Wettergreen. Quantifying Uncertainty for Remote Spectroscopy of Surface Composition. Remote Sensing of\n", + " Environment, 2020. doi: https://doi.org/10.1016/j.rse.2020.111898.\n", + "\n", + " sRTMnet emulator:\n", + " P.G. Brodrick, D.R. Thompson, J.E. Fahlen, M.L. Eastwood, C.M. Sarture, S.R. Lundeen, W. Olson-Duvall,\n", + " N. Carmon, and R.O. Green. Generalized radiative transfer emulation for imaging spectroscopy reflectance\n", + " retrievals. Remote Sensing of Environment, 261:112476, 2021.doi: 10.1016/j.rse.2021.112476.\n", + "\n", + "Options:\n", + " -sp, --surface_path TEXT [required]\n", + " --copy_input_files\n", + " --modtran_path TEXT\n", + " --wavelength_path TEXT\n", + " --surface_category TEXT\n", + " --aerosol_climatology_path TEXT\n", + " --rdn_factors_path TEXT\n", + " --atmosphere_type TEXT\n", + " --channelized_uncertainty_path TEXT\n", + " --model_discrepancy_path TEXT\n", + " --lut_config_file TEXT\n", + " --multiple_restarts\n", + " --logging_level TEXT\n", + " --log_file TEXT\n", + " --n_cores INTEGER\n", + " --presolve\n", + " --empirical_line\n", + " --analytical_line\n", + " --ray_temp_dir TEXT\n", + " --emulator_base TEXT\n", + " --segmentation_size INTEGER\n", + " -nn, --num_neighbors INTEGER\n", + " -as, --atm_sigma FLOAT\n", + " --pressure_elevation\n", + " --prebuilt_lut TEXT\n", + " --no_min_lut_spacing\n", + " --inversion_windows FLOAT...\n", + " --config_only\n", + " --interpolate_bad_rdn\n", + " --interpolate_inplace\n", + " --debug-args Prints the arguments list without executing\n", + " the command\n", + " --profile TEXT\n", + " --help Show this message and exit.\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "id": "f1b4490f", + "metadata": {}, + "source": [ + "The Apply OE function can leverage a large number of input parameters, but most are optional. The important inputs are the non-optional arguments: \n", + "\n", + "`INPUT_RADIANCE` `INPUT_LOC` `INPUT_OBS` `WORKING_DIRECTORY` `SENSOR` and `--surface_path`.\n", + "\n", + "which must be entered in the specified order. Descriptions of each are found in the docstring printed above. It is important to note that the `INPUT_RADIANCE`, `INPUT_LOC`, and `INPUT_OBS` are ENVI raster data formats that must be at the same row-column dimensions. The `--surface_path` points Isofit torwards the constructed prior distribution file for surface reflectance. Optional arguments are denoted by the '--' in their name, e.g. `--modtran_path`, `--pressure_elevation`. The default radiative transfer engine (RTE) is currently set to Modtran. Most new users will use the sRTMnet emulator for which you must specify an `--emulator_path`." + ] + }, + { + "cell_type": "markdown", + "id": "8b199b77", + "metadata": {}, + "source": [ + "#### How do you run Apply OE?" + ] + }, + { + "cell_type": "markdown", + "id": "f6028b6c", + "metadata": {}, + "source": [ + "The script is run via the CLI. For example:" + ] + }, + { + "cell_type": "markdown", + "id": "b9867343", + "metadata": {}, + "source": [ + "```\n", + "isofit apply_oe \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010 \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010 \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010 \\\n", + " ~/.isofit/examples/image_cube/small \\\n", + " ang \\\n", + " --surface_path ~/.isofit/imagecube/small/data/surface.mat \\\n", + " --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \\\n", + " --n_cores 10 \\\n", + " --presolve \\\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "id": "31d41c48", + "metadata": {}, + "source": [ + "Here, \n", + "\n", + "```\n", + "~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010\n", + "~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010\n", + "~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010\n", + "```\n", + "\n", + "are the radiance, location, and observational geometry files respectively. The `\\` tells the CLI call to expect a multi-line input. The remaining two requried parameters are `ang`, the sensor designation (AVIRIS-NG), and the `--surface_path` pointing to the surface prior file at `~/.isofit/imagecube/small/data/surface.mat`.\n", + "\n", + "The remaining arguments set Apply OE to run with:\n", + "1) `--emulator_base` points isofit to the location of the sRTMnet emulator to use as the radiative transfer engine (RTE)\n", + "2) `--n_cores = 10` CPU cores\n", + "3) The `--presolve` algorithm to narrow down the water vapor retrievals, which leads to faster total processing time" + ] + }, + { + "cell_type": "markdown", + "id": "ac5b2463", + "metadata": {}, + "source": [ + "We can examine both the inputs and outputs of Apply OE with this run call:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b18118d1", + "metadata": {}, + "outputs": [], + "source": [ + "# Common imports\n", + "import os\n", + "from pathlib import Path\n", + "\n", + "from spectral import envi\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "\n", + "from isofit.core.common import envi_header" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5b8a685f", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the input files\n", + "rdn_path = Path('~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010')\n", + "loc_path = Path('~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010')\n", + "obs_path = Path('~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0f7ec5b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Band names in the location file:\n", + "Longitude (WGS-84)\n", + "Latitude (WGS-84)\n", + "Elevation (m)\n", + "\n", + "Band names in the observational geometry file:\n", + "Path length (m)\n", + "To-sensor azimuth (0 to 360 degrees cw from N)\n", + "To-sensor zenith (0 to 90 degrees from zenith)\n", + "To-sun azimuth (0 to 360 degrees cw from N)\n", + "To-sun zenith (0 to 90 degrees from zenith)\n", + "Solar phase\n", + "Slope\n", + "Aspect\n", + "Cosine(i)\n", + "UTC Time\n", + "Earth-sun distance (AU)\n" + ] + } + ], + "source": [ + "# Print the bands of the input files\n", + "print('Band names in the location file:')\n", + "[print(f\"{i}\") for i in loc.metadata['band names']]\n", + "\n", + "print()\n", + "print('Band names in the observational geometry file:')\n", + "temp = [print(f\"{i}\") for i in obs.metadata['band names']]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4ce97d24", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the input data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(13, 4))\n", + "plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))\n", + "plot = axs[1].imshow(loc_im[..., 0])\n", + "plot = axs[2].imshow(obs_im[..., 4])\n", + "\n", + "title = axs[0].set_title('Radiance (RGB)')\n", + "title = axs[1].set_title('Longitude (WGS-84)')\n", + "title = axs[2].set_title('Solar zenith angle (Deg)')" + ] + }, + { + "cell_type": "markdown", + "id": "e12b5307", + "metadata": {}, + "source": [ + "The input image doesn't look like much because this is just a 10x10 pixel example. However we see per-pixel spectral variation in the radiance RGB, and systematic variation in the location and geometric variables.\n", + "\n", + "Looking at the output data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65ce0e9f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of the _rfl file: (10, 10, 425)\n", + "Shape of the _state file: (10, 10, 427)\n", + "Shape of the _uncert file: (10, 10, 427)\n" + ] + } + ], + "source": [ + "# Load the output files\n", + "rfl_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_rfl')\n", + "state_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_state')\n", + "uncert_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_uncert')\n", + "\n", + "rfl = envi.open(envi_header(str(rfl_path.expanduser())))\n", + "state = envi.open(envi_header(str(state_path.expanduser())))\n", + "uncert = envi.open(envi_header(str(uncert_path.expanduser())))\n", + "\n", + "rfl_im = rfl.open_memmap(interleave='bip')\n", + "state_im = state.open_memmap(interleave='bip')\n", + "uncert_im = uncert.open_memmap(interleave='bip')\n", + "\n", + "print(f'Shape of the _rfl file: {rfl_im.shape}')\n", + "print(f'Shape of the _state file: {state_im.shape}')\n", + "print(f'Shape of the _uncert file: {uncert_im.shape}')" + ] + }, + { + "cell_type": "markdown", + "id": "7054b0ee", + "metadata": {}, + "source": [ + "The difference between the `_rfl` file and the `_state` file is that the `_rfl` file only contains the solutions for surface reflectance variables. Here, the AVIRIS-NG image contains 425 wavelength bands. As a result, the `_rfl` contains 425 bands. The `_state` and `_uncert` files contain the surface reflectance solutions and uncertainty calculated as the standard deviation of the posterior distributions for the 425 wavelength bands and for non-reflectance statevector elements; here, aerosol optical depth (AOD) and water vapor (H2O). " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a518609c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the output data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(8, 8))\n", + "axs = np.ravel(axs)\n", + "plot = axs[0].imshow(normalize(rfl_im[..., bands], 0, 0.3))\n", + "uncert = axs[1].imshow(uncert_im[..., 55])\n", + "aod = axs[2].imshow(state_im[..., -2])\n", + "h2o = axs[3].imshow(state_im[..., -1])\n", + "\n", + "plt.colorbar(uncert)\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "title = axs[0].set_title('Reflectance')\n", + "title = axs[1].set_title('Uncertainty (at 650 nm)')\n", + "title = axs[2].set_title('AOD')\n", + "title = axs[3].set_title('H2O')" + ] + }, + { + "cell_type": "markdown", + "id": "697e2986", + "metadata": {}, + "source": [ + "#### The Analytical Line" + ] + }, + { + "cell_type": "markdown", + "id": "58752472", + "metadata": {}, + "source": [ + "In the example above, we ran Isofit using the full optimal estimation (OE) on each pixel independently. Computationally, this amounts to iterating through each row-column pair to solve for the full state-vector (427 variables in the above case). However for large images, this demands long run-times, and ignores the principle that some state-vector elements, namely the atmospheric variables like AOD and H2O, should not vary from one pixel to the next, but rather should be spatially smooth, and only vary over multi-pixel length scales [Link to the relevent paper](https://www.sciencedirect.com/science/article/pii/S0034425723004534/).\n", + "\n", + "The analytical line and empirical line algorithms leverage the assumption of a spatially smooth atmosphere to decrease run times by a factor of 10. Currently, we suggest using the analytical line algorithm and not the empirical line algorithm." + ] + }, + { + "cell_type": "markdown", + "id": "ad1b9d10", + "metadata": {}, + "source": [ + "See the following CLI call to run Apply OE with the analytical line algorithm:\n", + "\n", + "```\n", + "isofit apply_oe \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k \\\n", + " ~/.isofit/imagecube/medium \\\n", + " ang \\\n", + " --surface_path ~/.isofit/imagecube/small/data/surface.mat \\\n", + " --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \\\n", + " --n_cores 10 \\\n", + " --presolve \\\n", + " --log_file ~/.isofit/imagecube/medium/log.txt \\\n", + " --analytical_line \\\n", + " --segmentation_size 50\n", + "```\n", + "\n", + "Most of the input parameters are identical to the per-pixel application above. However, we've added a `--log_file`, the `--analytical_line` flag, and a `--segmentation_size`. The `--log_file` points the program to write a text file to print logging statements during run time. The `--analytical_line` flag tells Isofit to use the analytical line algorithm. \n", + "\n", + "A simple overview for the anylitical line algorithm:\n", + "\n", + "1) All three input files are \"segmented\" into superpixel blocks using the SLIC algorithm. The `--segmentation_size` value sets the number of pixels that each superpixel contains.\n", + "\n", + "2) At the superpixel resolution, Isofit solves for the OE solutions, which provides both surface and atmospheric state variables. \n", + "\n", + "3) Atmospheric state variables are spatially interpolated to full image resolution. The spatial interpolation uses the Apply OE parameters `--num_neighbors` and `--atm_sigma`.\n", + "\n", + "4) With a fixed atmosphere, we leverage a closed form solution for surface state elements that allows for a solution convergence in a single iteration.\n", + "\n", + "We can visualize what the segmentation is doing by leveraging the `isofit reconstruct_subs` CLI command. \n", + "\n", + "Visualizing the input data:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5ce57697", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting the input data\n", + "rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')\n", + "loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')\n", + "obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')\n", + "\n", + "subs_rdn_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_rdn')\n", + "subs_loc_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_loc')\n", + "subs_obs_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_obs')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "subs_rdn = envi.open(envi_header(str(subs_rdn_path.expanduser())))\n", + "subs_loc = envi.open(envi_header(str(subs_loc_path.expanduser())))\n", + "subs_obs = envi.open(envi_header(str(subs_obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')\n", + "\n", + "subs_rdn_im = subs_rdn.open_memmap(interleave='bip')\n", + "subs_loc_im = subs_loc.open_memmap(interleave='bip')\n", + "subs_obs_im = subs_obs.open_memmap(interleave='bip')\n", + "\n", + "fig, axs = plt.subplots(2, 3, sharex=True, sharey=True, figsize=(5, 10))\n", + "axs = np.ravel(axs)\n", + "\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(loc[0:400, :, 0])\n", + "axs[2].imshow(obs[0:400, :, 4])\n", + "\n", + "axs[3].imshow(normalize(subs_rdn_im[0:400, :, bands], 0, 15))\n", + "axs[4].imshow(subs_loc[0:400, :, 0])\n", + "axs[5].imshow(subs_obs[0:400, :, 4])\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Longitude')\n", + "axs[2].set_title('Elevation')\n", + "\n", + "axs[0].set_ylabel('Full resolution')\n", + "axs[3].set_ylabel('Superpixel resolution')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7788d2ce", + "metadata": {}, + "source": [ + "We can examine the results from Apply OE after the OE solutions on the superpixels:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "abf4b8ee", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.12389879..1.5404001].\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxMAAAHqCAYAAAB/WBOoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/XmYJFd5oIu/55yIyLWWrt7V6tYOEkiAQEISYhPzY7Mwiy1WXwa8DTxc82OMsY0uY1sYGYx9r2Guh/HgMbvNYjCbx8ZGYNZBYjMI0AJaWr1v1bXmGhHnfPePE5mVWZVZVV1drVaLePvJrqqMiBMRmScivv1TIiLk5OTk5OTk5OTk5OScIPp0H0BOTk5OTk5OTk5OzplJrkzk5OTk5OTk5OTk5KyJXJnIycnJycnJycnJyVkTuTKRk5OTk5OTk5OTk7MmcmUiJycnJycnJycnJ2dN5MpETk5OTk5OTk5OTs6ayJWJnJycnJycnJycnJw1kSsTOTk5OTk5OTk5OTlrIlcmcnJycnJycnJycnLWxM+1MvHBD34QpVT3FQQB27dv52Uvexn33HPPuu5LKcVNN920ZN8PPPDAuu4n5+eLUzGHv/zlL3PFFVdQqVRQSvHZz372lM/XO++8k5tuuim/HnJOO//v//v/opTi0ksvHbrOXXfdxatf/Wp27dpFFEVs2rSJX/iFX+ALX/jCknW/+tWv9l2jURSxefNmrr32Wt7ylrewZ8+eU3k6OTkD6dzTv/e97w1c/rznPY9zzz0XgLm5Of7kT/6Epz/96Wzbto1qtcpll13GO9/5Tlqt1sDtT+QayTnz+blWJjp84AMf4NZbb+VLX/oSv/Vbv8XnP/95nvzkJzM9PX3K9nn99ddz6623sn379lO2j5yfH9ZrDosIL3nJSwjDkM9//vPceuutPO1pTztFR73AnXfeyVvf+tZcmcg57bz//e8H4I477uDb3/72kuWf/vSnufzyy/nOd77DH/zBH/ClL32Jv/qrvwLgF37hF/i93/u9geO+/e1v59Zbb+UrX/kK73vf+3j605/O+9//fi655BL+7u/+7tSdUE7OSbJ3717e/e538/jHP56//uu/5vOf/zw33HADN910E8973vMQkb7113qN5JzByM8xH/jABwSQ7373u33vv/WtbxVA3v/+96/bvgD5oz/6o3UbLydHZP3n8P79+wWQd77znQP3s3v37pM95IF88pOfFEC+8pWvnJLxc3JWw3e/+10B5PrrrxdAfvM3f7Nv+b333ivlclmuuOIKqdVqS7Z/7WtfK4B87GMf6773la98RQD55Cc/uWT948ePy+WXXy5BEMiPfvSj9T+hnJwhDHt2dLj++uvlnHPOERGRWq02cL7/+Z//uQDyjW98o/veWq6RnDOf3DMxgCuuuAKAI0eOANBqtfid3/kdHve4xzE2NsbExATXXHMNn/vc55ZsOzc3x2/+5m+yceNGqtUqz3nOc/jZz362ZL1BYSO33HILL3jBCzj77LMpFotceOGFvOY1r2FycrJv25tuugmlFHfccQcvf/nLGRsbY+vWrfzar/0as7Ozfes65/jLv/xLHve4x1EqlRgfH+fqq6/m85//fN96n/jEJ7jmmmuoVCpUq1We/exn84Mf/GBNn1/O6WfxHAb43ve+x/Of/3wmJiYoFotcfvnl/P3f/313+U033cTZZ58NwO///u+jlOq6uYfxpS99if/wH/4Do6OjlMtlrr32Wr785S8vWe/uu+/m5S9/OVu3bqVQKLBr1y7+43/8j7TbbT74wQ/y4he/GIDrrruuGw7ywQ9+EMivi5wHj/e9730A/Omf/ilPetKT+PjHP06j0eguf9e73kWj0eAv//IvqVQqS7b/f/6f/4fx8XH+5E/+ZFX7m5iY4L3vfS9pmvKud71rfU4iJ2edqVQqA+f7E5/4RAD27dvXfW+9r5GcM4NcmRjA7t27AXjEIx4BQLvdZmpqije96U189rOf5WMf+xhPfvKT+aVf+iU+/OEPd7cTEV74whfykY98hN/5nd/hM5/5DFdffTXPfe5zV7Xf++67j2uuuYa/+qu/4otf/CJ/+Id/yLe//W2e/OQnkyTJkvV/+Zd/mUc84hH8wz/8A29+85v56Ec/ym//9m/3rfPqV7+aN7zhDVx55ZV84hOf4OMf/zjPf/7z+5SYt7/97bz85S/nUY96FH//93/PRz7yEebn53nKU57CnXfeeaIfX85DgMVz+Ctf+QrXXnstMzMz/I//8T/43Oc+x+Me9zhe+tKXdoX23/iN3+DTn/40AK9//eu59dZb+cxnPjN0H3/7t3/Ls571LEZHR/nQhz7E3//93zMxMcGzn/3sPoXi9ttv58orr+S2227jj//4j/nCF77AO97xDtrtNnEcc/311/P2t78dgPe85z3ceuut3HrrrVx//fVAfl3kPDg0m00+9rGPceWVV3LppZfya7/2a8zPz/PJT36yu84tt9zC1q1bufrqqweOUS6XedaznsVPfvITDh8+vKr9XnnllWzfvp2vf/3r63IeOTkngrWWNE2XvGRR6NIg/u3f/g2ARz/60d33TsU1knMGcLpdI6eTjpvvtttukyRJZH5+Xv7lX/5Ftm3bJk996lMlSZKB26VpKkmSyK//+q/L5Zdf3n3/C1/4ggDyX//rf+1b/0/+5E+WhDmtFDbinJMkSWTPnj0CyOc+97nusj/6oz8SQP7sz/6sb5vXve51UiwWxTknIiJf//rXBZC3vOUtQz+DvXv3ShAE8vrXv77v/fn5edm2bZu85CUvGbptzulntXP44osvlssvv3zJnH7e854n27dvF2utiIjs3r1bAPnzP//zgfvpzNd6vS4TExPyi7/4i33rWWvlsY99rDzxiU/svveMZzxDxsfH5ejRo0PPY7VhTvl1kXOq+PCHPyyA/I//8T9ExH/X1WpVnvKUp3TXKRaLcvXVVy87zu///u8LIN/+9rdFZPkwpw5XXXWVlEqldTiLnJzV0bmnL/fqhDkN4vbbb5dSqSQvetGL+t5fyzWSc+aTeyaAq6++mjAMGRkZ4TnPeQ4bNmzgc5/7HEEQdNf55Cc/ybXXXku1WiUIAsIw5H3vex933XVXd52vfOUrAPzKr/xK3/iveMUrVnUcR48e5bWvfS07d+7s7uOcc84B6NtPh+c///l9fz/mMY+h1Wpx9OhRgG7VhP/z//w/h+7zX//1X0nTlP/4H/9jn1WiWCzytKc9ja9+9aurOvac08tyc/jee+/l7rvv7s7L3u/5F37hFzh06BA//elPT2h/3/rWt5iamuJVr3pV33jOOZ7znOfw3e9+l3q9TqPR4Gtf+xoveclL2Lx585rOLb8uch4M3ve+91EqlXjZy14GQLVa5cUvfjHf+MY3TqgymmQWXaXUCW+Tk/Ng8+EPf5jvfve7S15PfvKTh27zwAMP8LznPY+dO3fyN3/zNye8z7VcIzkPbYKVV3n48+EPf5hLLrmE+fl5PvGJT/De976Xl7/85V2h49Of/jQveclLePGLX8zv/u7vsm3bNoIg4K/+6q+6lT8Ajh8/ThAEbNy4sW/8bdu2rXgMzjme9axncfDgQf7gD/6Ayy67jEqlgnOOq6++mmazuWSbxfspFAoA3XWPHTuGMWbZ/Xdi6q+88sqBy7XO9c0zgeXmcOc7ftOb3sSb3vSmgdsvzj9Yic6YN9xww9B1pqam0Fpjre3mYpwo+XWR82Bw77338vWvf51f/uVfRkSYmZkB/Pz+wAc+wPvf/37e8Y53sGvXrm4I4TA6oXI7d+5c9f737t3LWWedtdbDz8lZM5dcckk3x66XsbGxvlyIDnv27OG6664jCAK+/OUvMzEx0bf8VF0jOQ9tcmWC/ovpuuuuw1rL3/zN3/CpT32KG264gb/927/lvPPO4xOf+ESfJt1ut/vG2bhxI2macvz48T6BZjVxgT/5yU+4/fbb+eAHP8irXvWq7vv33nvvms9r8+bNWGs5fPjw0BK0mzZtAuBTn/pU19qbc+ax3By+7LLLALjxxhv5pV/6pYHbP/KRjzyh/XXmzV/+5V8OjY3dunUr1lqMMezfv/+Exu+QXxc5Dwbvf//7ERE+9alP8alPfWrJ8g996EPcfPPNPPOZz+Q973kPt91228B532g0uOWWW7j00ktXZUQC+M53vsPhw4f59V//9ZM+j5ycU8mePXt4+tOfjojw1a9+daCR6FRcIzkPfXLz2gD+7M/+jA0bNvCHf/iHOOe6jYZ6FYnDhw8vqeZ03XXXASypGf7Rj350xX12xu5YUTu8973vXdM5AN3E705950E8+9nPJggC7rvvPq644oqBr5wzj945fNFFF3HRRRdx++23D/2OR0ZGTmj8a6+9lvHxce68886hY0ZRRKlU4mlPexqf/OQnl/V+LPYedMivi5xTjbWWD33oQ1xwwQV85StfWfL6nd/5HQ4dOsQXvvAFfvu3f5tSqcTrX/966vX6krHe9KY3MT09zX/5L/9lVfuemprita99LWEYLikSkJPzUGLv3r08/elPx1rLv/3bvw01sqz3NZJzZpB7JgawYcMGbrzxRn7v936Pj370ozzvec/j05/+NK973eu44YYb2LdvH29729vYvn17Xyzts571LJ761Kfye7/3e9Trda644gr+9//+33zkIx9ZcZ8XX3wxF1xwAW9+85sRESYmJvjHf/xHbrnlljWfx1Oe8hRe+cpXcvPNN3PkyBGe97znUSgU+MEPfkC5XOb1r3895557Ln/8x3/MW97yFu6///5uvP2RI0f4zne+Q6VS4a1vfeuajyHn9LB4Dr/3ve/luc99Ls9+9rN59atfzY4dO5iamuKuu+7i3//93/sq1qyGarXKX/7lX/KqV72KqakpbrjhBrZs2cKxY8e4/fbbOXbsWFdY/4u/+Aue/OQnc9VVV/HmN7+ZCy+8kCNHjvD5z3+e9773vYyMjHS7Df/1X/81IyMjFItFzjvvvPy6yDnlfOELX+DgwYO8853v5OlPf/qS5Zdeein/7b/9N973vvfxmc98ho985CP8yq/8CldeeSVvfOMbeeQjH8mRI0d4//vfzxe+8AXe9KY38dKXvnTJOPfccw+33XYbzjmOHz/Ot7/9bd73vvcxNzfHhz/84b6KODk5DyWOHj3Kddddx6FDh3jf+97H0aNHuzloAGeffXbXS3HBBRes+RrJOYM5fbnfp5/lmrY0m03ZtWuXXHTRRZKmqfzpn/6pnHvuuVIoFOSSSy6R//k//2e3ekwvMzMz8mu/9msyPj4u5XJZnvnMZ8rdd9+9qmpOd955pzzzmc+UkZER2bBhg7z4xS+WvXv3Ltm2s99jx44NPJ/eMa218q53vUsuvfRSiaJIxsbG5JprrpF//Md/7Nv2s5/9rFx33XUyOjoqhUJBzjnnHLnhhhvkS1/60ol/sDkPGicyh2+//XZ5yUteIlu2bJEwDGXbtm3yjGc8o1u9RmT11Zw6fO1rX5Prr79eJiYmJAxD2bFjh1x//fVLKtfceeed8uIXv1g2btwoURTJrl275NWvfrW0Wq3uOu9+97vlvPPOE2OMAPKBD3ygu21+XeScKl74whdKFEXLVht72cteJkEQyOHDh0VE5I477pBXvepVcvbZZ0sYhjIxMSHPec5z5J/+6Z+WbNup5tR5BUEgGzdulGuuuUb+r//r/5IHHnjglJ1bTs4wTqRp3eI5vPg1qCHviVwjOWc+SiQvI5GTk5OTk5OTk5OTc+LkORM5OTk5OTk5OTk5OWsiVyZycnJycnJycnJyctZErkzk5OTk5OTk5OTk5KyJ06pM/Pf//t8577zzKBaLPOEJT+Ab3/jG6TycnJycnJycnJycnJwT4LQpE5/4xCf4z//5P/OWt7yFH/zgBzzlKU/huc99Lnv37j1dh5STk5OTk5NzhnGihsl2u81b3vIWzjnnHAqFAhdccAHvf//7H6Sjzcl5+HHaqjldddVVPP7xj+9rHHXJJZfwwhe+kHe84x2n45BycnJycnJyziA+8YlP8MpXvpL//t//O9deey3vfe97+Zu/+RvuvPNOdu3aNXCbF7zgBRw5coSbb76ZCy+8kKNHj5KmKU960pMe5KPPyXl4cFqUiTiOKZfLfPKTn+RFL3pR9/03vOEN/PCHP+RrX/vasts75zh48CAjIyN9XalzHnqICPPz85x11llonaforIV8vp855PN9ZfL5fGawmrncarWI43hd9xtFEcVicdXrn6hh8l/+5V942ctexv3338/ExMS6HPNy5PP9zGGlOf9QmO8PVU5LB+zJyUmstWzdurXv/a1bt3L48OEl67fbbdrtdvfvAwcO8KhHPeqUH2fO+rFv375uh8yc5cnn+5lPPt8XyOfzmc2wudxqtTjvnCqHj9p13d+2bdvYvXv3qgSsOI75/ve/z5vf/Oa+95/1rGfxrW99a+A2n//857niiiv4sz/7Mz7ykY9QqVR4/vOfz9ve9jZKpdJJH38+3898Bs35h8J8fyhzWpSJDou1dBEZqLm/4x3v4K1vfeuS9294+f+fsBChRHwbxszHIggoSHEci1scabRQChyCFnAiaAVOQCuFc4LRCkHQqO5YSoFTYJTCOgiUIhUhUAqLoLVCxC8HUNk/rcCgMFr789FQCAKsc4yXCjzunK1MVEvo0NBMAG3QSlGONMVAQxQiUYHJY7MUFIwVNXFiSeKYVmoJgoBSFGAKhiR2jEUBqXMcr7VIUseGaoHRomGy3uLwXIsAYeZ4nfpcTJI6nAjiLCjwH5XKPjd/zkZrtPLfj/9UADRGZ9+PUjTbKWnqEMk+bwSt/DlrrVAKtFbE7YSP/u27GRkZWZ9J83PAsPn+yhc9gygcfsnGylEzS290YWgGrm9E0Ms4JkvL7EtEWM6nqRQ8evuW4St01mPpfWAxo8WI5dYQgdS6FffVmpnFxsmKBzRaHS5Q2DjFLbOvZpzw2+/953y+9zBsPj+ZXyAgPA1H9PDgwGsvpnXe8vNMASpZ5urRggxZ7Fot9r/15qFzOY5jDh+17Pn+uYyOrI8Xbm7ecc4THmBycpLR0dHu+4VCgUKhsGT9EzVMAtx///1885vfpFgs8pnPfIbJyUle97rXMTU1tS55E8Pm+44/eQt6GYExnFOU9y/9MrZ87McD15+/cifJ2eNDxzPx8Bu0sqDc8OWiYPriwc+NE0WtIHuLBolWDpApHQHTWmElETZ+7PYhBwLxxTuwO4Z7o9Kkxfe+9PaBc/5Uzvc4jnNlYi1s2rQJY8ySi/3o0aNLbgoAN954I2984xu7f8/NzbFz505MFGGCEDIFQQScOKzzD3urFQQRQehAKbQSlAhKwChweEXAKxcKUN2MdKUUgfHKQMForChKgSYFikYjCqqFCGsdRmkK2q8XW6HWjkEUW0fKjFaKEGrKxYh2s810PcZEEZVqmWY7xYnrCnRaG0Qbmi2Hi2MSCwQGVSgzUhQOT80SowijEkGksNYRpwpbCInKIeWgRK3RZq7VppUIbWcojIwxHkLcVoht0WyliDicc4B0FYkOWim0VmjllyitEHEgBq2dVzCUQjAkQaZMOMkUCoXJttXG/975RHP37uoZNt+jMCCKlhG+lCM0Sz/naI3KRBQO39dqlIlSMRq+Qmc9Vp4b5XVSJlQhxK40DRWUC8PPO1VqWWWiO0w+37sMm88BIYHKlYm1YgoFdGl5AUQBasA9ocsyykR3jBXmcnVEUR1Zn/nusit9586dfe//0R/9ETfddNPQ7VZrmAQfdqSU4u/+7u8YGxsD4C/+4i+44YYbeM973nPS3olh810Xi8t+XzpWmGjpMQdq8H00CAq4aPh4ZpkbtNYrKxOmuE7KRLr8ctHgCisrEyYCs9KtV2TZe4ozESpcWWhfbs6fivn+cOC0KBNRFPGEJzyBW265pS9n4pZbbuEFL3jBkvWHWSWO15qITrDOkVhH6gQrDuuEwGiKJYMLMo9B5iFQojAKQm3QWhFqg1FQMJpCYND4G5HRmnIhpFoqEIUhzWZCMdQUigUCZ0mUMF4p0Ww7UmtJ44R2OyVOEtIYbGqpmYQgNMQpTNZatFsxM/WYmWZM6iBQ0IyFQqhpxgnHphVRaEjxQn1kFKEuMV9rsLFSQNKUohIiSbGpIrWOVjtlyloqlSJWwKUJLrUcn4/RgSFWjraLSZ2jVAyxTkhTL+yJdyv46Zz9p5Xft9IKveC6yMg8MJnXwYhGnOB0xyvkPTUOAeeVNx5GF8uDxbD5npNzJpLP55wTZd++fUs8E4M4UcMkwPbt29mxY0dXkQCfYyEi7N+/n4suuuikjj2f7zk/j5y2MKc3vvGNvPKVr+SKK67gmmuu4a//+q/Zu3cvr33ta1c9xr7pGjqIslAcL8iiBAVUAk0UBlgjlIHIGIqBpmg0QRiweWKUCAVRRNJoQdKmEGhqrYQ4tRQCQ4KiFVviWNAOYuuYbzUInFAoBdxfmyPUhsRZao0W7XZKai02tYgI0w1hKmmRBoI4KAD1dsJco8XUbIMw0ohApDTOCk4gCDVhqAmMoRwFBFGdjcWIqShkz+Q042HAWLmIDgOiUDNfj2kA9WaMjgIESKxQLpcZ2VDlsqc8ln/62L9SLRUoj0eEtRatZpt2nII4xNEbH+Z/dHQA8eFKiMJlYV/glxmtvYcDwJEFOmULs9+ddIfMyXnooxTVci4E5Dw88CFOp34/Vhx2nW70VrzpeXR0tE+ZGMaJGiYBrr32Wj75yU9Sq9WoVqsA/OxnP0Nrnec5ncGo1DH+T3ed8v2civn+cOC0KRMvfelLOX78OH/8x3/MoUOHuPTSS/nnf/5nzjnnnFWPkVhHGPgwiJFiRKAVQaAphprRSoGRSkTqLIkTDJpGHDM936JSLrBxdBTjhLlm7GP6HMzWY2qthEApxMJMK8Yo7b0X2lvp29aCE4KWop4KgTGAYNMUJRAZjQoMqfO5CQ7BWYtNoGwMI5Fhup7SaLSh7QONNOCsl9a1yXIutCYINVob5goh49Ui03MNKEXMtWIERRQY2rFXXApR4MNKtKGVWFIgPTbLA7WYvYdn2T5WIa3CfDtBiRADQaAx2hAoCDSEJkABjVaKOK9oOGdBDCpTJhRZKJTxeSFkuRUi0lUcFAqMItAKHkYXS84pYB3CgaabLX50cJJrzz3rpMfy13lOzsOElWKY1gGHf86t11gnykqGyRtvvJEDBw7w4Q9/GIBXvOIVvO1tb+NXf/VXeetb38rk5CS/+7u/y6/92q+tSwJ2zokRHa5T/e5BJm+48OQGEsHMrJRUcfKc7vn+UOW0JmC/7nWv43Wve92at9+4ocqm8VF2bhmlWCgSFQtoZ3FJm0ArdKBpNGPI4vpT60hSy8x8g2NHp0kTSy1OEGtxzpI6h4hDBwZxECIESiiGPncg0JogEVpxSpqk3iIvDqMUpcAQGUMQGJ/oYy2pFSyCRROGhooxiBIqocUmPhzLZQng7dQRW0cqQmwdYNGpQmtNGifU2wmNOKadpjgHOkv8Th24LKyrVAwJAkNsHY04JXHCgck5VBJTKwQEgSJ1Fmst7SRFW4VTFo0Qak2loCgVQlQpomA0RmnSVotSucjMdAONBTRR6PMifCJ3Fi6FVyq01j5vwvick2SlhNecVXPRjk0UCwvxs/snZ6m3fJm6QmQYL0ZsUH4OHWw0u+uNDulNGYtlcW6cc0K9maCApk6YGC2v6zn8cO8Raq1OaT3F9vEqF23dsObxjtWbfG/fESbrTb6++wBGqaFKhQrDbrk/SS2SrhDMm5PzEGbiC/uxVf8Ir186wfwVm07zEZ0eVjJMHjp0qK8ZbrVa5ZZbbuH1r389V1xxBRs3buQlL3kJN9988yk9Tl1N0KWFPATXNGCz+5ES0lGhfh7oRFHav3DPnr9msIE13bj03qysUJjzBjzlIK6ub3nq6j6LaS8IwPGoprll7fuIDswz9pU9RIfqbP74zxCjmXzxYKXCFhSS7Uongs5Fi4cUp1WZOFme8Ojz2LRhDGm3SUQRlkpEWrBNjU0SbCq0ExBrSVNLM7EIQjOOmZydRzmhWAgolgKsM4hzKHEoEZwIUahxQILzuQGifYiP0YAQadBKY4BiYDBa40SwIiRWiNNMYcBRKga0xdFOUsQC4rrJ3UEIlcjgBFJx1OOURmzxRyu0ncO2YsRZUmt9DogACBaFdYJKoeFiTGCyhFQLVoFNMRqcWKxNqbdjlBOcOBBFYv25xkqTiFC3KaI0BWPQaLCOUiGgBYwVCxTLRYraEegsUUIWKjkFgSYKDGGgCQJNGGiSOBfY1ouJ0XJfUrPSiqn5Gu0kJQwUhSzR2vaErTXimOIQ66RRmpY4mqklTrxaIU6Ik853ptC1FuPV1VeZsE44OFv3Hq7YP9R6bzJ7js/RShbmxGzTl1Bci0JxeL7Ojw5Ncmiu7seenkMpRWT853Dl2Vu7KTtpnIBWKLKHuS9b1jfeamy42mhf8MHlHrec00v5nrnu7+GxNsU9833LJdBMPffc5QeRbkTrmnFk4a7rwFpHWs4w+cEPfnDJexdffDG33HLLmva1VnRo0VGP+UYJrm0Qq/3vAcSRVwhEgRKoPKCJd44vO66JBdNaUCA6vwOEDUjKJyDsCwRNBwrG7vPPEdeTwF+ccn1CfNDw+1qLQlHYM8vItw5QfMDP48qPj/tk7Czxe+p553VvyqbpFQmX5VaLVrhF0qtertBA53gPzSDFCLd55RC6YTwU5vtDkTNamThr0zjjo1VmpyzHJudJ51pUCgFavNUxdZZ6O0FSX8FIYRkrB2itKIUBoTaMVwpEWhOnzuc8pCnWWVJxhAraTmgnltiCykrKkpVDTUS8w0ugkVgvxDufCJ5a/3LirQ7ioC2WWhZW1QkXCo0hNN6aH2rtoz6coJxgFFQj7+1IUn8cnfK1qpMbnYUZOTIFwQmB0pQChYMsCVpoxzHzIjTjxHtRtEYZCI1G8F6GxKY0bEJgDCYKiXRIKsJcvU0jtWwMI8aqEUXtQ5rmGzHTtRatOEUrCANNGBhU9nsxDFB5mNMpY2KkhEhKrdXv2jVKsalQQETQyfC6fCGaRmppthKSdNB6Qq3ZxmjFSDni4EwDlykqHX1lpBgSGs1s03sbrBOOzXuvyNHsZ7RMKNNMo8VdByfRWnHB5vFVnjkcmq/zk0PH2T9T6z9iEe4+NgVAMTQoFBduGPFeiJ7qJkpr1OKmRMqf83Joo2lYoT4kaLa1XsG0OTknQHF/neL+et97rmBWoUwoirvnKO6eW7LIJm32DtgkZ33QoUOsZnHfYDHQ3uxQDkbuXV5IN7EQ1hymPfg5a1oOUZCWNGHDde+ByhdzRAIvpOtkwQDVGaty0L/lIj30rhg0hcphh2hobVq9QlHYM8vIbQcp3TfT975yMHqbT6a3IyEoRf3y7WhrMgNqdpjGv3pZzZ1XT9Uw4xVk4+Byx8tVuMpZnjNamXDtFu2aIjSKVrtNrd4mLgSE2ocfCYIVH8ZjlBAGwkgUUjABgQkR0QRoktR5ZSJ1WOsFZSsQWy/AN9uWVuK8sI4g4lO+U/HKghPBOW/h7/So8JWSfM8KrYXQ+BCjuVqcpRFIVkBpoaeD0ZpA+5KskuVfRGXF1mqR+XbKoTTOkprFKxG95e+yfYoF0YIDUtfpAOFIZpsEuo0xmkrVUDIapVU3NCtxjnqS0kitL5VrFNVSiFERKMXESIkwUEgao6IAbTTTjTZ3H5hmcq4JInjZLOvXoRRRoAkeRjGBD0eS1A5RJBaYrbdopJa9U/PYRTfbDeUChdAwXW8P2XplZpttfrzv6MD4UdGK8oDStvum5zk0W1/yfi8/PHgMgB2liKJZxYNOIEERquFztpE6plPH/JCPrL2+/YxyctaOdYx87yjzVwzv91LcM8/4Vw9SuWN6ybJUVhdHYjNv/HqwXuP8vGBawxWJDkHTLw/nLWrR52sjjejle1KseAxNobrfogcYUtTB415AX7SodNfxJYrEYjbcsg+A+PwtuMoqytRqReNRGynfeXzoKm6sjFRLQ3tfrNQTA/L5PowzWpkIbczMTJtWKiiXUgwgVBZxjiRN0dpXcQqMJk4tymkQ5RUHldJOHUorX4HJuawJm/f7tq1lrp3QiFPacUqaKQC9VgTpsbgq6amxusgQK8onixtAsrCirC0DCofrhGLgaKvsfYHYaHRNs7FaRAle2XEOpTToLNSiozCIIB0hSOjmMojyoStKUjSKchiyrVwkQhNonxdRUL5ZXkFpqqEwF6fUWwkozdaxMptGy4g1tNpN5poxDigXC7RTR62VMFtvYa3rnldmu0YpsHlc+sOC+47OIQOE/elGG5P1ZDkZ5tox37r/wJL3bTjYqxFpTUEbXwRgHWkD5XD4ucy3LfNJ7m3LeeijU2HzJ+9j/srNQ9epfv/YQEXiRMgTUh/6FGYHP4dN7LwccxK3USUQNoTxny3dR/Bv9z5oJR0l0Mw841wKk8OVYLdjI25i7SFOkM/3YZzRykSrlXBwrkmSpFRCTblgcEpop4IFUuvncZw6as2UwICzkDpLmvpEZ6V80mnqvGci6bwHNNPUW2LFl55VSrqdsRcXfVmIOZUlAagKP36YbSRZvoPqrLp4PmUCeWodc62Y3ZM1wsDQSFKvzGiXlW3NchayQXoToSU7JqWypkTil5eMoaAN1oGkjhQhTbxXQRtNNQgYHY043mozPd+i3o6xWthSGaFSKZIIpFrRSCxRoBkph9SaoU9Ktw7n/H5c59Byt+FpwYkwXW8z14oZG9I8rp4pjakVgmXiTX1BgLV/j51rZuhyRTexbrXEzqFQlPTyFqtq6DvPi9ErPy8Vfk5Xhzc9CtsWTn3BkJyck0YUtHdWl7+28uJlD00EgtoKX46wIIws85xdxtG6ymORrkyxZGx8aJA6ReGdyZYKLA5HHYaAiaH1xAuGrqJjh869x6eEM1qZOHB8nmIxpISmFqfE1ucnOPGVm1InJGnCbCOm1vSN25wV39EZ8E3WZKGsaSbEh8YnE6NkobtzR+jPPAfS+bPrZPAKR2/cdbe7tIB1jjgLj+pkvPlgJNXXv6G7AQpRgnWOmUabkVLkBXUEJaon/lu6YVOdbDrVsTQ46Y7pE1M1WyoFX4nJLShGqIXu4eB7dJw3UWX7qOOnk7Pcd2SK+ZGUreMVKlVfh985oVKNOHfbGCOliJn5FvVWQjvxlaKSrJoVNvdMrCf1dtJ3U28mKanLEuLxOQvNOKVtLf961z4U8JQLtlIKg+70aiYpTuDOQ9McmWswXimwebSIGaJQHKqdnPScIAzrYb0WRaK7bWYhGqQmlAKvZFw+MUazGRMqXxBgucezQrFtNO/InPPwQCLD/jdcesr34/BVC9drrIczqq367DK67ftjdeL/lQMdg04VG37k31xyf8y216ngQkVaVARN+nLCetEn6UnVieAGdOYGfH7nKVAk0jFf9GPqxZchgV6QvZZBCVQPnnqvcT7fB3NGKxPlSFMoBByaa/su2E6YaybMtWJasfcqKMBaR5wlL3ct5d0Lb7FrQJFaUNphjCbpncWqY2HNlILMY9FZ2J3rHe3A6wo+x0J8QvRCX4YeRUItKBSd8Rf+994FKx3Pg8/PyHwR4Ht2Lxy+sOBNESBL9jaBZmOpwEghRLHQF0Jl/4n2Dg9rhWbbf1aVYsi5YxVmWjHNZpuDYomikEIYEAWGWpoixYDNxVEmJiq02ik28eV34yRlvt7m+HSNe9b07eYsJk4t//azvSS237SyY6zM1pESToTj9RZf/dnB7jIBvn7fEa67aFt3Pn1791Fq7QVX8Ey9jXXC9g0l9CKX23oULeoq3ic/VB+xcziBign6xg615qpN/dWh5hotxipFwgHhWJ1rT5+0CS8n5/QiRnWr4bjCKuLMcx48UkXpRyVU2n8nbG21tDc5FBDMK8bv6P/elOtXKEwsfd4GW9CIFsK6PXUhRZnhsV9SWgevxwBcKWTy1Y/ve0/ZTOEa9BCRRT9zTgtntDIx3U6ZKIRE2rB3rsXxrLKQFZ/7oABjlA8v6iQoZwJ5JxQp653Nwiz1/gLnIDDeg+hzETJPBV6VWLaeXu+kzoT21DqiYCE+SnXim3oViUWejc74gdYk1leNQvd4QTo76+6vN2eiE/Lk/ysozdZykUCZLHm7s8/sGEV1T8eJI04EZ4VAK7aWCjinSHG04oTZZot2YkmcIzSGKPBJ3OVCkcAYXx7XWSaaCWeNF7ltdV9nzgr8rx/dQxguvWQPzDa48/A0k/PNAVt5vnLPYdLUDrVezTdjrHPs3FTte3/PdB0dnJwa4CJoIpRS1V+R4yS8Eh1ScdRswogJfTNFpbh2y8TAdQedeaiEEZWVVVzF/nRmUHgY5c3lnMGIUX2PoeZFYxz+jYtPbHudVfdZI3kM+eoof6+MGmDhLx4xlPdrgmUcwN5jIUPvUS5UJFVDuKgyRFo26MSdlNAvClTqkED3hasqu35eCQEwCgkNR//TlatYuXMMvqIUrFKxWQeLVj7fB3NGKxOh0Rw43uDwbJ3p+bYXuDt20EyIt853tQ1DTTt2PfJ2Nz7JCwbeRN+1+Htvgq9KZKHrwOh6DkT6JnVHzVC9Y4uPiRKV5TgECpUJT9JxU9A/hurEUamFxVorEgQdqO6xdZSEbswVshDeJB3lSaG1V6Z2jJQph4EXhugJhcJ34FaZkNS1NkjHKi3YxIEYjIGt5QKb8L0vkm6TPSGOfXk4U9AUQkNYitDlEpO51HXG0Gin/OzQLFGh/7bgUlmzQpH2pGs0g4W5EIrCrNPUUEA5MDxxkTdiMXP1FtvLISPR2jWY8ydKBFqz90HotJqTsxJHXnEh9cdtXPP2ky86F1cJmPiX/WseI69u89DABYr2eLCkMlM8FhLNJmtSKHoVVZUuaJy9Ns/1wE6UmHzl5cuuo2zmlTmJnAcX+kgOna794PP5PpgzWpk4PFvn8EybVuKbuXn5XhZkbAGyLz4KDXFqcZnFvi8ptCdXoeOjcFkScWAU1vYoIR3BHTIvR0+YlPKCfnf8jgcjG9sphQm1T052XmKXnvwHlXkpFvwkCqV81aU2/hhUx5SrFEp3lI/sJJSgvCslq+AEgdFsLBTYWi5ilKYbWpVVn/I6VFeFyZKnVVZCTnyoliarGiXMNWICozBKEWmDNgodaZQGpTUORWId9VZMikatkCCb89BBG00YDf6+llMorPOhd9Giykvp4LxvAJLMyxecTLesjLEoXFGRWA0C1KcbVDasb9fvnJzTRbfIR87DHuV6+kUswisU6ZLSsOC9Gi5U3RKyHZabN5nYsC4KRbxjlKkbTj63RxQ0NmvKx/Jqe6eDM1qZODrVwGmNNsrHFdJRFCSL/vF/Wys47Ttat7Jwof4LQboCdUeMl6wLdkFpnzjdk2LR02CYTtJzV2/oyX1QvQFJynsltNYoAZdmCRWd/AUn3TCnjpdAo3yYVqTBCkp0nwKkVGf7rLJTtlA6TfG0ZiQKOWe0QmhMv9dD8AqAqK6XojfMyjmfIG6VoJzKklydPxtRWBQ68413Pk+lNNpoSsWQjaMlrAjT5KUTHi641PcfWYiwUz3XgtCKvSIfhRq7jCKxWsY3LQj10/OtriEgJyfnoYPLXus1Vs6pIR4LiObSbmO2tGh8YnV2P0+qBgTCul0fBVQgvc7nPpj//WNUe3V9Sx7q5PN9MGe0MjHbaBEUCkSBJu2Y9Bdr3pkXILWOQmCIjcOmNsup6Nr/+zZRmfVekTVi60Q1Sa8c1Z9S2ulEvdBDbkHryFIdsgRsL8krrbKeFj7MqBN/1BXsM+E+VJoUUNrHm3eOWDKhf+F0O2eRKUZaUTKGc6plykGA7sme6nhu/JiqR/HpqlKZ1yWroqCzKlIuyylXHc9Mz2cMKOUwOgvFckIxNJw10R+Dn3N66HqeTnIcZ8X3ORnysBGBOHGYVYQSbagW2Fgu0minHJ1p9B3s2ES/d2C8Wuz+XmvGxFln710jZZ6+Ywsiwnz91D+sbOLYFgVs3Tx4Xjda8Sk/hpyc9UInirlrz2b+mh1LltlWC97+udNwVDmLcSHohJO+gccjQb93ovc+nj0kkoohaKzCCOjwiokCWVIrv38H9poFz4O+6wH0kWkAGhdPcPyXHgEKwtoJn84JE/1kH8GeyaHL9SobNeYs5YxWJqx1GCeEWpHqrNxpz/IFT4F0rZpGK2wmPGdifdeD0VEGOkmWZFb4joeh98LrCt89IUJK+fwGwecbuEUXlMs0EpVdeLrrWYBOqkdX0FfeG1A0hgQHCrTS3gOBzsK5OgqAyjwrnTwOn3B9drnMeKGAUarH65FZIlz/fWThk1vwXnTzzhd5cUQ6n9yCJ6OrZDnxfT3aKaqdsufYzAl8oznLcWimgQkGhyFZ54bJ911MoLGdxowZUaC7FY5E8aD5kbaOlNhQjFBKUSkGnLNlBPDK6lyaLulL0ft3tRQhJeGccplHj43460jBWDVCgLna2gV6AeozTSrjpSXLbOxLS3eu9UEsfqbm5JxuhoU66URlVXIUMqAstNjV5RZZ1q9U5nqN81CkuUXQxcHnF82DHt64GQHSkiJoytLcB1nyy3BUbxj18HVWHKajSGS77U3EXqJYQF+vCHfxOcgjdlLfapi7IPSlX4Fk1I8Vzq+8/+VobtSUji+1+Rd+8ADm4DRqmRKFSlb2FeTzfTBntDIBXngVJ4Rak6reBOuunJv1UOg0jtOkdBKZoXNldhQCrVS/h0Gy93oStjsCv+n8ku1EUL4ZXKcsa8ePoLwSk8UueY8AC4naHVm9u1+1cCxGaWJls5CmBQVp4Rh1Vy3qnGukDZsLBbaUi4Ra9+RD9NwnVrhh9ApMKtMsRGUKkvhz75xHt0leZxsnWOtoxylzzVzTXy+sk6HNidwqErkUimJo+ity0C8YGxHsch3mVoEI2IbDlIcLI7qj2GZH0SlJq1hQtoehFFxUrXJBtULYfUh1PGwwWomYqy9VKLaXQ6rLdLfukDiYHZBgXQgMZrUNlHJyTjFH/o8LaVyyYcX1hoasrJMcY8W/1mushyti6PaTWLJMrfx1dBvcDllRlMIFgj7Z1k7KV4Fa3jtxEl+UMcyfE1HbYXA9eXbS8YyMDFYoTCyrqjo2dn97YJUp00iWVSRWSz7fB3NGKxOdUpAiEGiVVV5aUA4E+oT11AlFvTREwwvoqivcdOPAs1KyHTFHKcmqMSmyarMLkVXCQs+GnnE7ArYxekER6RH+O54ErXuEq+yYA7zA7rtvK+/V6ByLUT0CmfbKjHUYpZkII7ZXihSMQXcUF1k4z96d+Ou3+0tX8dFaEWh/zlorIhOS4LAoCoH24VHZMM45rOt0vfChUTZ1KDTbN46t+fvNWX8WvG5LWY0KsVAFbAWWuWdvrZYYiQY3h1MoRkzA/ArNDiOtiYYI9lorRsp+/PmGV2YDpZlrC7XYPyCroWKksGh7ITM0MLBz+8Povp/zMGDDLQcY+/phAOav2MTctduWrJMnXz+8WPHrXCkrWlZ3+15uJe+VWG65DPZO9OAC+hSJvkPUkGZRpEEdL2NE9DXOM20wrf7zVAIjD7TR8ZCDy2/gp5Qz2swWBBqtvVVWKy9E9F1LnTtpJkCJ88qAMVlVo26wU0e8X+gK3cmBELXwd8ct0BHO/UuWTFJFx7uhulbWQGdjZYJ695/yf2ul+o5Io4i0Js1CiDqKk1baC/pGYwKDMd5aatBEGDaEIdsrJaph6N/P9tf5qbuJ4Flyd6gpFTTVUkC1FFAuGqJII0poJJajtTYHZ1s4BWPliIlKkWIU0kosc42EmXrMbD1mrpEw30iYa8TM1GKm59vUGjFxI48hP9MwQjZ3Bry6hQrWxtZqkbFiuKyF/yTbWgD+GjdGUy2FhNqgUSROaFv/mouFow3LTCt78Aik5M+bnDOH6EiT4t4axb01xr9+iG3v/ykT/7Kvu/zBUiTcOr9y1o4oL6jbSA19yUl4nvvCm04hzvhXWgZX8B4dFyy8bBGSEUVa9ueiLVT3xUsqUp2SY1vn14ny9a9/nV/8xV/krLPOQinFZz/72WXX/+Y3v8m1117Lxo0bKZVKXHzxxbzrXe9ast4//MM/8KhHPYpCocCjHvUoPvOZz5zQcZ3RngmTeSVi63yYRK8LsGuJp6swCD5KZHGX34VwJC9se8HbKwBGK9KOi6PzY1GYSO8+Fpt9O2FAWoMyPcpON0xowUvRO0YoioI2xECkNIj2ln/lcycCZSiYTLnAEEWKooJqEDAaRkSBRiuNCTqKiPcWoHyIl7WWNAv9ihOI2wntxBFb31VYKf/5aq0ohIbUwnwjxWiHCTTNVko7tt08kM7Zds5PlN9vkuRhTg8GXe/SSd7nFV7hXVZjWE1orlI8/9Jzl7y/b3qeVvLgVfgKAk3SFmTRQSdOSBzEGqw4lIKRFToGJ6lFBeShTjkPOcLJNuFkm8K+GmYuwZUNk794zrLbSCC+G3MuwZ92bMFb44N1SEJ2ZoX79yqsJqLg+GOW3g833G0JGgM2OEW4gIHH6gxgvHIjSmESIawt/1yRbRNgLWqufkqO9cGiXq/z2Mc+ll/91V/ll3/5l1dcv1Kp8Fu/9Vs85jGPoVKp8M1vfpPXvOY1VCoV/tN/+k8A3Hrrrbz0pS/lbW97Gy960Yv4zGc+w0te8hK++c1vctVVV63quM5oZcJ3qvaCQtKNuV6cLN0J4fGSlhPf1TnBXzDdRT2KhNGKwKhu6JTgumN3R+0dH+jTMjKhrhNWFGi1IKBlgveCFyULNMoUEq0UodZUTMBoGJDiw4icAxGHUaC0phAYipGhWChQjUIqgSbS3tUUmYAo9CFOWvvt2rFl3loaiaXWSmjGKW3rSG0nd8QfQ6i172itfQJ4oBWBKOZqMamzFMKAaiUkSR1pp8wuvb09fDhWJx/F2fxJdarxOrRPiO9aIwfkUIRGYdRK+RVqxSziTmWyYaOEWvP0R+3g8WdvXrJsvFTg7iNTzLdOXMl87KYNlLME9IpanUCfxssdqQ99nI8FoxUjheXHss7fP/LOKTkPVYK5hNFvHyUdi1ZWJvTCM/BkcPhS4evBymUkHn4o55PgkyqIEbCDKxtp54VobVleGVjhI3RBlnw/5DkgGubPUdR2Lh1IORi71xLWTtxqVTtbd0OV4tHV3b9XalAn2nspVjNtZKyKmpqDk1QmTvd8f+5zn8tzn/vcVa9/+eWXc/nll3f/Pvfcc/n0pz/NN77xja4y8e53v5tnPvOZ3HjjjQDceOONfO1rX+Pd7343H/vYx1a1nzNamUitQzKhwjrpCuhKOkFL9Mv6+CpLPhdgIbyp29dB+3yBIHt1xutcc93qql0NhJ6LWnW9FNKrHGSWfddNVgaldDd0KVAGo70AVgoDqoWQahRQCQKKRiPiS2E22xbfNluILRTDgGopYnykyqZKRCXUIBbrHIExKKCdWBpJyky9zXQtZq4e00gs863UV8IyisgYiqGhEBgKgaZgDJExgJAmgk0dLZfSFOfzJ5QiTY1X4gaU4e3mgnTDwnJONSKdud7JY5EepcL/CLQi6lRscatL2B7GY3duolr0jST2TdXYfXyuu6wQGK48fwtPu/isgduev3GUAzO1ZZUJpRSPHdCE7sotE1RCnwsxVW8y02iveKxJ4gbpVTk5OevEMnUh1jTWzxudHAQXQDzie2ap7Mbd8VQoR7fylkNWViiWoblFIVn/qGgeormFgZxR1M+C+V2DH97z52jKh9zyyoTyisPSbQNsZrBRVq2qk/VqEq4fbM70+f6DH/yAb33rW9x8883d92699VZ++7d/u2+9Zz/72bz73e9e9bhntDJhnfgu0J3eDZll32U9IPoqMEEm5woqS8LW9OdHGOUtt938At1fpUhYWLcbUdJTGpbev7ueDk0xCmgHEGrfUdsYQ0FpJioFKlFIoCAymtFSyES5QKUQYJQiscJsPSG2jtSBcwrEESjFaLlItRIxVo4YLUVEWogT72motxJqzZjJ+TbH622O19rU25ZQKyKjCY1itBBSKQSUwoBQe+XDWkhTR62d4JwD8fkVXjHys95o5ZsAditWDU7o7ShTJ1kYKKeHTt5ML65bV7gHtZALJOIwGgo9iQha+9AGXzxg6bYr8fSLd3DuplEAbt93nO/vOZrtCwqR5jmP2bXs9psqRWZbbeptn2Q9Vow4d8NI3yE8ZsP4smNEgVeA2+nwJ1KrnRKnrlv6dj1IUoddpgTHgxnClZNzsoiRode8nNHSwUOQAQY2NcBxKhra417gUFYIGpk3orM8UyiU80nHfduv4nlb3y4k2e22dAzKhxc2cgHMnb/8IO0JRTSvCBp+x7ag/PH2HMPMI1aYPJ0mu8vpJNn59RmFTxI3UgIZH7rcuhgOrc++ToS5ubm+vwuFAoXCCq7yE+Tss8/m2LFjpGnKTTfdxG/8xm90lx0+fJitW7f2rb9161YOHz686vHP6NuFd9N1hKYexYDOHFX0FWVWik7fad3rKcALySYT/rVRmMB3m7ZpNlKmJGjtcwl6e0jonvGV9mMERhMFAZViQKUcIKGmGGRegDBgrBBywZZRImOYb7ZIE4tWXtgvBIYoNDRjy5H5OlP1xO/PCQVj2LahzDlbR4hFKBmFWMtMI2am1mS23ma+kTDbTJhrJ74SAsJIwbB1pEBkgixUw39uNhVaLsW6LGSsmxqS1dN3CyWiVZYHYcUtFUKzrRZf9blVeP0IsrnVS2yXr1SttKY44Crv5A358LnMj+cTZZY9hp0TIxTChQEfu3Mjj925EQArQj1dOXzpkm0TlMKAY/NNAM6fGOUXLl4IyRARbn/gyLJjVAsR9XbCsVqT0eLSdttxYpmabYNApRh6RUyfXPK4c0IzTkiXCd1rPky6vOY8+EgxREKDnl9alviUoMCFAnrwHcStMpnCrmPYx3qN81BE1NKkeO1AuSHnrKC1UTE6t/T78b1BvLLRVSpYOek+rdJXnra52b/8xsscSw8zj/ADlA/5nbY3KGYu6n/IrORREA2m6TBt8Z23F6GEbonbBUMwJ6dUaIU9exMSbBm6Spq0VlQmTsV837lzZ9/7f/RHf8RNN920Lvvo8I1vfINarcZtt93Gm9/8Zi688EJe/vKXd5crtVh2kyXvLccZrUyILJSjctKxhEtf9VPplW+zn528CJBMSZCusGGMIjS+YpLPx1DdBGaFEBmNUZp6YgGFNhqdeTPCwFAshFRL3lswUS1x1oYyYUEzPlpiYylCBz4nAevHOjrT5OhszEythTgoRwFbN5TYOBpiEYwxbBotkzooBortYyV2bqkiynfbrTVijsy2OT7bYL7RIk4tqfXC4WghoBj6kCWlNVtHS8zWU5JESJz11auctw64rAyu9HxQKruKOwVpO0t7SzV3o716PUCZNtfphJ1z6ugYu9b6KXeUitAYilEIWuNEmG0uDSHaPFLmVddewkRlsMWkE7q3mhCqZ1ywg83lpY3hToS9U/P8eP9xHr9rU89BKMpBwOTUgkBWz0KqyoWQKBjipZCsj8cytGMfHpiTcypId0zgto4T/nhvz7tyypQL0T0P0JzTQqda5Fpv4B2lAqSvOaEeYNOwJZh5hHRDjU6GuXMD5neuvN5yVA4llA8mTD265zmgIK2YgcevWCTPLUJW6CHkQr1iydrTxb59+xgdHe3+vd5eCYDzzjsPgMsuu4wjR45w0003dZWJbdu2LfFCHD16dIm3YjnOaGVC95Sp7PaE6Lgnus0fFjwW+CghjFKERpEVN8Kgu2VTRXwog2RuxUAbIq2y5iIK0LStt+JqrSlEAZViyHi1wMbRIrs2j7Jz4wjVYkQpDCkUQkQJUWhQ4qvLWCu41GKdpRVbqlFINKJ8+FKlwKYNJaqlAuKETSMVAu0rOIUBhEaTOminCVNzlvsOzjNXa6HFUTCKYhBgBVqpY76dcrTWphWnoDRpCpEy3hKd9YVwTrpa/0JRpu4vZCpa97fOu71en26KRI9ZpBNCY3PXxCklNAYspKvo3LkcuzaN8YxH+/CkRpzyye/ek/2+cFd//X94DNXi4P4Q4K/HsgmppcuXA+4UNhiKgjDQJOnwc4pTSzt1HJqt808/XkioM0rx5F2D8zUa7QQIvDLfvzsQYX5Ao7teluvRkZNzMkigITDYrePYreMLC1JL+R+/d2JjaYUdGX6drje5Z2LtuABA0MnJnXdaUrQm/BjaQuVgVjSmJzxq6tGCW25aKB/2puwKx7IOj3SdgEqE0tGUHUcXOtSJUex/5thyh7hEoeiIK83NSz3UvQQNe/IN/Tg18310dLRPmTjViAjt9oLB8JprruGWW27py5v44he/yJOe9KRVj3lGKxN0E6kXBGK6D3zVlXc7eQ7gXbeJE0KjkawkpMo8GLZHAXF0wno0scMrHkDs/DaB0YxWSzxixwYeuX2MLaMlCmFItVKgUo4Qp9BodKARLWitMVnIkWAJjebITJ0j0y2SRJhtWKLAsGE8pFQsEEYhWsAEkuVa+Dpo7XZKHFtaScr8fJOidlAw1GPH8UbCTCOmFlvi1OKcZOcAYWBoxAkm1N0L0tEb1tTLAFNJj/mkk0OxyOGzUH4zGxtA1qHjZM6ppVPFrEM5CnjVtZfgBN7/jTuydVYWpBW+CpoRvawF/4INo4wvY3lRKB69cws/3D04XtM6x9d/doBvD1m+HI126nM7wgWFQiEUVa705pweRCuSS84mvXD7SY7jrbPxtjL733DpOh3dyjhRuHVqarFe4/xcsSh8yhmY36lRAtV9rrvOeqFjtaowpmHrKAsb7mwxds/KBTQGbk9mwJQsDDsWqgcfvPv36Z7vtVqNe++9t/v37t27+eEPf8jExAS7du3ixhtv5MCBA3z4wx8G4D3veQ+7du3i4osvBnzfif/7//6/ef3rX98d4w1veANPfepTeec738kLXvACPve5z/GlL32Jb37zm6s+rjNamVgQgnw5WCe+xKMxKrO4+2lntOoqC0ogTh2VyJAo31OhY5bvfK+SJad2tvNlU7McgiycaeeWUa679GzO2zZOuRCSJA6UJooCtNZZ+JQmCA0Oh9IaSXx/3UBr0iThO3cd4559M4CP8b7wrDEKQUAYBpSKIZL6q8VkngkRRztJmKu1uO/ILPcdnOHYbItaK83CmyyCQyQrj5spUi7LdfDFoHzYkmSKk/QEIi44JmRBeVAdpUwg64a9mP78Ce8V6uSm5KbcB4GTiXMCLt25iasuXGrN1wp+46mPBuCCLaPLexOA6kiRx19+IUlq+dev3w4MSPBeB/7pR7v58YHja96+GaeICAUNLo79iZbW362c8/BGeqMqpD8970RILj+ftDdUby3HomD+CZs4+isX+jdyG86Zw0neIpMKtMcGPJcVzO/yk7S1za6uiaHGV3pKh8USnbxesvn7Tap7T66ZrRIoHreM7k6RQBGPntGi7Anxve99j+uuu6779xvf+EYAXvWqV/HBD36QQ4cOsXfvQqikc44bb7yR3bt3EwQBF1xwAX/6p3/Ka17zmu46T3rSk/j4xz/Of/kv/4U/+IM/4IILLuATn/jEqntMwBmuTJgs4VnEl390ztfSR3VyKLzwq1F4b58Pg7LO/3SisK63dGR/mI7O4qOMBhGfkF0oBFy6axNPu3QH2zaOEAa+TGqxYAgDgza6W7vb4EOSMD4vIbVCYLyAVW8lHJ9t4ZyQpBatNeMTo4xuGAElGKWxyvnO2eIQ5WgnKbV6m2/99Ah3HZim1mhjrXRDvERcpkRktZeUoFEo8Z9H0In+Up07Qk+TObKEG7JO3f4T8NuzEMqUWn+u3tPjFm6Eme9RxCt1dL1BucX3VFMJA8Jlmh804pPvQn7f0TnO3zza58HoZWLDCJdddi7gvWDPe8bjEeB/ffn73XW2FiOMUsw3WoRKUYmWd0ufSlyadhNMrRNqjTbV8vIKhZOFCnA5OXvfcjnJhJ8zWz5xP6O3HV3bQOswn2aecRbHf7GnilqnGcxyu7X+/iwnmTeRhzmdHEFrfZrVLUfxsKG11fk8mWF05oECCbMohJ7wq5EHVPfveIOQVE7V0a5M+bClut/HLKlUKMyktMeXF2fTssG0HCY+OZnkdM/3pz/96csa6T74wQ/2/f3617++zwsxjBtuuIEbbrjhhI+nw5mtTBiT5TJoFA5nBWskS6LOKjyxkAvQ7RKshLYTSlFArZXQE6DTDZHSSqGMQrSiFAS0ra8Kc8VFW3jKo85mvFIgikKfdyDiFZusWYUgJGlmnTfek6GBwPkG6i1raca+6VsxMmgNxUJIqRiB0lib0Gwn3ruCMDlTJ9IGm8Z8/c5D/GTvFI1WjHOWbqi8+OZ9C1kMdMONtFI450hdp/le52T9S7J1e5UGpRbKuvZ+jnFiGatGvjN42mN5FrxXxEGnz0bfvnJOG+Uo4hXXXszQWkYn+SVt27qBRzzy7IHDPu8/PIEf3HbHkkT8qXoT64TR4lIB3jrHe79yB72K6BXnbCQyho9956fcf2x26LFYEb6+5yBPPWdw3gRAUTnCRUquE2G+0WKkXBy6XU4OwH1//kSf49DD0ZeeTzoaMvHFAyc0Vvvai7FbhseIExgaL3wi5c9+Z+gqx150DrNPGxAitQqFIuehT2uDIi2fwh1kcsAgJBTG7tJLykRF0wplhXhAmL9yMP7T/vfmLvD5Idu/Uad0ZHjigrLC2f86w/5njw9dZ2RfSunoohLcTihMp7Q3nNEi7RnNGf3Jl4ohzdjhRHzsWSYNV6MArRT1doK1QpIJvIHWGIS2QDtxlMsRYeC6iZ5K+TAmrTQm0BSLIZtGS5y9oYoOAx6zayM7NlaZGCn7MmMoxAlBoMEJifXuEW2U72XhfLUco4UksaSpQxvfdVcUlIoGYxRp3SEK2u0WrWaTsGRIrEMjzM632HNohp0byvx433Hu3DtFoxl7xSDzBnSUgM4L+iNfnBNSfA38kagne6mjZPVpF52EVDJFI8tHEUHrzIuiFMZoIKvck706WRRdh4QSTkGUS04PBaMIVtWSWZ200nD1Ex/JT+7YQ7On0tPOnZs579ytQ4debpezzRbWOTb0VHVqp5YPfOMuFnu0vr93CoCZxsl7WdaD1ArxgB4XrXgdMvxyzkimnn02diRk8z888ODueB0sNipV6Lh/INVancvCorHrVBbq561LSzQLQePBMbmJkcW31WUViZUI5xXKCe3xhfe0hbF7lq47er//GTTWtq8lnKxcoZboR37YVUzjfL4P5oxWJi44a5yf7p8jTlPCrKRrFChKoSEyGo3QaFuUEgLlvRX12HWThxuJpVgIUdp670JgKBdDNoyW2Ll5hAvPGmf7eIVyGBJFEZVigHUOleVGCIrUOm/1t444saAVBRP4EpTOW+itE8T50GxrHeKE+XqbwzN1WrGl2UooFkIazTZiLYUwohQapufq/PD+SUYDODTT4N93T9Joxz40KzsH1VsProdOdaaOXO/EUY9TJipC0HP38Ms7CslCUnUnXEplGeqSKRSpFVpxSiHQxJ0GdpkHpaPaSCfMqRNulbMuvOyqR1Iq9IcGfX/3YR44PjN0G4XihqsfcdKhOa+4/kpKxZDHP+78he+007vhJAavxzFOhI2VMvOtmE98+x7fMHERq829UEqxpVLl3un5vvd3jVWItB7olVjYB8w32owsE+4Upw6bFxXIGYRWzF29BVcK2Pq39668/mqwjtIX/n3o4iMvP5/aE5bJt1jBO6Fihe70Flh8Wazy5i3rmJAqD+ME7Oc89fsUqv3llO667XwO3rd5yBae9fBKNM+yS0Kc1Ml+1gJB3ceUtyfAxDDyAIPnjSz6OWxIrZi/oMrInv5JWz9L40IYfSClODVsQq8i3EmtTmFY9hjz+T6QM1qZeOz5Wzk2l9BsxSBCYh1t65hupkyUQ8bLBaxro6wlUpqGdaSAMhqttM9TGC1RDAMq5Ygt4yXOmqiyebTCWLVItRz5MpKiCI0htZbAGFSWYG2M6TavE6zPxQDECVY5nFUo0QRZ4rIKjG9Sg6FSDDBGZRZ/nzBtncMoiIyinaTcf3iOdpyACbnjwCxzjdh33+1ekJJNxv4rVHqXZ+qBE6HWTkmsIwh13yYdRaLjjlBZ0rUvl9t5Fkm3hOZcPWbjWJF2oolTn9PhOrFSLFT+6TgtctaHgvFdn3t5wnnbiALNz45MDd1uaG+FVfLS5z6BUjFEKUWwOjfIqhGBZpJy9+Hj3Hbv0YHW/l4u2bGZnx2a5Nj8UhOXVopNlUrW66J/2b65Bgo4pxoxvkyCiYhQa7ap9iRkF4IF711TIG81kTMMCTS1x0zgfv0RbH/fz1ZcP/revcSPOw971sSSZaqdUPzKT1DLdFWXyCwJuVrCYoXCO5U9Azow55wawtASLuqFcMkTdxOGKXvuPrlKXsvR2m69V2IRosQrFCfz/QsETUVwQAgb9JWiHUR9Z4nywRbR7NJGEmIUtXMriF5aLapyyEdvhLUsAXTIsSBCNJsSjy2Its2NqtuorzSpiJJ8wp8KzmhlYtuGKhdsG+OBIzPMNGLirIqQOKGeOMJAM1IKOVpz1FIf6hMEhpFKxMaxMjs3jrBtQ4XxSoHRapFiGFCMAkqFiCAwKI3vOOwE63zPCVGum4Tasch3ymAa7ZvYKaV8rwqnKEcBifOeE/DCk9GaSjGiXIywTlEsCGFgqJRCiqEhSVKOzNSptRIu2THG/sl50tR6L4BIn5LfCUlaCHHqCWPq8TOApp1aanFCMQzoy6OV/jwHrUBp+vIeOt2vlYIkE/ii0GB0SgJZArj3lIjSPka+Gy+Vc6ooBMb3mjiFVMuFk/I+rISIDxlqrKJ79L1HJjk2XxvYhdoo31ByEJ2GdKvxcDgnfQpEN9cqJ2cVSKixI6srLnD8ubtoXTw+sOGWqSvO+ud1CuvrGb7XGLoe0/p0J6SeyYSFlCA6tcEuboAisa6ID29Sq4jwLB1oEE3HKDtAuQk0bohirGw33XVFlBWamxaiIiRQC5U612F65fN9MGe0MjFWKTA+UkZNzmUGFpUVifVN22qxoxQajDHEzlGMAnZtHuXC7aNcdPZGRkoFgqwjdSEMvTVeKe99yAL/JWvq5pwjigyp8+Viff6DwrmF7tuh0WijvbKhfN6E0r6akq+yqggCL2iPVYo88ZHbSK2v2BQGmo0jRYqRZnKuyaGpBrs2ekXn9n1TGBGCQJGk3VQJOu3kvFNA+kKWoEetyLp8O1HU4pQNFcka/kl3fa28y63Tk6PTn6KDyrqAd0rDttopUWSIQkMrtgvds7NwKEG6FbZyTi3nbxnnnM2jVEtra1R13rYNXLxriKu9ELKiyNEtJXzqabaTrjK75DBW8aQ51EhQKMaj5RUwrQYrEMVM6IuXaaiXk7Na0o0FkiFhGeJWvqY23HIAMYr6Y5Z6NvrGGpZgmzVNG1oKNOeUs+PCo7QqcN/U4HtwsG/5KnO2LKTVIfejXtviwMVZo98HyeZn2hY15N6pVmHoSUuaQEDHy99/bTj4pNvjvv9GNJffv9ebM1qZKIQhF27fwJGZOo3Y4lyMFZ0JzkIzsQhQKoSEIZy/Y4zHnbOFjWNFNo9XiMIQlCLQA7KQOiVOgaDbPtvnCISqkyOgcVmYUpKKt35qyYRzTWiMT9A2Gg1oB5JVfSooxSW7JrzPQPnqsRqYrcccm2thlGbXphGswMRIkbnZFpuqRQ4mtmtdVT0Jzv5+oFA9/TI6HoWFU/KhTrG1REHQVUS6CknXodEfOuXLYSq0Fl8mV0GznVKMDIXIELS0jyPvhHz1pHGcij4DOf1sGSszUgqJBlg3wXe0nq43h25fLUXs2DSk+6bRazNf9mxz7kVns+feA7gB3oSRsQqbtoxROl6Dny7fhO6ew8eptU/OUtu0QuwcMFyZGKsMtyp3Qv9yfn7Z8tH7OPay83EDFNLSPbOMfvsYpr6yl23q2buIt51cQHzhYINgZoXmX8sJk+rk7QBWNPZkA9G7Y63LMGcUU1LkWFjEjg0QcAXk7JjwQDRU4JdAsKXlQn+W2fnSKGn/dk8X7OZWoXQU37BqEbYoJFUw7ZWTq8sH6pjmyXlhnFkIWRqIUtR2DF/BRmr5LuCrIJ/vgzmjlQlQ7NhY5bHnbqYZp+y387SSpCtgp05op8JYJeCiLWNcct5GLtgyThQZwiDAaN9Uzii1EDYhPqHYOkFUZsHXxjd/E4fCh0GIEpR1SNYoL1XeY+EEdLYcvAUzCvHhTzh8Vxi/bKxc8F23ZSHXwuiUUiFgZDRktFqkmTgu2DrG3HxMaGC+lfjciUz673gjfGlXQZTqerQ7RolOarQA7cQy24ypjBiM1ojzioIPN1yY2d0EbrXglegNe0pSSzNOiQJNuejzSXwoiaJzZFrhhdGcU0oU6KGKBPiO1hedf+5QmWLTSGnIEk4sQWDIDiY2jZGmloN7jmBTy6Yt4xTLXmAvlYuMjpUJywWe/ITz+eb37x86/OR8nXZyctWStlZCNpYjCoHGOiHtsZIpBVFgKK7gtQiNxjpI8uSJn0tGfnAcVwmYeu5ObDlg9LajREe8sh4dbFD+2eyqxmlePL7qcKhhzD9hE+1zRlE2M+Asvg0Mrs/Rv4oGjPQJkCeCQ+HWqbqN+zkMi51tl5huDWnaoMCNW5L28PueW06KG6Is9NKNT+iV83tubcmIL/daOO7nSFqVrkBuI7BFcAVoJVA8Nnw/0UyCTk7unqnEKxQUddb9ume8zObbHlv+/p2UNboNUW1tx5LP98Gc0cqEdY5yscCF28Y5NtdkrhmTzvt+CiKCUhCGho2jJR59zibO2TZGtVggKhiUKKz1+Qsqc/W5LKRJRHDO4TLhXAmgNM5JVp3JgQbdbRbn8yVcli8hWbyP4BWEVmyJAkOo8GFOKJz48KZm08ctFUKDAIXIsHPjCCOlkDAMSHFs3VDhorNS9h6BZmK5P3W00hTXZynoCPGdp4d031YsuDGdE2YbMZvLBcKe4+1s0Tu1u14PnYU+dd/3CxqthNFyRDEKaMWWdmJ9/KTWmMCHijTjh1PxszOXyy46a7iB0lpYJslzPdiybQKXpqSJZeOWMUqlfiFqpFzgSY87F2cdrtYaOMbtew8y3xpuhXUizLebjBSWKkfbKiGh1mythFSyBGzjxCu8PZM+DDRJ6giX8cgYowidOtUfWc5DmLFvHsEVDLaSKRNHB8/Zk8FFmtlrtzP2vw8tWTZ35WZcJaT2+E20t1fAZZ5q6J+34gWw5RQK0aAMD686lQ8zkg3LfDlWQbp24Vbhq6yoZcLq4jFBJ763RFJliXXfBdBcoYm7C5bzB+N7RUy2aG9a2utHZTlvSnyitjUqy7vQ6GRB1hEFpSlLc2L4ntKiwlQU0SluFPjzxpmtTFiv11VKEedvG+fYbJPUOWpZdadyIWTreJmLz55g+8QIo9US5TBEaS/oxrHrljx1mWKACM4KqfXlVwWFMl6AcFnfCOe8N0IrcEp1FRefKwE2y7XwIU6KWtuSJJZSoAmCCBNoHy5khflmTJJYNo0Vu9bO8XLI+EgJAUJRlIsR52wdxTpLwSjmmgnH5lskNsXZ3sRrj2QuBCWqP2NJ+R4aqRNaqaVSDDNPC93E7o4i1Kne1Mmf6DawoxPGJCSp84pSaKiUApT23cUdQoLQSlOmlgmvyTkxzt+2gUppafxs6lJSdwolgdSCMUuFa5v1OtGK1TS72LZj47LlvcrFkGde8wjSg9MDl99/dIov3H4/x2uD55RWsKkcMJGVdj007xWPTeWQ88aKRIu8ZForIm2WWO7i1KGU70szTKGopSn7Big97bzPxM8NG7588KS2L909g62E2NHB3gkpGKau34Vu+ZCp6vcnUUDtsgmmn7OLdPF24uv+L4nAcN4gtJxCETSE4mT/hWDbq7Pc5gmpq6OkYwoDOlAHi0sXPUh0Kzk5VuWVisdY1sshBhrbhi+fPy9k9B5H0BySM+GE4mQbV/RiaVINsuNkSXUnvz+Fi1iSzF06anFGEY/poYerEkdQGxAym64cRpvP98Gc0cqEOF+lxWjNtvEKj9q5iSDQHJyuoRTsmChz/rZxzt06RrlYIAgMURSSikWjMMGCbCNOUFllpnZisc55+Uj5PASFD3+KwpDEuW6uQxQo0lQymUrh8F4NayEmpRAaAqNIYkssECWWUlF7D4XxpTbnmzHzrYTAGO+1QGEC48OmEKIoYKSiuGDHBgpGMVVPaDuh2Va0Y5d5VBb8Cp0Ebe8lUFlOhsJoRaANUahRKALjSzaJ+N4XHS9LR3PoZpL0BNU6t5BorZQQJxYTKMLIoJ2j2bbMtRJm2m1mGjG1XJlYN576qLMZrSy1uv/00HHuH1oaVrFpwxAX+mqJUyhl9SRtTy3JxHqvhjFk2fknt58V+M3rHosT4V9/tHuJQhEYza6xCk87f6HEYpyFIT1yQynLi1o97cShQtU1EPQyHyf8bLbOjyfnlmyX5u6KnFUy8a97QUHt8ZsHKhSiwUWKI79yIQCmloDA5IsvwJZO8NG9jEIRNoTqXsfYff0SW5rmivF6MhY0KQZLc2kKevn8GjlZXaOnNHBfb4nOrbxHXjiVHH9CBSUwcm97oEIhgcEVAorHvBFIsgqYLjjxvL3KoRQxAUlFL5nzQdNSONYiOjKgvLhdIf8oZyhntDKBVqRWCJRQiALO3TpKFGk2jRaJAsXOzSNsHq9QLIRYpxHxOQOFom8op7X3Siin0cqRWt/FWkR8RJxI13XcbCVERpMam5U99cnYJtA91ZW8UuKc4AQvaGtFuRDQQqGc82VkRdDaT/Jzto4yUgo4PNNgxGjO3lghCDXG+JhuIxBFAQpNMdLUGjE7tyS0RGi0E47PtWm1U5+7YXyyeCdcyxuMNZFRFI3JGvsFBEYRakWUKSwignWdUCjJFAUWPBN0PBJZ8zqfoIEDWs7SaFha1jLdaHO81qbWSkisRRCszYWrU00xCCiGIa1k8UNJMTpa4orHn+8rZZzgw0IQpGNp1woVBqh2vNS7YC20gGWava0Xr3nG45icb/DFHz/QfS80mh1jZZ5x4Vl96z5hxxgAcTtZziEylFZiKRdMT300qCcpt0/OcddU7iPPOXkm/mUvdiyidnl/JR/R4IL+SXvwNZcAmZV2LYKf8+FMvZsGTWHsXsfIA2uXWNc3IfXhE0O+WipBm2rYopYsDe8BEHsSn23n45TsLjbocayyvIkHoYHa5BUVTMMxel+/0C6BwS2qRlg67D2/jbNKXcXiRKjuT5m5KOzb1rQs1d0NKnvXbuTM5/tgzmhlwmhNYLzwnLoFheKsiRKgKJcigtCglBf4rYNGkqK07ycRBpp6MyZup76ztXglPtQK6xzWWtLUESiFFQgVJEmCcxAqQ5J2Aowka5S1YLV31uFEiEJNgO+sncYJJhs7xU8krQ2jlSLgq0oFxhBon5+xkBytiMIApQ07No9Qa6eMj0SMlEPu3DfL4ekmIsJYOWC0YGjUE9rxQtWnrrYjPmzLH6Pv2m2MV1y0lb5eMCqrYOUViEyhyDwlAqTO0XKW6WbCTLNNI/YN8cQtlIX1u374XCwPVc7ZPEYQaO45dNy/kZXx0kZz7TUX+/eSNLPurKxUiAiSeSBaR4533y9t3+zLjg3f8KRKwwisKuF7bKTEtqz6VJpaRrVeokisFyLQSNPufP7u0Rnunamfkn3l/Hyi6ynBtBeuXKSxI+ESRWLdEAha0o1B33C3o3Lg5PblMm/6erBe45xJXLLxMBbNtw+fB5DJKgthozp0uER3l61I73O8t+TvQ+RR7AqatOLPR1nQqVqiSKwXOsGXos3OffSeBuWDJxctkc/3wZzRyoTvjeBDnVIrbBgtgBJm64o4SUmtoAOf1KwDjQkVifOehUYzJQo1RuusE7WXg2zqSFKLtSnOOZRSpAJKa5JEcBZwoBFEa5LUJ28XQuNDlyx+H2R5GamjUPQegFIhxInLLP8d4V4IAs2GkQJKwBiNMgrrsjyNTPYLAw0ayuUCE+MVZhsxu7ZX2LxhhHozJbEWrQSbWo4cazAz16TZTkmcVxpwkrWBJ5MnfX6D1j5hOjCCE7soqZuui0LjG7+0U8d8kjDVaDPXSminFufcggLR8VyskPSXs44YxY6tY+zYOtb9m9FFJSfD7FJP0iyLjYUnkxMQt6AAWkfr8OSJHYO10GhDZbB1reve6rRGHziGw07OL7sbpRVveOUz+O1RH+615/7DfP1ffkCybJWntfvw51oJ/7TvKLWe8KVu+F9Ozjqw8X89wMb/9QAA9Us3+LCmde4030G34ewvtQnqPTl2ocYtUw0u59RhRXNPbQsH7Tg7N/tcsSQ17J/c0LeeDr2RxSW6rxy8yqIEUJ2CL1mI8on2DVEgWpZNwl4vJp9Q4fjlPvS2fNiy+d9bqHT4/bnzuFoLY/cnRFPNvrwKCcyyXeVz1sYZrUwoBSOliDR1jIaKIAxInSUITE/H26y0Kb6yU5oIOtC0WylaCaHROKNJ0ix8qSc/ohUnOCs+3lopKoXAxy+KIkl82WUThig09cR6C7/xJQUC45M7VRZqHieWIPA5FfVWgil5ZcNonQni0q3H5KSnXCu+9KfRGpQQhgFnbayyc6uiFGkmRnV2TI5GnDA506Dd9rkfTkAS2w1Nci4rH4t0G+k55z8DAuOrVLGQhO3zKjJFyQRMt1Pum6kx12x7L4QseGY6DWf6o2lkzTeBnFUSKAY3PugEwi4iDKATDjU95xWADOcc7XbCsFu3ZBriCTsfFL6MhzE+mbv3uHq8GaoQYh69E/uTPQPjhJUCffYEurIQTnXO+dt45gueyD9/6ltDdx8VAuIsFPBE+dyeI7TyErA5DxKVn0yz/X/ezYHfevTQdURn1W3WYK0555+b6HVqqt3BobF5qcw18ZO5s9jf3DBgyeD7t/dSeHPG6GiDYnEhtDVuhswcGj0lHghlBygbi/cjoGNfJnboOGl/MnVjm+HIVUW2/e/h3oLSoSbNbSXcoEZ0K5xrdLzZ9cL1H8jK2w4jn++DOaOViST1cflG+3mRpI5W4kOTrBOsFdCOoniLpuAt/6isBGSSosKAQugF6SRJSROfVJykPs/eWkvclm6losRacFAthahAMxKGhKEmSawPi3IK0SCiaCcWpRWFLLk5ToQo9AnRceJQSoiyHg6+IpTOcly9xyA0xldaUr6SVKenRbVcwASKJE0JtM6SrAOqge56HpQIrcSSOMG6LEk7Q4Gv+KSyDt9ZtSpjjE/GzipThcYnj6OEZpxipNNJW/o6Xnd+9CoSC721c9aLjnLZy8BP2ArMNGF8SEOsI1M+qXoRRmuKxYjWkPKrrUOTFLduRIVDrKZOYFDC/VhP0nivxTXzmBEFMFbuno95zLmktz/g1+k5YXPeZlRhsDv8RJ4NnWsGfI7TifaL6Ownn905DwmUnNRkVIlDiwxswpfz4BMGll1bpth7dOPA5RMbawRm6T0rKiVMnD3D1L7xwQOv5iY5SO7u2ZX0VqMShXJ+uep5nOj2YIVCD7dTndANXCeCTnsEjxMlML7kf5I+ZEK/Hg6c0b7NuJ3QaMW+C7VSmWKhUNp3mbYC0/Mtas02QeBzJMpF44sbiCNJhVozJrWWcmS6+QzWOtpxSqOVEBlFFGq0UhRDQzkypNYxW28zW2/TTnw4VBRqipEhDHR2X5eu8I9AIdQUQo0VwZiFztnNVopNrbe6auVDjgJNkPWAsJmXwgTexWGdD0vyzR80SmvCICAINFprClHA+EiRaiVipBR1vRpqkfW6E6rhw8T83SIKDcUooFLwCpZSitQ5ktQrIxoYLxYyT40/R+9elR5BV7rj51fq+lKfq1OfrXVfFjfEK3E6UCd+NzEaqqWuItEdSSuCy88juPy8rhckuGgrDFEktu7YyIteed2yu4qMJgoMUWC6ikRnX2Ew+MA/dv/BoV6JQYpdTs56ULp/nl3vvH35lRSgxb8WR6YOmZjn/8Nwr4RKBd1eW+hHJyF1vV4PV84Nj3F+dLT7+snMMK/Eg48SdeJNC7P4IzUgwlS3/av79zKKRGuj4cDTl+8Eb9q+pGzQdAuKBGThWYOPu3C0MdgrAWA0Eq3Nlp7P98Gsu2fipptu4q1vfWvfe1u3buXw4cOAt66/9a1v5a//+q+Znp7mqquu4j3veQ+PfvRwt+4wJmfr6DCkOG5QSjBZonUh9B2BnROoC+3YAkJqQTtoxwkGH67RbKfgHCOViNBkwkbBEeiAOPGhSCQWtEKcH6cUahLrO0A3mjFp6tBGUwgDVKYEFALtw6msZbbeZqxSIHVCGGUlX1NHO7YopWglQlH7plpKK7RWhFkuh9I+IVwEAk3WTM+HfEShD3Hq9LnQ2peyTJ1CG8NotcBsI0bFNhN+MkFfdYOdsu7WikKo0UoTp45WnBKnDo1CZ8aqjidiNAq8opO6rvLQHwbfDY5fZbZYzlppzTUoVEuExVOTvLZ61qBIrDwiAOZx50HmKRn2qFMAWhFUhpfATefrvqHKoO2VIgwMzUXemhvO3c5n9xymnYc55TzIREeaXPCm24Yu3/e7jyXZMrxz/aBGdbt/qcS5nz81YU55R+AT5xe33M6Xj1/CXfXtK698ClFO9XW8Xk90m1V5zZKqZs/zqkOXb7rdEjSHzA0FYtQSxaG9tUzh6JAwp5Mgn++DOSVhTo9+9KP50pe+1P3bmAX36Z/92Z/xF3/xF3zwgx/kEY94BDfffDPPfOYz+elPf8rIyMgJ7ecn+ya5dqzq+x2kDm28kB1mZVWd8mFN8/WY8dGUShiixIcxlcKg24yt0U5RCoqhL7/aTCHOGtnRaWaHLxUZpynWusyyr5iab2UhPkIQBAiKMDRs3lCmoAPEOYoF7btN4wi0PzZBsM4SaNNVIBbKsfomcv4C9wfpnNB5SynfIyJ1Xmh3mYEqNBoJDYXQEEUBURRQiAz1ZibXZ52xlQbtW3ijs0pNrdiSWp+0brOwLJ15VVz2Al9ithgENBOL6yQ19SbzZp+MKBlqIctZJ3rjzFbLviNwEvXj20eniDZvwKzRqnOiqK4L7UHZXf++V1gu+Kpm880FE5xN88S+nPVhvXuZrZRioaygUkdjm49RyXumnFrUGm5qG0br6AEhTiew04emS1Wtx2GdoGdFa6QYLkrGfvh4Ch5sTolEEAQB27YtbYUoIrz73e/mLW95C7/0S78EwIc+9CG2bt3KRz/6UV7zmtec0H40itFK5PMg8CE5NlMAyCL2dRb/j4jvWO0czlqs9pWWAqMJNaRJStspcL6kq/NJCqSpzzmInc+fsOJzJpSCloX7Jmc5Nt+iYDTbxspMjJQoFkOcc5TDkDAymCBEZyFPNktcVtDt82CMP1brBCsOZb2yoAW0UaTWkVp/qbjM8wI+MdtCdox0KypFgWa0UqDdTgmyzsVKgwkgFSgVAlzWnK+dOJyVbr1jrz/4O06nr4TLKkEJ3ltRjgxzLUXe0uihiziH3Xtk6QJrMcuEWM802nzu3+/jpVdcMHD5H/zTDzhS7zc3PfXSnfzmsx930sc8lFIRmu2hnq5jR2f5ty/++JTs+rlnb+GWg8eoDxCsUuuoteK+h+BD8Tmdk9Nh73OKvppTY+lMtUVNa3O0cGmvUjazorDrVLpvvcZ5uDIzX2J8pIlZTqFwDJWJz74lJqz1f/e1nYbJx54677ZyLO3KvphTdOOMN5V8ErYdsAORNVV1yuf7YE6JMnHPPfdw1llnUSgUuOqqq3j729/O+eefz+7duzl8+DDPetazuusWCgWe9rSn8a1vfWuoMtFut2m3F6x/c3O+8+y5W0YYKUeZld6RJA4nXjgWfDy0sz5sJ01SxBpq9RYzc02qpQgnilac0GjG1JttqlHgQ4msReMrIqWpI3GO2HaUFF8V6chck/uO1Tg826QZWwKtmJxtsm1DhR0bKxglGBGMKSBZEjR4t5ZvBNex/vsuQpIpQTpzTzjxln3f78ErIk58fLdPLFeExleHCrTKckCs95pkngvwBXSiUNNKYKoVMx+nbHYFQueFIWelm9zttS+9YDHJjsOJZNWxvLeiaEzXkyJLJKlOzkTHBJKLVyfKsPk+EHFgB6h1IsiQhoFWKQxLPUeHZuv84w93M9+K+eh37+2+/4orLgQFf/jPP+S+yXnSRTfmemv5Dq4nRScethRBK6avGUq9BbNN3FSNdmvtsRsiQisZ/HAuGs112zbyzaPTzLQXzjOxlkY7yeuVrYITms8568IwGcUWFAefVmDbt9pEswtzNy0b2hPh0PjznNVzIvN9a2meRC8VwxJrBiZgi2hmayVGKi3CoP/+nrQC5g6PkD24FxZkgvzZt8QUptwSj9cKDbhPis4zZpBC4SLBFQRlFaZ+cvNumBdPtCKeKBLOtNG993gnqLyh7rqy7srEVVddxYc//GEe8YhHcOTIEW6++Wae9KQncccdd3TzJrZu3dq3zdatW9mzZ8/QMd/xjncsycMA2LihShD6MrAqy4FIE0ezE7YUBdis3OWhyTlaSYEjR2vsn5xnx6YqY9Ui7XbC/sk5cI5GoJltxoQKto0WfN8J57CZTOwEGnHKnmN1dh+bZ6bR9mVcEeJUOJZ6AaPWjJlvtNm5cZSxckSY5Tog3gMQBtoL8oBRvneF4AiNQmnfT8Jk5Wg7Mj74xGujHCIKbZSvLIXPebDOexCU8gpLK06ZrjU5MFvnwPEa07U2zThFgJHQABqRrFt31rFbKdCqk0uR5UmIXyZef/GKUNYVu6+S0+IvJ8+XWDPD5vtionKICQwnqrB1vq/e2/cDx+f46t37mc1CdqZ7SsZ++vbd/PjQHPcem++WXO7l+/ce4n1fvJ1ff9ZjT+g4lmWxUKMUFCI4PO2VCvDVoBLHhlLEky/dyTd/sm/ocMdbjhEjhD1N96x1xNkDxoksKVLQoRoGmJ56uHFqfdnofI6vitXO55zVs/Xv7uXoSy8gPqs/cXU1hs6kqrKuwH7+plVDeyxcU5dhALuOpTLtw0A5X+18v7e1lVlbomCWGoOWCxF2Ti+55ceNkNqxCjbphJT3fJdO2PHVwYoEQPmQZeOP4Phj1s87Mej4lYO0LEjWkFE0oLMKURWWVSiamwzlIxYTLwzsQkVazJrfOSGaH1IswyzWYhzKujXbOfP5Pph1Vyae+9zndn+/7LLLuOaaa7jgggv40Ic+xNVXXw10rO0L+ATi4RPpxhtv5I1vfGP377m5OXbu3MnWjVWUNlnDKuVzJQKNijuCsBfQo0BxdKbOsbk67UZCnPiyr8o5lDg2lEJwlno7Ya7eQgPVUFGIfEK3CLStcHimyf7pBoen68y3Eh9SFGoCpUhESK1lvinEqaXRSogT35l7a7PEOdvHMQAKEueTrwvFEHHSbWDnP5ve0pMqC4Pyx6EN2FR8dSalcDbrvJ0JeFr7jtVJYtl3bI7v3H+UvZPzzDVaJNk5h4Gm0yyvq0g4r4BoVFYZy+9dxFcZzfw8WbJ2zxfTG38pCwLqYkE158QYNt+Lm8coVheSLnWaoAc1ZFgFDoXK8lruPTrDrfcd5tj84Frfh2Yb3H10rq+8cC8ztTZf/fEeZmstzts0IO8pNFz/Hy4j6pSUdb67NgDtTLUp9dQSHHYv0Mr3qWj1P3yjwLBzyyhPevTZfOuO/X3LjhyvI0AztiQajFIUlBAq6atkln0oQxUKLQuRA9IJp8xZFcPmc87aKeyvs+kzu7GVkPmrNlN/1NqrAjmjkGDtd2wnGrdOVWkeDgr6sPm+uHNyzRWIZW0iWL1VoKLahIGlXYtoTJdI42FjKYqTMtR6b9rCyB6LaUNr42CForZrwbNg2mqhgpN4OcWZhe9tOUVIDCw5ZQUuFCiDafTPw8K034cLoDWhURZMAjoVRCsWGoUr4qomqq3ieXiSARP5fB/MKc+irFQqXHbZZdxzzz288IUvBODw4cNs375QweDo0aNLvBW9FAoFCoWlhYujMPRfRtbgTSnfG6FSDEmtRWtFpRgQmLJ/TxxpKUIQNo+XcdZhdEDRCLP1FjNTbY7Nt0CEQqDYOloAFFP1mP3TTQ5M1ZlptIlj64VvrcApXKfKUjex2nUTpuebCa32CCOlCIUvCzvXTKhEARuMIjABYZiFDems5wReoO9UgLVO0MorAakV7z0QX2kqTZ2v94wXhOJEmJxr8oPdx/jZwWnmmjHWWQw+QVsrhVEKcQteByed0q7iTVtZaJX0aAv+WPyF3idv9V6Y0vOros97kbN6hs33oFIg6GnYRmJ8paM1uGsF+NLdB5ittWgnKYdn6ydxxBDHlkPH5kibg8ONvly4m6dfdSGlYkhfRzproSVewVDad9Beg1wTGsOORYrM5HSTenMhFMlXvhTQghrwxPO5TEt3fsf0PI007S6JjMGK0M6TrVfFsPmcc3KU7vfd4lsXjp7QdhN3JH0dsIOmw4WWtJL3mVgPhs/3TjUJz45ohlQMc3Z4Va5hpKlBfloiDoVGKSBpnZxXQYkiaGkKM4OXi4H2Bi+860T1KyYKdOYSE7PGB36mUJiezyeahaBFV4awhWwfLRjkRHPR4AdHUIv7cya0QmRp9aeck+OUKxPtdpu77rqLpzzlKZx33nls27aNW265hcsvvxyAOI752te+xjvf+c4THttmsfyB1l2hGOWrKYXGS7OFwFAth4xWCiTOkbRTRAnFKKTZjLE4ZhuWg9N19kzVmKq3iQLNTDMmMjDfStl3vMGB6Sa1VowT52syK8GJIu6EBLmsmVtml29KwvF5aMYp5UgRBBqjfHjSnsk6520e4eJQUylrwlB3K0dpH2uENr21HrzEbrMu3SI+4ZosQVpBdoHAXCPm7gNT/OzgFLONNqmzmWKiAfHlZ8XLcx2Fp9PxulNOSi3oE164UuLPOSsDi1okci3R9FXm/Vj8fs66EgaQpGtSJr7204P8r9v3MNdsc9ZoifHSyT2MCoFmc7U4dPmP7zrANY/bRakwQGBxzocuGQ3LjLESqRN+cmQGgB2lIrP1NiccArbIS/rTmRr3ztaJezwYgdGUVAAC7TzuNucMYvynKWP3pn3lYXXsiOZ84PxaFIo87GNtbAxqHEtG1qRMFPdqwnsN1ij0DmD85I7FBYpkme++eBzSkkINkhgFlI+4Rk5CH1UOqvsdKIhHNeEJ2rdE+WPsLSFr6gmmkfYrDkr5PhO4NSkU+XwfzLorE29605v4xV/8RXbt2sXRo0e5+eabmZub41WvehVKKf7zf/7PvP3tb+eiiy7ioosu4u1vfzvlcplXvOIVJ7wvpRSNdspIMeyGYHTKmoZZM6ow0N3QHa217/KsHNZacI75Rpt7D89wz+FZpupttPYlYhtxyn1HY6ZqbaZrMY3Yl4TtVDnqCNwJtkewVlmJM6/ktJIUFEw3WhRmNM4qjtdbHJxp0o5TzpooUypGPgZSKZzL8iGyOmkuOxejfAgVmceiN4/CGEWn5Gs7sRw4Ps9d+44zU29leRm+2ZxP+FaUjO4qEl0FzH+YdNKmVfc/j85+V1n4U5+ikIVB+b97A52y3x8+18oZhXPCwenBd+P7J+f4zL/fx8EZv9xb5MuMDVEoDs42/fWi9AC7/UODWjvhi3fs5cdHplEKauUymwvRCY8jWS+YDj+drfUpEh0CrSmEJlcmcs4oNtydDOwzoWMhrKe5d+IhxeCHZ+GAofozg6kpL8BlD+P2+JCcr/2CCzXmIXyv0glU9gsj+70s0ZpQJNUTf9okZU3h2EK4blBPBoddqSz0wz10P5MzjXVXJvbv38/LX/5yJicn2bx5M1dffTW33XYb55xzDgC/93u/R7PZ5HWve123ad0Xv/jFE+4xAVAqGI7XbFeYVpllPUl9HkAY+KTpqfk2gdIUSj4h2xghbidMzTX52cFp7tjvrfhGK6qFEKNgar7F8fk2cWpR0ikxS08JVm+p1y7r/UAngVl18x4Ev00hVJSjgH3H6tx7eBYBDk7Xma412TRWyYQ5WVAgFGgcxhhcVi7WWiEKFqpAdTpri/MeDOeE6fkm9x+a4dDxGmlivXKCP3jrINJQDoKuN8JXkIJeJUJl/zqZErrriVDZ+WUfvkC3B4eQNcPsv/hV97+cU0agGXQZ29jy00NTAzf5+PfuZbq+kGA920oQGmhVYaToxxKB49k6dx2ZBXxlsEEKRSEwjBRPXHBfguAv2CF5C3a+ibQTdMeDlzHXivn6Tw/wN1+9o3vsu+sNNkXRwPQL6UTzDdhHYLySsBq08s0lkyHN8HJyHgwEWbZ/wGr7/SjrOw3bwolZXR3rV+Ly5+1Kmpsvc3R+fMn7ieihqWPVn3pFokNhJnv+aiEezQx/IhSP+eUTdzhs0aCcoJNuKEIXF6gT/s6HIWr4fOt6LRYlVeoYyoeFDXf7DRVQmrIk1cHiqerIG4s/H4FoLiGaWlAmlu1yrfDPmhP0TuTzfTDrrkx8/OMfX3a5UoqbbrqJm2666aT3VSmEhFERLUJqvXSgnW/A1mqnhEYRAodnmowXQ0olg7MWZx2TM3V+sm+KO/dNM9doExhFJTKIFY7XWkzV2iTWdqMcVZbgDY5OQ9zeZGOdXYs+38FXWAqNZqJaYOtoiVZseeDYHHGSYoym1oyZqbV8RSYRn4htsjCiTNpXCAYyz4rgrJCKI9IGyS4ApXy/jVaScuB4jfsPz1BrxaTOLZR7VQuVmCLjK0F0ekj0+hI6J9VtFNb9zvy2uvd+k21PpmT0JUx0Nur9mbP+KKAYghrgUYhPrAvIXCvh/qka509Uu+WAbz843beOtXaAQiFUCobN1fWIiRffUC/Mbks9c8fW27R3H8G1EqIowATGeyDaKd/46QHe86UfLRmtbi3VoF8x0ABOvMeuZ3xfTln5nI4eNpUKHK63BiZca6UoBIa4vfBIeBjl0+WcAcSbi6TjkZ/YvZJJx+G8aD62JzTFo4Or+pjYUZyMaW3yhgEZUi55MevbEfjnp2nYkfkxfnLvLu46dPbShUZgR2vVY0WzMHo/zJ3vE62Vg80/6P/+0nJAUE/RKVl4g0IU2KIhHjl5UVBUlqTdkY965p4YSEtLlV6deEVi4o6lN07TBrvosaIsmFjQKQvJ19ltPKglVLM8oi7LGKfQClHGF/XoHOcqlIR8vg/mwWlje4qox5aJsRI2dTjnCAJNnKbMNxPQmjAKKBcMZ02UsalQa7RJE0ut1eSH90/ygz3HacUJoYZSEEHmxZhrJt0qL9b5ECGt/Zw1WX8F15snoDq5BQvmTqM14+WI7WMlarFj/7EarTjFOT+WtT6Z2jnBps6Xnsya5Unm4dCZd8AoIXG+8ozS3guB814PrZVXgOYa3HtwmgOT8yRJ2s2HUAoio4mMoWAMgcrCnLL8js7F0yscdlKvF8KbvHKktb9PdBK2e5UI6R8ku2nI6s1iOSujtf/Su6yvXaMep9x+aJr2Mo18rLUEpiepRoSpmg+pe+S2DRQz4V1YVClpNXS01SRThEIv2Ls4ofWzA0h2XHGcQpwShIYf7jnGfxugSADcOTfPFRvGu88SBRTEErBQwQz8qYSBWaJIADxz1xb+4d4DzA9QzpLUZXkZC7j04WRrynkok45HTP7yOdQfNQ4I9Fh+lVMDFYZDTy6w6wutvgTsLiLotqN8wFt203T1wmzOykw2qpR6ekr8ww+uZvexLes2fliDTT/0CfXDSCsLCoULNWIU2kJhNqU9HvTlPMiJGAIXrK7dMToVn0T7krAd+UA5lY0vFI8PViQAKkdS5nYGPdtBNC/d8rDGdo4TUMLIvfNLxlCpRUIz0KgpSnnPfo8nWmx+/14rZ7Qy0YotrdiiRIgTi7FeEK4UQ6qlkErJ14fftrHCsekmd+yZoYRjutbg9j3Hmat5j0S5ECLimKmnNGOLiFtIQFaSJVf7fVoRQm0oFgJasaOdpijJBJMseTMINBsqEedsrmJF88DhOWZqbdqJ7TZ7CwPNaCnyZSbT1JdMcwYlGt2p6uScr9qkfeCRMYq29aFFQQAar3zUGwn3HpjmZwemmGvEvqkdnTwjf35GKSaiqBua1I1w6qAW/+LvDEYrlPbKks/XWOiW3bEy9OVfZ14MQXzRnrxiwvoxWoKRnrryjaa35A9hmUaoJ4lb4mOea8bceXCKx+3cBPj5MFXvF0bmGzEj1aIP0VtMYHwlp14SnxTa/MkeZEAH0zSxtNsrdFzq5vFACYsZEAsi4hs4DqNgNPVF3vBOD5acnAcTWw26M/jQr15E67zq0pWUD3npCG1LxoiU74AtfZus/ZhEY9epVOZ6jfNQ5F3fvB5dXLjH6eT0eO1dZLq9HjqYWChOpzQ2L4iEbrFtZdjtLvNI2MLi8Cn/05Zk4ARTojJ72PD7qOp5iBVmszCtJeP4nJ8Hi3y+D+aMViYKkcE533hKZ1qx0YaJUZ8b0WynhEZTCDUj5YjNYyV+fO9R5mo1Iu1LpJYjQztxzDVjUPgqUFqRuIXetj6/yfdgUAqqpYjztowy30rYfXTeN8nDl4o1CsqFgM0jJZRo9h6fZ74dU2+nXeVda82OiTKbRosUQ688+BQEL5Z3+kv4hO8sZCrwXb6NFt9PIwtFkdRy+HiNBw7PMjPfRHW7dPujj4ymEBnSVCgYg/N5514Yoj+vIUuD6Ho0fI6SVyZwCll80XcH8CFZnZyJTplcnA/NynlwEYEktcy1EsZ6rO0rPbo63/9aSZ1jsja4VwXAf/3bb/CG/+PJ7Nw23r8gDKC8/qVDjVKouLXg5Q6C4S7vZXjuOdv45wcOM9lT9raVWOYa7WW2yslZX1yk2f22x+Gy+HZl1ZoKXBx8ashZX21TmMqtsKeTrnd/8XeY3aJsojHhGr6jZfJnlj0e5RvBDaN0TGhuVrhF6XGDFIn1QBQUpxfOf1ifjBWxDglM/72/NzY9Z104o5WJZmwZqfi+EojgUASBF/rTGMIwIMiaRUZRwLlbq9TmGnz12AzbRotUCgFHZpvM1Ns4cWilEPHKR2AUrdRirbfud7pMi0ApNFx01jh7phvsmawBC4LYWKXAjokKWmvuPzpHPU6o91hPlVbs2FjmqY/cxqbRImFgCIwmNJog0OisIV1HsfA3nEwNyTpix6nF4sA4GvWE+w5Osf/YHK12ghPX5z3QRpNmQr0R71npLeCken/SUWhUdzksKDmdDTu5GEKWMJ41vxO30FWyk+CaW29PIeUSNFtdCz74j3++1uQLt/wQgJnWwrLxYjhQoeh8Q3FqfUUzBaNDEqoDoxnUi2E1aO+Sg0LPbceYhRyJdUQpuKLUn4DdSlMKgSE4wYfIR36yj9lFHhCbVwHJeRARBff9xRX0GjLFyJoUip1/fjvh8UWK8OYNcN6A2P1VsLgZ28mwXuOcCUgokGRKYQcFGMFu9oYLmyx84SsqFkrhQogDQzQ/+P6kY7f2yGMFyYijt5Ktsj0N7NYRAdJS/31adBY1fYLHP3/RKC7qz50L5xNKxwb3RFqJfL4P5oxWJirFkEJkUAKJFaJQYwKNFkFphU0tcZJiraXZshit2DxWYKwUcOh4jVbqu15b52sbO/w4zlmCQBFoX8XI2h7hXHuBvJ5Y7tk/Q6ud+rAjrZgYLbB5rEQjtszUmpQLAe3ELVRNUoqtoyX+f4/ezlmbKoRGY4xGG40o36Eu0BqLLy0bGo3SGusEJ9bnEmnfqK7eipmN2/xk93F+cN9RjkzXiBNLkjp/DlnIlbXC1Fybs0dK2NT3xlio4pSRfV7C0goJ3dZ1PXkR7cSRpj6R3VnXDZvqKhLZmAKssUFzzho5fnyeL3/tJwOXdRSLxZ2sG+2EuR6lwwnMNmPGSutQoamH33/dM9k4Xu5/MytAQLS2PhcKCHomrQBOC1edAk9HTs7pQBTc854nnu7DGEoe9rGOhA67cXDoZlexWPSQFl+FZQEF8chwhWKtzF4kS0KfxAiiFHqFaNNhiAYb9WrIoBNHWn7ozoN8vg/mjFYmIqOZrsWMFgMKkcnEXm8Sl46l3AlJ4giUcGy2wee++wAPHJ2h1ogJlEJrRRR0BHaw4nzpL6cIjLfEigLbyZ/Iwo9+cM8hJmcapFYwRrF1vMRYucBcPWZyvkUYaKrFAKMhtqCMxigYrxbYMFIkCgxRFBCFAUFg0Mb3mkh8xrePK+8R8AOjsdaHD7nUkiYJ9+yb4ke7j3JwqkatldJKLYl1pJmwGGjlK/AoRTUIcGknt6P3U+zxRECf4rDQ0M77TRVekYqtL1Xb1/Su64FYWLfrxs05dZQi6O0PsVIOAXBkvslkrZUl+Q9GODUKxXryLz/ey4e+9dO+9xRghsSKA75rdeiv+b7tlCIekjw9yBBmtE/qS9I1PkVzctaBrndi0Zz3ceRDroNBE/rYtC988Ihz1/0Yc9aXtKAgVehUhof+KIhHDdHcQ9eDWjkgjN276E3lw/mGIQqClusmYXc3aye4ex4YvNH5j4ZFnolkJESMpnw4LzKwXpzRyoQVYXykQKQza7tWGOODMLTTJE6TSooG4tSx++Asew/NM91sk6aWQCtMlmScScrdRm4+p0Ah4jBZLkTWt4t26rrlM41W7NxUZbQUcny+zXSt7a2lWhGnltBo4syNqZWiHvueh4UooFQM0UFAEJqsclLnIpKsgpL3WjjncydS6xBnSdOUo9M1frD7KAematRaMXGa+iZ1mVCvUFgRNIqRKECL8g39yMKmpLd6q+q+/N79Z6Cyz0Jpwais7rUT75VwXS1ioZqT+MpXnTEgD3M6tbgTrpb1P79xJ7NNH+LgsnC15cKWFnfGbiRu/cufOgdxMtQ78Vf/dgfteKnQfni2ecIu72IYEAbrYw3K9eSc080gReLBZn07Aj98LLUroZNOAvLqmfhWhGlluYmBQllBL6MvzJ7bL+KN7U6WCOInjfYei2EJ5RvuGnyeQQtO9AYeNBxmQBL2g0k+3wdzRp9JaDSI+DAk74TwJVdTR5xan1vghMAo0jRl6lgdZRxOC6KFxDrvCQAC4+vMZ/nEiPhEYuuE1Lms9Cvdv0XAGM3OzVVGyxFTtTb1VpKVT3U0E0s7FQKju3k+nUTqcjEiDAO0CQjCAGMMWussiVyyUmdeGbDOl5kV5ztZ15sJzVbMPQenOTrToN5KiFNL4hYUiU4ZV6N9r4vxQoSzslDYJqu41BEkO3kTnWzsjrehozA58aU0EV/u8/9j79/DZcvO8j70N8aYl7qsy95r3/veLXXrLiSEQCAbYwRyZOMAcYIdzmMnWDjkiDxPiE0IxCcPUkxEntjmYg7iwImDDJwoxMaYg8GxxbGFADlyJCSha6ulvu/7utdtXsYY3/ljzDmraq2qtdbee+3dvbvr7ad6r1U1a85ZtcYc83vH973v51zQSYxLm8bZjsnLvG7it8DtwGwisXZ6hW/7jrfOfMcvffTz7I7yPSVuBx9F7fmvE+u5urXVdsJ3vPkhvuPND/Hn3/Tg1Gs/+p5v5+RKe/YblQ7aCe+nH8Df/7l/wTArcF72PfwBrOZTg2I26TnG4aiVJolurjxrgQWOCiXwiv/6j29egHpU7PTgS0/d5oPcHnzgAx/g4YcfptVq8Za3vIU/+IM/mLvtRz7ykakFtPrxpS996Y6dry6qAHvvHFVqzMbsOWXtjyoicSOxdO2kUj12H4qx7dmToGvD5tf48Hjj9GCbVeJUQxRIHFybJh8AK08Hi9i698Xk46DPoefoMI4zmrBtw/BC6/ANFzgS7urMhHWe0nriJEJphdIao6s4pGoEZ7Qiz0vWt4Z89coO/bxsVt2FUNZUWCFNDEkcxM9F6ZqyJ/w4QxFpmtX7NNHc3+5y4WSXS1tDRrkNBMYF93qjBes87cSAKIzWJLHhjQ+ssdROSZKYJE1Q2lQy69BEyyiFKNU4I2k1JjVFadkd5PT7Oc9c3WVnmJNbh/V1t+o6L6Cqjt06OFZFBpxCKWnOX1XEQem6a3fd93p8wQrSdJusOUHpPK4iU9N+sOP+1wrVlHXuc4Ba4BgwPyOhtSKZ0fXzH/7BF+hlcwLsWftRcM9qZ9/zCkUr0uQ2BPQ17j+1xHd+7cNT5UN/7o0PND+vdlvow5yU9p6b94yymxPJzTIRayXRDYuvAb7zlef53SevsjGaPhcvQumEscH/AgvcHpjB/ugqZCVufF9X/sbrOPsrXyK9PJx+QYDeAD5TlQ7K0Ur4vCj8cXUEvon9/Pqv/zo/9EM/xAc+8AHe/va384u/+Iu8613v4gtf+AIPPPDA3Pc9/vjjrKysNL+fOXPmps75RqGLihDMmouFmZmmtX+bYPKjEwlRkJ/Yvx/Riv69Md3LlngwHjzZacW1t2pk4tax9fqJwXWUv8ueTVxbpsXlt4h46Gdawx6Gzke/zOibXoHbez/TUC4Zdh8eP29LDZ88eH8v9Hh/seKuJhNZXpKmoXeCVhoIAbx3HmuDSBjvGI0Knri4xXo/Iy8d4j1aQqArEILxwpHGJgThRuPFAUFTIQJWgmWrMYrUaE4vt2jFEb2sZHuY08/KkLEgXFPeB9F2GgeRdRxHPHh2idc8cIqV5TatdkoUG1C66mYd9q9U5YSkFBpF6RyRCjoN5zxppHhye8BWP6ewQR8x2XxLN85P4TtqRwZD+G6YIA3UixWoQMSUarITatKvrnqunvtc7dwUapqacqlaa0FlElsHrbJ3hlng5pEXUBOFxMzMK26s9/jI732G/oSg+p99+km25tiYBhtvmVnqFM8JvDWKfl4ynGhud3rFs7yn6Vt3wrXpC598kte8+SGSvY3hlA6Ng2bhFnlod48jlVY3p+H5t89fZ5BnmAk3AScK6xdlfAvcOehcTTcS00eL8fYiyVKGf/oxsnx8/SbPbNL+9MUwiecVaT4qmTjGso+b6Qj8Uz/1U7z73e/m+7//+wH4mZ/5Gf7lv/yX/MIv/AI/+ZM/Ofd9Z8+e5cSJEzd7qjcNH0soCZo1dUSCW7FIRSiUwIk/jjCj2duLUXhmlzrJnMUbHylsW4c+DxXKDrg9GQs/6WHhBVWqfWtYMlmdvRe3eOvf+5luNjOnz5+htS0wYVteLkVkp8K9SCbscI/aAfuFHO8vVtzVn6QoHWXpACHSIVNhrSMvLEVRYq0lLyybvRHPXu1Rehd6N9SDsor8PUIpnqx0WBecmZJIN6VPEOZYVzkUrS6lrLQT2lFEf1SSFS7oGWoJQf3wkESGTidm7USbNz50hgunV2i3U7TWVXeGEMzr6tH8XNnDihdcVY4lIjjruLTRJystVvyEVqEiIDpoQOoSp+U0bs4Jqu3qbUz10BpjxsednAQmLjNEQram1l2ohngwteI9Vep0fH/uBbyMS4AKt68h4JXL2/zh73+OjY3eVDnQm+4/c2AQvTceNkpxdung9K/zvikTLJ3n6fUev/GJ+SUSg94Ib0zoaq32DrCbGyUn04TXnFzmweX9GZQ3rnbCuJ54KKVnHkspRRLNzi7866cu8/zuAOt8Y1BQK4sOKrNaYIHjgii4/P2vBlHTpSJudoKyLtX1sTSPGu2rYEbgV9rYM0vNwy3fneUeRVHwyU9+kne+851Tz7/zne/kYx/72IHvffOb38yFCxd4xzvewb/5N//mdp7mNBT4SPZFXxILbtmF7ICEVUVBMXjoMEvYPfvRUCwfMqcqQqPc6hH34cRBVV4aJBJ8JDdFYGehWFHsPKIZXJizQ5l+uFgxy/xINBQnE4Zvf0XzaPDQBVjuYhyY3DcPPcdsY4Gbx12dmaiFlKV1mEo/Ya0nL0psGSwny9Ky1c/Y6GVk1k7YooYGdI1QmNB0SypL1lqUHXTG0gTqnVbEyU6CIXT93RkUlNaNVyjH4oPqHA2rqeGR8yd4zf2n6XZbmMhUAuuqHEiqvEQTmEvoF1EFiyIhI1BYx/rOiEtbg+BKQ1htFaPRBG1IbDSJNhgVfl6KYryti59qIhHKwbQZ18TXp1w3s5uqd2perMTp9S8T2Z0azZGqsqeXUBbvxQXvoQBiDUZx8fkNPvWJr3L1yva+Te8/uUSTRpqBemzXMErRPqD3w9aoJN8zGffzkiev7x58zlqHARtF0+z2ADyw1OGZ3cG+M1dOaIuikyZ0Iz9RviTE3nNqRqkXhDljqgN3NR0YrWey4Iu9UeOOtsACdxpiFNf/o0cYvvrEjBcJFY+zriFhKvDyVcfjaKSOXXvhReOPyeKy3s/u7vRckqYpabrf7nl9fR3nHOfOnZt6/ty5c1y5cmXmMS5cuMAv/dIv8Za3vIU8z/nVX/1V3vGOd/CRj3yEb/7mbz6Wz3EodPibaBtK1STx+K4PvSf2oFiT6dvxDEzeZw9rPpf0/D4rV1NCsn3IUZoqhYntDpka+w8K3Wf3jznbgWIFfKKw7XG3bCWw9PzsnYpRDM8aXDpxryqEpBeIBudWm+dHbwmavZZLDzQYuRncjvH+UsBdTSbSODR8u7oz4vRyWJ4vSouzLhTbiDAqLJe3BuxkBcPCIjIjrJq4LlyI3JHK5aleONVK0U4iVloxvVFJ22j6uSUrXSNOrnekJvZntOYVZ7q86eGznDvZJTKmKTeqT0Sq6F2qEiQvgq9WQgUVSqasoywcz2302R6F2vfY6KDjQJPqUMueRJoIE0qeUGhRlDgUddZCV9kIhanIRFgBmVhprbMPzZwhIf2nJpyuxpxsCmriJ6UCeVngNsF7sPDcs5t89rNPc+nixg3vQisViOXUzUjYyQpW5zSuGxSOckaAvTMq+L0vXOTbXnvvvtfue+yeUNYXDsrURTdjhV+AL/3xU6ylMWW33VDWjaygyB3aSbMqGxvN2XbavLHl55dnRFo32cb6OH5WcCX7flhggTsO0Yre182v5a+1f4fup0683SXT8f333z/1+4//+I/z3ve+d+72ag+jqhcAZ+FVr3oVr3rVq5rfv/Ebv5HnnnuOv/f3/t6dIxPQEAqlBd+aTSQOhci+7JQSiEYyV2gdZYKeISozOSw/Bb2HZx1n+rybJUQBNcdNTIyQn6oE2NXm6UbILtREAkAiRb5W7cPLXDIBUC5pipXx8aKRYLL925cPngrHe2aImiWgW+DYcVeTidqkICtCOZP3gnUWTXA+8l4YjEqe3xgwzMtQKoRgmowDzeQ6STCcCOICwzdaEaOJjGGlHVNaz9ZgxKluQhypKXvVqRX6qiLFOeGR0yvcf3opZE8QVHVgX4u8K/H1VElRvQ8RstxSlo5RXvD85gAnQicJWgglmkhpUqOJTdBZhPeFCdWWfkwk6rKmqueF1oS6yer7qEmEVERMqs+kqAmSzK8RnyhXaTISN1mjvsANwHkuP7/O88+tH7LhdAZJURMJxV6+JwK7eYnWiuUkZn+4MnsM9LKSP/zylX1k4vxDZ7n3leer8T8De9i9F+HpL13iq599DgTOtccrkkYpNoqM4iY6UAdntekPW4/tRcXSAncd1Isj8+tQuGNiKfV+nnvuuSlx9KysBMDp06cxxuzLQly7dm1ftuIgvO1tb+PXfu3XbuKMbxEafCpIcvAEJJXscfwEKF9pJWZMz1EWypFcS4V4Y3/5wD6YArrPC72H994Q5r8HmJn0Fj0u48rOjV8UAziFmBsfL8WSwu1Z3/KRolwS4v4N7+6mcTvG+0sBdzWZCFawnpPdBIVgrcVXImhBsM6Rl5bdQYH1PgiV61RdFdCHsp7w8+Sf1SNYT1Pa1E1DadPVXh4c3ZSw0o5Dl+o9wUgdgHsRstLRik3QPZSWKFLB4UBVvaUrS9h6H7V4WalAhsQL/VEO1rO1mzHMSrpxRKQUsRaUaLSopmSrISjVBCLChCZDB9vYajW6yaA0WZX9M0YtCm8WIvbVm9SrY3uTiWpClL3AC4kn13eqxNnEpC6qqTqah+1RwXIS7ZvuOrHBeplb/uP2lEA99Nr70fNuHs6Ddc1A8V64dHmbL3z8qzM3P9NKGQ1KiuLGyUQS7SdOMJ9MDJ3nzFKXS7v9xrkq0oHQRBJ+dgIjuxjkC9x53CiRWPqTTZKLYO89gVQaIdcGl4Dcl8KbTqGHls6Xd25ov7ej7GNlZWWKTMxDkiS85S1v4cMf/jDf/d3f3Tz/4Q9/mO/8zu888nE/9alPceHChRs/4TuAdF0FbcPENKMrzczcIF8gHgo+rbabgEsUyoE+avnmIURCZqXH5hjcZWeEqKcwN9ErLj+pcK3pQe9jyFcVcX9GedgqDO+J6FwuG6vZ2nZfOYgHDjEK27qxsbsoc5qNu5pMmKpcqJNElFVmwrlKH69C2Y44Ia17PWjA16U6gIwr/hUhLap0FUBXNrBGK9qJoZtGXNockJWOJNaUznNmKSGJQsM5P+OK814YlY7+qGCUFRgCOfGRJzYGUZpIKZQJZUaudodRYyKQFZaisJS5ZX1rwIkoot1SwcVJfOP6UJOQqbOQqh5ehe8qkJYQRDbSjok3KKUmSpvqzM+YJijF1MpuXYaFkvH7qn9VffxFnHXb4b1QVhoapRRRlQEQES7vDPm9Lz23/02Tf+gDMGuLU52Ywnn6ewL6NDI8cLJLsafB3Nb1HU6eXZ1tDVtY6I1dNlzpePbzM873qKjGqL9FnUPmheuF5zXnT2O9J7eOUVmSaCGdIEZOFAM7viFY65hNgxZY4CYxe53nhtD+yi7nfvUJlBP63/IovpuQX2gzOhNRLgP3rcDXrxBfG3H2Hz8FgHUFPHnLZ3/b8Tf/5t/kr/7Vv8rXfd3X8Y3f+I380i/9Es8++yz/+X/+nwPwYz/2Y1y8eJFf+ZVfAYLb00MPPcTrXvc6iqLg137t1/iN3/gNfuM3fuMFOf9QBlTNKRr8RJYi3lEsPb4/TPOHLAQ1+56x5lIuhe7Zeo/BnzdQnKjIweQ+JsWl+w5QZSEmn7qldJnCtuqGdjePcgl6Dyp2H0o5+4lQCpXs+rCQqxWmENrXS1yicOfHWa9FvHLzuKvJhLWOdguoXJzEC84K2oAxijz35IUl0iH4HouMgcotqbZKbWrHdeg8repGc1rhPFzfyRjkFhC0VljvWUpjuqlhe6hCWVSVUaiJiYiQFY7rOxkPXHDY0jGSgsJoOmmMiSK8IYiTqui7XiW1zlMUju1eDl7Y6WXs9guMUhilcZUllVJjk5+GgdRpSRkTAK1qp6iJ+tKJpQ5VZRjqLERjM6ukIQdKB02G0eNMSH3xSVXmNO6PUwnM7+4h9qLCaJAR76kby0rH5u6Qncr6NTKa5XbIBVsn/PPPPTV3fyLh7zZv6o/nlSURtAdG+aAxIhCJx86u8B+/dX/B7ad///N883d/A3qvKHo8cMfHjA3f8NZX8C/+jz+ZedzSOURqkdL0mZvqjhdHiqLyI6+HeDlj8QxCZiFzPpAPBR1jKES4OmGb+YZ7zgLw1PXr7IxGU+9fig1fc/5E83teWP7dzDNfYIH9KNdSfKKJeuVULwmJFMXpFhLr6Wu0GsTxeoY9keCT6WtUF45oo4oStaI41ya5POSeD3yh2cfSR54A4PK7H6NcXps+n7NtLv3fXwuAzzL4bw//DI7jK9e48Xwj/OW//JfZ2Njgv//v/3suX77M61//en73d3+XBx98EIDLly/z7LPPNtsXRcEP//APc/HiRdrtNq973ev4nd/5Hf78n//zx/IZ5qHbHmHa07NQniX4XhR6SAA+8djT1bfgYeVz8++fokLvqHmBvhzQ/kZMMH9RdUbYQHYaNt44Y1t9Y/0iRMlcQqHsREZl7yZV+6TBPYal58N3YCqXYpcy08mpXrCsBdzagmvBziPji+ba1wWnsrOfKOhcnR5hyoeSsAZH6GPxQo/3Fyvu6kivN8hIkxgjUvWOCBaxkdEgnlFh2ernbOxmFNaNWadSIeA3latRSGXgCVkL6zzeBh1DO44YZZZeZoPeorJVHRWOUeHoJhGx1hSTw6IpWxKywvLs9T6vfWiNSGAglTB6tUN3KRoH3zUBIfS0EC9Y63DOIdax28/H9rOEIFCq3hdIrWUY93dokgQTdrF1gK8m6o8qXtXoR4KGIuRrvATtSei1oUF7TFV33vSrqI4WzK/GlrRpHDQdrUj48m36+7/c8KV/92WW2tO1w5+7tMnF7XHBqHWerX5Y1nGHrM5b8eA10YwlLqXgwgH2sGe6MVrBdhYc0h5aW+L/9vWPzN0+HxVEkRkL8r3AIIdZ/S8UtFoxWTad4bDec3lrhywvMWqcalYoNELXjIlJEofXhkV47lrpiGJNW6mgF6pOYTO3fHE7EASt4GtPdbmSL2wDF7j9cEsR1773FYweWeHk711k9Y/Gdf/l6TYXf/C1ze91bBbtlCgRLvzPX2LjOx4ge3AJ3zb4xKBLT+fz25z/1UAWfKp57ke+hgf+7mxi/lLCe97zHt7znvfMfO2DH/zg1O8/8iM/wo/8yI/cgbOaxtve+ATJ0nTR/xc/8yBXNk41v+tCk1yqomZp/jcTLgZQsxu5KSi78wPeYjmQiXgYDlGcFDa+5sgfpTnG3qzEgXCQbGpMrvDRNNlRHqKJHor9+8KLS8+HuG3nlRqprZHrQ0ogJsopslNhdbO94dl61UtHh3A34a4mE5ECZ13QFrgQUGsVVi9rS9jntvpsDnKUhAZuKI2OQqBlXegsXVoJXZ0Zl+cYpUgTQ6wV26MC58HokPHwXtjJLFvDnJVWTBppRoVqNBkKhfeBIJTWcWV7yMX1PifTmCgyrK120FVpU9B4qFrKQVU4hFJBD9IfluSDjN6wGDspEcqaQoduj5MQ+CPjPakqzWBUJbpW4+yEVFqRZnmgmrREQgM8L0GE7vB4J6RKIy4QLwhN/YzWKJFQP66DT38rMXSTmG4a044NShRaFoHZXYlqTOkDFPRrnRilYGsUiHZh/VQH7El88sOf4ev/3Jtpdysy1BtBNtt1yWjNO771tfzOv/hMdR7h2nxufYuiDKu3UWW2r1EkB5zjpdw17Tie7Yfjne9EnEwM17KSJ3bG+XQv8In1Afctt+fubxpqdunWAgscAJ8aUHDxPa+lOB96pGx9271sfdt+F7S9eOB//BS6IsjnPxiWaTa+4wF2vukcS5/e4Oz/Pq5L0rnnwb/zqdvwCaaxqCF/YVDHCzeLciloMeJhMFvRTvBzshliJLg21YfT+8uhprafzE5UIUDrug7N+ggZBGx4bVbDvRqbr9MT2qBwPFModBmIRJ25AEDB6PRepfohuInpezHeZ+OuJhMiobzJlQ7vPB7Y6Gds9UZkWUl/lFFmJSstTaITCu/ouxJjNM55chvKGyb1A0Io70kjQxppdkdFaHQXRBRYF7Igg7xEISy1IuJIT7kW+Qnxghehn5c8u96jfXqF5UgTRUEIbStb2SSJ0JEeZwsqa1jEY0vHTj+jKF0gQCJY8c3PlZMt4kMWwVRZB6Wr0i0THKl0ZXMb+IeviEcgPFTkonSezDp6RUmvKMmso50azi93iFVVkaKE1W5KYjSR1rRjQysypCYiNhqtdNCy6OAa5crJq32BO4qq3GyeA1esdNUckanxKxLKp76y3ufRM8v1rqYgwMagZCcPwf1Xrvf4pT98nPf8mVfvIyBKKb7pLQ8Tb/VgqxeejExg5zNm8zBG6yyb8NXL68faIO7K0PJUL2dkZ9/FjqYmgeU05sETh4tEF1hgEk+/92sDoTgmnPrnz3Lqnz97+IZHwM30oHCicccUFB3Xfl4ymKOXUYQeC8rufw3Ce5JdmbJR3Yt4IE2JT7oFpz+puP7WOU3pkj2qUKvHzX/nHL9+Q/uSOVYtgksEZRXRnNBCydHMCVyiKU7EN378xXifibuaTOR5gdER/X5OVpRc3h5yaaPPdj+jNyroZTmDvKSXlRTW4wnkwSQxTaPnpvSp+kegFRuSSDMoSsoqc0AVuNfXtnXCbmaJjWl2MimAVhMhSZ2deGC1zQnTwkQVYfAOY0wQUonHOSrhqMc7R1FY8rygNwyExnvB+kAkvITuxt6BeNBSNbCrheSVfkGbCZ1E9T5BwpuUCs3wnGc3L9ka5vTyktw6nPdoHbQjIkLhhaGURMC5pTZqqY0RHY4zIWOvj1uXVPmFN+wLBqMU3/WGh/nNP9mvoqyJRI2mfE5ChqHGE9dD8P/K08tTgr+r/YLBHgH2pZ0Rf+/Dn+dH3vn6qee/5RteuT/DUQfyZjqoEkJG7lf/949PPXcncbE34t7l9kvItG+BFxXu9ICei8UIf1FDweBeRXdG3wWTy0xx9V4ku+G9e0lF0hNMMb3fuA/n/q3iyjftOV4ygzVEHpwKj72nLWB6x0eWbxTtq4rh+RfNRfaywV1NJi5d3wU9YreXUVrLMxsDnt3ssz3IKa3De0/hfNNkLWgBwop+ZDRKeRp6LWHlPq2IROk8WelqmoBSulmyjI0i1ZpL2yPqpJrWClXXUygaaixVOdX1nYzd3LKUl4w2BhQlnFpu0WoprPOo6vhIKLkqS8dwWNDr55RVOZb1nsJ7cie4OjvhBfEQq9BjYvLSVlXJFdV+vYzJROkc/cyyPSroZSWj0uG8a250geyErtuZc2iBJRPRSQyx0ZTWE3SwdUpH9pCp5rAL3Ea8/p41kkjz1Pr+7tNehN/78kWW0ph+Pi4pSvTekXI4vrIeSMVDa12uD0oyO3tZantU8Hd+9zP8d38+FOB+6zc+yo0ELXle8qF/+omp504uLbPd7x1rduJG8OByTKwUr1y5lz++dJ0nN3e4d3mJ1505ReE963tE2QsscBAe+W//L57+8a/Frs5uCnm78cz/402Upys91GT9eX1J3yDHEBT+mIiJvMwIzqvf+AxpWvLMV87ve01Zz/3vD4sqm9/3DUi1IBNlcsMZpJpUlEuKpCfoOXbWJoMLH1Vc/ubq9VlE4gAoUZj+9Gp7sSokO+oFc0pKdoLWYucVKaiCzhWLjxQSa6KRw7ZvjPgsxvts3NVk4v96/Cq5h7y0LKUR68OCrX7GMC8rAjHu6tx0nPZh9T6OqoxApRlQKjjUtCKD9xK6ZfvQC6J+q9aKTqIxKPqjEiew3Aq9JpJINxkDqFxypNI2eBiMSp7bGHBpkHP6RJd7VrpVIzmNiUKvCfHgCEF6Xlh2ehnDrMA7j/Me64XMeaz3lR5hnCmZsoWdKNsCGi1E6T39MhCInVFBVtogNq+/o2po+4kcoXPQMoaVKK0qUxRKa7wL51olbZrjj8umaP4GC9xe7J2OhoXlY0/VYs7w/S8lIZ1bziEBR8UzmwO0NtN1UXuQlY73/c5n+Mjf+Q/hINqSFVCOz2d3WPCbf/D4DZ3P0AlbTjiX3li6uG0MGsXAzq4TeOXKONBTzf/gzfec4TWn1yiq80605kK3C4Tx/kyxn9QtsMBRsfQnm6z80ZXGUem48NW/9/XNGJZJl7bqnjgVnMqefxe4bZg1jUYbIy78vz4z9dzaPwoecb1//81I68ZLc2rEfTm0I7S2cOH3FZe//eDUh/J7MhMeTKZvaNxIBDadFl8fBbYTSjHi3uzX063Zd52dhxNsx9C5Ulmp+9BvotnvC8PvXxK4q8nEFy9vgYnQCk53YlxljxqciGjEynVsbUxlqSphJT/SGqcBCS5N3TQKvSEKGwLsqu+CVpCa4FJUFI7Chh4PSmu2hwWnuglZbCisrwjI2HGgDqVE4OrOiPtby7z63CqrnYQ4iYiiIMYL2YnwnqJyb9od5BQ2EAkvUDiP9z40qUNwlcjDoKpmk9KIubUeaxxK79gYFmwOCvpFWe0z+LMFHbYa60aoXZ807ThibSllOYmJlEYpQWtNZDRWe7xXE5mHmk3UnzcIuRf3ozuH6/2Mz17eANjf90SN/7mVv8lR3huuv4PF25QOZhCbef0hVrvL7A77uMpKtm+FoR2fz+Xcc2GCUHx2J7hEpeoAkjFxerFWvPrU6sRLMnOFtrZMnvxoqnlNca5zVPH2Ai9nPPA/fprn/8vXNwLstf/jOU589Ao4QTnPfT/9WZ7/r94AgBLh4b8dsnW1+PpGIUYduABwK1jUkB8P2l/e4tRvPhHc2PcG/NW8qETuyD31sMyHKjXYGeNpzsmVq0LcU01plo8CkahhO3sIxRE+5OQmoiE7NX4m2Z0z1msN+ZyX4+HhtWOL8T4bdzWZsN4Hz3klDEtNK46IdP3HqVfbA5QOek8lCvEhvXSym5KXHuscy60I64WdYRl6UlQkIoo0rUhjHQwyO848AHjojUpOdJKxyFnGjgfB6nWcyBrkjgtLLS6stkmSiDiOKF0QknvvMUqFrtmFZTAqGGYlznqsE5wDV2ckCNspVPUHrJyhAK0EbRRRHDIlg8JyrTfieiXiDrooqWxl6/MkCKa1IjaGdhxxspOy2kpoRYZY61BCVWVolAr2u95LEKRPljg1/6u+51tsHrbAfnzm8haFG8/21nvWRwWfu7KJ9beWeTgMkdYVIZkc2dPoJhG/+je+lWI3lP/EK60jlVUttWO+6089xj/7w/1mwkrBcqfLxd0hw9Lua9BYeOG5kaNXuT3Vwy6r3MTS6rwhCKc7cUhtTxIeM/HzrlWsRP6GSz4OJFALLFBB5557fuGLTecxnVn0hCVxenHAQ+/74/H22a050j/03k/xzH/3JmSO29qtwIuaymbf6r5e6vj4px4jz8fZBWsNnS9d49RvP4POb2/ngXjoUQ58rOb2ofARXPszDkw1ic7qMTHrtq7Btz16tH+MCVAuCbqoMhp7dimmIhSDPedbkYJyScbnWy18uraQpRPPTRy2WJH5hOIWsRjvs3FXk4lTSwlexUAQI0eRCVoIgIngNyyYB0Gw1gorgnPCa86tYEXIrWVQWK7sZBRlqIaLjSaJw76y0lNaXwUoYcW1lh0XpaOXl7QiQzs2wVbVj/tB1N20awrSbSWkcUQUBTLhJJyXUcERyltPWXpGo5KscJSV5qL0wc62LiNSSmEAr8amCkoF8bVTwsg5isIzspadfkFeuoaAND0iqlXW2Bg6iaGTRnSSiE4cHrGuRLr1gFd1n7HQuE9pBU6mdBHCOMoTGQd1C9w6/uTyFu1Wwqh07F2fchJ0MLcTUUUqAer02yxCoZTizHKr+ePbXtVQbykN5YZzshJaKdrp/CnpUm/EsHRzx5SVqaqp5jQBcvGcbaekxqArpzONmiIQk1iM2wVuN6LebGtkCCvD0c7xOeFFO8UiTfwC4+OfegzTbjEYpYifnndU6dCjedZMx4NAJCRUW5TgmUMoFLjWxGCpSUVlDatKPZtgcLCLkrLVBnO2mbVIX2dI4r6iXK4IRbMKyvzGfC+dBf+7Bnc1mUhigzIhgNdAJzH0YoMxGi+u8hYKgVZj+1oFEl5gN7dooyicsNkvGGQWrUM3X60U1oeSpqArCLRk3OAtBPVeoJdZ2suGNDaV3axqPJh1RWLiSLPUTjl/soMyhiSJgl5CGerGc4hQFI4sL+mPQjmSdVLFXpMEpf5/sIBVHpwEW9eRdVggjjWU4WLzapyJMDr0nVCExl7dJGEljWnFhsgEUhMbTax18/15CSVVyo9DR23qV+sTCiVhItLMFzXxWOB4MLIWKW9+lrx/pVuRUbi0O2JUTpMP5z3DwiEC6cQKZp3t0xN3AQUzCcXJTspPfPdbp/YrVRbFDnIgZMBuZgW/mND33ChEwtiPzPi4guCEuYRigQUWOBwOjTum6O249vNixGDYQvv5jUAPw+Z3vRp7PgGjSHYFPYOLNg2xJ0s4h2H+rYlE2E5mEgqXwtbXzlmUUhMizZtA/fabem/VrO7FsJC/GO+zcVeTiZ1RiY5C4H7PcpvlVoyT4EC0MwzCZaXAu7BaGhlDpKCVxig0w9KToCidJy89iQnZAeeF3DpK73Fuop6iFmDs+TkvHIX1xMaQRgbrJrIHWhNFik475jX3nuD8yS7ddkIc192Ax7oD54W8tIwyyzArKW1wbHI+2MaiQtim1ZjgW+vpFY5+XjKylsJ7TKRZS1JOdhOi1LA7yBmWDq2gk0QstQJ5aEVVj4iKPEGdQdQNQauMZBEvoRGehOAxNVHoHK5qXcjEWrnUAnRZrPDeIZxb7vDo2ZM8cW1r5uv3LndYSsaX+4UVsF7YHhZsDIM2x0twBwPIq8xBN46mSMQkakLxuntP8s7X3QdAO4l44/1rM7eXOhsRR3PvKk6Ez17dnvma2aNVuBGcaifEenrinrycZ8E6CeRjz0ZKgzJzvpM5zy+wwAuOeXOxmr0q/BIq537RY/jYKtvffIETH7088/Xtdz1K8eAJpCqLK1ZAOYgyMFmIUSYW7Bsbe5P5uc5NSgRtITsJvYer2okI8rU5A+UIU5uS0LNiFlyqbjpjYDvMbag391zcnMyFnj+2Xwxk5W7FXU0mchEiJNT5KEUp0G3F3LfWJYkMm/1RKFmKII0j2onBeU8SGerGzKoa361YkxF6LmTWUdaWstU2YyP+OgipVuar1fdR7ugsRSy34lCa5AWjQoO6bifmoXMrfM2Dp+i2E9I0QleRuK8sWJGgPxhmlt1hzqhwFC44ONUuUcFxKmQxcucZFSW93NLLLKPSVj0xhLaKaceaB0+38Sbi2tYQL4p2bFhuxSylMYkerxBrdCOapfrM3gcHqPraqjt6K0WlCwnlXpHROEInb+f2EgqBm1xJXuDGsJREPLK2TMdocuv40vXt6hXF+W6LlTTes334fXdUkpWuIRE1nIwzawfha+4/xb//5od44/2njrQ9wPrOiGJOw7hBYbnSn2212okjltOY+Ca6Tncig5nxvrqT/N7zTlRNrsb3UK1DXxYnYXFiFuY9v8ACLyTWv+vBuhHRGGrOzwc9NwOLGvJbR3G+xfa3nqG4EBH1LGu/OyYVu9/yEKNXnZoS0Luk0tqUQjTjFltvacqD77/ZaWH3lZCdnSp7OBgHNZkWiIZz5kYHrn1AadIB8IncEBGJ+mqfiFw0pLueuC+Nze5ezHt+6lwW430m7moy8dDZE3Q7LbLCgvNsj0pirTjVTUkTg5NQJqQVdJOYyCiy3DbCYFN1B/ZVwJ5ZT24d1vmxwHMirTc196qJfwVGhUMpxdpSgokNvcwCik4r4t5TXd78yBnuO72MMRWRqPQbzhKCcBHK0jHKSvrDkqIhNNWaf1WqlFvHoPD0izJkIwpX9aHwjQ2rM+F9rUgzdLDWabGUxCETUYnUlchE3rAqmap4WWOpO3H9ioQCmTpb4USIIk3SSrFeyLOcPLd4Oy6pEhZc4k6iGxtecXqF3Prmu98cjDjZnu93V1aWw/OQOUfLzJ/9X3F2pSESVMccFpZOMn9q2Rnk9LLZ9eBZOV/3MSwtikCEYqPIXNAETULd4NKXEJyvJrMvMZ6oUiJNlukJNOR+gQXuBoiC7W+9h+1vvlA9cfzH8Gj8MZVrHNd+7jpoobiQUFw4h+lbaivEZNMwePOFm96tSzTmAAew4uQEkYDqpq04qCmEqAMC+wPGl8mrc6oIhclk2sFJgT+GzG40hKhaj9pLKOK+EA1v7SJYjPfZuKvJxNc9ei9n1pbIi5Jnr+7w1JVdRlmOMZozrTZZ6dgdlTgnpFGEUkJsDEpBiaebGgRhpyjo5ZZRJVIGQvmOTF4bqin6a64zNV6JtE7Iref+pZR7zyyzOSoZ5p6ldsTr7jvJK86foJUmaKODy5MEQlOTFu+F0nrywgVCIyFgFwnWrrn15M6yMyro5Y5RaXHe4T2Ir4OekDnwIuSlY3doGTnFUhKhkqixfA0EKJSHhcZzjWSjedTPeYTaIrch7VU2xiSaznIbrxSmp/BuhLXjjE5NPBa4zWj+aAFppHnd+ZOIwOWdhJ1RftO7zux8MvHKc6s8fGZl+lSQoD1Sila8/329UUnp5t/cDsOgtHiCQcLQWvrlmEwoYCmOSavzPdsZZ2O6icZ5mGexrsQhyhDhief4Inq/KNtb4IVD7+tOM7mk1X58e6aI27UNo8dW6X5ui95bTrPxFx6YvcPD6vwWuCMQA2LGE4tbilj/7vtAoHXFEO/c/L5dqoKD0ozX8jUoTsx4IdhCziYUXt1SLZDJCWVXOgT9dTM9CJmDYhlsO+y/c2l830q2heG9Ca61/9jKhe7dxUrYfzSYkxmpYp0Fbg/uajLxivtOcc+ZVVqR5t61FVZa13n6yiYQ+kacWWohosgKWwkwNbER0kjjFVxYbbM9yukXNgina6H2JFmoxAl1SVPT6A4qu1RV2aUGIXc7TXjdA6dwSrE7sMSx5hXnV1jupMHW1YTyJud9sIWtReLeM8otWRnsZz2CFUdWOHZGBf3c0i+CK5NzUgU2ocHd+HyrTt1aYQVGpTQ2agodas51OGe8J/T/lsp1KRxzYlfjRnQ1iaoeQtB3WCdY50haKZ1OSpmVDLMSL6EkqtavLHAbIRIiZNkfACsF95zo3hKZOAjf/Kp7eNsrzu0/JYTdUYlSakrIDXBtd0RW3rxriQd2ioJZ4b4A/bLkfDf4Bb7yZHvqJtorPCMrDaFQhLphhaDEgVYk+vZa6y6wwI1AFIxedQKAa3/llVNR4al//ixLn7jeEAq7EpPf08WeStn89+4HeZJrf+UVt/0cnSjcMZVrHNd+7haIAUk9MqdWKbvgiHduz+r14H4Y3jMnuvaE1cC9f47yxprS7YW2QrQ7u/xKeUh3hGgQxvPJz/Wn+MzGm4XeQwmuXRmClKFjtymgfU0QrTDZ7R8/i/E+G3c1mei2U0wcXJHWVru8+gHBO8czV7bpe0s3jVlph3KmwvpQF22CPuLsyQ6nujFPbfYZlX5saTrlc1qJktXkIk4gF7rKSgSRtSKODMudlBPLLdZWO+HcKiFzlCq0ichzS5KoqiRJhzKmyh5qMCpY3x5yfXvIIC/InWVjlLPRy+lnJdaHXhTeebwLwb/I2Emn7hURbGhDt2vnZVwn3pCK8eCV5n8VQZCQqag7dyvG4tPJIS8S+l4UhUUPMrR4tAJjwo6c9zjxjJxlo3+DrS0XmIvTp1bptKZLlna3+2T29pCFGlaEaKKW9PxqhzQ2rBzYiVXYGeak0XR2IiuDW9TNSgus+JlEooZWitee6sx8bTnRQCAU4gWNx0yQMO1LvNJzdR+FQFlpiQyKaGIzATazgryYb/e5wAI3Cok0l//Gq2e+tvEdDyAK2l/eAQXD15wIJKLClf/0sQP3Ha9nVf8KwXVj7FravKa8kDzfP5bPsMB8SDKHSBznMYwKzRCr38tucHByySHHndEP4lYRDQ/RcXjh9Cdnt7U+9akhCAzuT5EodL/uXB3va/kZIVsLPTRmQfmQ/fCxCs6Ui3XOY8VdTSZC1krhfLA4S5KYtdUuFzf6bPVGGKM52U1QQH9kAcFEhnYa8fDZJbaGOVujcqovBISAu1mjr4r/VROIhyBbV8v0RutwnOUWr75/jVfcc5JuJ8UYg0Fjqn0JijQ2QUxderQKKQUvilFecnm9x9NXdri82WNnmDHIS672RqFRnneIB+cc3kmlXxiXNVG73FQlTtZJsJUVwUBV3sTUNns+Hs5LY72ZoNEVYULVZqI0E0tdM66cpygskQnHHxWWkSvZzXJ284JBUTLKb2+g+3LCf/gdX8/K8nSg/OF//Wm++KXnDnxfEmmKyklp7zQeaU2k9YHN7jppED7XU/Tf+DOv4cFTy7TiQ6YPgT/88n53klPdFt00niIUzgv9vCQ/QDPhqu7yt3KDW040RkqyGT05BCid30eAIPSwuFI4BlWJ1pLRnDCqKdkqvedfPHUVt8jELXAHsfkXHkC+48bfF+0WnPknT9H5cqih6b/pFBt/cVwOpUeWC//PL/KVI+xrIUg9Imp54g3Cx4Iu57yxciY6qGN1flIHe9hq8t94vaJcUUh6hLqf4mhZEeVBWXVggH4r1rA1Tn16SOeakJ/ab7GrBFqbwvDcjKMImFywLY1tQTwSkh03/b1pjiTyXoz32biryUSaRETagHi01rRaMSdX2pw90WVnEFb0z6+uIBLq/Ern0CiW2xHiYb2f4/bVb9f5hxBmy1QkXekHlAYVukAbo+m2Eh46t8IrLpzgzMku7VaKoLBFuHriSKN1sJDVShFX+7Pe0xtZLq/3eObqNs+t77Ldzyidw4snUiDe46xU5UyBBIRKq5CFQOmqZD7UJakqE2G9YL2nZQym6nUhVSqiJiJQJ2PGtV2BfIybek1qHmoOIr4qe9IGrRXDrKQ3yri2M+R6b0S/KCvCsShQvN2I44goMtgDgthXnDnBF69sgkC+Z7ifW+2CUjy72W8cw9I9Gomf/94/PTOTUCfyZi7kC3OF3RuDDBFYasV4EUrnubIz5J98YjJ0Uft6SlwfZbSTiKTSPd0u7C0ldwLP5ZZs4vP0nee5Xs6Xrm7evhNZYIHbADOynP+fH6f1/Ljd8NKnN1j69MbUdkctRhTR+GPykZWFH+0+DF5hWX48nqlxKZYVoiHZkcZPZa9b0vqb4XZ1cVOhVpooU3SfHh9YZjg+mVzuSDfQOgMxPhmIRtOZiLKtEG1obd344s9ivM/GXU0m2mmCEJrKteIIBZxY6XD/uVV6w4z17QHDwrLSjhnmFiue1XbKA6c7gOJ6L8d6qVyQ6q7Q4WcNlZh5fE0oEzrmajRxpEniiBNLLV57/xoPnFnm3Ikl2q2EJAnWsza3lE4wscZbIctDCURLYqz1DHPL89f7PHllk4sbPXYHBdaFtLPWkCiFkVBmIoSJQhsq+7KK6HiPiEJX3vfaaEykxvkQNSGoBuqlXamerAmKUZpUV6VO1WZepKEejZi6mrA67Zjz95zGK8WTF6/z5Pou24OcwrnQIVtVXbJfQsz7xYhv+dOvp5XGfOKPv4Kfk13wAtkBc+a5lQ6xMTy5vsPJTsr3fO10nfW8v2BeWkRMEFrv2UiATz1zfe4xN4cZ1nue3ujx//vCrMyKcLE33EdHi1HBSiuuDBVmvevWblYC5NYRmzDJK6V4KrOUC1uyBe5iqImO8/f91GeJNxYZ4xcDdKbDfTY5ILUwoeGchbIbCEW6LdgWbL32aMdWedA/zD32YQ1SBZItTfvy/u2Ur/pf7IFLFJTM7X1xq6tESqBzzTM4V52TgngoHFgbu8Cx4K4mE9Y5fKHAeVpJRBRp0iTi9Iku955eoTfIuLab8dj5VTppjDKKsyfbPHTvCXaGBbtZSV64qocCjaZAowixRF1CFXyJ6xX+Vhzx0LkVXnP/GqvdlNOrHc6sdlheapFEUdhRtdpfWocqPEXpyXOHdY7BqGRzZ8R6b8Sz632u7fQZjgpcVWYkIkQmZDOSxFB6h1KhI7Uowbugt1VVpkRrhTbhEWmFQeEKx6XtIa01EzoYq0CQGqvZhlyoqtdG5VRTibEVUmV0QpftymyUUjx9axkaONduERtNJ01oRaZyfgIdqSm9xQK3F2/7+lfR6aT8/kc/t+81QfjMpcNXz195ZoVvf/W9M1+bsSDWoLBBA9FKppfDjhJ6/9uvXuELRzi3vdjNSpbS0HdiEl6E7WF+DCY1wj/+yhUAXnfhVOjtssACLxRucUArgUf+m393kNvnLcGhcMc02R/Xfu4m6FyF1e50dsS7/OWDtGkB2RrsPnLjx1ZFRSjmHPsgtK5rWtdufGXdxQBqH6EQBT7hMGfaI2H1mZBXG62ZY29Etxjvs3FXkwm84MSTaEWkNbnzGKNppTEr3RbtVsrGzoBhaTm92kI03HdqmXY7ZTuzDHJHUXq8D4JMxbh5la/KN6QSWhsVml6tdBIeObvC6x9c48Gzq7RbCZ12QredIKLICzsl1s6L4BIzzBy7vYL+KGNjd8TV7T6b/Yx+VlJahzipNBQhF+BwCJp2aih8hPXgrKv6OIQshNIaRah5T3TITlgnZKXFiTDKHMtJzLnldiAFaly2pFT9b5V9kdrdJqwq2LpsSoEWsN6xa3OuDXN6eYGJNIXzrKYxRVagEBKjgrFQLVhfLObeMbzuvlM89o437HteRHjPr/7+Le3733zxIt/y6nvQc4Lq9cGIK1dmN5q7XejnJYO8nDnGfvnTz/DX3/TgTe1XEH7rqXFG5fOXN3j1uZMzdRQLLHC7oUvPI//1/8mTf+9tN/V+5YVX/PDHj/msFjh2RB7dmVFYJgCHk4mDoCzIQZGeU6h8//wm+vbdwF1cCaVnHGL969c48/GbLx+NsjExam86spMG/9KpJnrR4u4mEyoES3lu8c5hnRDFmlYasbrc4tzJLv1BxvObQ77h0fMsryR00pQoiei2EpLIBO0BddZhr6GTIjaKdhqz2m1x/6kur7lvlXtPrdBtxygdSp2MUVjrwsp+JYaWKrOmNAxGJVc3hjx3bZuL232GWckwCyVNXhSID0HRhCjaSwji08hweiViMHL0XIboYO+qtSLWEAf7JkrrKWzoZFzRBHJxXNwecLIVk0QRSjRMlkjV13KVDXFVyVfdlVsBjiCM3cgsfVuQjSxeHBSKJy6tExtdbVt1x6YmEdPkZYGXISoXkduB8TjbDxH4Xz79DH/24Qszs+YthGTG89Z7fueZ9X3Pf+nqFo+eOXFgI74FFrhdUAKP/PD/Off19e96iJ0/fX7f8zp3PPzf/l+389SAcK86PkHqsexmgWOA8uq2EQoFB6avr3/DGsPzs8dUa0NId2a/eZJI1Ei3HPmqwR/T9P1Cj/ePfvSj/N2/+3f55Cc/yeXLl/nN3/xNvuu7vmvu9v/0n/5TfuEXfoFPf/rT5HnO6173Ot773vfy5/7cn2u2+eAHP8j3fd/37XvvaDSi1dovdp+Fu/ruaLTC2+DyMhwUaK3pVPFypx1zarXN1a2UK9tDepnlngurLLVSrDg6acTqUsrVjX7IRlSCIV05NLUTw2o35exKm3tOdXjgzCoXTnZI0ojERGijGBWOK1sZrdTQjoMYOYqCKFsEityR5yW7w4znr23zxOVNekURmsxZ32Qi6mHZmD1M6BsU8MBql7IjbLRjNoYZhfWhDMk7itJRuiC2bgSrFVHwXuhnBRvDnHNLBqV8pQxpWETVY6KSZdd2s+IpfOguvFmU9PKCohRE+aouP5AHa6mcsDyakB3StVsUNN3FF7i9sOvbuM3dma8ppfjZ7/3T/Fcf+sN9guYaZ5fb3Lc62071MGwOc9YH2U2993aiuRRmfOQMxVd6I57ZGVtfClUn+jtzegsscEM4KMt7+v/7DKd+59n9L8idyQ77YxSkHtd+7ibIkoNZWQkIlr9fM6Lzmfbc99uuUKzc3B9atATXlRch5sXr2elQB9W+Pv2Z1ZyFq+MuJHqhx/tgMOBrvuZr+L7v+z7+0l/6S4du/9GPfpRv//Zv5/3vfz8nTpzgl3/5l/mLf/Ev8vGPf5w3v/nNzXYrKys8/vjjU+89KpGAu5xMoIKmQCcGNSongnJFK4lY6rZY7ra4tpux3st5xAvGKJxToYOz0ZUTjgdCx961pZRzqx3Wllssd2JWOgmdNGa120YZHbQTkUGbIGqLjEI8ZEWYDLwIhQudt9d3R4zKko7RPL/ZYzcrEPGVRmMs/B6zB1XF+eF37wXnQjfrlkk4v9xCxHFlJ2NYWsQHu7dJN6c6K1FHUaXzXNodstpKSE0URNEVYxGpu/oK3nuc9wytZbco2R4VjApHKeF5cYAOYm/xgjZBvzF2uxO0gjiKGBYlguA93EKz4wVuAHKAQDiZU6LzjQ+f5YG1JbRSDPKSi9s33hNkIqE2G1rd8eVGpeBPPbC/mV6Np3b7XOyN9idNNDBHqP7kxi4PnlxmueqtsT4Y8vTGJnpPtCYL8/IF7jCUk7mB1FHhL6xhXzPdKdvaDH7/t25pvwscBXJgxCt187g9f+LsnMMuV4JPp9Cj4yditzM7Mf+gMDw7/wtpX/ekW/vPSXToHzEL6a6nWFa4qgdF61rG8ld291nqWvfiNyZ417vexbve9a4jb/8zP/MzU7+///3v57d+67f47d/+7SkyoZTi/Pn9Gc6j4q4mE4JGG02rCpaK0qF19YrWdCrtxKnlFqdW28RxROmCKDoymtMrbTZXO7DkWWknnF5qcaKbsNxKiJMIUZAYjdIGpTU6eLGGAFop4khzciklKyy9YcHWIGNzmLGV5WyPCoaZpRVpLiwFdqdEGnvV2jltMhMRfq5W9QlPGK1C+ZIrWO8H0XZWOJwETzbFREfKesKp/DprstAfFVzdHXLvajd0v64O6nwgEYXzDErLTl7Qy0tG1gVXJjfOVoCuXKEq8bYPHSdFSVNKorWiE0cMCot1fkxyFrhtsNe3cTuzm/xM4se/8638D//8kxTW8Y5X3ctKK6aTRMThgiFqa5RSPL81OGRPY/zxpXV2s4ILy935Gyn4oy9fmjkOrvcytgbzJ+9bGTm1G9MsOB+6s+/HjDt28x7Pc9s9vFicd6Ex4yLrtsBdDvfKe/AXTiGRgWRPbf4RibFH4Y9p/fe49nO3QJYstA9fcRu9OqP1eIryitF9Fh+DRDK2QNWCx98QoehcBonU/C7YFaLd2YtRqmSfDe1x4cAFe8/svhoHDB0lQtKH5HqfaDtHOY8qZ+zkCKufd/t4997T6/VYW1uber7f7/Pggw/inONNb3oTf+fv/J0psnEYbphMHFavJSK8733v45d+6ZfY2triG77hG/j5n/95Xve61zXb5HnOD//wD/OhD32I0WjEO97xDj7wgQ9w33333dC5lNYTxRpBobUmTUL6qywdgiJOIk6vdogV3HdmmTQ2aKWwLnTDfvX5E6wmEZFSJJEJZKFa6S9d0DtYFZrMee+xXiOFI1IKX3gGhWVnWLDeC0H+1jALjdqsJbcO8QovhsxGdGNDYgxePFZAnG9E0GMyUP8esgdGayKl6I0KlNJc743I8hInMlELPjERyGQ4NC6fst5zvZ9xopWw3DYYCQHVyFr6eUmvsAysZVRa8sI1rlI1w1FGVQSCphZLqr+1F4WqAjPrBVFglKKUhtMscFxop+ExAXN+DVHgNnYOfOvZlQ7/3mvvwzrPWicNDl+T+1GKlVbC/Sfhua0BAvQZd3P+/WcuoxT0srIpl+rlBc6HPhEPnFiee+xhXs5MTuQ2BOXz0FKK3SrLtRexNvs+w3HAaDWXJGxnBYjFLJwFFniJQJIY6R69lGEWnCjcMdWQH9d+XpSYkcZVQxMaz7UPJm6+JYzuD9u4dHYmQ+IxoVACy09ObFT9OLlyb/KqlMgrhvfNn9PmNcSr+1rMg20rohn2sOFk57/vVuC1Qs+Zv0WDKj1mdNQOKrNxO8b77u50mXKapqRpOustt4y///f/PoPBgO/5nu9pnnv1q1/NBz/4Qd7whjewu7vLz/7sz/L2t7+dz3zmMzz66KNH2u8Nk4nD6rX+p//pf+Knfuqn+OAHP8hjjz3GT/zET/Dt3/7tPP744ywvh4Djh37oh/jt3/5t/rf/7X/j1KlT/K2/9bf4ju/4Dj75yU9izI1R3ciE8FkphVIKj6fu62i0pp3G6JUWkdGIeJQyKGB3VKJQrLRTWlEtTNY45ylKhycEFtYLCs/OsMQ6T+kdWz1hZ5RzfZCFDERRkpUlhfWUzlFWq5ZKFIUNXXI7ScRqO0arMIB2RzlFGQJ0UdL0gqgF3FqHCpF+VtLPSyJjgmDbT04kMqYMs1Zam5eEUWm50hvSSmLQhs08ZzsrQtdh67HisVWpk/eCqEAmVO1uVYmz1cTxQiM9qGcG533V88NQWAdKbpf+9uUJrWFPAK1aKeqwTtTAc9d3uW+1y6i0M4cKBEKRxIYBJQLYCXPuzVHQRWyP8n3B9uV+IB8PziAUn3ry2tzjHQZNWEWZ9fZSwo312AmF2p+d6BeBQFkftEqxhujlV9q9wEsQ5rlrEBv8hVMv9Km89FE1z52CVUdaDZdC49tyaBCuPSw/E44RzahaVX6/jqZ9LdRbDGYQCjO8+aBZDHOTvTIukDhezDhdH6nqq1fkZzsoL8SbLy6d3/333z/1+4//+I/z3ve+99iP86EPfYj3vve9/NZv/RZnz55tnn/b297G2942dox7+9vfztd+7dfycz/3c/yDf/APjrTvGyYTB9VriQg/8zM/w9/+23+b/+A/+A8A+Ef/6B9x7tw5/tf/9X/lB37gB9jZ2eEf/sN/yK/+6q/ybd/2bQD82q/9Gvfffz+/93u/N6UwPwy66vtQd7FWWmGqhnLeBd1AGhsiFdK3pfVoE1ZDe8MS7yGJTbUKr+imBoVhqIJ/vhPPMHcYpRjmJbuxYjvL6Y0KennObl5SuhBgBAcmwVaiY6lclZz3WIROK+K0a+O9RxtNahQb/ZzCOrzXIWiSQCBMVQM1yEr6hSUvHZEJzezGGQfVfOd7Jyil6qSCamIj530gPtaxFGt2C8v2qCArQsgYCE29Blxd4ZV+I1RUqea5MEGMO2rXm3sJJKTbihiWYTXau5fwStOLBPrEEqYo94mwRYQrW0Fk3BvmGK1IY0NeurkBviAUN9jhJ7OOy/1QHlUTChHhC89tcG3nxnUYNQalnXuvCZ2z3cxypVsdcVoHTdWgCKSqcG4is6IwC5n2Ai8RqN4I1b+1wOqFFqTe9cg0ypj92QkBseH7EDduwnbQ9KMcxLO9OObC5NC6FiKLyQyFHimUvfnZ1BQHkx8ZCy6PFbV2wkcqRExmfBDXjnCt6JbMdm/HeH/uuedYWVlpnr8dWYlf//Vf593vfjf/+B//4yb2ngetNW9961t54oknjrz/Y9VMPPXUU1y5coV3vvOdzXNpmvJn/syf4WMf+xg/8AM/wCc/+UnKspza5p577uH1r389H/vYx2aSiTzPyfNxbXWdEtJahaDCerQKq5Rah0jclq4qFQJL6NarStBOMcwsw1GJc0IcGax1REahEawXCu8Y2tD/oZdZnHhGpcN6R68oQjdtHzIQSJ1FqFbwG12EoNEkRtM2obzKe2E3K0mTiJV2gnXC7qgIhEJURSTCZxoVtskahHIiiCumP1k+FHpd15gUT9TnoGpdN1YEB8RxxGo7IStKytLhpdY31O+qd1ELuaWx0EVRNwkPx5ggFL6qRY8jTWxCVmfBJW4c88b7PAyykt3+CJ+F9xilOJnEXN8ZstWbDhRirSnUfDJx0+dsHZd6A4xW3LeyhADPb/QPfd9ByNwhqX8R/MxtFI+vb/Oq0yemnr0+HJE7R78oZ7xnjMKH/jOZdTPvhc6HBcVoMbaPhBsdzwvcWajNXfS1Dv7syRf6VF4SuNHxriOPSixEYRFHULhSI1Y3ZOJ2w+TQuRpKgUb3EOKa8tYmOH3wNHsgkYgHUO6R4nWuOUwumOLg81JW8LHCm9nb2eWY8kRKvP3iEVuvrKxMkYnjxoc+9CH++l//63zoQx/iL/yFv3Do9iLCpz/9ad7whv29q+bhWMnElSuha+y5c9NOKufOneOZZ55ptkmShJMnT+7bpn7/XvzkT/4k73vf+/Y9X2cDQnVQoLlGK7wK5RHeecrSkhWWsnCUOCTy7PQyssKRRhpDKEOyzrObCcPSsp3n9IqC0jqGpaO0jsx5CmuDlWvVWK4O8p2rXI1UdR5KESlNx0ScaqUkKK7vjLi0OWB7lNNOIx5YW2KpFVG6yi2pEiI4LwzykkFuKV0ot6r7QPiKtNSrsaEjdrVYsbcWE5pcoiaUgBmtWEojVjsJrURBVdrUz0ssMpVtVSjQCl91qWy0DxNi8eaQ1Q9OhNw6cuvC38GH/h0L3Bjmjfd56G3tcu3auMmPUcFxa31OViDSmrIikJPIvWN9dPOrlIVzPLvdQ6Ow+QvpaiR8eX2HNDK046i5Z13qD8mcxUtogSGiJnIwQfsBkFelivPgJNTlLvrYHQ03Op4XuLPQW32kuw03SSY86vh8918CAuwbHe+67TBL48hbRIGHMpsTns3JTugC0vWb//50Ad2LComE/MQL+3eIB8HgJdkd94juXrREmeASjY8VolVofAeB/FQ11bqUqWzEXtilBJO5myYTL/R47/f7fOUrX2l+f+qpp/j0pz/N2toaDzzwAD/2Yz/GxYsX+ZVf+RUgEIm/9tf+Gj/7sz/L2972tibObrfbrK6uAvC+972Pt73tbTz66KPs7u7yD/7BP+DTn/40P//zP3/k87otbk5qTwApVfflg3DQNj/2Yz/G3/ybf7P5fXd3l/vvv7+yNAVjQm8IrcFL0DzkRSARWW4ZjgoGWUk+9JzptNkdFCAQa3DWMhgWoXO1CJlzbOQ5W0VO6UMjuODcAiBEWhE1AX0gMnWvCI0i1po0MnSiiNUooaU017dHXFwfstEfUThPHBmMgvtPdukkEaX3aOfIC0cvK+nnReOG1ETxIjgH2qhKH1KRlwkNd62ZnvhWq8yFYLQOJV9G4fBNdsMoiPS4cMpWVrfjUifZJxxTU1mLieN7obCOQW4DgeFFa2H9osa88T4Lw96AbDhNAJwI10bzJ8q6m3NZjbFBWdIrCgal5dleH3OAE9JhyK3j409dpRwEkdtqO7npfd0qPntlkzPLrX0rYLq5/4QsYunD4sDIjYV5caRxB2RGhNCPb+83tTAv248bGc8LvDBQowJ9dWvqOX1Em0w5RncbeQmQiRsZ7zp1qHh64UIpIYodBy7sTxAKkyvMEKKhonPx1jIZ2kH3Wd1YZNsDjPpuN5KesPqU3Wf3agqPKYIWwmLGPcKKCXF55nHJ/OjDJQa7mu4zLDskGQ688OP9E5/4BH/2z/7Z5vd6rP0n/8l/wgc/+EEuX77Ms8+O+8784i/+ItZafvAHf5Af/MEfbJ6vtwfY3t7mP/vP/jOuXLnC6uoqb37zm/noRz/K13/91x/5vI6VTNQetVeuXOHChQvN89euXWuyFefPn6coCra2tqayE9euXeObvumbZu53nrI9NFwLAb7WgVDkZUlR2qBB8J6sKLm6O+RaP2OnLHnlmqNjDInWDDNLlpcMRgXWuqpUyWPq7EOlMHZOKL0PK74q1OTVGZHaOlUrRWw0y2nMiTShoyNcLjy/NeDizoDeoAjajpAQ4OrOiG4acaKd0o4NIsKOLRkUtgrypGEINclyIsFJqiqHMlVQ70VVfSKYjmYq7YRWKpAgrbi0M+Byb4Rzju1h1vTHiIxCm5DdET9uPLe3kEpXQqY6GzTWbFTEygmFODpxELovjG9uHEd1chgNRlx+8iK7hzg5zTxGZOgVJYOi5FJvwNPbwV5W69Dx3eg5k9wBcgrvhe1ewZef3W6ee/TMCt30xelAraqU3tDOvm3X2onZpU7h4or3LIAsmjTux+10JlngeKA3dtEbe8px5LA6lQVm4ajjXSUOczJHz2tYdwhMBsoq0g1F62ogEd6A3rP4NwnXVphcZrr+igr6Ah8HUTbA8AK4lNuibbhVaCvEA4dLZhMobYNuYhbccsKoHWPy6RuaLWP4k2M/1WPFt3zLtxxouV8ThBof+chHDt3nT//0T/PTP/3Tt3Rex1qQ9/DDD3P+/Hk+/OEPN88VRcHv//7vN0ThLW95C3EcT21z+fJlPve5z80lE/OglCKKDEn1oBI/a6WItaJ0jou7Ax7f2OHx9R0u7wx4bqtPYlQogbIO63wjfm4yDEo1TgO1i4uvSpu8SOVTT6MzUErRiiJOt1vc0+2wbGK2dwsev7TNE1d22ennIdPgwxsEISss6/2sEZl6gt6gGSQTCQGpdQsSrumaSMQmaDJiHYTodbai+X5QIVtSrTQPMsv67ojn13tc3uwzGJVY63FO8E4wAqnWpLEmmsiA1EKpuoxLJiarpm/F+BRxFd9WPmQrFrg9uPjEc/OJhAIOSPUCfHljm489d6UhEhCC4eGE/WsN5wKplsKHJfk9N6xZRALgieu7ZKWtRN/jN1gXSuyaMT7jcaswt+j0lMR65k20/mr3EokFFng5wos61sfLBdHaAURCgTIHG2G0LxlWv2AaIlHDR+ybt3waHr0HCM3b0kA8atSLpG5PIrlzOWgfdMHUpFw/p53MfRyII/yZde0vf5OIhn7mYqaSsO+9ROKoWIz32bjhJcPD6rV+6Id+iPe///08+uijPProo7z//e+n0+nwvd/7vQCsrq7y7ne/m7/1t/4Wp06dYm1tjR/+4R/mDW94w6EK81kwWpPEqrEuxXvEeYrScn13xJeubfPcVo+89LQSw07lYKR9WM0fE4iwP5Gwr8L5Ss8gU4GVl2CZ6SU8r7ViKY4512mx1krxHi5uD3nyyi69UVn56HvEV4G+olrpVwxzy25WcrqbYsWgtOy5yMKqv1ArrkNZRmw0tTRUKYVWEkTgEuq566DfaEVkFKUN52t0eE5cOCcIwb5UzEl8neFR6FhTWCirFdjqbCqBuQdRhB5++y+Gulmd8/vqrha4JewNsw/4cpVCdRNkd3apQjHHCQnC324wKlhqp4FMemF7ezSe1104topDnZwXYWs354nnZhObL10NK56PnV2psnBwrT9iNzt45VOj2GsMOyHdORRr3eSWV9T2Hk8RhNfRgkgssMACtwlKCa2VnNFWe/brdn7/BwiEQltCCBHB7iM0po/9+wEUnauETtIeUPuJRI3uxfDv8B5wSThu5wqk2wfPwmVb7Z9/ZaJC65ApdOWZ4uANjoK9za4EdOmD09QCx4obJhOH1Wv9yI/8CKPRiPe85z1N07p/9a/+VdNjAkJKJYoivud7vqdpWvfBD37whntMAE2wgwQBpasyDdvDjCc3d3h+p8+gLDEoVlopDy53KApLaiJ8tXKuUI19f1gxDfvKbbCEDKVCAEFwjSgckBjD6U6bc50WkSiy3NHLLZv9jH5WNB2ka8myUkH8qrRCA3nu2B0WrLbjQIZq99fxp2vEzvUPzgutRGGdhDmgujrrPhu6+jnSQVyaFeEzaK2oP4yIYKrsS4EEpl6REPEhu6MMtGKN0VCUHi+BhEj1+Q+cCJTgVSjLejGmR+9alC48Kug6FTWDFAReLXPToX/wzGWuDUZzDyUS7GRXOikbm7O3k1KgFNZ3M568dngX7i9f2+XRM8tsDnMGxeGp/W4c0S+nCUcc6abxpD0k69VcO7eANDHkxdj9KtIQLQb1Ags0WFjDHg3ahUcDX6X959UCHzC9LT9hiHcPnod8FKxitx+b/frwHAzPKeLeuKzpIHQuhbKnzhUhOXy6Jx4JZWf6HONMUBZcGrIj81BnSvbqJW4Ucd9TLmmkWi02hceUt7bPxXifjRsmE4fVaymleO9733tgw41Wq8XP/dzP8XM/93M3eviZCLXNoBHEe/rDnK9e2+GLVzYZFAWihHYU8eByl88/s8nDp5d44PRypTMQlA62p+I9WoeA3HtpghWlBKWqmsQqMF9LE+5Z6tCJIkaZ42p/SFY6vEhl9cr4e6pi73YaYZ3H2dAFW2vPzkDRTiI6sWYpiShKRz/z2LppXPUZpQr6XWU9G7iBNJa0Wikio/EqiNJzG1yiGv22B19pHITw+ep+FrXI2rswv2ld6SYQUqOJjGaUS+U6BdPrtPUJTq8ANJKPRWrituGR1z7CM19+hs2rm1PPi0BZOv7dZ56d807YLY+26rO+cXifiMlKt8PwxPUesVHzNRl7kMazFxgio1Fq7MC0F4X1XNoacs/Jzvwu7Eeop6rfukhELLDAbBxnucZLqezjMLjLbTiXoVf2z8XiNPnF7tw6dHUUz3UF268+4skccQLvXIYoO+psH0TUs2DyECC41ozKBoK4evNVKWuP57dEKG7HaFqM99l4cSojjwijIU00eAk2rnnJKCt46vouX7i8ycYww4nQig0PnVjm0tUhz6/3uLDaCjXg3lddnauYWisMisgYtNZNkAS6WvVXtI3mnm6bU2lKZoXLWyO2Bzl5aTFaEUcmTAAThEspRRJFrC2lXK3KRUJQryhKx5XNAedOtFnthFYqeUVKapE3EMqdlFSOSZ4oVo242miNVmC9MKwE3LUQdJxOrC7ekFoJ5SNSlS158JrKoEmC9aVSmCoDqrVipR0xLKAsQvanObOGV4QarslLQwH25soSF7gR7Jlrs7zkk599/o4d/vRyi9hovnTpxoXgt4JASHTo4D6HVFzaGnLhRDtk5iYwyC39usxKgZnj/LHSTlidqDQYZiVF8ULa3i6wwAIvZUipyS/fORulcjmUQnUu3bFDAmAKUCKU3fk9ITZflXLyiRxtp29ytqVx7WrO9hLIyQzo0tPaHN8bfKwOtI1d4OZxV5MJbTR54dASgmxbWLb7I55Z3+byTh8nQSdx71KHtmg+fWWH0voqqPZ4X5UHAY16mGCVmkaGkQ0WsLoSWJ/tpJzrtvAlXN/N2ByUjEqH964iD6rqN1GVHGlFEmu67YiTSynLScRGL8e5IEZ1TlBKGDnfkIzVdoynzaWtIaW4iaC9XucPfTHiJMIo0EqHXg6KQDaY4DETNVJSOS7lNjTzCxqKsIEQiIhqSrkqHUlsQnm8F4w2nFpK6I8sg7ys3GzqA1QZHCZOFUBXuooFbhv+zZcu8rHPfHXquVRpHuvMrrWt8YbTJ2lVq/4X+0Oe3Nmft3Z9fyRv335WcmV7fsnU1LajguV2jNGH77g8QiduLzKXSNS4vD3i3GqbyCh2hgVZuYcMCLjCTRGKE3MsbTutGK0UWX5zDiwLvMSgNRzQk+TlAH+MVpkvhT4TNwJ/sYU815p6TjTQPXg1fveVvrnhtq4rOhenvzfRsPMqOVIHa5NBunW0bINL1ZH1BrMco/ZCFHOJRI2tRxNOPFlgcqHsGvxe9yatcC2FycbXoSlmX5O6DKXqcgsdRxfjfTbuajJhrScliKBL6xnlJVu9EVlREpvQoO10t83DS0v8289fYVSUaBmLOmtryFCGVBmgSt0nIwTVsdbcs9zmwtISMYrtYc713YzdUUFZaSIqXTXV24mMZqWTkMaGJNJoHY5X6xRCLfv4DUJw0FlXCmM0q92EvHRc743AhdKqWoDdZBOqciuR0NU6nEMoXarL6OsKJqp/pdJcREaD+LDfiq40n7361wPWCQaIIkWEIlGaVqzRJiF3nrIMGRDvw/7CdxDOxFOtHC/qQ24/9sztciQ/3vHf5d6lDvcsdZrfc+v4P78aimhNlU53ZvY+d4YFW/2CJNKcXW7hRNjozxZ994YFXoTtQcFKJ6ad3LnpZ6N/SDM+AZc7otS8oL0xFriLoKt0rta168QLfUYLvJxQTeHZGSE7PT32dF4tkUZVrOPUTK4QDSHuKbwBv6RQHqLh7HHsWsEav1gNOosou1PjXVEsR+g28+uWFLiWJso8eg6RWOD24q4mE6bSOigR8txycaPHp55Z57nNHpEo7l1Z4fxyhy89vcXGbhaE2joEybXV6UQ7BSZF0u0o4lSnxX0rHc52WoxKxeWtPhu9EXkRGtlNKAQaHQIIaWJYlbjq1xACeKVCaZFSwZ2p7iPR5BuUYphZNnsZSdTm7GqLQWHpjyxKKuel6v++6jQdTlpXjefGn2VW/C41F5Fga+mg6REx4UZbc4GqVlPQStOJDbFWFIUNgnURWpEmjjSlE4qicgaqr+FqhxoObryzwG1B4YXHh0Ne1ekcvnGFySGjZ8zYxql9hGKrn7M7KsfZMxUI8+mllPUJQrE7zCcTfwD0hiXeC91WfORzvBXsNfWYB1s4ODipQ5wYdDQ75WbLRcbiJY/GcliN/92Xln35YFFDfrxQHqKBwh6SnRi/gekJXNgXdIuRfYQi7odGd1PbabAdNUUoal1D/acRoFxSiIZ4DvE4duz9jHO2sS1NcgiZMLlHzTlvZQ+fvxfjfTbuajLhfBBcl85xZaPH555b58tXN9keZKy0YvCwvZPx1JUdSutABX1AXrrqgqsuEql6S+hAUJajmCRZQhBSE5Hb4IrUGxWU1k90mg4ReqOBUDDKLaiQ+VZ1BF/BaN10m64zAZM3Iec8vWFJGmkunGxzdrlFXo7CMX11NVUHt1UnbQjuS84HUuInMivT4VtFRWRMZHxTE6Wmtqm/C61CPwsRyEqHE49SijgOomwdaQovDLUiIwRiddCmlcZEgegtcHvwv/zWH/GpL84WWR9k831utUUa33j9mXZVOZ0W1nsZ/czu60cBIWN2aillo5/TGxYz4ysh6BZEYKl9ZwjFkXCE4VqXMs58bZGJe2mjzkbsw8uXUCyCq5vDgfauBwwhieSmOoSJGWcp4p1KSD1rbp4gFHU2Yt82KmyDgnjwIhrvRx0+867RI1y7i/E+G3c5mQiORfkw5+LGLs9u7LI9CA3iltOYVBu+/NwWg6xsypE8wqiwIVswsS+lQ3lSZDQRhkRFKB30CKV1IXDyY4KsqMuN6ketaGjkDQ1ZqIN7J0IU6XAlVs3r1EQsLwjWOXaGBZ0k4vRyQj93bPQcts5k1P0mfLB/jU1EXnpcpduoHaRC1mVMElTdrwKa/gJj19rpC0hVZV+oQDgy69DKkEaGVhxhVXC6aivNaqppR4a+Vgy0wllPbDTtNEIrKBdip9uG3iAjn2OxWljHb372WRTwXW94oHleEDb6GWeW2yQzVtez0vHZi5v7nodxCdy1nYxBMZtI1DBasdZN2RnMLnmCMP5GRWjauDxBKGrzAE1lDLDAAi8aHDSfvXwJxQLHC+Vg+ekwmHoPydTzyit8ModQCKji4HtuvDufSDS7qQjFgdsosBXZSPrj7HSjgYiYK4xe4KWHu5pMBAtTz04/4ytXt7m+O6S0jqXU0I0N/WHBte1h1ThunA2oyUSkVXBtIugItFaUwfuVNIpIY411nvXdEc76prFdbc8aMLGqXzk0Nc3pqpKm3DvKwoesBWOmoSbeXhML7yEvHJv9nE5quGe1zago6Y9sqCKS8E6RUK610jYgMCxcE9zVTetUTRImrmepMhJKhayBp+ISzfaV3qHqYaBU6KCtlcEiZN6T+ZCBMEY3AvBuGpMag0YRaU3uXNBTLG6qtwX/n9/9OM9c2pj5WlE6vvr8FruDYDn4L750kT/3qgsNqS2dsN7PWOumjQi7hhdhcIi4uHT+SH/X6AhE0gtkhUVEWKpLnpr7kkJ7mUkorPchG1c1jqwJyCy0WhWxtX5+R3YFOjUoYOAc3Tk9b3yd0VtggZl4+RGKxUrtjeOgrIRykG6BqdZhus8phvfU9/IQ4OsCfCz7DTJk39rgPtTN7A6D6MNF1KKDKLtQEI3Gp1jDJcG16aBziYf7+1FMorXlUYdUH6nC0vqT58LPVrCveWD2dk5Qh3XnPgSL8T4bdzWZUAhFbnnm6g7PXN9hkBWICCc7CRGKSxt9ssI2BdP1qv2osHjvMVGEqep4PIBWtOMIow3Wezb7Gde2h1zZHHCinVRdnX2TAairhGoJcwjgw8XkvVA6S249ubVY6zEqWKwGshGOO1lgFJIEodypn5Vc3824/9QSZ1fa5OWQovRN9kNBsLd1Us8vzfkoFTItGjWVNamP5D3ERuHU3omnKm/SGmOCGNwDJYLygiV0F7fiG/3FyDhMdf+sy8VKLxTOVdawL48b6p3Ah//w83Q7odPPpcsblDPq87PC8uyV3YZIQOjIHmji+G9RWMfWIOdEJ6U9xxb1VnFUC1WtFInRM29wSqYJhXUez9iEoH4/mn2EopWG6S0ygRjHBNOGqe2qbu8oGh2EFWHoHJ0ZhEImrqQFFpiLlwmRWODoeOSxS0TV/K08XH76NMP+dOc2ZSHZGRMJgHgA+2qNvELbUGlxFMe9m0GyG2xbD4OSQDpmlkPpkEXRJbPndz/OXuwlFK3twLaiXMbv3XMM3c+In7yOch6z3m+ej564hH3lhf1CuYVRwm3DXU0mvHPs9Aq+fHmTjf6I0jmMVnTiGFuGjIKvsxJSUXYJgVTpPEs6ZBmseEykaVe2j9uDnEtbA65u9VnfGZHlJZxaRutQ3lOPxzqs0ABK4ZVgRShKT1F6SusprOB8sII1WqFVXNnR+onwnuZikSoqL61je1DQSjNOdVNW2glb3iGVDabRilgrhrmlbpxdFS9V2REFOpQ3uZqJ1xqR6ri6PotaI6EV2oRsjSiwgKNi8h68mmxap8isQ1WkocbYaDd02fZu4cl/XPjyU5dotYLTUKQUZ1a6rPeGgTADw7zk0vU+W7uHOBdVyK1jZ5Tz9EbB81sDIGQdrvcyHjy1NPM9z2712RzmWC904ohklvZCQhbAWs9qK2YnO1iGr7UiiebfEWtCUUjoer33VhA0OmHcKQilhEC059y00UQEQiEKVPBWnimmLkUYeU9Lz5KjL/CyhXgO9bt+mcUqi5Xao+HU2R3i7tgpTmnh8tOnGewGa1hdVqLoo03f4BQaiHYh2a2eq8be8Pzst7TWgxOTcoJPFH5WBChBBxFlAmp/kL8PviIL817WCiKZmxFRHsyEM1TdUyIazRJ0EIw+NgeY67voUUl0ZWffZnp9BxMb3ANnJgwTjgeL8T4bdzWZKK3juWvbPL/RY5gHXUQ3iTFohqOCUW4bYTQytn51TsitZVhoRIcASnvNqHTsDgsubgy4sjVgZ5BTlBatFLujnLWlFJhY6a9X5AkrpoVzVSbCUZYhAxCyIVVvCwm/G6VwE+LtqfSAEKw9K6H49Z2M1GjOrbQQPFuVxWUahZXcUW7xSjXXyyQxqctalJ6sfQyD1xOCqUjrcG/UYXUXFbpgu6p3R7Oivec8awXGWMQ9PnajEUGhF6sAtw3LVbbs0kaP9Z0h24OcjSP2e6iRlY6vXt/lE8+sN8+F8r9AC+87GZonPb89QER4drPfdJ22zrNCTFKXSkl4TiR04AZYSmOcwCAvZ8ZYoafL4ZO9EhUMF+a9Dk1X7fiATEtNKLwCDhGhF97Tjs00WQ42aIee7wIvUdTzeV3Lun8DXm5sInwjxxMUvZy+ubVzO0GD9pVTDNfbmCJYtd4QnCLeFToXx0+JCeVHAKOz4d90I8yhretVmRNVA9vWmFDUQb1i7NIUjUL8NE+IrR2YI1g2eqNCidG8KlMZk4dD+1gI6O0hyVPrB25mLm+GTPJEw1K1sgTt1gHvOhyL8T4bdzWZ6PVzvnplm61B1jSuOtlJUF7YHuRVp+YKapwqMxpKa7nWsyijGeYlw8yyOyzY6gUHmtI6vITAyGhNPys5s5xitEaqbIeTkKkonSMvw8M6GfeR2JOaExFK64OlqnXjc6tj9YlfBME7zyizXNke8YqzK5xdbpGVtmpLDXlpKSuHWBNVDeJETR4yEAloiEH9XKQ1aRV0hQyExxHKvWpRuZIQUEqtAWGCoNTaEJlIb044QxmlQnDnXzrM+8WIlU7K5fUe65vDQ7UOs7DRz9ncI5K2Xvjq9d1wUzGhBOgr13ebMsEaoyojslLpaqz1DYmYxGorRiR0Z987eUZG04rv7DSkq890mBt5Eml0NB00auXxlrmakZfQQtMC89B4cDf/m35tQTYXOCLWzu9QXm5hn2zfVGQZjWQfAVEOus8T5rgoEIvOZbUvkA9ahkAoRIe+EXF//0nEQwENLtlPKJQT9AGaiNuFo0yzYi36qxennzu3BhfOQGc2oVCLsuybxl1NJp6/vsNz67sMiwIvnkgr1jop5cixO8wbt6WAKshWsJRG5EXJ9WHBMLds9XNGuaW0HmcrcamMg28vnkEefPHDIr+nsJ5hRSBK5wNxmQjYA5kYH7NGYT2t2DDKy0p3IE16Y2rdVQEEjUZvVPD85pDzJ1LWOim59WyPCqwbl1xhK0KhJu9loXu31qrJImitSWNDKzZ0WxGF9wxKR+nDNrraruZCtbxj8tR0FTxCWN3w1edQSqGVRqtqdVst+kzcbvSHBaPMkkQapaLGbrWc6AptFFzbHXF2pY3eMws/ud7jyfX93a8h/Mm/eGX7QJXAqBJPL7cSvJ0fnteao7IeXM25qbow70if906im+63rNVGo/E4uyATL2tMEYqXNxZlHzePfCel6FfzzEQBwWTgr3wof7JL+/lGuhUeMyGw/DT4eP53aoqg0/SGmUSiRtwXZIl9naOVZ1ye8SKDFPtZjrq6CVEE956b+R51wD2sxmK8z8ZdTSa+9Pw6m/0RI2sRhHYc0U0iNoeWvHCNSLhe8VcaIqVZaUdc3h7x3GaoN/eVO00TmDdlO0FP4L2Ql5ZhbsmcZXtYMMzKJpgP5UrVEr2q3jdhy1pDEYK8tW6L3WER7FyrTaYDqjrgqkiAEzb7OZERVjsJxmgGpcU6FdxppBKfWsFEQX1du9Z4QgWTMhoNpHHESjvBimfoXEUwFLFSWC+N/a2ushy14LQmFa04WMS2E4PzQlmG8q46MxTpcJxShMJ5RBbdKG8nnry0xaX1UDAbG82JToLzws6wwFbkt2XgI09c4ttefS+mqodbSiNy60Om6xaRlQ7nc1aSg/tFnGin1ZiYvvMcpQz9TsPsZV0LLLAXiyzEAreI9c+fZuep1fETk9NOtaKni0AKdh+hsYN1SdAW6FufvtElR8ouxIPgILU3/j2K69OdRl09ssCdw11NJp66tk0/L7A+lDOttBMSE+xcw3MVKZDxNbrcTlDApa0Bwyy4OtWOR/W20zQ7/OycZ6OfkXvPbr9ohN1j9UC17bjSp86FoJCqZwXEkWGlExp6Weea5mLzVmZVc3zHtd0MrRTnVto4hHXvySpLWGkIBehImgyFCKAVrciQRBqvNX1rg3WrEkRCY7o6g1GXSjnvA9FQqslSxMZw72qX8yst2mnE7qhkd1gyyEuGRUlmQ5lX7sNyhdH62MVPC4xRlA7n9k+aRitOdFM2+hntCfnA731pnPL9pkfO8ZVruzxbCa/vBArn5vcKOiQ7cZweSkpVttJKZp6PVoqVdrL/hQUWWGAfFiu1NweXRXg7+/4oqnY6Gj+38uT45/790NoMzk93Cj4+IPN6WHbiGP+sqrAw4dK5DyJIdlQV+41jMd5n464mE9d3B+Si8ZXX/LmVNtYKu8NioqZ5XOYUac2pTsz2sGSY7yUSE4HFBCGon/MeeqOCk0stdiSfGYSoPTW0tVWsMZo0jlhtxZxZanFyqcVmLyPLyz2lWOMdNfoENaYkSsIqsBfhdDdFRNjo5Yxyh6r0HYFQ+MrRRhEZTTs1QR8RXqJwwXWqzr8YdMgoaAllS6rqvyEhs2G9B9Gc6qTcu9KhlZoqMyJ0EkOiA/moXXuM0k2Gxi5WCG4bPvPEFa5vzyYDCugcYBn4sSevUthxluBmOzeHLumKWGuM1k1PlxuCzM9O1KP0SNbo6vB7lgLarZg0jchLRy8bL8nV+1/tLIjEAgscFYvg6ubw3B/dS//ibNc8ZJpI7MXSc6C8GtdDHTQ5TsQz+16q9ZB1Fce86fuAP4sowNTmFLPf56OD+00cFcp64i9eJHr6OmI0KpoIYat7mB/dmAnJjWIx3mfjriYTw9IhVcAUR4YT7RbrW8NgCbsnQNdKcWIpZaUV8/i13VCiNJlTkD3XQZOhUE3QnZWO1ARhsfd1JdKei1lVgb9WRMbQSSJOdBNOdVuspnHoOqw1p5ZabPYzSufG4nA1NlatG8YZrUkiRWwMVhy93PL01pB7TnQ4tdQCFBtkjPKx8Nv7oGVIWxFRorEaRBzeBRcCMdLYaarqs1svQS9RfRm+0kIYE/QRsTIkRvHkVo9BaSmdoDW0jGEpMsEMSil8ZbUbek68KEsp71oca1WFwCC3ZIUljcM4BSbIKyQTWaXM789jKwWPnFzhsbWQph+Wls9f3wyZrD0nms0QZu89H+8EvafR3SSJiLXByuyGeVor2hNdtO2MjA1At5sQV+5TaWxI4zYQBNUb/du3mrXAAgu8vCFeIZOGJLcSSCoou+BjTZTJ2EZ1YmqMGrtVoViesVKjoFiB4kRlmlJA9/lqcWnPFOsSdShfwbCvudyk9WzZUUSj+aVZtfjZR8zexgvJp57CXAoiEXEecYGhKAUqTRdlhy8g7moy4cSj0CgF3STCuiBWzgo71elWoYgjzenlFlujkmFeVlmJWt8wsVMZ/7CX0DsfCEUnjdmt2USd3lNUwX/wzF9qJZxst1htJ7RTQ6QNkQZtQvfqlVZCEkdkpa/Y6XiFWOvQxCuJNCiF9Z6hdbhKf2BHgjGae060ONlJQRSbZAzzsmqqFwKzonRYEwhGrPQEZ1FEWmGiQFY0CiWqyWw4L3hccKuyQURRIIx6tip7klrSQaF947BZ28nWjk91c7EFjgdfvr5JMqFLGOQ3L2/fGOQUVYBfO5FFRrPcSlBqmkgAtHQIwHM/diF77emTPLi63GzTiSPees9ZnAifuHTtps7LO0EZxWwj2aB5QoVr34lgIt00p5varjIImCQVy0sJ0Zx+Flopziy3F5m0BRa4QSxWao+Gf/fxV6NbYxehzvbNB2C2E+xWAWxLYVsKbYVkN9iv1o3gaiS9MK+VXd3YxmYnoVwef98uUew+olAeVp668XlQAKKQoZjZvwKw7Yq45BIyFRIE4HtRv78hFSK0PvY4eqO/b9vq5VDadAfm78V4n427mkzUlRkKuLDcJreOobVTbqQKiCPN2dUO957o8MTlHabcv6pAfi+f2PsnrldbNwc5p5fbDOrAvbJIjYymnUSstlJW2wndJCYxUWgEp8cWrb4SIKSx4UQnISscuZXQdVorYhO29wIj56sO0gKiQ125CgHX9iDH4zmz3GZtKSUyius9GGTBdQoBV4QLS7UUZWO7EBpmJkqTak2sDbHRlcYifA/OQ1YqXGGr4k1BS+im7atHnR7VqrLPVQqtFE5V9rLV0V6MLj0vFZy7sMz69T693gH58Bm4vpvNXLm3ztPLCk535/twp9pQiOfN509xrtuZuY1Rim+o3DI+fvHq4VmJPZhHJKaPoYljhTmkV0RNKrrdBH0EUXWk9YJQLLDAArcdw/PQvg7xbDO9uSiXmOqdUMNHimIFOtfmz1/xwFN2FMPzCjunGZ1o2HlFmDdXv+px6cFZian3AnKEqNKlIa6Y2ZhuAjWp6Hz48+hDm7GqoNFczN8vCO5qMnGq22boBIdwz2qXrWHByLnAvCsFslKKdhLx8Nll1pZbdLcGGKPwrl5hnxjMjX5CIY0fahUWS5CIZqVvsg+FCyVAy2nMiVYgEGkcERkdSIQKQXq9K1+t3NfZjLWlFv3MEttgo+oqByRXyER/7PoUpi86EaE3LPCiuGe1w2o7oc5uDLJaiwHeekyuUWkQnGqliXWocU+1wSiNFlUJsMMeyuqzGq2rchVFK4qITSBOpfcU1mElrIKoalutwE5Y8AL4eV1qFjgeRAqVTN8URAQ/clP9G47DtalGrEI26yj4hnvP8dFnLu/XBe2BR8h9IMsRL6xo/zAt4QILLDCGiEKOaYX1uPZzt0A59nePVuAN2Pb4qegYZQDxUND2aN/zzis03Yt7a8D3Q0xobIfM6Vx9qzjyLm//+FmM99m4q8mE9557V5ewCEtJzKXtIblzoIOYU7wiMoqVTsJqN+Xzz28zKhyx0WGlXmqvpYmLZd/fVjX/1tmJfmY50U3RKJbTmE4UEZuQWdBao41GEQL0ul9E/d7Jsp9OErHSSVjvO0aFxdWvV+VXjaC70iOIoukTEPQRwmBUsBlrVlsJrdhweilFoRhkJQ4fmrVWA1Y8eC24qptw4YREh6wIEvQOriIhsdaYSFN6h9ZgCJkRkVDuZSVkT2rNhaJyhJrMTFTZigVeIEx89zWxeG6jf8sr78f5F7UilBPXhAhNY8cXAq5KW87KTAIsJREtM1/ZXhbHR9oWWOBugEcdW0fg49rPSw01sZBodifqFwoSVVmGGiqUMt0WQnH42RyalRi+9SGKV52b7QIFuMLAJw8+ymK8z8ZdTSa2RzlWG950/2naiaF0oc5fGxWEnF5opRFnVlps9DKevraLUbDcislyh1SOQ0pCNU/DEqvoeNafWRB2s5JHV9q0TBRckJRqrFW1Hq/Z1o3cIPSDEB+C9UpfjdGhRn1rVOCxTQkUNZGoRNj1+TSCZpGQOfHgEIa5o7QZqdEspxFnl9tsGc3uKLhaGaNwqGa914lQiOCsYJUhMVW3X0KvCesFoxWRrmr6RCi9B+XRKJyTijyMvyMBRKkg4FYceeV6gTuEavK8Z63L5a0B5RGa88zDoydXSLWmdI74gMAaIPE533zPCQT4d1d2yKryqrImrrPe9AKlBdz4AtwHBSwnMWlkDhzZC/L80sZT7/vaZtK776c/R7z1ArT/XeBlC+UEMXOCkyNieEYjSqHLYPd6EFae9OiqStW2xkTGJ6GsavZJ3vy53TwOJxKDt7+C8qFTiJm/UDWrfGyBo+GubgLgKwekCytterllWIZuvMqAihTGaJbSmFNLKZe3hmSFY1iEbsFJ1S260UtMCK/nVfqrKoNRWscgLysioRtbzUbAXOsKqt+DM1IQNouvXwskZrWdsNQKpVEV76D5QSpzgvGv4zSAhBIt74WiCALaflayMyqJI8351Tb3rXU50UloxRGx1oFgVftxBNelUhyFd5Te41UgMdZ7hoVlVIa+EaXzWOcpnSd3Hiu+6XztgbJy2DFaTRH+SGvSQ4LNBW4eG1sDhqMbC2Z6o6JZfd8HFQLq9UHGxmB2feqja6uspKFXS146CjtbD6GA2AeFXWIUqVG85dwKSaTJKvH0HeMMVhj1igM7dAccfEZKLRRAL1eIVjz7o2/ErSa4lfC49J7Xkl9oH/7mlzhqQepxPV4u6FwNna1vBNFotmAZaCqyR6c02drs0G54VuMaEfQBzeoElp/2QQBdrbGYXPAJuLYKRKKOV243lGL09kfxJ2dr9I4KSSNkjgHHjWAx3mfjrs5MRDo4sJxoxXxqvUcvK5tsgI4UqTGsdhKsFzb7WaNZKK2nm8ZYV1BKrYeor4ua9Yfyp8k/dX0Jey9sDQvOdNuh/KgSJ0+0hQg/16ayvipx8pVGQ6nK5lMqB52Y3qjAOl81sZsxWciETLwmGQgKobQOrQ2iYGdU4AVOdBLSyLDWbVF6h9eKUjyFF0okNKUj6E1EQjkUSgIBiDXaBSG2s64SZdfnLuPPV5VxORFcJcJWKmRAIhOyNbewAL7AIbDOB7H9EbEzyCmdJ62sUQvrcOOuiUAYY7ba5+YwZ62TAvDY2ipaKbpx1JTaiUhDJpJqklYIkZTVz9N//E5UC/2P8NmaXim3CBsuFu+E0aAMTlWtiCiZvKkIN/A1LvAygl2OuPKfPhac685PBzPlmRZyiAHAAgvMgy65oc7RUQbKh07UKMG2JrIDUjvMKyQK83B2UtPaCnPw8FwYpy6dKJOSce8HX7XWUQ66l8J79vaFqD1c5AhD3rUUJjuGSbVeqF1qkX3dw6jSEX/lKtHzWxMbHZ6VWOD24y4nE5pHTi0zLCzrgxGZDboDFMSxYSWOWe0kXN/NGBUuuBV5oZeVnGgnDCONrYPkORh35h3rKkQJw7ykn5cst/Q4vVOTkuqiC+JjBfigV6iOpdS4rEo8rLYSdtKcYWGbjEbDbiaay4WPNnG2dcrRSUOirPNsDwqy0pFEmjjSRFoRK0WiDUuRRmlCtkF5nA916w4oveDEhUZkJjhLeTSx0eSFUPixMLwmEkopnITvJI00uVdNsz7U2MVqgVuH8tJ4cQOcXGqBCKP88Dr93WFO4cKdy1R/kyQyFPi5jeYK59geBaeopSTGzPhTigQyC5BGmkhKlMyf2F97ssvnNwfsHKItOArhKMuQLWu15kxjTqZ25KsSq3xkKQtHFGnilsFXxH6BBSZRrqVc/48eJnvFytxtNv7iA5z+rWdJn79zneRfbFgIUo8G5ZlqCpefJAiWh4e/N8rHxKP+N8rAJTJFKGoICpdAfqKyyE7n1m2PBeBKaF87WOwdDyT0t5hX4lTv9giEQ7SqekrMy5RPH8OvBjIvscHev4a53iP+ytU7TiQW43027moycaKdcH65xTObPbZHRSjVIdQtd5OI090Uo+Dazgjnqm6/ImSFg3ZodDX/TzkhxFSMiQRhBcA6z/Yop5PEqKZ1b72harYVCUsG3k8ELJP7E2hFhm4aszMqcZPN9GS8r5pMNGenKmF1VbbknTTajaJ0WOfRGqKospzVgRQkcUQ7MUQq2HzWDbysCLn3ZNbhmoZ8Ifujq/4YWoWDJVqznMTBvUlCcNqJIlQMhQiFeATBqOAYtcDxQIlMpbhbseHEUgvIGc3rOSFCPyvJZ5QjGV25iB1wzKx53+RYnIavMhRKPLE5eGI/3YppRZqdI1RnDbLxZ+qkUVNOWFYZmbpUqhFNK+jUjetc5RAw63ydDw0cXXi/SQ6/8z203GU1idkpLQO7EFm/HODbhuFrThy4zejRVexKTHpnTulFiYXv/hGxR5JlW8DJ8PNBhMIU7GsGB+E5ZQhe73Nga3H0AV+r8jQ9H+LBwYsqugCOWNnnWuODmny8GKv82JzSR0yRBl3WG80/Yb/aCY+VDogQP3Hl0HPZ/aZ7GL2yi1FgbrE36WK8z8ZdnaN96NQSWel4ZmvQrOpDcCI62U5YSWK2BwW7o7J5rQ4+RqUjmmzMtZ/cT7804cwEIU7ZzUoK65vyKamyCkLVj6HSS7jq3+Zi2rN/jaKbxLSTCDXrL9JkK2TcBbkuh6r+tT6ch9ZVPwgfdA556Rhmlt1hwVY/Z6OXcW13xEYvZ7tf0B+W2NITCbSVoqMMXa1BBOt8KF0SiE1o/BdFmlZsONVKONtKuXepzb1LHc51W1xY6nBhucPJVspSHLMWJ1zoLGqKbyfaScSJpZTYaAbDksGwZDi0jIrgEBa0L7c/+FUIhuNaIRJy68jK8aP+PLkNOo3CuVCq5z15bquHY5RZRpmdSyQm4Z3HFofXGdy/1OHBpQ7n2ynn2ilL8V29BrPAEVCeStn9xrMv9GkscER84AMf4OGHH6bVavGWt7yFP/iDPzjS+/7oj/6IKIp405vedHtPcA5sO2Qoyi6IqR6aRo9gyhnWsbcB2kK6e3z7Ew0umXik4QEhs6JcXcER9Bd7H0eBX25h7zl56Ha9t56n97YLZPe2yE+AW4QktwV39V3x4VOrPL09ZGeYY6vOvFopltKI1TQmLzxXtkeUpZvOCiAMc8tKO0ZrhTsknqgTBBMJBUCqQMcGG9VJjYWve1h46iYTtfpiolyxIQbeQzs2dJOI3ZFuulhPHKr5R03+VJUXIaoSefumMVfz9ppEieB9sITNy7AfrRWR0aSRoZUYEhPKouJIoxGcCt+n0pCqiGUTY5UnRROjMKLomIh2EhEZBcZwPklo9YcYYDmKiA8oeVngeOCckGeOwWD/cr8/IAUcyu5g78i+GRgFLXP4PgpRLKcJUrHmkXX0prIqodfK3kzKqCqLCj1cZu9bRBiNSkDRXkqOdN7eCzb3ROnsnV7otHnlSrfpCH4ijpo1hf4iQ/GSRXmmxc6fOn/odt3PbhJt3VjTyJcaXuiyj1//9V/nh37oh/jABz7A29/+dn7xF3+Rd73rXXzhC1/ggQcemPu+nZ0d/tpf+2u84x3v4OrVq7dy2rcEMcFVSWZlaw+YUutSIlW7O94ClBWiQ7ISAMUK2CXwUXXnsGqftkL0/jInl9Sib9nbMmsKPg7baXe0+5G0E+y9J4kubs18ffDG0+z82ftx3ZCxDo36hFRuPkPxQo/3FyvuajJhRLHTzxsbUq0UqdGcSBPEwpXNIbuDAud9RQjq7ISidJ4k0qHjrar0FHtyBmoy8h//02zlvKdflLTjqOrVMC6DmqyP2hPeN+JpL9VEIJAaUwXlmtLu6X0xdVwZi5Imfq37P4TzVkgdRFavqTqzMXEqTgTvPGXpGeYWYxSt2JAmBqcFpX6C48EAAQAASURBVAmfC0iN5ky3DUaDtRS5RROyFt6FhmMOQ9xu0c4L7l1q0U0idobH2G1ngZnY3Bmxvj07T661xs1gy94Hly4RQas63Tp7AtdKsT7M0Uqx1koazQUE37Pa1COI8A++CQw8nOm2OdMNv29nBVfUCCvCbl5gndxwx+xbgXdCNihpqbFHYlSVPZ1upbz25DLRnhv1akUoLo2E4Rw3qwXuUigFWmNGQvvpAaOHugdufvLDF0kvL+a4FxI/9VM/xbvf/W6+//u/H4Cf+Zmf4V/+y3/JL/zCL/CTP/mTc9/3Az/wA3zv934vxhj+2T/7Z3fobPcjGlai6hlw6ZzMhKbpNK0cYOYTCu0FKcNroaxo4kVhXHIUH54FGZ1V2AkfApMLDFQj5pYjCrSPC36lTfE1D05loqPL2+FcHz3B5nc8gk+nw1zbUaCEdDM4Wi1wPLirycSfPLPBoHS00WRKIwrWWikJms3dnGs7Q0rnmuCdiX+cD0F8EmmKUuH9PH2SQqlKhr2nbFwE+nnJyXYaAg4Jq/h144q687WoCSIgY3oxdmUKAVkaGdqxIcvLuSsS8yrXRQTvwp6ajvITfKTxqxKZsQ4tOCc4B2XpGGQapYQoMrQTQ9rSOOWDfa2JKQqLNqGUbKm6UAc22H0mGkwaSrbSNGLQWwRbLzSaxowVvITV/zpbp1Sod5xVGaSVIjGGP7m6CcAbz60FjU9lN2yUwlRZstwKrcij5xAK24z3MU60Ek60Eoal5csbu1zNjicws16IjiD+FwnlTsOd8V2le7IFwJtPnWDeLlbiCK3aPD8cTX1v+gjZmQVehKis+FQUoaKI9nXLuX/6PJf/ygPk98yui0gvDtD5IvMqx1hDfqMrtUVR8MlPfpIf/dEfnXr+ne98Jx/72Mfmvu+Xf/mX+epXv8qv/dqv8RM/8RM3da53CmL2uD7pQArqr6oRdc8gFMoLOgedh3nJdkG0akqplK/2rRRlF5K+zNRnQCgP2pdxSMGlEpypdtStJrgbiJ4Wqx8E303J/tSrqjdC+19/HoDr//Gr5/aUsG2FnBJaG0xlSo5yyBdyvL+YcVeTic88dR0Vx6y0I6JY0WlFnExihsOSazsjsmKCSExlDQKRGBWONNIMVUUYJi8EVWcVZKKZHVV10TiHkVlH4TyJrlydJLx37xAZOzSNQ3kNU1qNkJ2I2dF51eF66rBjYiAE0lK/3pQyhd+N1tj6smj0FeMzkmrjcd5kTDBC6VUINMtSyDKLGSrS2NEflkTa4LyriEbEA6ttumnM9qign1liHDY25M7jCstosXJ7bLBOZqZ/5RB9gDbj7IQIFHZMJGoEQqGmOrQDJHv6hNSk4uvOn+Z8dzrI8qIYWUMncuy9q3hgx+01ix2jE0c8dmqFq/3jIBPC7rBgbelgWaz3Y4enSQy2Qv5bHpxH3QO6keHRlSWyie8/myeEX+BFDZUkqD1jPVnPufcfPc1zP/AKypPTZXPxZsaF//fjRNuLpnX1feO49gWwuztdwJ+mKWm6/3peX1/HOce5c+emnj937hxXrswW5j7xxBP86I/+KH/wB39AFN25EGivm1ODQ747257OXLi92QXG+5U9Tej2rrxHg3BA1yI0v5s8DaPIlyHdlX2WtT6B3YfU3CZ3Pob8pJBuHk9w7BJFdBRr2b0DT8HoHa8LPx+ymORaiuGFaXG7y4+wADXjsDeLl9LS011NJvKyxIhmx3vOrKSca7UoS8/1Xs4gK6qAaZIkjMt8FDDMLWtLKcaM+yFMFCOF/09kNZrQol7xV8HVKbeOtjHBHWqSSEywgHHZkuzbRkTAhyxJJzEYo7HWV4kEYeoMZjGLOu9RbWsqlyovEhyfQl6luQjUNDdqsifjF2W8ag04KwxdSV5atK4E2HFEKza0kph2GlFK6JK93S+53stCI75EsZMtgqvjwua1IfEM8e9wcPh3XJcmDXN7oA3qrU6SIjC0mnjP8lYPfWzy7Bs5l5lQgYD5I9blztw3oawrX1jKvqQR9Uvu+1+e5On/8jVTz9/zC1/CHMWSbIGbwv333z/1+4//+I/z3ve+d+72as+KfG2VvhfOOb73e7+X973vfTz22GPHcq5HRTRQGLv/nELjuIPnEXcECZhocK09xzyC7ez0ySiKZWivT8/W26/SoUTqDuKA6bva4NbmXuVnu2QtcHO4q8kEooiMohUZTrRTRODa7ojtflaVMclE4LT/Ii5sECwbrVEq2JmqpjRoUu9QJxXGZUqqIgYiwqi0LCcxMWoitg81HeHXow36SGlaSUQSa4oSgnZ5InMwrlmqRRA0hlyqzn7UnajVxPHH6vGah+wpm9xPgKagUKJJjWatm7K2lPDKCyd45MIqrTji+k7GU+s9rvVzxIJG0G0hs55y0Q3stiOQ0+lSpilMiOA7acQwt/syEMd3LrKPSAAs4+8woVBz+29ESjVGBQfBecHMaq7Bgki8XGBX4n1EAuDZ/+bNPPCTf0y8uSi69o1y6nj2BfDcc8+xsjLu7zErKwFw+vRpjDH7shDXrl3bl60A6PV6fOITn+BTn/oU/8V/8V+EY/qQqY2iiH/1r/4V3/qt33osn+XIqEVnc6aTI7k5HVO1jHKyj0gArH3es/k63Tgy3QnIvOjUMdVvaS48c21zb4VI3I7x/lLAXU0mziy3uf/sCmvdFCvC0xt91nczitLt6Qy8r+goWJJVV29wiAkN5MYL/3UWQDWlQmPtw5hwiEBWBptKqeulZfza5OFnnMVUykwTbG2TyEwM1jonUROCOgsRdthUTU1kULQKTk2u0k1MZjgmS7DG/8r0E1R6j+rfVmI41Wmx3I7InOdyL2NpOeNcuYT1cH03Y2Mnx3lPHBsKa1kfeog1ozsopn254kQnRSvF5mBGidAMN61OGjEq3FSzOi/cUDftFwrOeWC+o1ON1gHds60IxjMlJJ+F3/qTZ/n33/gA6Zy62wVe5njpxAEvOqysrEyRiXlIkoS3vOUtfPjDH+a7v/u7m+c//OEP853f+Z0z9/vZz3526rkPfOAD/Ot//a/5J//kn/Dwww/f+snfIFwLUIpouH/+PaotrI9qp6I9OICkHDuOcByXqqDjOCSQn9vIDhBDiGMOySyvfdGz9RqNn7MgtMDx4q4mE2979AxOG67uZDy93mNnWFBa2/R8mJ8nG9f5ZKWrmncp3IRcebKMqMlUTGYdJtb4S+exoSsdqJpESBWkN9LrsACxR08hta1bSGRglCKNTHWOfnwcmT7mVPnUxLp07eqkmhbU1bkoNck3xl/Fnp/q343WdP7/7P152GxZWd+Nf9Zae6jpGc98uk+P0DRNN9jQyhgGZZBXcQ7EXCExYoIB+UnQX15JrpiOVyLR1ygJDpdelz8IeglcJkE04VUbDSJhiLTMU9Nzn6nP8Iw17WGt9ftj7b1rV9WuZz7Dc7q+UH3OqdrDqqq1d93fdX+/9x14HGwGNGsenchwcrVHL3Gf0sW1PqcudpgJfZIkRWCIogStUzwp6EeGwBPMBBNEllPsGZ5c7XJuvYcnBfXALcVYC50ooRVWL83UA0U/cTK9jdBLUup71FdhBkMbWdkkL9KGJ3sRTzs4x4MXVsdeLysWHAmalF0QGxKJvUBiXXPGKZ7aePznnst1//lL1J546na/Bq54qcx3vOMdvPGNb+See+7hhS98Ib/zO7/D448/zk/+5E8C8M53vpNTp07x/ve/Hykld95559D+hw8fplarjT1/uSCzpnTGExsG0TtBtCAIl/bmmItfNSw/Q5JWFDjzujD7sMVKS+/Q+P3X6w1iKh0AYjJR2uvPYBR5n4ud4krP96sV+5pMrPVSHji/wlI7IknTQtpUqaUT+X/yZXwXfqfWEmRdolOTS4XI/1MRgA9TfXcM4xrTASrPBIwkwpzUKDumGFAMUeobaC14UlL3vKwzcVUuY/yvAxqQNcvLSMmIinREuDU4TC6TQbjMSKvmsdAMaPgea3HimgJGBpPtLQQst/ucX+kR1Q06NXhCEnoSJS3CWGZaAdoTRJf4xvBUx8mlNktdJ7VIjWW9n1KeHOuRZmYCoaj5ighBlI5m8i4f1uOUi/2BVERKwW2H5wF44NzKxEaoOmsGKYWYKEXaCNparGHTik+fP7mEGhnEodk6h2annY+mmAJc4QVxBTsCv+ENb+DixYv8wi/8AmfOnOHOO+/kox/9KDfeeCMAZ86c4fHHH9+T8e01VDSQ21jp+iwUXaDZWrlWHQ53m76cCJegeWYwXmGg8aTze3YPyyESUYb23UPqnZVntVn1ms2yE/Uncb24SkgbgnQXt+8rPd+vVuxrMvG5h88RGUGalbkccIiR3F7l9+Ve70eaRitwq5y2EDgNIe/jQPZquUSsEK7jdGI0OqvZLwZbDqREwlXLcf+vTkdaXHBT81VRkWmYtmyeWbfGdeMuJByZVCtXSImR7IZAIIUk8CQzNY/5uk/gK9ajlMeWu3STBGMN1koGTfgEnSjFCsvB2RBjIQwk9Uix3O0DgvW+Jqi5ik9T7A2+eXYN5TlicPPBFmdXu6z3R02g4zfXdqQnZihyI42QYtOqUJthkl+ijBaGDoIn+zHtJGUrCcSNYKxFWsFsbZABSzbJtmwVJxZbSLFVx9MU1xqio3We+CdP23Cb02+5k6Pv+yaNb65cnkFNUYm3vOUtvOUtb6l87X3ve9+G+957770bmrv3CvGCQdbcvclfk/idren2NyQUFry+8zqkzd0FpjK11DbJYiw8YFi9VeK3IVyxJYl1xbgmEIkyjAIC8DubxWvbR39Rcg3F6lc99nWk1+3HoPzCaD2wBYzO4LJECHI/g8A6nb+UyLwRXB7dVGoNB+YHIShKjxkLsXZZAVFsMjDpFCv/mdxIiIHkqThW8ZB4yjXTKwi7zc89fmUWnomiIZ+jHVLKEuEZjH5AKJxmvOYr5moBrZqHFdCOUtbbfaJEo82AWo1KvRKtiRKN7ylqvkKnmkQ7SYw1glhaQk9yoLa1TsRTbA7LoKDAoxfbpFpvKdCdtE0/0UXgLTJCAcPeCSkFUVXTu2wcBjCl601bRW1CDnlNOAP2+W5EN033rLweMPQD5Cu5a0JxYqFV3BNGcWG9hzaWo/ONyten2L+wSYJNXeTmPdrjuvd8mZP//DmV217/7i/hrUTI/lPbFzZJDLDTYz0VkMwYVFRd3WmrKGqwACoBuWqxEpKZkng5Hf53AVvaPzuGkdCfF9SWq7+E5dslJoDGadePYtNqGlv9LqsEGLskARsRCa/nqlwmO7x9T+d7NfY1mdDGIlWJAGQY/n4GaQXnGxim0nngJIUorYTaIdtEfpicDBTnKJGX1BgXYInBIfJzCmEZ4guZxyGXDOWSK+kpAl9Rt5rAV3Qjhi7Y0aZ5ZSe1yFlFJrGSQxV+inQJEkmgJK1QMVPzssALlnoJ3Tgh0WYgFyufJy+zK9xRjYV2L6EXpYRS0okSzq71XZYGS2IsjVqdVjAlE5cC5T4kW0En1jR9VcyDXqJdRq+8UT5HtlLpCEta0ZzOIOiXCMWqkEOvgSMie3UT9ZWkOdLhFLFVQmEn/h5u9BkYyyWrhjXFlYGNI3dHLn2vwlqCs12u/7UvZoTCcsN/+AL5zd1bjrdWVWaKKUaxzWDZ+DjTch5XjGYEMnIgLARr7oUky1RUBdXSUEEGBNaz9BcktWX34tKzBvfv3OsgbNW+O4NMswzGKLZAKKykuuu3qH7PQ8eeXrZ7jn1NJsr+iIHCqSorMfp3UVgohBQIKfA9V9FJ6FzWMEJJ8qpOQy/l5EEQG01q83DJpRtygpJnJgrykKcIyNvfWYywNAJJo+bR15KaJ7PMRc5q7NjF5U5dEk2VJFZSDghGngUJlWKu5tOqeYCll2pW+ylRaki0HiIRtigXlb9hMTindeTLz5qhdfoxa92Ii+t9Em1clsYY5us+an6aZ7waYCz8nduO4mX+gv/94DkutPvVG48Q4ipsdC/WCNYyElFV+m6hHiL6Md1k90W+hZgQ+AvwlCCdoKmVBQHfGdZ7MWeFmGYnrhWUV4dKEAaCs12u+8+uApB/ccI18xTG1JB6edA/OJBchssWVdXmxJJ1tGZHAbNFYH3L8jPc/buqFGz3KDSEwF/bfUQuLJM7XW8lQ7HD6aJiC2Jn2YnpfK/GviYTgzLCFR2sgcofh/zPLLK3OOOq7zmfQlK0kixdjcVOrhv2WFbOWpLUrejn8bcQg4BFZIojYR05yKVIFudx0BhSa0n7MatxQqcfIVXeAK+ie0CR4iilM/NzlbIVSgmsldR8j5maoqYUVgjaUUo/SYm0IdUGYxnxnAxfx8U7zmRZga84OFtjoRnQj1MurHY5ebHD8nqfJHXHk1LQjZwpfoorj++6/RgHW7Vifjz/lkPc/+gFzq7tRcfpcYwXDxjAyQo3P0Yj8OjGkwlHoOSGlaaKbN0I5Oi1sgOkxnJ+vcvp1fWh55M9IEhTXF0QBmpPtK/0MC459EKT+FnXF/9O0wg+vfl+0+Dq0iOeF0ON66IFQbhid2Re3hSCyopNOXSYeR02gd+xRXakCjIFFV2h+MBA7VzM4qPDndbTNOLBTXadzvdq7GsyAQxMA0XWYCSAsJRW70WRGcizBkqKopqT5wlEkq/tl6sfZeG/FVnjOlG0n8jPoY0l0U7q5CvpMhO4rEcRtNiBA0FbQ2wMPW3omtQ1d8s9FDgjt5KCtHgTksIsmxGJ3BuSV2ISwh1DSkHgKebqkkAJPCXR1tBJUiJtiVOnlbeYwWQuVuYmTO7sfFIKZho+h2ZCjLY8fn6dC2t9lrsR/TjF2Ex7LyVxatAVfQ6muDSo+Yr5RoA2hvPrbgVVAC+69TDXLwwvwRxq1WhcQXN8H0OMIWC4jKDFFqZyTwnqvprYq0TKzSs5KSnGOn5vhUhcaPc42Kox6XqI0pS1KCJKh8eWpk9t/fwU+xP64AzxHdehj8wNnkumWZjLCuGCdCuEWznPEM+KsQ7YJsD1W7hCkKlF6mpSka/HSg10LUlV/4tsu62UaFXxsObceGLT9+71Ia1Nfj1Yjmk9tE54YXiOp2bahHKn2P9kAsZcLEN0IlfqlDIEKgu2mzWfRugx3wppRzGqK7Nmb9nedrAvmQOhOMGAY2CF07AnmW9iWNokAFP0ntDGEBlDN03p6pSeNkRWZ+d00qFmoPA9hedJomSwxpvxomHjdk6TBEgp8ZWkVfOZrwfEiZMv9dOUXmKcqTqThtnc32E3IBCDoyOlC+xm6j7Nmkc/0iytRax2EjpRQlKYdAfH6ieaJJ2Sib2CEhJV6tYmhOsXEWRN1VxFLt+VPbVunpxYqPO0wzNXasiVuBBHrOiEBEOCRSEIrKCbJGChlw5W931PusvMQqx1can7ys31zSClYCfJsfUo4UCzVkk6ojRlPYrHiMQUU+xH6MOzxLcdGyIS28G0VObWYCVZSVOHZCbzayZ55r+8jXvOBFlTu6sItQuWYN0iE0cIrBAYb6AwLyvNVZyt7wqX0ci/XpkyVAJ3Iuz4dlaC3WwRKbakE8rlhksRzUfaY0Riq5jO92psu7vTJz7xCV73utdx/PhxhBD80R/90dDrP/ZjP5at/A0eL3jBC4a2iaKIt73tbRw8eJBms8n3fd/3cfLkyR2/CYEYYq7uufwVUeiqlZLUAo/D8w2eeWKRe249xC1HZ1FKDCRKJZJQHEiMH3nUimFxwU5iByZt95Kr8pQYQydNWI5jzkV9zvX7LEUx7SQh1hptDRZLoAQL9YD5RkDNVxlxyMlDiURkREIIgSclNU8xU/NZaAQ0Ao9EG3pJykovZqkb042SihK6o+9t+On8+wt9yUIz4NBsjVbNJ4o1Z5Y6nFnustqNSFIX5FmBm1HZ++9FKevRFlt4TrEplBRDD18pZusBB1ohB1ohM1l5VCUEB1o1DrZq3HXdwsTj1QKPmbpP6Fcs81yi7PNSEnM26tPVmgRLB00XTddoOnFCJxmfL4EnCX1HHrzsEXoSfwvN6UazEtvBWpSM7Z8TiX46lTNNsf+hD2VE4tj8lR7KtQ85/EhbjihYlT3y25lwJMIEkG6g6RfaZQiqPAdWXJrmb7WLluYZi9d1REImWZYizTINFWPxIovXd5KswWPzLthQ/R6E3sBnUUKVpyRYih2ROD/Nuu01tp2Z6HQ6POc5z+Ef/+N/zA//8A9XbvPd3/3dvPe97y3+HYxU9Hn729/On/zJn/DBD36QAwcO8DM/8zN87/d+L/fffz9KbSN3l2UdcnInyi8AeQdqZ7BWzDYDjs43ufXoDDcfmWWm5vGVxy/yxMU26/20WM0dHEYURxua0hWL+blvItG6WPG3GBJjiayml6R0koSu1kTGuN4NQ5WWnItCZBIsJQWhJ7P6/+W37JiEFAJPgq/cyrSvXMDleYJerFmPUqJYO/JQVKeyBaMeegsj7yXPxnhS0gwVrbpPw/OxWJbbMaudyFXKKWUfhXTyJilF4QmJEs1ar8olNsWVxkovRinBQrNGL07pyARjLP1449V2JR3BXI8Tnuz2aXoerZJcSltYTmNSYVkYue5X0piT/S6RGf4lSLGkWygP4ilZyjg6+dJGJmprK/xG+WtslI9zOL/ew1o7VCK2l5azcFNMsb+RnjiwayIxLZV5+eF1LV7PBehWWYwvsGJY+lT2U5jsFu31XZ8soQHrnjdeKXJKNcHJVViFzh3DC1HhiqV1ctyn4UiFxQQb31G9/uDL3cqCvNR2SO5Vfp4YTCCGMj1j5+uV4yuHxqnuronEdL5XY9tk4rWvfS2vfe1rN9wmDEOOHj1a+drq6iq/+7u/y+/93u/xyle+EoDf//3f58SJE3zsYx/jNa95zdYHk6fVhgwMlPJsAiUloa84ONfgthPz3HXiAMcPNKgHPv04QUhJlGr6qS48FOnA5IBbJsj1TBSBf+6byE4DuGZZriqSMyEnxtLWKetpQjdOSbR23RgLdmKHG+JZSztKSdIuNSXdAobIfBvZe5TSNbZz/R2cXEsgiLVhLUoQsUBrF8ibjIWUQ6rMAz4WSA1ok9OhB56kFfrMNwKUFKy0E5Y6EXGqMXkwmHtRpEBKUFkFKp1msq9U09vAQDvFpcdaP2W2NnyZr/cTHji/Rrvvvpt64FEPPPpJSj+ebMiWUhAGrjv7yU6Hk50ORxsNjrcazoekJIk1fLPTBgHPyFzWLc+nrRMe7XZIdnj3HN1NWwsafMVEQrHZmTYiFNpYotRwaqU79Hw9cNfGFFNM4eCCq72Ra1xLwdVeQBjGAmbVtzTOWVQWEwsNSlusYsyfUBichUCkltqyGfIppDXXDVokKXKtj+wlzP3Fw1gJZ/7RbQD0b5rBb8PsI3bTbtxbfl/5QuQG02Yjc7bUFhLQ4YQDWPfZDTXDY/Nu4lvBdL5X45J4Jj7+8Y9z+PBh5ufnednLXsa///f/nsOHDwNw//33kyQJr371q4vtjx8/zp133smnPvWpbZGJYpVeukAGm9Wwz4J0JQWh73F4rs633XyYb3/mIa5baCGURCCIYp/5Zo3Zmke7n2CVq4AkpMh8BWKw+l52Ww+MGEMXQ2oM/VTTThMiY1mPU9pJ6iRM1hSSCVFkPAYkyGYkRRtD31qMlrSUREpZrMAq4QKZmu9RDxTaGrqxoRcbUq0REpedkDIbf56dKX1m2fDLLTEGkia3+tsIPOabAU3fY72fcn6tRzdy76H8UQhAKIFULiOBAKMtOivHaQ0bVuOZ4tLC4vpL3HpohvPrjiR0E81Xzq7Q2yQDUYV64I15CM52u5ztdpGeJGiUMhEWvrnmKuDcMTfDtzptRwB2CF2RZRgQigpD9S5u0sZCNMHrk/eYmNTQboop9hNEP0ZEKXa0V8sUVwXqfoyuQdRx91YZW1qnLXKbCX/Vt4QrZqxyvtfPJEjn2tQ/81DxvDBw/L0PAHDynz2T+VMhwuztPW8jy+ZWZEyFHH0b+5tAYnyJTKZezr3Gnt9BXvva1/J3/+7f5cYbb+SRRx7hX//rf813fud3cv/99xOGIWfPniUIAhYWhlNoR44c4ezZs5XHjKKIKBrk1tbWsnJeAqQSzDYCZusBqbF0I5cBkJk5tRl6HJqv87Tj8xw7MEPN8xCeIFCSWqA4ttCkGfogeuQeBJctEBTG6dz5nM38siMiaykNuCAj1ob1JGUtSYkSZ8i2Q1WXBpkJM7K/EHmfbNd3wkpBLVAkCYSeohkqQiXoJZblXkI/TtEmG4a1SGuxSqA8J4PSmKHA3zI4nSid08mqnExqtu4zVw+JU80TF7us9WKX4TASZO4pEYNVhexj0engs8p9Kp4U0+o2O8DE+V7CTM1HScFs9mdc+pyVFMw1AgKl+I1/8CIA/vN9X8Zay6ceOU9/QnWkS4Wvra5j1S6i+w121dZitaE2ki3YWm/w8d8ia9nw84kyM2DNn5KJrWIr83mKK4Pga6cAhkrCbhfTUpnD2Mp8D/wEKSx+TUKs0OlAnySERYUaIS03vvwxAB783zdjLbQekojLbEO8/re+Tvc1d2E3KMO9U5SEHkPw+psH+1JbRMSY0XqjClH961wxkvrJ9ckbbYLpfK/Gns+ON7zhDcXf77zzTu655x5uvPFG/uf//J/80A/90MT9NtI/v+td7+Lf/tt/O/a8lJK5Vo2XPusYxxeaLHdiLqz36EWuwtByu08n0QS9BKUkINAWPAtKSqwHSikiY9Emr8KEm9xmeCVUDEo7DS/p52F6LnUyLksgS8Kh3NghhHVNvEz+focPV/YgGGtBCg60QqzWeFLRiRPOrMXEicGITLhnB2Ow1gVXxoLnCRJT0lANDVk4TiOdP8P1ofBphgpr4exKj5VOhNau6pOQYEXWCI/S2HF+DuveENY6YuJ7gkbNI/AV61PPxLYxab7XAoXy3I/Ov/juu7hh0RUD/8tvnuYTD5wl1QYpBTcdnOE//ehw0YP/z6vuAuCTD5+7RGRik5tint6rvMbza63Q/w1hM2mUFBCE416rXn9rWbFy0nFSGdrRHeyktzLFGCbN5ymuEhjrzE6bVMiZYmuYNN89qZHK3V9eeNcDzDZdtviRr1zHo187hjEShCWYjbnhpY8P7fu0Fz8CwPkHb0Qnexy2GYvQu1ypFwMJ9U4gR267OpSoaPtj2kqpWYTASjHtXr/HuOS5zWPHjnHjjTfyrW99C4CjR48SxzHLy8tD2Ylz587xohe9qPIY73znO3nHO95R/HttbY0TJ07QqAW84PajvPSZxxBSstaLSdIZVroxX358iUfOt4kSTSNwK/SeJxHWyZhibQiUZKUX0411ERyIzPycr/gDxVJ+mTsM4IhETgxSbTDGUvM84tRicIG/BUpWA9z6vVsXLVeMkVLgSUHDU7Q8hUKw1ItZ68bEOs26fucZhpF1VeG03tpYQk853wSD8YpS5kUI1/U7rwBlLSy1Y1a7MUlqGKJS2U0iJ1jluNBaW9CmwHPZnsBXRNrQ6UT4W+lONsUQJs33X/m79zDfrI9t/53POE4z8Pjol5/g9mPz/NKPfPvEY6tMjraX1ZqUr/Dr/sYbJc6wjw+jHetsaqFYiRrKE2xtABOmWL3mbUgo3DVp6I+kvDeTMEWpK65QD6beia1g0nye4upA8I3TiCghuueWHe1f/CbsAa6F8G7SfH/lt3+ZcHY85Lr5zlMEYcI3//ZGagt9rn/xBpUtL8Etxz+5RPiFxydvIMBKZ3aurBwlQWfm6/JC+06JRY6tEArLsKfEys19Ef3jLawvaTy8sqNxTed7NS45mbh48SJPPPEEx44dA+B5z3sevu9z33338frXvx6AM2fO8JWvfIVf/uVfrjxGGIaE4Xhf9xc+4zAvuf0orUZIlBoatQCsIdJO02yM0+8n2nBxPcYYCgmQq9cviOI06wJt0Tqr2iZFdbwlRsu+5s9nDynQuD9bgUesLd3UYBhkKGShMRo0sHO7C0JP0fIVNeVM1EvrfdqRIU1TrBGDykzZSUsKKXck6wiLNpZG6CH6oqRLdGOXUuJ5kpavmG/6KARr3ZSVbuyazuVm8xJzstrJycYWiDPZl6ecHMv3FKkxrPZitLaZbGuqTdwuJs13T07+JXn+zYd59bOu5+ZDrQ2P/cF/+l38+Pv+ikcvXL6OvlbrwcWSZPPLE6AENjEw8QdDkJiN54/vSZq1nd3GtDYTvRGb4Vr6EbjUmDSfp7g2MJV9DGPSfBdy8l3juqefY/HmZc5HG9+/D/3Dx7jwgROkS8GG2+0l2t/zbcUCUB64i+w2bhSYCZLPLWUq7M5Jh/EEaf3yz5fpfK/Gtn+F2+02Dz44aDj+yCOP8IUvfIHFxUUWFxe59957+eEf/mGOHTvGo48+yr/8l/+SgwcP8oM/+IMAzM3N8aY3vYmf+Zmf4cCBAywuLvKzP/uz3HXXXUV1p63ixXccp9WoYSGTKYlMzgRxarNGcM7UvNyO0da66keeawAWJSlR4gJogcsqCCEzM/HAvzD4ugfZCVt2Doms07UUGEEWkDvOkPWicyVfGZRNzfcWQlBTktnQp+l7RKlhab1PL0rRxmaVAyyDRnP5AQeSrDKsde/bGIuSAqOdBlNmmYj5Zo0DMyEecLEdsdyO6MdZp+qikd1wtkSIUlZFQs4PVOY78ZUgNZb1XuLGPBgNydTodNWhE6esx+Pys1RblDd8c9O7rFVuJ3lmUguxcfKKDeBLuSmh2Aj10KMXjWcnktQQT0jtb8VgHSUp3QoTu556hKbYhxB2XGoy+u8prg6MNr8ro1x+Fcb9BNtF+3V3V2Z+rQDricoO2KPb7SZDMSk7oQMxsZKT8TfPTph6QHpkfuz5NO3DYzsZ6RTbJhOf+9zneMUrXlH8O0/n/aN/9I/4rd/6Lb785S/z/ve/n5WVFY4dO8YrXvEKPvShDzEzM+jC+2u/9mt4nsfrX/96er0e3/Vd38X73ve+7fWYAJr1MOtCK0m0xvMUqbacW+1zbqXrTKnWoo0rqaqU64YrjQUF2hi6/QRhLUo4JQYq9wO4sL+wR+QVnsj9E853QC4byQwP1lhSbdDGZDX5M9mEtQxqIbnKTDUpqCmFsBahoWc1nSil008xxpTqGZcJhMAWdawgLxmbc5tcupFog6ck2rEJaoHHdfN1jsw2CH3F10+tcGGtR5wOqkzlmY7ilOTSr+HnlRLUfIXvK7SxdGPtGtdREm+J7NObLuFeVfi+3/gzzq5OLv86ipxceJ5ET/xVsGwicrokCH1JPdjkFlbhp+j104lEIsdGhMJYjbbTSGuKawPJM46T3LFzA/ZU93H5cO73b0S3tx625eRCmMkZhNEFpCFcyoXzLWYl7IgsVgcCs8kPzkaEIlhNCFeS6ve2lfc7ne+V2DaZePnLX75hV9k/+7M/2/QYtVqN97znPbznPe/Z7umHcGGtS71mmKn5WR+HmKV2xAOnlzm/1kVrg8zKqR5frFPzFOA6UhtrOLPU5fEL6/QyeY/NSUL2sBaQdvDvwrCTZS3yYCMP5iUZeTFoYwtZisFmF40LUOqeR0M6GVYvSumnGiUFrdAf5C4qDat2EKCLQSIhHxPYnFugjcvCJNoS+JLr5hsoJVlNUvxYs95LSPTAG2GxpeZ4ovivzDMu2r3rWqAIs7K0/USTps4jYk3uBR8Qn/y4U+wN3v+pBwkCn7/3HTfTCofvpl85vcQnH3oSIeDIbJ17X/fcsf1/9c+/yHI32tF3stE9Nk00PRNR8z331Wcdte0eNXeb1Ola5RUBNsFoAq9e8xBCVGYsNoO2GjMlElNcI4jvuoH0liPTagKXAff9zV3Ieo1X3P01auFwZvjsNw7x0P+5AWvBm0k4/ponxvZ/+C9uptaTO1vp32Cf+IZF0uPzCG0RvYTmX34dpKDzmrt2cKJLDxU706jZgdIrXI7x16bl6i8F9nVx6a88epHZZoMDM84zsd5PObPS5vHza/SiGKxFKcFM3efoQsOt2mdZiOW1Pp/9xllOLbXpRAlJmhGAzIntOjlnTudcajSGstTJPYRylQKMtXieIrMruKpJUtH0FNZY2r2EKE1Js8pOWkq057IZrqyrHY+CCn2dLdIIBb0pOtGJoqpTw1dIKTjQCvB8wYUowjMec8Ir5Ejl0reDnhR5J24KEqWEYq7pg4BekpKkrjGfNXbg5SjKYY18RFPsCWJtITX81/sfKzzML7r1MCv9iL957AJRVonoiaUOP/+R+/mF738e1sK7P/ZFwDWre8kth/n0IxfoxHtXX9CTrnlikZ3LKyJlFcl2A+GsTZVIXWdIAn+yl8Rs0AV7M4xmJ7RNi0aQU0yx3xE992b09QdA7dLVu4ca8i21Rt6nSLRCasUnvnS7+70GnnXTSfSpGk986Rg6ziTaKyGn//QGjn/344Dg4b+8CYA08ugcgcY5s2fN48D9xiOlk095is5r7gTAhGpr/R42OvZGN998XXSDbeQEme1Y8ZkKjGYnahdjvI7efbJlOt8rsa/JxBcePk+tVuOGg02avsfFbsSZ1Q4r7T7auHJMSgpaNY+an2UlDMSR5sGTy3z1sfOsdCKiRBfBtbYghR2W9sDAo1BYC0pZg5xIZLImYy1xqvGEQCEIlEdNOgNFuxcTpSYzfRts1knbFNkM14E61SNx+Kg3oojby6Kn4Y2aoUcr9OhrzcUooZtqagiE7w1vOzKfRf7ms6vdUxJPScJQsdzOu2APjyvfp5SsQVxL7R2vInRLK+p//eBZEqMLIgEuK3VypcvPf+R+js3VWC2V5w19tdv4fhxipGncHnzvYUYQ4rwgQCWGHU2j2IhIhIHLnmyWnZClcplabzCUKabYbwh88LYnLa7CQI67ezwVfjL68SCr/NDf3IC3JEmj0vdgIF4NOP2nN5A0Ie0PwjR7qSM2AWazynxbOUxVcb5tQqZ24v1WZrdtvUl2QhQrprjMyx5MsOl8r8a+JhPnV7v4PU2SphxuhVzoRKz0I5JUO+lNtlgvcZmAfpRitWWl3ePBkxd5cqVDXBCJgdnZ5uVTs/M4+U6eCagOX4R0wbw1brUeawmEYNZXGOvkTHGiSbQuVvRzr4WbUM7E7AOBkkRimE04r8SgDGvun3CDyiVOLppXWRfrmdAjtoaVJKGvNcZa0szELaXrHA4U8iaRV2xwR0VJdywr3X5CgDaZGTvL4AhZzo648RSdvqWY2Dtkir3BepS4niQjMMbyxHIHWbG09OzrFvjy6RXW+pehB4hx2QmjTeUPg5KOrI5C5oxnk1rgxlji1BBUSKE2XBQTpXNMgOcNkyRfeaSk2ULFFFPsb/hfewIE6GMLV3ooT1lEnQBbZWEzEK8ExBVdp/sHBLWl7XfB3glyA3XSkuOL6AJEalEV48izDZsuvG+UndjoBl6QhMknkAlD0Xo857vF0f5UpnopsK/JRJJorEhZ6UAoBZ0oIR0t9Widpntlvc/B+ZA40jx+doXTF9aIkqxvQxHQu9VMYUsr7dkxnB+idFwxeOQZCZEZq30hkMJ1hY5iTZSmJIkmHQ1CRjpfuWyFJPCkK207UDNlpxxkHwZ/d54GKVxGI/QckWjVfHrGsJIm9LLSt+BM5yIjCXmgP6g46lYCpBBIJRBSYoTzmFgNaWoKv7ktv/98LNkFLoRAqKycrJ6SiasN842AO47O8c1zayx3o8132ABKCvxNZBJGm5LfaARSut4XE+BL4QojTPhlcR0fBLZU2UNEdjMOsimUGifCBXmfYoprAHKth9iDpqLTUpmXFzoU9BcgXLGo3d2+Xayz0dqIgKQh0BOSFcqIjVf7N1cjIdd7hF89nR1Q0L/nFsQmVf42g0wZa0pnfIHdyGy+RUznezX2NZlwfRUsUarpJTrr2AwDu4H7X5SkrK73WOvUOHOhzbdOLXFhvYc2pshIDI6ZBeijMqfScQf/yRvAgSckQSYHEgL6iaajNf1UkxqdeQvcgUTJoFw2K2vrtvGUK09rrNu2yEYw2Cdf9feUIvQUNV8S+LLYN8HSixO6Ni0aZYu8GpV0npDcF1E+rpQCobIsjLVFF2xrIE6zClWSYZaTZyNz24TMshzWBZJTXH040AqpLyuWS89JwURiIEV1xxCZzaWNMJFIbAFKCpIN9hdKoOpy+EfCgt1C91RPCcJAEY2UeFVq8ntSUjoCM81OTHENQJ1awjRDTEWZzCmuXuiacJKnaFT/PGGHcRX0YPtNtDZ5Q7qdQNiNsxNypUv49TN4TyxlTwjCwCN55uZNLYVxpMGMRLEyZSIZSesKmVrUNDux59jfZCK7OoxxjekMLvDNg3JwmYZ+knJhrUv4pORbJ5c5s7LGcs91ejZFoFKIdYr/lq8zJzGygy2yQFwpRyJ8OcgmxNrVsNcarB3pJj04xdg/86BfZpkDY2zW8G6wSirIGs8pSRgI6oFP6CmUElhp0UCkDV2tSa1BW+sIg3GRvs0YUW70zi/0ojO2FBiyilcabB40WUGc2qzcbakPRSYNIyMRLghzpm1jwO5yhWGKAc6sdvD84Ut2pp77gYZhrWWtH/PEsuHEQnPs9VMrXdb68ZBEysKGWYJKed8mY94NkdgMQkm8mkSNdKK2vkBYgY23cG7p5u3QUxt8BlJKPCCFKaGYYt9DnV8DIIGdEworNo4Yt3usaxVV9q8NblFCg9eDtD7+mozBSIZ6LQgLMtnogNsaLcDEXg57AbncIXjgyQGRADAW/1tPgueTPG3zKmNu6o1kkDdYwNQ1SYxHADsnFNP5Xol9TSZgcH2m2oXdebYiz64ZY+lEKSeX1rnY7XFmqU0/Tljrp8QFmSgFVHbk4ORmZ5E7rzM/gesk7SuFJ11wHWtDYgypcZWOnOuf4iIWGQup8hHk5WeVlIS+R903xRiUEnhSgXCVqDyl8DxJ4At8T2EQRMYQp5rEuoZ1iTXFG8gsGdnfRZGdyAmElAPvg7YWo93Kq830mrm6Q1tDoLyBydqWxi7ddoXvJAsiryWD0ZXGE8sd1Ihh8uBMjcOzIfUSyTDW0oljlrt9lrt9gizbcHimjhBwdq3HN59cpR0NlwTZ7Luquu1Z466xSQF4lZ9jO1CeJMi6MyalnigFkQgnSKwCiTAGO6EaiMtoZo3r1PZu6FJKPDElFFNcG1Dn18BaEiEwh+e2vf/UkLo1CNwiRxm6btF9MSZXEiYjEx1b9FnQAW4RMwEVWayEtDbYR+rNm7WNwkrcmCZ88LttepfUKeQPKrKFpConEv5jFysGBf7XTmJDj/T6A5UVAa3M+01sf3y6JomFR2BtZUO8zTCd79XY92QiD2xjbfFVqT8EuADYWNb7CY9dbINy/okk1fRiV1GpMP8MpQeyQFgMS/5E5oXwhcT3JL6SWAT9RLvMiLXZPrncqjTRRaYtzPwIMmsIIbPu2TIrrznfClloBPieZL2fYIDAcxWhjDVI6QiBFhCj6aXOQK6NyybkJeestYW3YeCuALBo6+RKTpLlxmywaG0w2g5JsgC3emvdZ6lULrzKKl4JUTonbv+cZOx52aApRnFhvU/oSZrz7lLW1tKNE5Y6/WKbbzy5CmQSHWv58qllesne1NrWxkDqmtpt1jW6Co5fV/+YSSUJQreKBNDtJUUmUYYCMYlI5KhJZK/6xyLWhmhCH4wtyHyRQuJJxpvfXUM/DlM8daAurMMDZ4gXZ4vnxAQiPsXeIZ4DsPjr2cKdBq/r/szhr2e/r7Pux1z17K5LthYQYBQII7A7KOwluhFyNcHMj2e/0xCihcE9OlgDmSkVgtPL1USihODzj5KcWKxc7NH+ZCJhldjUc6FDSTzrU7sw7BkazXJMsXXsbzJR0uwn2uArhSRfSXcBijGGXmyJtUUo5xtItQucsQOJQyFryg8tBoGOACQCJQWBdLImK6CfrWzqLLsh8o5xFQOVOOmS50n8QKKEQFqXZZDKmadnawGHZus0AoX0QHiuNKYQAoMg1o40pNqSCjDWONmTzWVHZtjLkH045Q4SWBdwBp7E8yU6K/Oqtc2IxHDGoXCg528t80XIkkG1yAaViARy9BOd4lJBSlHIk5LUcLFT3eH6q2eWWesnGzad3Am0MZBkTeRGMMKnhyCEQHkS5Ql0mdtYi5CCsDZ8e2qUShYmwpBuMrcEZJmL8R8IaQxM8J5qLN4mdMJmGcBRGdellHVNMcWlgvUVIgzxO4MoVqRblIHs5W3+KXj5xLMQz7g37vVg5pHqe0+wZsf8AXsBK8EEorLM6tD9e+R7lt2E4MFzBKfWiZ5zQ/akwMw10D70Dwz/HsSzmcQB8GsQbjIuvdhw3pCqzPEG60g6EHi9TX4bjCM2o8fekiF6Ot8rsctuNVcWeZBsrc0C+ixAUdKtoMv89Wy1UQh8KR3RLUlzyP+dm52zUkVCZNWZpKTuKWYCD19J+tqwHiX0Ulcm0lpbjKOYZ3YwSiUE9dBjsVXj4EzIfD1gNvSL/hcSVykpTg0r/ZiHVts81u5yJoq4ECVc6Mcs9WPWY+2kHtqCtgjjViissWAs0gzerCh9RiPebWeklQIj3Oems2o7uSQrly25vztfiMjKOFlsQX4QjkTo1GBSw0BZNYlUTbHX8JTEK2WABBSd1y8XZCbPq0KS6uJhrC0Sf0IIwlARhgohBV4giwdCUNuDWufKwI6Ewmw8fS2gtSZJ9rBz1BRTXCFYT2GPH8LctrnpdYpLDOGarV1OWFVNJADSuigeVlI8RJRS/9Ip6l84hTq/RuNjX6Hxsa9Q/19fR/Qieod2/xvUfvWzsDttqLhBhkEY8Lp633bC/sQnPsHrXvc6jh8/jhCCP/qjP9pw+//+3/87r3rVqzh06BCzs7O88IUv5M/+7M/Gtvtv/+2/cccddxCGIXfccQcf/vCHtzWufU0mbKkcab7aqrJA18mss2pIUuB7kkagmAlUZiIuy3BE8YfIul97UhAoSTPwmAl9PCnpJJr1JCHSGpOdu7ziX/wlC6gFTko00wi54UALAVxcizi71OXUxQ6nLnQ5eaHD2aUuF1Z6nFvtcmq1w5l2j7V+QpK4IN1oRyBE9lBW4FmBb112Q1pQlgEZygczWAjAZUccEmucRyLPKGRdrAeVL20R8ClPZlWfBL7vKj0pJV2X7WRAIhyHscX+xecwJRWXDEoKbjrY5MjsQDgbeorr5lt7fq69+BrT1BTEIghk0ThuFF6w+9vSbpPVeoN3nCYpyR7JxKaY4krCKom96Sjmadft/BhZqcy9ejylMPIbmdagfePO77b2EkZ0aW1ALOqff5zaV8+ObSOSlMb/+6Vdn8uGu2umOMnrISz4HY2/vvP795We751Oh+c85zn8+q//+pa2/8QnPsGrXvUqPvrRj3L//ffzile8gte97nV8/vOfL7b59Kc/zRve8Abe+MY38sUvfpE3vvGNvP71r+ezn/3slse1v2VOecwqAOPKmCrPyX5S7YJcVz5VMlMPaIaCTjcuGrC58qcDzb/MSq02fI+aJ52hWVs6SUqsjdsuM1GXy6G6Bf1sWT9vIAcEvqTV8GkFHmudmPNr3SKDkh2F3NEtrDORq1Q7OZa2yJwgFAF+lvkQeRamxAYzk6r7PLKu2sWdKnM5ZGw90YamVMPVafMKTXmGJ69yY0H5sjBrp9o4/0Ti/BXue7ClhYBhxfm1ZDC68hhih9x2dJa5CSv4E2wIGx9dOMOzHu3Vsumorr4AQFU0e9oLxEmC3qr8Y4oprmYIgbntBPb4wd0fa3qf3z42WmwTG7w2AdoX6BDC5ck7VjaHuxK3b5kFL1U/NQLWfui5uz/H6I+gBX8txevuwf37Cs731772tbz2ta/d8vbvfve7h/79i7/4i3zkIx/hT/7kT7j77ruLbV71qlfxzne+E4B3vvOd/NVf/RXvfve7+cAHPrCl8+zrzARZcJ1flElmhsylSlK4hlqHZuu84GmHOdyqExe6fkHeM05Kie8pZuoBh2fqLLZqIAXrcUo7SdDWDLpD28EqfOEtGBmWFIJG6HFgpgYazix1uNjpO/NoPgntQBaVN8dwvgPwjMAzAmUHD2kGNwJb+jPnN4V9JFM15frGwi+RExIgMTaTpohBn4A8OZMbwpVEKYkfOMO4Ti1xZOh2k+KcBUreicF3Q9EJfIq9wbHZBsfnmsUj9KpXb3wluenA3PZPkHlklC+LR2wssbEk2WP021RSTpQ4XUp4RuBd4oaIo56MOI6nRGKKawb62bfsDZGYYksQiRh+TFiz0QGs3lb9u1lJBnBSJROA8QS9Q7J4dK4bfox6LrQ/WeJ0KbH+ohOsvfTG0fUxhz26rac1MSR3CleSvSES+xzGGNbX11lcXCye+/SnP82rX/3qoe1e85rX8KlPfWrLx93fmYliTdRNGoMLboQUaAtKSI7M13nRMw5zbLHJt86ukHshjLVFeddW1jG6FnhIIeinhr5xPRqKtMFAUTUhQHYjUVJQDxT1wKfTSVjvxVhhCYpeAKWVe5FlNDLPhrGuIpMavCtk9jDZ6xZH6u3IuS2DQK98fY7+KcmqMgWlLtjCZVKQIhuKQCpn7NXWovsakzoqYgB8ikxF3kEcBsmRoRNOl6wuGc6txhyY8WlukhK+7ejgppHqcQHPufUep1c6WzpnWsqsKSHYXTJ6+zC5AQoc0TbO+5N4pXFJUb3itU0IPZA7JWky6LkyxRT7HPrbb8fOjlfg2QmmHYF3CCMQ0m7aaiCtDzY4/IGvorrDXq32sw+x9oKtydS6RwcLP+GKRe6yg/Z2YUvBSefbjtL5tqMEp9Y48Idfd096kotvvAevvwdxg4U0dCdsno52VAa28rCXYL6vra0NPR+GIWG4mUV9Z/iP//E/0ul0eP3rX188d/bsWY4cOTK03ZEjRzh7dlzKNgn7nEw4FKvpUrI4U6MeevRTw3wz5Lk3H+C243OcXe2xHqVF07XQk8zWfWbqAZ6SGFyVI23JOk+TyaAGwYvIg/bReZ7NKykFzZpHoBTr3Zh+lNXFlxZrDUpCVkRqEMCXezTAoD9DduhhT8agdd5gq5xIlOlEIWwaxPZZxk+Rvb/MGyKVcMfM5Fl5qVpjLWlqnWej6Dlhs3G6vgLCZhozO/w5lYa2oRFqiksHJSVPP7K4+Ya7gLRAatHoIptVRqx3rktNUo1fyryYDaokCTHebM96IDY4ve8paoGhH1evVAk9ur1PmibTvhJTXBNQf/MN9HNuxR6cv9JDmaIClmEScSmgAyau9Vmx8/MLbTj6ns9w9m0vGBxvg+R1emSGpR/79uHnamJjQjGspq5+vYTO8YDGk1dvZuLEieHiB//m3/wb7r333j0/zwc+8AHuvfdePvKRj3D48OGh10b7n9ksTtwq9jeZcI0Ois7L842QW48ucNv1c8y3Alp1n7lmjVQbnnximU6kEUKy0KwxU/Ophx5JVtq1qAaV+R2kzEufZg3wimB/bBBFzNwMfULPox/rIkgRIq/0RHG84vvJu04PGZ8tmJLcr5AfufK0DJ7C4rIxeRGl/DDl8cri3O7fruCTy4Z4RUlRmZnZHVExNus5kTJU7jWXQ2mDK+dpBbrUSGxw8my8nkDstBrDFFvCUjtBG5itDwLvnFxfTlhj0XZwox5trrdlCKhJt29+tI2IxIZjyu5uo6QiSTRpavGUpFl389Na18dio/rtnueT6hQzoT/FFFPsJ8gvP4x5xg27lzptpP3fybGeSqjITsgEmqf25++mDTzWf+DuoUB/c1O4qMzO6MxEraKRhUqR+T+rFnUnzh9B77BP7aLYlfkauCTz/YknnmB2dtDj5VJkJT70oQ/xpje9iT/8wz/kla985dBrR48eHctCnDt3bixbsRH2NZkQMjcnC2qBx81H53jOLQd5+nXz1EIFCOJUc2G1z2NPtmnVAlq+h581OxFSuP4KGYEA53cgW+mUUpDqweK6MZlJIZ/5giLiDz1FPfDQ2tKLkqxpXBbeZyUx86xIzj7ysZe1QbkfQ5RPQZYNwEk6YEA2RlVFlsxHkQf1iMKwXXATa9HWZr4IgcFircBYU/SaMNr5NyDvbiyKv2sMvpCMX/+O2Cklsz4UboV5iksHa+G5Nx7k79w2uOjXejEf/sKjWz7GwWYNKQQnl9u7HMzgrzrVyA34hC8ltUqiOfDvKJy/Z7ewnss0xH3tfElQSBVLvJ5G3afXmZZ7neKpAbFnnrYq4ftujvXUwm03nOHmE4NArr9W4/6Tz9ry/s2vXUSkhtWX7G1p342a2PWedyPpM64f30cIrOfu67WLht7BnZOifGbqUDhCIShFahvsMOllIfZoeu39fJ+dnR0iE3uND3zgA/z4j/84H/jAB/ie7/mesddf+MIXct999/HP//k/L5778z//c170ohdt+Rz7m0wgEMIFrscXW9x14wFuOT7P4cUm1lrWewlJarm4FiEQHJypD1bSZeYByIMK4Uqn5n0ZpJCFdGKiTSIfhRDMNUIk0I4S0kzLVHSRzq4nJw3KJ/TkFJK1Fill5tkgi+OzrAaF4qmQOpULwpazf/mUV4BCDBVPSIwhUBJPShJtscYRiZxE2Iwk5f0lsKIoJ5smliBwBvf8PTjZFAXxMNq4ZnjbrAw0xfbw3Xddx3fccoiGP7iU421+5uWmd1uFj6CKThbYJA1dNJa8TIgj1yl+o+BpK8NRGUOaZiemuBYgHz7tCPaJw5tvPMWe45m3PsFNx88R+IPVcuNvLywTqUFu0w/gdS1yQtPOwYEnv2R9haltTBT2qku3Bey4UXRHiOY9LBDs0x4TAO12mwcffLD49yOPPMIXvvAFFhcXueGGG3jnO9/JqVOneP/73w84IvEP/+E/5D/9p//EC17wgiIDUa/XmZubA+Cnf/qneelLX8ov/dIv8f3f//185CMf4WMf+xif/OQntzyu/ZlLyyAz3X8j9Lnt2Dy3HJtjcSbEUy5A7kWa5fU+59a6hRciJw+eEIzl1govtCsn62cGZZt5ApzXeBC4Q7aiGXiEniJJDXGihzIGeQZiIBWCwpBRbDMIxrNEBlK61F8+xFyihM3+LFIRef4j6zJhB4QhD/bkmBbOde/2pOvEbU3ezZeSTCmXyoiiG7jNyEYuO/E9ie+7Ttqe57RNWluSxLiMjxn0/5ji0mCm5tMMhn98WqHP/3XnDZf83JeDCozO3Z3C2I2JxFYhhEBJhVKX23o+xRR7DxGnyMfOIh/dutFyDHaPH08h1IJkiEgAhM2I57zym5f2xLl64VLjKks0GSWI5z3i+V2so1/h+f65z32Ou+++uyjr+o53vIO7776bn//5nwfgzJkzPP7448X2v/3bv02aprz1rW/l2LFjxeOnf/qni21e9KIX8cEPfpD3vve9PPvZz+Z973sfH/rQh3j+85+/5XHt68yExSKk4Mh8g+sPztCsBaTGstaNWW3HPLnc5cxym3OrPRKt0cYF2r5wkqVUm8I4LO2w5EFJRyjytIQtk4hCQuS2m2+EJKmmG6VoPZBPuLKzGSmwLlgXCjwrsqyIIwsKR4p8pZAqbxI37JvICkqNZzNyPRMMXbj5sy4zITICMshiaG2QWVUm96acdjPLJWZlXcn+nn8G7jkhnTTKUy57ohPnORkQrvKQrrK7yT7G9z/3JurhcB2/mw6OV2TxpODwTH1bxxZUd7GuBwKhx+94okRCKw62p82T8jl/tRDThq+oe37leNJU89AVGNMUU+wUydFZkqcvYmeGw4E02dfhwVWH5z3rQfzm8P17rtUd204pw+zB7UlOrQJdIbO3ElRFxSarBEZZZEWC1QrQe2n+LmuwrwJ47ZRgOUbG46kTuYuiIZcLL3/5yzf8LXzf+9439O+Pf/zjWzruj/zIj/AjP/IjOx7XPr9buH4OC806nlJYoNtP6fRTzlzscHqpzYV2n06UFBkJsiBeG2cydl5kF/3msiEXtLvSl0ARIBeHELnEStCqBXhKsNpLiZLUERxKSQ8xkAwZmwdtAmNc5ShwwVIz9JlvhoBgPU4yMjFI7ZU5hCzOX/Jl5OPOsxEIN37pZE5WgM7OryHzdFB0ApeAyQdd6idQlH61LvMhvbx5nUVrTaqN+xxL+0wJxKXB0w/P0qwP/2LUJnSL9pXkJU87yicfHKw45tUZROnfFifNW+lGld+apzJpXgVG+zAMQe7+l2Osj0teECF7XmWd6rWw6L2oBbtFeFLQ8KszE+m0etkU+wxmrk5yqDX2vN5q/5i9zChcJQHnpcCRAyuEreomo6NQvua25z/KA5+9qXjuzhc8SOtIG5G4e935/xHQ+bqif8MM7TsXJ3ocquRGNq85P0GtOdqPYieIZ0c8CoVGezCGS9mxexJUbFATqjqNVvGrxHS+V2JfkwkhBAvNGgszdeaaAVIKuv2UpbU+51a7nFvtsd6PXWUiM2AEOiMTRbUkM5jzpghgsqZuQmRBf5ZxKF0QSgpmaj79WNOLU7TJS6dmJuhCIpUd21h8ITOCMfBAKCk5Ot/gaUdmibXlW+fXaEcxSspi5TfvjTF8bYosOHSZB2ld1+ucYvhSOh8DAzJiEUTGFH6HXCpmsAgtsJgSeXJ/ybfLT24NJEaXMhE5kYHy3aOq4MIUlweeFDzz6AKffPBssYph7QjRyzJeUaJpR9s3HkuZlSk2riyxNqU7sQU1IeAGWKgH1AKP1QnnzYqaDaGYXwKUcIRJSYEqlgEgGtlLxu61wAoSQWlRYWeoeZKat6/VoVNsAaYVktx4aPCEtYRfO3XlBnSJkFw3T3p0l8bPsh53t3gq9ZnYAEoZjt92jgc+eyPPeO5jANz8zDPIOwf3N2/B0ntIcTpY4Fw4s+1zGCXAZNkJOyAdAuepSBuTv4t4zmVD/KoEioCkKar3z2MI4fa3EoyAtOnG4I0marJbrfFApuw6oPDXE7zObqs5Ted7FfY1mWjWAm44PMstx2a5/lALC6x0Y1baEeu9hH6aoo0r/ZqaQYlWWwo+xnyggwQGArfymQq3ap/nLshWdxuBj5SSbhSTlE2vpRVVU5r9FheAmSzoz+VFNd/jhgMz3HH9Ir1EsxontM+l+NISZQG5l5GaIZlV/gCkdZWeivKxQqAQeNIFjJ50r+gs4xFKSZB5JkR2TGutKwVrBoFnXpUJK7A280yM9pRgmEgMqlSV/5ziUkBri5YCNeFjLghfBfJiAzvNJEkhMBjSjFhqU7pJ64ysjgTe1801qHmKG+ebWY8Ty1o0fnPfKM8gcPM5N41LBLWCUjgkiSM2KsERm6z8gBECja0kFTq12QJA9QcWepKZQBFOyx1fs9DzDcyBFnquQfL0o4MXrEVGCf5D567c4PYYyfE5omddR3rk0lWRmWLnEAJueuYZbs/IxCgWX5HAKxI630zhC9s/vlWABhHjpN6ltSCpwUpblGfNoUOLlaDruRTKVhKKpLXxb0o5K2GlIx+uCqW79+bSrMIzmpf5zklPxUpTLvNS/epz+u2U2oUYrzMtnnEpsK/JxG3XL/KcWw7zzBPzzLdCzq/2WevGXOz0We3FxEnWQ8LarNmUzRU7WSBlxwMp4TIIiTYk2uArSSEAKWn/lBLMNQKiRBOnugiwiwzYSLyd+yCkWwwgtyRIIVhs1Ti+2ODgbJ1+qrluvsmZpR6xTrPA3EK2b55NsWQGayuKrpIiz3Zklalc0SpHBgIpMAikgIYvCaV0gWiaD2YwYFGMV7h+EtqiU4OxWZUqSp9boekqZW7yIDXLekxx6ZBoy3oUEVdUF9LW4CtFfAnL8xpjSHVVdsGSxgmecIT72FwDKeDZ1y0yEw5uO1IIHl/tVhKK7UIA9awnt4nG33Mg3K9XgiEmy07mTSItpLHJCFK1P6PlT4nEtQ59bJ7o2RXFC4Sgf88tiH6COrV8TSyRxLcd3RMisUe1DYpjPdWQWoWu1PtYnvb8xyue3zsIk634j5+aYB1iYdGhQIfui0lmKORUsY8rtwrDlaF2eHFYAfGM27kWj0+EXHoltRuzZUAyckLi3lN1papwaW+IxHS+V2Nfk4nvfM71POOmAxxbaNDuOZlRJ0pZ7cV044TUGFJtSivpWcBL1jHXyBHdt9NWpKmhE6dEWhdyIJE1esO6gLmWVXBa7fRcKdjSIYq/5qfNSqb6npMklbtoe0py/WKTQ3MNlKeoScGh2TpzdZ/zbUcmrLHoIo+SS4rK/3WrqdodGZmVn5WZcTw3k+eruUpK+v2Us6t91nqJO7Z0Ei2lJFa47ISU2XFTV+Y1f4NlIlEkIaxLk4iMqInsnP5UEnJJ0YlTHjy/yqmVasPeTC3gYrt3mUc1QBolHDs4ywtuOoRfkT6Zr/mkps5yb23o+aIfSwXy4gQ7hY/EWEOcGtKkwoSXSQpnasNmSW9KjJ/y6L3kGbT+8LMDPewUU+wC2kq6OqCnq70UAsstXoWD+jIhWIPOcSdrqrofJzNgfAgvjrxoq7cHisXPncKogUyqqkt3PCMI1savz2tIUXRVYl+TiTtvOchsq46nJP3E0Is1a/2YbpQWpSDLun9bXkFH4IncY+BgDSSpoRtremnq+j1kfgEts5g5e26+EdCJUqJIDyo4VXgEir4VykmmBLmB2pGNmie5brHObD1ASFkQkFQb4sRklZOGtd75u8gNtO5RklMJi8mM1kIIfCWoe4pASWJtObfS5+Jan248qD6FACGdGVvgmtbpVJcyC4PPrti+lKoRWSZCSYHnKWqhYqYeMBd4fGmnX/AUQwg8RTDSWforZ5YmEondIi9AgKzuQu3m3+ZB1cuffnRiH4vU2Mq+GLlZvAq5V2I30NpWEokcUkqeffzgUGnaC+tt2v1o176LKa5OmNDDhlszyF4LkL0YkaTYbfY1GEORjt8DXMOX1qzqE6rhlfEn45mJRCKHJzTpRh3kJiGXCMlqE3alXKgC0YKdHPzbatOy0FkGo2K/3CuxG+hQYDb42OJZMWZIr7Ukfkcg0l1Osul8r8S+JhNhGKA8Safvqgq1+wlr3ZgoSbNOtxmRoBTolzwCeYUii5M7xKmhn2girYtA3VhX0SZNbZGV8JWk5inOrriSswjrfEKFy7mkUxdl2RCu87SQCGnAuKxHqp0USylJL9GcWelxeqlHL05oNvzC9F0oirLhGwYEJ3s77jnrDKpKSeqeYi700MZycrnPcjumF6Vo7aRZpSJXTvKR9ZewmTbRZEQsr00rRJ4NGUiacoO27ykaoc9iq8aheUeQut0JAsYpto2bD88y0xiu5vT4yjpnVrtuHlbAWEeSRcXN22Rk28Cg+WDp9bnSyvxqJ3ZN30qIkoQk3UyetHHQf74T8a2lajJkjc16nVwdODjTQgrBaq9/1ZSpnWLvkDzjGMmtGzdvuyy1+S8T6p99BBJN/IyjWG8XfVOmhtQt4XvnvkhrZvhG/Jert/NFfYKkgiwILL7UHPHXOBvPkZdfMdmfSeKhjSRJVfGxlT+9PGBPm+B1xgmFimxl2dgyNvs6vC4EK9UbCT2QIbmDbXysS43VZ9SxnqB5Mtpa1aZJmM73SuxrMpGkTqrQ7Sesd2PWOhHdfkKSuEBZZ52oyxmDPAjOVxelAGPcymusDT2tSWx21VmLxpGHKDWZkseVg42SQYO6gUcgO0l5gtji5Yy0OGOTlAJtLb1E8/jFDkcPNGnUfJbWe5y62HEBvzEkscELhyecyXwLRmS+CeHKxIJbTQ6Voul7zAYeSgjOrUZcWI/ojWVssgGWMjaQBXHlJIQEoUXxSyqGKkFJZ0xtBByaaXBgpkYt8OhrzXqsUWLa3OtS4hXPuA5fST778JNjr1lgad1JnGzph8R1Mrc82e7Tjp3foV7zkUAwIfifawY8udwtyd0AFErmVZzGc3KA89wYm8kFd/QWB0fMq65dhh+lojDBCBZbTaQQLHd6W8rKTLF/EH7pCUSUEj37RNZddBx+W4OSYK4NE2f9bx9HxCnRc05gt1oKdoo9w3fOfQNPaD7TvnXsNSksL5h7GICjwWrx/Llkln7q8zdfvI3HTx90T9Yswohq/wMlQlG6ZaUNgRUWv8ek2zcmyNYR9yDmzasx7UVmYqdYu7WG8QSzj/S3lJWZYuvY12QiNQYlBUmiWVrr8+RKj04/ycq+unKwTp7nAppywG+sRQoXNPQzj0SsDdqYQSnN7DxSimLl1leSA62QUxc7pGlR9shtX7riiq7R1p3fmbodgRDWOBKDax73xFKb1kmfXpRycb3PqYtt0tQ5IKJE44Xe4FrPiET2xvKCUCghCT1BK1A0PQ9rYGkt4mI7ohdrsFkviDzNkWUzBgfOn89OU8qG5J+BtbKQM3lK0Qx9Ds3WODxXp1nzSS30E4OODTONkKO1gLRf4YSa4orCGjjV7tFLdm96ltLDdT4vm7CdcT/Hf7v/IX7oubcQ+GrbUllZccNPEoO1Am8DP84Gkt3BBhvgBTcenXiA+WYDJSXn1y+NvGyKK4fgm2cQUUr/O24pfiyEzUhEhvhVzyX42OcR8dXf4GorqH3lNLKf0n3heEC7FbgqPHszlmsp83OpcNhf4w8/9WIeP39w5JVN73pj0HUBcqQikwBdsovNPgRrtzCxj8VGqDJCqz4QsqFMabfYaKztG0OML5j/xs68hNP5Xo19TSZCz3Wobvdizq90WWn3iBONyQhBUZFIOkOlRRTVkJwMSNCLU9pRQqTNkHTBFM0WwEqBp1xVo8VmjcTYokEdDHwRecfqQv5DRiqkxRpBkheKNeD5mZdCOpPq0moXYS1L7Yj1blxIUFJtMKkFTzhDdWG5diu9npS0fMVM4BFIQT8xnFnqs9qN3Wdh3fuSnsiNFu4Io/ed0t8L82vxh0BICVhCX7E4U+fYfJOFZogRln6iaceamu+z2AzxpUIpIDVEUzJxRWDsICux5X2ACEu4zR8kKRRCCVIdu4xVhdH6v//tw7zu226itUea9DR1Cwa+7whFnGgeO708tM3xA9WVatpRSi+5NlaWp9h7+I+eR/Rjei97JsJa/PY4o41feTfB//oioneJ7m/1EJ7zjOHnPjN1nz1VEMi0yEpsFVaC8S0y2SahCAVWWoK1TCodjG8z+zCs37w3zezAlX4VZlDOVViQpfWoZEbgr1dH2iYQezaOKfYO+/orSbRB9xJW2xEr7R79OMUaly1wC+uDpnHSuqyAJyRIi5KSThTTjlyNsUBK1xTOGKwU5JVkyXwOgVIkCG4+NMvjF9rkpU+BUtA97CmQmVDdSoM1ZBKRvN+FIwO+AE+4LsTtJcNqJyZO0qxkpfNyJInG90SRlbO4TEErVMwFAQGSTpRypt1nvZeQpGbQXyDzOpQbl5Xt2iJvVpGTlIxICETRMEZKSTMMOTwTMt8MWZgJibWlnaREqaXuKRbqIaEnXfZDJ0Ra0OsldNpXrhLFUwUvedoxmqHPX3795BUbgxAS3wswTF6t/R9ffJRX3XEDB1rhxG3K2CyPobVlvdPj4upopyOH0xfXObbYcoUBSktAczWFJ2G9onzsVnHrwTle+fTjY8/3opiP3Xf/jo87xdUB7+wqzT/9EsmLnzVxm/gVz8H/319Drnb27sSLc/D0G6tfe/6z4W++DMbSe+WzsTP1wXi/dZrgK0/s+LT9A3Dh7uHgzfQtfHALO08NqbvCS2e/RUtFfGz1jis2BuMLogXXrG4SWo9C58SAAGyGKtN3GTKp8FWUkMwI/LaLXxrnNDIZjC1akPQO7lxC3TsSEC2OL2zpuA9f3GTn6XyvxL4mE70opRclPHx2jQvtPnGqh7ILEsA6iZG1zgeQ+zk7UczFToQ2Fk+4so9SSFIrMEleijXv0+DMxYutGscPNFnrxiyvK/pWOymQLOJuYLCaL4tkQG7zHkihigyGEDQCn+vnG3S0YaUdFZVzchlSmhpqQpBaZ72SUrLYCGkpyXo35XQnoRslpFpjjcnaRthibBZct7oRFFwoG4cg/9O9IKWkHngcPdDgxsU5wPDEUpeEmLlGyGIzRGafs69cGdm+1nSjlNBXpKmprAI0xd5DAFGqWS2tlF5tCmhr4WNfe4I7ji+y0KgBcK7d5/xyRQZFwNH5xlaPPPH5M0ttji82GTVsNAPlzNT9nUtVqqjOtWOnm2IrP/TJC5+Jf/+3kOdXN994q5g0iQRwz530joTOMF3aLn36MWzoE96/vdXsPcHUkLprCGBpvck3T7pGiQ0/5gXffgW+yw0gLDSfgM51kDbdxWE8MZFceHtQkTxpCuYfThGJHboswhWD0NA9shtP5g7v4NP5Xol9TSb6UcLF1ZiLa13avSTr95Abqx0J0DrzCmTRuxDQTzXnOz20hpbvIQElJVZa4sQF48VXnEmWmnWf248tsNSN6SUps60AvR5jjMnIw0CAVN5ZWIvAZlV1sl8nMQjWG6HPjUdnueXILI9d7KB1u9w/zlXbMaIwWksBczWf+dDn1PkOq52YVNtM2pUVuh0q7ZBXr8rf//DkFSXJlIPEU5JmzePAXJ3Ds3WEFCx1Y7Q1zDVqzNUDAiXxEAgJsTFc6ESs9RI8KZkLAwKpiGzKNLzaO3zsKyep1ypy0MCp1TZrvXgoAMoXhkZJxcn1DtEeNrKTmZzQIkYM2uO44/gic/WwyI1NLIpk4cmVHofn6hON2+2uy0huhOOLzYllZOu+RAqP5d6AUAjgO244suG0PT5T4/rZrRKdKa5l+H/zAGJpfW8OdngRbhzPdpXRO1bHVrW7FwJ94gCRrwg/861tnXb5FcdYfs2Jbe0zxfZxvbLMqOob3mfWZnng1BFM9tvdSULe/dlXgbC8/Ts+NrTtB//X3+HM0sIlH28VOtdDWi9XZ2HivVLXQW1we7ZyclYiRxWRAEdsgnWLMJrOsWFCsZm3Q6TD3b6n2BvsazKx3k14cqlLu5+QmEE512KlPZMi5dkKIVzFpou9iH6q8YUzFAdKEnqKlTimn2U3yqv0QoCfSXi6/QRhoOEreoEkTmwRQEkGfoM8E5JnI1ywz9CF53mSpx2f484bD9Cq+Tx6sZtJlBhEWVl2Q1h3/JonOdKqsdxNaPdjl41xLXsLM7b7IzMPCgqCIRFZCVlReCZcBkUipCDwJDP1gMXZGvWaB1aw1k9IjGU2qDHj+9jUkPRTmjM1hCdJrKVvDXiSxVadZhgyF/hEUR7YTjMTe4VYa9QEEpBqMzEwNwwTCmMn1yGy1vkPql8c/mdOInIIJL70SUxVR2x49vUHmakFW67qlPeImfRrZYttJkNucrJASU7M1rilMZCMpJt0uZYZqZ/i2oZo9/A//XWSFz6z8nX/M19HrHRcQ9O9gJSuUtQG2LAKjpToI/Os/+C3sXRnNkG15cZf/MLGx/QlJthFHnMq+9gS8vLwlbACbQbfgbXQS50M57fufwU/+dz/Vdw3o8QvSMeEQ+0IVromcF6v+kto3wBpzW55fXDTcWzhOEJvkKizFr8DjXMpF5+dMQgLtQtbyS5svsmG+07n+xj2NZlYXo9Y6Ub0swZzBbJgXAiJLyHF+SUSbehECb0kHRixpTNoryUJnaw/RV7GMi8fq4RAGPj6E8vEWqONodXw8JTMGm7ZUsxji8lmrctI5MfJSYHISMrh2Rq3HV9gYaZOtxfT66ekackInl8T1mKMJfAlLd9nthZyZsV13rbGDio8laox5WZwm7ErURiqB3+XWTfsRugz2wyYaQSEvkKTNRKzAg9FTQlUCv04xmhLLfCQUiKEYLYWsBg2SXSK7ico4RFISVe7/gXX0sWyn2GA02sdrLUkma8IGJP/gJ0YoM/Ufdb7SWkxqkI6N4FQ3HXd9ohEMZp04PAR3u7Ly46i6SluaNSolcpimtSNvav8sR/E62bqHG7V9nYQU1yVEMbCSgf/M98gecHtQ6/5n/mGIxJXmYwznpes3FYjLSXOnviZuwC4/t1fQejh8S5/13HWXnTkcg5xim1ipV/nfV96CbLrNMsXTQPdyBQYsUBsUamZNpz0aCMvQ95VepRQtE9sj0hcLiQzsPIMiSllI/oH3Nhro125mWYlLiX2NZmwxjizsrX4mYFaZ+VgsS5wV1JijKVvDJFOaccpWhsX1AOR1nSSlChr4ibIV3EzKRJQU5JON2Gl3cdYSy1QWKtcJiRrjpevOORxmLGAyVeBMzN0aZFVScGth2e5bqFJmhoeenKNU0ttkrSUYcmGYQEFBEja3RS94IJ915ivDDEoSYsAkXcRtkVvCIRESgh9j1bdo1XzaYSBy7xkZuxASnxPoBOLTjQYQ5JXuxKOXAVKUKsH1OoB2lpIIfR9lPIQMDCBX5JvfoqdIM7m+BBGSPhosFGGkoJW6NNP9IZeGIEYdFbP0Ay9SiIwX/e5bq7OqdXqfLg1g07YNh3Mp5qvONxqEAjJubWdl2hVQgwRCQCZfSZPm68XGb4cDV/x1OmRPIWwFta7GH9EHrre3XsisbwKvgfXbdw4byNYxRCRAIiubwJw+s3PGFvcSY7WSeeC3dXcn67UXnKcbc8i297g88luWSaw5DckoQVed4OMhQRdc6VZNyMUeqS3la6ZSiJhAkgbdsPzVkHXnJFbGDZtnLcRjIKkMXzuvOSs17Vj80nYTF61m9TydL5XYl+TiSRJieKU2ZqHLxWr/Zh+PLhKBO7HIDWafpqRhqx/gxCC1Bg6sS2MzSoPWrKVfgH4UqJTw3ovJU61y1gYidEWjMsy5CZkcm9E5o+wdlxSkgf7Sgpm6wHtbszJi+t87eQy51Z7me9j/LqNE0sUJwjhJC1DGYx8D1GWZ7nnpHTryEIIlJLUApeFmKv7+L7LLkgpUdIZUoV1F7jVFhMbtNbuvRiBlIPMhhSCQEkwFpNqfOVRm2kglKK71snM8FxTF8vViifbPU6udkiMwd9N4ylLxoInw1OuMdLk3yJLnCZb7hAdeJJmUH0bmgn94eugdEiJoO55qGaD0HP7a2M4vbK2pfMCNJXicFjtQQGYC7wxj5Ebx2Tp1RTXFmzgET/7xt0FH1tFlMC5i9DPoiul4KaNPRRlxLPQvn7yOLu3z1U+v1nVnU0xDa52hY+deRr/4+TtThe0zcYDZdmbsHZTbZFRTmq14VaWoZX+jc9vsX710dQGVZOtckG/MIP3IGzWg2KLiOYE7Rsm/95JTfUPldjlNJvO90rsazLxzdPLrHZTbjs6i5SSbpLSxwW8Ski3Qm4M63FCO04LP4TM7NKpIcsquFKxUrh+FCbrUeFLibDQ7SfEiZuVSoqs/4ObUUpC3uEtLydrrC0qKrnr2wUfYuQiPrPU5eJKn9NLHc6udulFeTWqQbCSm6e7UYoxhpl6gDE2q1A1OFZ+3EGp10yjKSVKSVp1n1bNp1kLCALliICg8FJIK0CD1QatLWmq0an7LBxJGZS89ZTLAqXauNU5IajNNAlmZmmvdWl3Y5Ikz7BcQ1fLVYgn2z0eW1pnpR9nhLaaUCx1+5PNznsIC6QV3YEfPb/GTYdm8TbRhJdR9za/PQWeZNFzsiNTmm8Hsv4TM/UBWTjfj4kyg1PL8zgc+Mx4268GYk12TUyNE9c8rJLoE6PNwSB55vX4Xz+J2Ot+JVEC55fd350pCQtc/L4bAEhborijNk+DlwVf0Rx0rnflPbcLm2ewp7fqy477zjyd33vkbr68nDfJrCYUIpKX7/upOI+/Jkhm7bY6V29FfuWyBKXzZkFG2nL36ZXS+WYeBS+rAh7NC9ZPSPoLO7gHG+efvSwLBE8h7Gsy8dUnLhAEIbcdnSXVGqNtseovhJMwteOElX5CnBlXPSHQWGdaxgXJMhMz5FWUlBQoBMJY+rEmStwquxTOI2eta3onpUAaUXgjikxETiSMqA6mBRhjefjcGlZbOv3EdY4uqj2V/rBusTgxBiEMXlbJI894FPcfsiyJFJlHQuL7knroMVMPmKn7+J5CKYWSLqOQS8GEBqNdFsJom5EgW5lZEMKRCSGEM6JKgc2qZq2v91g6v0JnteuqaNnJ+vspdo9z7R6PLq2zmjUGNEBqLEJYvNKK+kovYqV/6ft9WCyprg6uTi63uX5xhq3G7nV/+7cmKQSHZ5qA4NbG+ImkEERZ5q+l1I6IBGSmb+1s7VNCce3Chh76pkOVr6W3HsV78Ozek4kyjIXT50HA8h23jI9PDcpvxnPQX9zheYRbYRZmh4RiWipzR/jLs7fyXx5+Ll9ZyTwrxWc/TChUV2L1ZSr0PeH799cFSQuQW5sgsroGx8YQgx4W8YLJ/sxeAKyyeFlLl3hW0J/f2VwZZOJ2SCim870S+5pMLK31aDTg5MU2SghXhcaCMYbIWNbjmLW+M1xjXS8EGJAGkcmBciIBFiUEKqu+1I9T+rEmp8uuMlSezXDBtLUWnRmkjRkYrk12vAHyvw/IwGonxpisy7UZernYxZ3ZutUjBL4n0caRoULSlEutpEB5El8paqGiUfNp1X0aoYcUEp3FQIF0BEprTRobdOG/GPhNXIEoWwzJScZcQOZ5glroEYQeqbb0+gn99VV6kabX7ZPEadGF/CrzJ+5rPHxhnTBwgtBGoHhspc16NHzXNkCsXePFfuKWhs63e0i5N+blODWuFHGJJIrM2G+tJdGTf0UutHscnWuMZSeUFDSDYSdCcwMy4UmJtwM515FSWV1j7IC87wAFoRCyWgo1xb6HrQUkt18/8XV9bB7xxAVEfGUcnZ3rBn8XVuzO97BbQjHFpvjY6afTaGX3NQH/v4eexwNrI1mvEqGQkbuvqHWFDuymZVS3BAHWgzI3EaZkSt7gu/f6zo8zmp2wjD+3EZkwPpuWb63C+k2D+6yMQexifWzXhGKKMexrMpEaTRSnPH5hncVGCEIQG0NsDN00pRs7nwOZ/EgLlz6QkqycqjtOvsKvhMtIpKlrvJZnMyQuK+HkTe7vsXaZBGMg1c6InWclconTsHlz0LguP5bWBp1Jrdwmgz0KiVRefcmCkM54GqcGbe3A7yAknhIEvqQWejRDn2bdJwg8LK6ZmS+dxtwAJJZ+5PpyGF02KQ3yKFkD7kEAmv2plJNNWSHpxIZOJ6bd7hNFiZNG5ZkNcvPI9Jdpr/DxB06jstX0Q7M1mqGfeWKGYYF+aji7NugMbYydSCiMdnNRAHKTgKTdT8eCcCldpm6zr/qhc2soqWiMeCS0hYPN4QpJUbbiO2YYB2qBIvCufEs+ay0mTknMIJ/fi3ayJDfFfoS+7gDqydUrRib2HALCIOGGmYsApL2Ix7eym9221H/DY12ruPdLr0TWs/vcRm/UAkbgrQ4ibhULtLAbBuFWuNX7DWEFeqQYnUiByJ13o/u/1wVdE9jR7ERFvwiT/VtWSJ10DfRkq9plgzA4SVVz8H70FjIv0/lejX1NJrCQGsNyJyIQEuFJ1tOEfqpJjVttz7te50G8JyRWQGp1YaQUwsmfpBX0o5RelJIaXay4SukeeaCMyPo1WEr+BTteXckK56kSg/HmlgabrYzaUpprQCTcw0mXstcECCFp1nyi1F3xnqcIPY/AUzRCRbPuUQs8lJKkFredhZryqCuFSS1pakgi7YzVWQoiz3BQOv9YzJmZwzwlMQbOL3dJEk0cpaRpWnwGeew3yGlMcSlwfq2PN+9kbGPIrotR5IQi/65yRFFKt5eghCD0N14yqpKtGQNmC640pTweujBeeakZ+hybaw49l48jStIiu1X3XJGAuue567GyQ55gKyXzrTVYYxByZ1InYzRpqkmShPPnzxfPR8nOO2pPsb8QfO4hZPfSygetgPj45g0SZ4IevtAs9Vo7Ok/Dj5mrdTnaWuWN3/ZJALrrmv+1pUEyNaRuF5uYrav8BioS6LCCUGQ/s3m1po2g+nZMWmM9SD0nd94oo9BfBOtt7QtKs2nor7vjApjQYoWrAIUETHV8sNVz7Aa5AVwH0D02OJ/pb+Hc0/leiW0t773rXe/i27/925mZmeHw4cP8wA/8AN/85jeHtrHWcu+993L8+HHq9Tovf/nL+epXvzq0TRRFvO1tb+PgwYM0m02+7/u+j5MnT2578CbT/feSlKVuxMVun/UoIdEGKQS+lEgp8JSkHigCpVBSkJRKZHpSUFcKtKXdjWn3k6GKSnkfCnCNqkTmmyjxg2IsucegiLfybXPjdaYXshZXTjXfLC/bOmkxXwyqMdV9H20sYaCYawUcmq9z3cEmhxYahDWfBIgMCCSzfsCs5xNYgY4NJjWYxDgJkrFZR25b2UxnvKzr4N+dXkKn3affi0kSV2o3lzUNDbv03yn2HnqEFAyeN1xY71bs4ebp6mqf5ZVe8ej2Br8gu08kVX/fA0Hh9hD6HqGShEryrCOLPO+6Qzzz4DwHaiFSjN++hIATtc0IkSHudYg6a1ijsaOkxBqwhjR1RHn0QzHG0F5vc/r06SEiMcU1BmsR/eqSNKIXX5asq/Ulj//fd224TdOPec2tX+Qf3PVJFutt5sLha3+m1mOm1mO21me21keOBLE1L+H51z/I//cl/7MgElNcOQgt8Fer72EqEgMpxegtdWe32GFMiAit2tmxkxlXvtb4ls7NKe1nJPSvT5zBuioLICzxgS1k+ja69KQFadF+RlxGYxsF0Tys32zpXncNRfNXGNsiE3/1V3/FW9/6Vj7zmc9w3333kaYpr371q+l0OsU2v/zLv8yv/uqv8uu//uv8zd/8DUePHuVVr3oV6+vrxTZvf/vb+fCHP8wHP/hBPvnJT9Jut/ne7/1e9ATz5iQ49Y/LCPRSTZQ6z0Qj8JivBzQCL+uJIAFBrA2xNhjrvBF1T1GXil4vYbUd0csqJpF5B0qFkVxWIctS+EplVWvMWEbCZgMbmKGz5zM1UbF9Fr8UfSHswLydd+4WWbM5KTMiEShaNZ96oDi80OC6A03mZ0KslPS1xVpJyw9Y8AJaKERiILVYbbEZgciD/qIRWOb9EOVxDhEJl6aw2d+NMcSpziRNeohE2CEyVJXemGIvcW6tx3ovGQ5qbLU0aCvQ1rpraMcQKOkjKv6n/GDH8+Ge6w7z/BNHaJR8FAcbNY40a5lfQRQeJumGMfFcFktvfY2os46O+3SXz9Ffuzg0eWV/Hdlf55HHHufhRx8jiuPBdWMtq6urLC0v7+zNTLFvINd61D7+VUSSjj1qf/ElZG+D2pe7gJVgaqp4bIRQpbz+9s/wfU/7W+459jDvfvX7+b9f9CfU/ZjQS6j7MT/5so+5x0vc42BrndBLkcLiS8133vJVXnf75y/Je7lc+M3f/E1uvvlmarUaz3ve8/jrv/7ridt+8pOf5MUvfjEHDhygXq9z++2382u/9muXcbQZJplvdxrfCjD+zoNjqyCeYZioZI/eUbO5hGoC1m9PWb8jwYQlOdGMJp3Vg+yMHTyEYcNyxbIvkJEs5EbFp5g9oZsG3TSs3KVZfrYmrQ/IkJXQPwD9w1MSsdfYlszpT//0T4f+/d73vpfDhw9z//3389KXvhRrLe9+97v5V//qX/FDP/RDAPyX//JfOHLkCH/wB3/Am9/8ZlZXV/nd3/1dfu/3fo9XvvKVAPz+7/8+J06c4GMf+xivec1rtjwe45b4h2IHgcs2GAu9xMmdyEzSziwNoVIEQhDFmtVeTJrqIiCWuW9B5NeRKIiAkAIlsmpR2cTPkiMUZmkhXIUXAVhREB4ga3AHUglEFvW44WUkIjup+1Nk1aMUgado1QKOLTZACPxAoY0gtoaaULQChQKEKREHMl+IKPs3zFCFpkJyRTmWGkuLlG5uAimkq/xkBjeBYWlTyStiB89OcWlwYd01UpxvuDIYsdZcWK9uAHc5IKWkVW+OPd9N0oq5tTss1EKUECx3e9xYG28lFzFMjCyW7uoySX/48zE6pbv8JK16vfI8jz3hsqbHjx4linqsr++8Sd4U+wuiF1P/H/dftvNZAb1bZzn9z+4YjCGTvIzKP5Sw/NNv+0u+49hDQ89fP3uRX3/t+/hGdKzyHD/2/E8A8EdfuofnHH6cF5741h6+g8uPD33oQ7z97W/nN3/zN3nxi1/Mb//2b/Pa176Wr33ta9xwww1j2zebTX7qp36KZz/72TSbTT75yU/y5je/mWazyT/9p//08g5+RO4kUoG/sjPp5Z4MR0K0OH6fvhRFh3TTYCWE57yi5CsIgjUXlq4/LR1bFJI9iUxGUw24TESrmoGs3uF+B2YekqQ1QTw/jUkuBXblYlxdXQVgcdHVpHvkkUc4e/Ysr371q4ttwjDkZS97GZ/61KcAuP/++0mSZGib48ePc+eddxbbbAvZvFCZTsdYS6JtVnXGeQbyaksWp7v2LCyvRay0B/0QchQZiewf+Rq+yNIHOi8XmzW/y7MQQoJSokQUAGFLgXruJ8i28eRIYC9K5VYlgaeYadQ4ttDkhsMtjh1sMtMMWYoShJQs1GosBDVaQuGlQGyxqWM31pJV9ihnDEq9L/KXbDkjUurUnX2wVTIlKcVg+5FHeWtb+u8Ulw6N0Jnsl7sRy92ITpRS20FZ1b2AlIJGlYcDaPge8hJUPZr1VCWRAAiFGpq+naWLY0RiOzh99iyra+ubbzjFFDtE59mLQ0SiDJEO++ve+cI/HiMS28EPPPtzPOe6x3a8f3ksxSrxbh87OP+v/uqv8qY3vYmf+Imf4JnPfCbvfve7OXHiBL/1W79Vuf3dd9/Nj/7oj/KsZz2Lm266iX/wD/4Br3nNazbMZlwqiFggO6p4iEiia1fmd9PCxNKvXk9cEkYhE0pEYhgzD3pDthLVrSAS28D6rYbo4G47NF75+X61YsdRh7WWd7zjHbzkJS/hzjvvBODs2bMAHDlyZGjbI0eO8NhjjxXbBEHAwsLC2Db5/qOIoogoGhjd1tbWsjHggvksE2BxmQVrLEZYlHCVYlLjZE01X5L2Davdfqnpm82yB9n7yv8j3Mq+EXnmwxaBuBEGbVypVZtVY8rlFkOfkcl8HdkVIaXLWhjAxqZ4A0K4TheektQCj5maT6vhEwYeUilqvmK+UaPuS5qJxsSQJhq0ITWiZNbOUwQDEpOzBkv2uYxkC/J9S8mHgXlaiNIxs/GXdy9lOMrvffBJXEuXyuXDpPm+VQghqPk+/WTcTbey0tuxDOpK4J5jB3dVejVEEQnN2vknMXpqjr4S2O18nmIAkQqsZ/kPL/8gx1vLV3o4Dpeg7v7oHAnDkDAMxzaP45j777+fn/u5nxt6/tWvfvWWFyc///nP86lPfYp/9+/+3Q4HPYzdzncrQNcsqj/+maaN/RWB9m7cnRSw9aBH+5YU2ZcIfZW88WmfiUrsODPxUz/1U3zpS1/iAx/4wNhroz/+1tpNA4KNtnnXu97F3Nxc8Thx4sRgP7JgtrSrtq53Q25QVVLQ8BVRT7PS7meG4bwyE2MXZx6I55WatM5r61ME24ZBc7yBZs8NxkmMnL8Am5GRjPAY66RIrrKTxFOKZuhzeK7BDYdmuPHILMcOtTg03+TwXJMjsw1magHr/cT1vejHRP2EJNHF+8g75hVjLkmWil4PWYam0GwNvdvhvw4kYwPvCNn7HbJli7G/ZHtlYieBa5A3xbaw0Xwvo1XzCf3qzzcnFADLa/3iYbcZmMfaDj1yHw/AXCPk+GKreBya3bjqTH0kO3GgVee2IwtcN9+6JFmLHGvnzk6JxBXEVufzFFvDf/qu3+NYa+VKD+OS4sSJE0Nz5l3velfldhcuXEBrXbmAOWlxMsf1119PGIbcc889vPWtb+UnfuIn9mTsW53vMhJD2aYyrABdd7+1yawpHrutdKRDitKuInX9GorHJlWtvR6uD0kG1RcEKxKvLUZiir2FWldXD5GYYiJ2lJl429vexh//8R/ziU98guuvHzT1OXr0KOCyD8eODfSa586dKy72o0ePEscxy8vLQ9mJc+fO8aIXvajyfO985zt5xzveUfx7bW1tcIFakFnYa7H4ylVwSlI3uwPPNbjq9VLWu3GWKSitxo9cBDZPd+Qv5NmPYoPMZ2AtMi/rJAbr8DYvkWoy74MSCJlLgbKKUFISeorZRsBsIyDwFb6vaIYBrdAn8BVJaljtxZxb67PWidDGMt/0uX6mjtGSosFcNiD3XmzpPQy8DFhXkm1Us57LNce4Rem6VVkmBeHkWXaEcFStkogsWySFwExvAtvGpPl+rNHAL0mYIqHRm9zFV9b6Y3NcSFlU8hqFtZDocYJZxoGZOr5SYzx8K9/0icWZrCACRdPIHFKIoayJ3KPy/UEQEEX9PfdsTLE1bHj/nmLbeEIv0rJ9gqr6oVcC1beSnR8LeOKJJ5idnS2erspKlLGTBcy//uu/pt1u85nPfIaf+7mf42lPexo/+qM/urNxlzBpvv/Oy95Hc2aw+PMrn/0evnxu8nVggWRmXJZj1TaaC1ZsIxNRlGsden0LN3B/fWRVfvT4pZd21AW7CvkPzdVy+74E8/1awLbIhLWWt73tbXz4wx/m4x//ODfffPPQ6zfffDNHjx7lvvvu4+677wZcGvKv/uqv+KVf+iUAnve85+H7Pvfddx+vf/3rAThz5gxf+cpX+OVf/uXK805KcQo56AEhJVgr0FnaIFQS5SlSrel0EnpRmsmRMmFTJl+yG15MmQyJUoyd/UNrS+jn3W8HPRaKYFsObnAWQAg8KWjVfBZaNRqhh+8rlFLUA9doTglJN0k5vdJhaa1Pux8TJQZjNEJIrNVc16y5N5iRADkyWpu9UCZKlow02GzwJWODHf5n6V3nwZ6TOuXnsiU2IUY+sLLcaUohdo6J8z0vIbwFGGM4t9yZWL1SSDGepMqwWcwtEGOlhMHJ4JphQCeanNrOqy5VH9e9TjoYwJfPLAHwzCML+KXO2TZOsGkylDmrwtrqBawx+L5PkqRYu3vN7BTbw6T5PMUAy6+8jtUXH8FOyDTmeOvL/pyan3AyWeS4v0JNXJqKUlcas7OzQ2RiEg4ePIhSaiwLUV7AnIQ8frnrrrt48sknuffee/eETEya7zUvpl5qtqk2KlkELgsx4d421jgugzBsTTpTsbuwLltSrrq01X2L5+3wIlDjEZcd792QDlWDCpYU3oockJoJ6B+yRXdtcTURiinGsC0y8da3vpU/+IM/4CMf+QgzMzPFBTw3N0e9XkcIwdvf/nZ+8Rd/kac//ek8/elP5xd/8RdpNBr8/b//94tt3/SmN/EzP/MzHDhwgMXFRX72Z3+Wu+66q6jutB3kpVPnagGB7xUN6IyxrEcJvViTaOO2Q2Bl5n8wouR1sCMBdckMUFqJz/0Clrz8pqtcJHISYSnM2G5fd9TQl8zUQ+brAbWahx94NH2fmq+QUhGlKRfWeqx0ItZ6Mb0oIUl1IVkSWIQErU1GFmQW8Nsi8LeFp8O9t5z0FBdgKZUgKuzRZflSTiCKwLX4OAZLBG6bYTqRE5hycDclFZcOIYqIydkJYybfecf7iGTPA9oaVEUPh83gyMDk1w/O1IcIwaRjlMeVZD1fHji3wi0zIWG+vymoM1Dd2Xt99SImKzctEPie5xosjhEK51vqRQn1cNzM7asBicuXB+x0Zk+xS5z9sduID7sKYnrGRzc3/jl+89/5CxYaHYSwaCRn0jkOqzWacrhxXmI9ntSzNGRM14y3Gj7uL+NnUZzEkiJJRlsYbwdXcKU2CAKe97zncd999/GDP/iDxfP33Xcf3//937/101o75HO4HPgn3/aX/Jcvv5T/c/rW8Rcr5NdbgSsrbJEVfovNd974lDLZvpwplyfVTg6bqYUevGYllaVg+wctplTYylJNKKxwx5B9ialVHKh0YhO63yixCyP3NDNRjW3dQfLqCC9/+cuHnn/ve9/Lj/3YjwHwL/7Fv6DX6/GWt7yF5eVlnv/85/Pnf/7nzMzMFNv/2q/9Gp7n8frXv55er8d3fdd38b73vQ+ltlcSTQiBpxStMOBAvUagnDzIaEPbpPStwXgCKRUyEW5VUmc+CAbVlbDZhMz+MlhgzzIT2RM2W8oVwnX9TbUp+QsyX0TmjVBS0Qh8WqFPva6oBT6hp5hvhoSBR5Ro1noRnX7KSqdPuxcTJVn/hizF4YLzXIs06E/h7jM2IwWDFebCH0FJvjSmYZrwWRbsg6H3q4u9bFH2VpZvOXaQDRl8Evn3w45uiFNsDWIsN+S+iwQna5uZq7O+uv3qRbu5vwkhaIa+67FScdy8j8rEc+vqs/dTjdGmcj7l0sTycdvry+gRn4QQAuV5oF3HdjFEmJzEqhe73PxsPRh0nx/SOTrk6wWjmFqEptgqkoM14qPV5YjLEMLyxuf/NYdmVoemYWoVF/QMeTHudePaHxsEqVUoYWhIl7lYVINyxjWZFAtKABKDwJKOEAq5xTtBXplmL7CT47zjHe/gjW98I/fccw8vfOEL+Z3f+R0ef/xxfvInfxJwsqNTp07x/ve/H4Df+I3f4IYbbuD2228HXN+JX/mVX+Ftb3vb3ryJLeJQY52mP0xghCXrDO2kTCbY/gfishY7/+GVscBUFMizkg0zCYLJr8tEQPXt24VgI4QiWrSYiug0D9kqSyEZRygATH3CQITFBFlfu35F09MJHpaRQ1zR+X61Ytsyp80ghODee+/l3nvvnbhNrVbjPe95D+95z3u2c/oxzIUhc60GTV8hUkGamqJKk80JgsqCGAVYUVSAUjIjEblxOWebo3Mpi7GHJEDWVXlKUoOSEqMkJvNQ+J6kHno0Qp9mGFALPOo1j1YtQCKItObMcofldp92LyKKNVGSkuZmasrrraXVfpubqw2eUG5ltBhXyWhdljllQVAexDmikHfqFsMzuSRbyrc1uXm8tEwiGao6O0wkiuhq8KFNZeqXDk2laAmFxdI2KasmcVkzAAF+oGjN1miv9S/bmAQQeKoy0N6SZ2GH8yUvNtDrutKtaVIt/5BCYIQczryVkF+DVWRofKBVzGHKnqfYG9T8hO+58/OA5cbFC5XbxNZjRTeQwhJXZBdyKU1dbiA9xKKwpGMX3/64eb/hDW/g4sWL/MIv/AJnzpzhzjvv5KMf/Sg33ngj4GTUjz/+eLG9MYZ3vvOdPPLII3iex6233sp/+A//gTe/+c2Xddxf7N6AOpjynPqjXFya5dTZxeK3HgRoZ4zeCaHYDaycEOReylubAKMgmXEn1uMJtdK2jkhUqrm2omIVbkWr6j1eS8H95caVKUi/RzhQD2n6gWtSl1dbsu5qlIisTGxGADyZBRxZhaVsJgorENYibCZ9yjIADuWAnSIrkXMObS1hZvj2PEnN96iFHmHg0QgD5ho1Al9hcL0p1jp9ljvOUN2NYtLUDFVdGiCjCOWT4QKdKDV4PoNxZcbuonFcnpkoHSd/QgqRZWDAeUZGc4alk5VzihnvKJtjR3lXZfDIFgPIKbaNplLUlSz8BzEWbcYdb8GEvg8bQQhoZr0bOv3hYx5baNKqBfTjtJAgVe0/CYkx+FJuKIfaKayxJPHmxKlckWonEFBJRKaYYi/hScMdx05uul1svS1nEaqgrSTdTcupq0D28Za3vIW3vOUtla+9733vG/r32972tsuehRjFl3on+Hr/GKphONpYIYk9TpsDY9s5KdAOPpT89mTHnza+RVoxOcuwwVQoMgiX4mddgq5tYbtJRGKLEIlAxFOZ015jX5OJuufjCemMwfkyeDZHpAAFRcpB5BVkjHDBNy7tZo0zZWNc1SVMbua2g87X+QldFOEMqNJ1+/V9Regrl42oBTRrgesPISWeUPTilJVej+W1PqvtHr04QZe6VA9W+CenACGXMFm6SUorCEsapmHJkdtlYJom80jkAVAukRpbgyrzjhKHKUtp8kpY+cmqdOO2fPyiUd8Ue4mGkkNEYjPUGgH9XjyUTZr0tUgBzcD5eWBAIOfqzlB4eLaBp1yFtEQb4lQTp+5XSRtLP9XM1qubyLltDJ0oQVcQESUFC7sw6gohCWtNon5nx8fY4pmYZiCmuNRIUsWnH7qNF976wCU9j0Gi7VSfd7nwtd5xvtq7rtLPUoW8t8iWYEGWpTq5VLMkrXASJoswjqwURcEkaN8yLp4tQYKZNBabNbfbAayEpGVdpapLXAFSaDH8GU2xJ9jXZEIJkVsUBgvpWNcUzoLMl+FtFvoqkEpS+AyELfpNFHKistyH8oUlitc9KagFilro06qHzDYCmjWfeujKvBoL672EtU6XC+s91ns9ojh1AZTN5T+5QKkkCSr5M4rUQ/aecg9DJ0oQzcEmoyiPV4icGOQSJYEeqgU7LKsaPs4wLO6zGr8ERekI1knJqr6sKfYENSlpKm9sZT0UkqZUdMz4ctOJwzO010vaXGu5sNYjSoa3VUIUlcVyNAJ3izi+0Bo6Z97puh9rlrt91vsJ2lg6cYKSguYGGZHVTkQ3Hi9r6UmBnHHFFLYP5+cJay2MNSTRzjtdTzHFlYawECceH//mHTSCiOeceOxKD2kypiu1W8aD0WH+tnsjkR1ecGk2IhYX1llanhnbx+uOexhMOKhyVMA64lFpLh75XPPjidRmkk53PBNkz20Q0BsfJxuvOIfQFrXNVX8rIW1akpksvrA2841cpZjO90rsazIhhMBYkMJ9u8YaUmtJMMSZdKjmZaZsmxEDz2l2cjOzNQKTusDbSvec8xYIZC4fylbYpRB4nmAm9GnVfRqNkGY9ZKYe0gx8DLDeT7iw1uXCapd2NyZONRbtOESptn85K1G8n+Jvwy/knMJiaUcpafZe7Njm2ZYj12FBLzIDda4rHN2tvO1A6JVlICxZE8CMoNiRDIe1pa3HRFZT7AEOz9TwJ6wgNqRigYCOGQTRApipBZxYaMFCa2j7Lz9ynpVO2fxn8YSkVVHNaCPUAoUXKVa6A4PnUidCCkE9GP/F6SdZgYEKpMZydr27AzJRqrYkBI3GLB1jSJMof3mKKfYNRClY0UbyP770PJphxK2HzyIAb0SfcqWn99SQujVYBJ9uP63S27K4sE6SqjEyIVJQXYEa+ZbjBYMteylstuK+zSpF1gM9UoLWem6xU1QE9FbayRIjAWkT1DaqFVvpunrHs4O4yHog0xKhGC2De4Un/HS+V2NfkwkX4+YGaktPazo6oW8MSEHT95mrhfTilF6SuotEQmwMSIsVlvy6tjpPS2SEguKfWOPIhi8Fs3WfAzM1/NCnVgtYbNYJlKQTJTy50uXcape1bkSa6syvkYlKclJCnj3YZBZZMRzgZyquKNVExtD0PXSaNb+m1M179AOCoXMpITGZ6LEYhRhsN5SNKZIjA6JgjBlozvMsy1AWJT9OJrCa6pz2DN9+42EeObfOei8e8q/AIDPnS0liXJWxRuhxy8HxlS6AVitElIN9bSE1sEE52a3CWsuFdp/Ds3XCUl31ODVcXO8Rpxu75MoZEGthJnCZGN9TKJURVWOzz6Cq94ag2VpgdcWVrh5bwBNiQ6nXFFNcSkTXNbESrC/H7tBlIpHDWvjg/3kRP/+9/w0hLA0ZD3kkEqtIrKqUnU5x9SC2igWvw/lkFjPyXUWpRzf1sZ4tKgoJDV6n+jsVluFg37B30h3hsg8yGSYUVlp0yKbBfFkGJVMxqNJUmtvWA6ssukZBJIaPkREKm21bHp5la0brKS4r9jWZyKsSGZyRuZ9qeqkm1prQ95hpeRyebRCnmpVugpUWKeHJbp/YGAzWpetM2bwtipV3rEVlWiEpBLOhx+G5GmE9QPk+C80aIDi13ObsxTYr7T5RokuG6qyj7wh3sOX/bMArxkMk958wlNQCj17XorPgryxnmnD7ASia/BmTUYRCbjV8TlEM0g7kVxZSbfEDidB2cD3b6vFODRN7jztOHOCrj18gTp1fIScVWlo8KTmkQs5HfZSUPP3Q3NYPrAQgId5e2+lUW9IK/4O1lidXuxybbxbz4sJ6d6JpG9wcDpXCK9VXTbXh7mNzrvpaCVGcEkXphlNMFhfyMNyxZOW483FsRILLzRmneApDSooKH9vA6X92ByaXAWaXm9jCEmVL9rMs/DDynhGTCEVNJPgT63IyMVO4ZVjBrhyxo8e6hvHK2a/y56t30jMBPROgkcRa8cTKAg+tHoT5BFZ8hAFvdRs+lszLsN3MxEQIJ3lyLUyy35gtEAkrLVHJRx5eEPh9xq6RuGmJ52y1XCpDVWlYyNZZi7KS1WPfcB7tNiyZzvdK7GsyIWVhCkAKQc1T9LQLMIw2aG3wlGC22WBuxtJLUqR1DX/aSUInThDCdc22RmMz/4SUEum5QMRqp+Vu+T7H5xuomo/neRyerROllkfPrnB2uU2vH2cyIJsnIQb6vzJcBO/+nsmpBi/kT5ezEgP5hhDgKcmBmRqh75HEmlSbgriUJVRFISbpSIYoS5mERIisi3b2+bnNs53KxMeWK99YUq0JRtd6892GSIUoskZT7C2edcNBAB44vcxSu08sDDpLBYdScn294eRsE6DNhFV5QSW5lXJYvlbGufUuJ5faY8/nOLPSKQvyUFIUcrmhUwuo+x5PPzhMgDwlK3/AwsBDAL3+uPdiK1BSIISqJDcNXxLHk3P1nufhe/mHNcVTDtL57gAQClfJYw8C8l1oHnyh0VrSjoYLGAjgObVzzNYme4jO6QZn0+bYavkUlwavnvsKAH+9/gwe6x/g4QsHeWx50b3oG+yhCJsKWJ5Q2mgjjlG1ODnhvj70+gRUejMmoKz0yBEdNPhdOXbuYMXFJP0DO5vzBaGo2N16dsNqTULnWosp9hL7m0yEilB5pAkYbWn4Pt1U0000cWpY68WsdWMOzTdo1gN8X2K0xb/QJfQEjy2tc67To2sjdJKtMGXSJOGc2EhfEniKuVYNr+5jpeTIbANtLQ+fXebMxTb9KHHVmXLJUT5ApyGimPEjUqCiUtLQhZ5rqwZEQwon5ZDSdertJppGo0YQeMRJgs7YS3HovDO1zI9vi4Z7CIFSAmMk1pqSFItChlUe7LCCRGQr0XYgASve52AfN5zpT9Olxm3HF/jGuWXOrE+oXjThjvnw+TWitCIDIQUECiI9JB06ttBC27zreenwdmcxlJKi6O5ONsRm4HHrgW1kUvYAQoX4YWvs+RgIkvMT90vTFKzF96v8JVP2/JRDvkx6hVdOHnjgBH/0/7547PnfAD78zv9nYjnkw6qLwvBEOruzE1dIs3aMp9Dl83dmvsk3zr50QCTKyBLFVavv8bypXtGXWdnXWAzd93XDHUS1ZTVf3YPI2sqNswzVO2UxxA7PbX2Drep4DYjO5MEY37rCPVHFibcy/6bzvRL7mkw87cQ8USxYXeujU4MVFhFAKgwrnZjVXoxcaeP7kusPzjE7EyCF4IaDdUJPMRN6rPQaPLbS5vRSm04vRiemCPClkARKsdiqUasFRMZy3WwdbS1ff+IiZ5fbRFGKMc6DMDovCi4xcrXmmQdRZCaGy6y684ssG+EkVlJKwsDjyGwNg8ALPMK6Rz/SgzKz+biz4+dz3mZVmHLztBSuco9GuM/MjheLNRYGxD9/zf0ZxSn10AMx7IkoEwtn+diwyNwUlxDWWFZX+8zND69ubeX7UFJydKE59nxqDV5pWezRC2ucXe1mc2qSuK76bimly/wZA7O1gJsWq70dGyEIPIQQdHvj/TU2x+5mprVgKn7Hqp6b4hqCnBCk7AWh2EV2Yrc8RgpLMGLsTjdqd1zC1JB6CaAs0dP6hA+M3L+38gFJ0PXxG5FuGVRHFh4GkTrfhZUWO6HuxlayEjsiEoC/5npd9I5c/i9daFD9it+AqudG953O90rsazJx85E5QHFhtcuFtT4nV9r0hS0kHlFquNjuo40lTi1P9+ZZbDUIA0WaCg7M1Dmy2ODQbI2/FfD4+TV61skmVNbJeqEeMlML8JRiJvQRQvDAqSXOLK0TJwPN+kBqBHlE7QzIMLokJGTx6iALke8hBHlGQAqJlJJaoDjQqnNotsah2RrNRsh1B1ucsYZeN0WnuWxk5EIYXXEQhWgKqQRaM4EZjytvbcYUhBCuW7dliP4UZGREnnUNXSvXBJ51cJYnLq5XZyZwsqIjrcmdg1Jr+MbpZdqlZnbWkmUuttI5egApBAdmQo7PjBOXSw2raljVuOznneIaxhXMUHzqc8/iLz7x3Mt+3ikuL975d/+Q3/rcKzm7Pl+9wQQikUM3Df6qLEze4AiFiABh2WLriwI7JRK7RmCwwXTl5mrCviYTvTil1fAJfEU9VByZq3Ny2XXmtZkGI00tK92YVK9RCxUHW3WMdVWRhBDU/YCDc3WeHs/R6SWcTboIIZhp+Cw2QxqhT+B7HG7VwVj+9uFznF/ukKSpq/pkB9QhR162dfgnxa06FdmInHxYMXiZXMok8KSkGfocaNU40ApohgGxgPVYI5TmCw9eQFlHZpyhGkxWhsr5NUq+i8IXMWAXMst42Ky5nchIT1H6FSeNytOQgiH2QJoafF8isso45fYVuWprWi/nykFby6Pn1xDn1/jxFz996LXX3X49f/7gGZ5sb94tejuwuMaG+Ry+ab7Jo8vre3qOUQjBmDl7MygpsFKwM7cFeMpDqX1965ziasY2k2ahSKiJnc5mOK/rnNe7INZT2cfewwpMpOjfFPNrL/tA8bQQln/x0j/hNz/zKh68eHTPzynjjFBYV0kqqai0tKfwLXa2OrMs1jwqL4aNytNuAaon8Lr7u+P71Yh93fby5Pl1vnV6mYeeXOHcWof1bkS7E9OPUhcI42QHqXZdd08ttTm33GFprUc/TvGkC7TnGgE3HWhxfKHFYqvG0bk6JxaazDVC5uohzzw6z0KjxrdOLXN+pUOS6owL5AF29YwoUwpRMjaXrZt57wcpJZ6nqAU+B2dq3HxohmccnePEQpOmH6BTQUMqmp5y/o4kJY00wpQkJoWGvURsMvKSZzzKr0rpzp3Lqkp/MOiVPfyOcqTaeUykKL2XsqxJwFTkdHnRiVMevrDGwxfWeOzi+uR7noBX3nqUG+eHMwI3LbT4yRffvqsx5FK3G+fcsW+cn5mo1d4bTD743PwRfE/he3LosZXsSewf2vDYUzxFYSamcy85/tVH/x6BSWnJ/tAj2AKR+Hu/8s9J0iuxhDzFVmG1xPQ994gG35UQtniA+1V+83f8Bd927NGh/W9ZfJK3v/ijuxyEQEYCr+vuff76lbsH2pkUlB1/bGFItjlZoje9q18a7Ovltc8//CRaKMDiSYgTw2o3JorTwoWQewW0May2+3z+4XP4vqTme9xyZI4jQoKR9Hopc57HMw7PgYSu1kgluengDIdnGzx6bo2zy11XPakYgVuDHzJRZ14FUQrqRWGoHpiqybt3Z36Imq+Ya4QcaIbMBB5KyEwmJYr3ECcGKd3qb25yxuaSqIFXS5SGUx7XqIE2z05owViJ2GyIgwpPuJuYy0RQdA4XslRSQYweYCff6hST8MdfeQzfH75ktTH005TEuGzcaP+JSZBS8MIbDvLaZ17PXMPltpUQBJ7iR+65mf/6uUd2NEZPCk7MNSlNc66fcybnM2sd0lIfi7uPL3D3dQus9lO+cW64IpQQ8B1H54pxVSFJNFFFJ+3BMSZ3dFE2Aiyp2N6KrMtKTIOypzRyY0y5qhOw8p1HWX7ZURpfX+HIHzw0tIsFHvu3z3O7h5N8FxsHSol2+1X5kF5091cIgoQP3zduwAaIEq/yOnhSN1jSk2WNW8IeasivpZXaUbzjM38P1RiuttXXPkarQYO2Lb5/T2re8OxP80N3/g02W6ZX0hB4CT/7ov/Jr3zqe3Y2SAuyzJftgFAkreH52TrcpnW4Q78dsnRqbvxQ3sZvJjmg6R/fwJezwbUgUoFFgr89qZPXldVeie1gOt8rsa/JxKmLbYT0qIcKTwmiRNOP9cAUnBlDTdb3IUpTLqx3UUoghSRJNfOzIVjFExc6SGCm7rMSJVgrODrT4PBCkyQ16FQThhIVCVcBSdiBNAhybRFFRD1QL1H8rZQlcPIMSaMWsNAMma2HtGo+oZKY1KK1RWZr/UKQkQjQuhz0O5KiSmZtSqQgc18UZGY0NSjIx2MLb4fIdU6lTMqQu5tcQuV6XLgVEzGoFjXFJUOUanRFYG2sRe/A+esrSd1XNINh991CI+RHnncz//X+YULRavkIAc+59SDfeGKZi2vjMinBuOwoJwNHZ5o897o5ZrIa+zVPEXoSv+HzHdfPYZLhCRTk/SaMJU71mBZdm93MOTvRHA4QegLUeJUVYSOwO5eUTHENwRjO/vhtRMccITUND93w6DxnkcdumhkLOHRrcJ2Z0IxFJEILxA77BAR+Si2YXM64dxj+yUd+fCxL+Oq7Ps+33bizhYMCU9nHlrCe1pBJBXHb4edX8xJC0jGH45HWKj/7oo/yK5/6v4Z3yGTZacPidRnyTYyNp+LfXkcwd8cSXtPJkqRnkMpSn+1zQBkunJ4f3i87fOcGjbcQIUY6WWsrsWbn4hixwe1f9GW17mYv5up0vldiX5OJJE6RniSWkKSQpAaTlWjNG09lFV6xxr1uDXjGXVcX2oJTFzs0Ah9tjWt6FxmkFByda3Dz4VlmGgEPnG3TjjUzTZ/IpkQ9TZJkzX6yGC6Xd+QZgGG5kS0aXUkh8DwXwB1ohRycazDfquF7Hta61dZYJ1mgP3ivAgHWFESp1CCbjAfkLTfGJmjxuiWrJZ6TLVGQASHycbqj5j2yRd43A4b8FMK67ASSsR+o8nmvqavlKQIpBIvNkO+/+0Y+8vnHaGVBUN59uhYobrt+nodOr3JuZXL9+lF4UjAT+szVhm87SroeMRMbxWWTr6o3Rd63YieQNsWjO5adCFQu/RtfQdaiBjZCmp1UkJriWkMyF5AcHA4QTaAwh9Sg828VKnTfVmRFDHZIKJ5x8xP8wHd9ij/6ixcNnhTQPwDWgzMVpt0//uK300sCXvi0b+7onFNcfVDCcrS1wtue/+e857OvHkgWsglnpSMUqre9uSYMKF/jhcPZBCktyp/cFNH4uBKuI2RCWIuXWtJ4h5leIyAZz06ISI6vnGZwZXL3IDsxxRj2NZkAF1CkqUEpQamVgkO2Gp+vnBsLiTbZtSWIUs16L2Gm5iOloJtohJQcajnPxMGZkEZNUVPg+wrlK4K6B0qgEkmaWNJYo7XJMt8Dy/FQgC2cUVkJaNV9Fho15moBrZrP7Eydw/NN/MAnSg1r6z1HkuRAROU4iiiIUVlPVAT5mXnb5Nd5LreiTDDGqbwzYbsfstHXBINrctARe+CE0MZgUS6D8v9n78/jZbnO+l74u9aqoYc9n/lIOkeyLMmDZFseQLIBT9hgsA2E6Q1JGEISCMZvfCE3YUiCIRfIJ3kZzOSQN44dIBjCvRAzGxswNjE2tkBgIVseNB1J5+hMe+qpqtZw/1hV1dW7q3vvs/c+krbcP6nP7q5h1aruVVXPbz3P73mEGDf2Kv/O8NTDcrvBXKM+J6AQgmPzTVrtsCQRVbTigBtOLKCk4OzlHq044MRy2w8R/cRk2Si9bruGRbjRh2CofPjhZEjvXp9hhv1GEZ+6S7SbA44eWh1pL1lmaoaey5051np7zKY2m6l9UuBtg/oBI4Xj9OLFfFZwfBsnwTR8BIVMBU45TNN5DeaVVN7eA6o6kF3BeYIzElmdymHIWN0uCpwqLKPdH3c23sdxoMmEUoJASQSOQEocFmeGTKIoC1fE+UtBXixLoEJFIwpQOYlIHbTiiCiQtMOAUPqcTJGSnFhqYIxhPWkTNwPWugM/K29hs5sx6KdkmRnR5g3NboFSEIcBi42QQ+2YZhgSSuHrQSCIo4C5dkynb9ggyYt5FTSgdHd4cVR+drY4lMvPU/r6ElJ40jQsBpOHOFX6BZQVsb1mA6wryMB4mtlqmldXWebyb3no/hn9fQovzAxXF0pIAgna1sefPrxen7VpodUg3Cb+31d6rsdcI+TESptIBYSBZKEVee9aqhnU1H645cgczXB/H1TTvBM62cyJQe5tc6P5xZy1GDOAioDVSoFqLE09phMBVtqZd+LzHJdefx16Jd5+wytBnvO/Ltzpu1/4Po6EXWTu8ujYCF0htosSXn78Msff8AHA347TpuCH/vzlUw95z6PXcWh+gy+44bP7dhozXAEEfta+xgh2CH7t3jtqd7vjms9xavHS9LanpD1yyhMKG7qy4B0OmLeEm+P36fYNG6jGzmqP7BRCOVRoMFnNc8gKXDhkC8JsqaTt/DYiqfTViG15go18GPnMO7G/ONBkIlCKKFCE0odQDPIYwBHDQlTiuIVPWxlFAYttL3Y2QC+zNMKAUDl6A81jiS/EtbLgHxRL7RiEoBWHDGzG+fUe1jmUgE+eXePxdaCfYVLraz7ksdyBksSBYq4ZMh9HzIcBzUABXndhgMHAcGm9T5JaBomh30uxxo1kQipIQ+kpKIhBSRA8cyhCnRhusmUbyguteDvUTYzuBwVH8KlfvRDc5csr2oni3zzNbBHKJaTXhDi3vzefGcax3G7QbgRjBrXDkRjLpV59LPVnL3VQSnK4vXuDqBkFHFqoEE/hi8k5B8lg1Ng+sdAgUvtMJhAINDrtja0zWX804UBFJWGNwWiNswbB8PuxCNiGTEgcgbBjMcAAqmbZDE9PdG4/PKKD2A84Ccdb67zx5N+NrfuyGz4x8llIMPkNvSkUx5TkyFKHZ9/+yXIbbeW2ZOJYo8ctrXWuDUZDFjvBzjyMsyJee8PppUtcN786NhlnnOAvHryJv3jsmbX7dbKYV57+FDcsXdj1sZ1yuKoVKPAeCmcJOqP36saRPvIKBc/bQQiHCmytdsLqUd2DE7YkR8LgyVdOKEYb3e6g/rxtzaXrzPYDcDbe63GgycTx5TnCKKYZgLCOfmboZoZBZtB5dhspffiPFJLUaEIlabdCFloNmnGIw9d0sA7Wuinn17tlDYVn4Y1xKSWHF1ocXmjicGweSjHWYp1ldaDZ0BlGWmQokanFaod0EAe+6N1yMyJWAcpBYe8V4z1LDRcu91hTCc46sszgsCjh45x86JYbXkRUvBIUuoahhkIKgRVecO7KWQlX3WFEbFGSikJUURncMhdil9eXGHp6pPDri31VqQkBISSiCNOa1ZW5qlhoRhxfbrPYrI9l2EgnizIfXetxuB3vmkxo49B1N18BcRzgnCNN9i5WTtMeToTUPSWs1WRJD5N2a/Yc3X4YJgjGWewET45Ju6hocuiHRBOQ1T60aiLCZphhBF/xjL/l/edvoV9jzVzbWuNrr7+bb7zhr8bWrVs5Ym82xZCsH1IhR9R4e1I4/sFz7uF/3HvrxP684NgjvPbUp8eWb6rZzftq4/TiJV5y4gGuXxr3MGir+IsHbqrZy+MTF67jhqWLeyATEyxZAbrtENahenu/oQWtbLKu0uUZK9UOrGoJw5lU4WdjaxtlKqEQRoAV2Brrt27ZDDvDgf7qbjl1GKlC2qEgSTL6iaGbajpJVhalE7IQJ0t6WUogJXGkiEKFyD0bSWa41O1ycaNPt5/SCAME+L/Ch0dFoc8Y5XA0w4DMGlJjObHQ5tH1DgOtQVpkKEB7u7wRhiw0IloqxBpXhhEVReScczjjsyLp1JReBCEcUg1n/gthalFn2jpH9TbvBEOxeZGJqQZloqbiM/k1J4oZXqimgvV98YymIBCqqE0hhvUtisxUQriyz9baPMvQ04h6P8k4stAaSw17eH6y7gEglJJsSqanXqq53B0Pg5JCcOOxRW6/7vDI8nvPrZJk/i6eZpZskj5CQKMZMmeGZMYM+jjVytMJT4bDobOk/Jz0NlBRGxnECDG6rzWaNKkjEruFQw/WQEpU0PRLbMKIIEjoA16hZ4bdwfEFX3G5/HTDDZ/jo/1nsJFOT60qheNl13ym/Pym5/8J7l7LB87eQkePEvmbF8/XEondQgrHv33ph7jYb/G+B2/AOsFLr32IVjAk+c9YujylhRn2Cy86/BBha3TS55aj5zg2v1G7vcBx8+FzfPri5OJ0iQvYrEntK3AcVh3uODEauvY3F07R11Gx0VSjO5u3BPHw/p45iXBmG02Zh2oOx1e8lGCswNaFcTmwe8joVIthLLaH2XKaM5PkquBAk4nluRgRhLRDxaqUaDLmAkUQKrRzeWiTN7aVlKQmIs28kdsIQ5pRQC/VnF3tsNYdkGYGLMxHIfPNkHYrJJA+Ht0BQgqvR5A+Tj2SkhPLbRYvRGwOvGfBKgHKXyRGgBaFLHtoqhepVR2UKVULgbgAkPnyauhRTgRGPQ4epbrCDb0MLl/gIBc5DXUPdfcCX9Mud4XkLRbvpPRUQ0mRi3F9X13e73J/fIiZcw6X542auSb2D8++5hCNeJQ4JJkmM5NDyZpBQDbBOxFKwWpnQJqMrw+V4o0vup7nXrs8svydf3Efq11v6D90scv5dHI2p6bTnGqk5XhL1i8RSoibQ0JhjcUYjbMOZ4ajtN9dHWlLpx0CIZAqKgmFswZrrk6aVt27jJw74o+TbEAlXM+FAcgDfeuc4UohHM96ySb/xy/eV7l/3seP3vUa/vjRm0pCsdjocbS94e/XDmJhCKXh393x2yPNfc9t70c7xZ+fe2ZJKI7EHU7PXR3D/m2vfi/f8vtvIDWSH/6iP+Zoe1jXJXOWbC8GVlVMt1c8jQ2973zWn9KeHzWcH84OcdnM1W6vpOUNz/lrfuKDr6tdv9TsYZTksWx5bJ0SlmfHZ/nel4wWsfuZv/oyLvbnATjXW2A1meyBVZFBXjsMH+3aEIwjUrokFN7M8HZW2NAY6ycaGyujzwWlHCBHCIUrjLOrgcqYlNnocfYcWjQb77U40E/Ex1Y7zLVbpEFAd6DZTDK0NVjnkEIQKl+cLgwVcRigraHbTdHGETdCLm70Obe+yUY3QWuLcA6FIFKCRijzkAWHMd5YtraY+RfEgUBb76VoBSGRUGRYColnKCVNGSCEwOY6gtI1kIsfhlWx/egUFfZgnUPmOohiM+NcXiyuCGvyxyoL2wlGvRP5zENVgVEQj+ol7L0TlWxR+T+FliKUEj8VayEnPcV5GuuzaTknsJayaNrT6Bp5SqP4vSemVZ2CxTigfYWC6G+785by/Tv//NP80foj9f0CTpvNseWd1UuAI4gagCAZ9Ohubpb7hFPihHSySdhYRCg/s5ZlA5LB+DH2BULgBrMZ2xk8VOB46/9zz9jyH3zR+5DC8tELpzDAi08+wBtuuQuAEMt1weTx+a+e914u9ua56+JpAF55/DP805s/PHF7n1xjWnWUyXDO8V9e95u72HOGq4lQGALsiJB+p3jxqQd55pHzV7TP//eF7y3fv+Oel/OHDz5v4raNo+M6tG4SQQRR4LPNWCfRVoJyLJ7YoJ9O9pIr5dOyFpOhzmzjlZggSt8JhBOIFLYXUMywXzjQZOLspQ5xR3PNyhzzYcilrEeiDQvN3LPQjFhoxgQqIDGObpJyMfPE4eSJRTZ7PguT0d4jofBhPKHyhv9mP6MRBejUoiIIZAjKh4AY46sNzzdCjs01We0NMICzjthJ2tKTDKkUJtF5mFDhncj1CQzT2Ra2f0l6C48FfqUrq15XRNWVGPChwNqHIxlRkIxqeMbIn1FCkRulUnrXixDkRfN8x4rjG7Z6I1xOfEYJhKh5N8P+IwoCQPuibhOQmXHvUKTknn8ZJQShkFicr7lSQTDFI9VZvYwTEidqHiRT4l1Fnpa1TIcoJEJIXwm+FtsEz05BuI1QfGvI4AwHH7ahsJFEpBY1GF5PQjiWjk7O3PX9L/xjHtINLm3RQPj7pUBNMP/XkyamH6C6fqwl/YjNrMF8WJ99bV44NpjgWd6GYqRcvUKLM0Hq7nEiWAPgcb04eaOa76QRZih59ZKbTNMwdNOIzGrCGk3N5CBrj0ANizVqFMaMVpGvQjUMpq925b0Q6Tb7bNfRabvOxnstDjSZOHNpkyBIsAiWGjG9xJJZi1KWIAJpBGlXM0gTuv2M1GRYbVicbzHIDKudAclA++xJzocxCRzdgeaRi10OL2yyMt9AZ4Z2q0kjVHnYk6CbGMJAcXixyQuvP8xiI+DMxQ7rGykmtQgnUFr6vM1SDMXOpQfAzyYX2ZlGxlQeyuSzKDHUHLF1u4q5lL8pj1EsL1TcdRCF88ITkACJyy2ksqK1qDQxzDfLMAyqGj5VqDqG7c+4xJML4xz3nhufYf/C6w7RDHYfq6qN5ZpGxAuX57iYZjxY6C4cCGe40axP3nnCmHBAZt1E70TQXEJUwovCqIUQkqS7OjruKjDW1D40duPJKZBmGuccjWh/M/nM8OTBBoKLbzjFxp3HmL/rIkf+7/sBP1RXlvv8/Efumrwv9XaJRnJGz3N9UB8T/68/8A3cv3a0/Px7n3seG0mTf3fn7xKreuN/TtSP9Ei4XRPcUPiJhXQvmfeeRkbRUwmZCWorVb/qOZ/k2pXde05TG6CdrDWqhXK0TnRq9yu3qVkmhaMZZfQmeCd8wMPwYEFoEAKSJKhv8SqNqXISdq+hfTOM4ECTiVBKlFKsdRMy41hoRxxrzdGOA4yxbG4mDFIfU76RpCAdS40mqxsd1jY7PL66wUD7eO3cGYG10E8yHr20ibEWIQWNSHH76aO0Y8VCGGOMr6SNEIRSsNRucGJxjo11TddpjHV51iaLsIJGLHNPBhXhcr5NxagpDZyiL6V+odjAu+8Ke75KJCrRUsNQJ7fFsM93EFtCn7ZqH7zmobJvXsvCt+0qDVb2LVLTVrwmswvuicGkEE7rHB9+8GztPh89c4kXnVzhmsXmro75hx99gM8+ugrA4SjkcG5YW6vZvPToNv2d4JXYBYKwgZg7RL8zng3FTNGSKKVACHQ2qxUxA5z/RzfRuW0FgM0XHWbzRT7xwPHWJr/6Fe+Yuu/9usnGFaaBsa7iYavgQ4/cxPd+4Ot526t+fXynKSW1N22GEY5lNV0MPsNTD84JbM3suzaKn/3Aa2v3+YO/fT6vfs7f8cxjj+/qmD/z16/lo+du9B8qhxbK0jo2PaFFHGoCuT9aSBUYGsIxGIwTENOfPFnjAh8xsa0HYoYnDAeaTCzPt7ju+CEW2jFzUUgUSLTJ2OwnXNoccKHTZ7OfkmiDNpYwkqwPEhpK0O1qemnmsyDhjWGbh+zozHFutcfFzQEIwVwr5Ei7yWIrxOBoRiEOh9aGRDtWN1PWepp+atFmaGBb5yv0Oie2ZFlypfHuEDhnR50HjrJmQ2UBY5mWilWVZQ4YC2ApNBC4imfEEwZrCuLjSo/GkOPklKNkKlvhj2Nz4qOEwAlRVsueklhqhn3EZy9v8OmLq7XrGnsw2rf+dGLC8iqkDFg4fB0bF87s+pipcURbvBNh6/BYJqcCKohoLx4fC+fqb5yd2llfVHHSLXA2cGeAc715vvQ9/5w//eqf39X+FsEDepEbglFP3T/83X/Gxd587T5/e+FaXvk/v3dsBP7JN/z/kFPiIhKnuWTqDcE5GU10Erstf7cu3xaTZjN2g8+7y07w5w/ezG8/cPv4Knf1HPuTvmZnJN2zc7RPTvdMTIIQjlac0ktGs1aJKScjlWVuLqERjk7sPN5f2j7EaS9fUH284PaYjfdaHGgyccvpI0gVMBdJkizh8Y2EC90+a70BvYEmTX04AtLH/JvUkGqDbIYYZ/LMSH5kWMiFxX523ThDZq3PZNSH+y9scMPRORqNkCwvWGWNY3Og6acanEN4d0LZvyIQqDC0vd7A/8XlYU4Tr2ox5rYuCIAvm+VKsbRwVZeAwwnndRMMQ52kwItKyTMuWYvDjiVbEmUtCef999MurmpF4UodjHF19wxXC3/12HkeWtudCPmuxy4z0IvceGg0m0ggJc9cmuf3P/JAuezLv+B6nx0N+I0//RSPXdzdw+ZqwDqHrtGFNOeP0998fHKY3xQ4tuiNKogbbeJGfQYWcRVj02e4Onjkzc9lcEO9Yf+kQNTbGK/+je/lD/7e22gEV+5N69h0IqF459nbeMfZcSGu6SXAT1zxsWbYOf7/97ycP3vsWbva94/vfS69NOZ51z08slzgaMqUj/RvLJd9QfN+iiol/+bDX8d9qyd23+l9hhSORjh+3zx6co0Ljy2NZa/cCWzDIhNRT0aEw02YY3PB08i6f4JxoMnEerdHBjyQakziyUMn1QyMweZF65wDYauGrmOQaYJAUhS+9XSimsA1F9ngwEq0tpxd63FxY8B8u4ESEiUhdTDX9K64C6s9koK85EcrajdY6/zxCk2BLwxB4ZvY6nFw5b+5p8CR72tHwpVK30WuwUB4DYbDF9qT1iDyQi/OCoyxZSamkZmCISPwmonyeDlHqVah3PK3UEwMFRRbQ6R28EPOsCN84P5HCLbUmRjsc2rUWCmesTQ/FlP63o89VA6X1c16gWgBISQLR06xceHhsXXaWISS28Z270XTUOnI1PbtlPobwJiofLjvnno1w1MN24zFThbzJb/1Zj74NT87tq4tY0LUtocI65zFV4hpRlUABNtcVLJ8Im3tSz1t3ukwnwlSd4Z//oFvQTZHw9DsJKt2h9j6dUnhaMlkbLuP928o32/abULhnKD72B68E0ArHk03PkjDKzYFpo5mLWq1JE8EZuO9HgeaTFhrWeslmMyQpZZOokm0Tw1LHvcvA4lQAAKkD+nR1hIHQV5bYTSKp3xfCqO90dHra+5/fIMjC02EE2jn6GSWw0uSJDOkmfEF2nJPh3cEDHUFUOgRhscYNcAZHrQIu7LOZ1UQlUYqg09QVKHOw6lGlkNGJeTKWoytEpUiYldUzhXvXdlyGXvDTpb7FFtUKFr+zpMZUa28PcO+wTpXpt4tsJ1hO3B2aqjT/Rc2eOzS8KGx3Iy58QXjs7RFNi/Y2a+61a6p1sJwJgMjkNIXjhzZD6jThWfdiwStFeSW+g6TvBIFGvNHSToXcNsQh4mYDeHPezggs6PjdE7GpWn+nMjggIe15GE9OngVjmeE457Dd77unXz3+7+JB9dHi0JO8koU+Lrf+U5+5SvewVI8nrZzO1w102sW9rEjaKuQdnviWUKACx0im/zL/fW9N3LP3zyj/Lw83+EbXvXnY9vZK/31pxDXJAtIgVAZwqBel7Z170aYkeiQrTVslXBEweQJscPH17l0fgFrnkJVQmfjvRZPoV/oyrHe75Nkms4gYyNJGWTai6PzLElCetO3CGUqjHJjXJ71qSYtWWnpV8xu542W/sDw2IUOFzcGdAYZSgofTpVZwkARKjnMpFTVTRdkojzE6Oy9GzHLBaMGenVZvlwU1a7JBdVuZCvnhpWyXV5Ebut5+R0qWZ9GQpOGXhPL1pVbDUVXnuOosfk0ukqepogRKOe9BcXL7NborsABvX6Gah9BtY8MtQyu+nJYq0eKzk0iEn5Xh+6vYk22dcVUCCHJtCbT2chLGz3V++GcnQ3hGUpoK3n97/1TXv97/5QGrXyW30PhCHCcDizPCIbXT4jl+qBThpdU0Q4TfuKV/5PbjozWadluyHXSBvMiZEmOvuakr3U0CfMyZhZz+vSC6ktsX5FmQfnK9D7MDwtH42gPO6FqNeQE2yhSvTNyJATEgR7X/Iit9sQoZFFrYuTZAUg3NSRpYojTDFcNB9ozMUgyej1HP81JBMOgobICW/FXijyLkcNmlsQ4gkAhhPW12AovwZbxJ4UgDhUnFls0pOTiWh8ZBkRRyNKCJEm9R2KhFdJuBqx3BKZ6ARbHdDWC5MIbIIYhR4UTomqYV+f5xTCuabjc5V6P4j2U6c+KZa7qHiEP/3KVc3YMvz8nGX+suYnPIpe3U/bDFcefXcxXG1E+s6+nkIBeNl7hejEICcX4L7Q+yPjtex7mjbeemtjeofk2puXY6A3oVapnW+dIkqwkslSNmwlxFM5ajE2RUk4RQ+ebO4tPIjBctl24VHf9HM6aeuIwZYzOQpk+f3D0Vz+HiySrr76Gzu2HardxeDE2TB4zCsfJwLKiLNpZ1m1CMCUD00qjSxRq3Nac/lMKdf3ya36dlTgZT7JB8Qyrx96rykzGLOzjKiL3TmxFsCmR6fj3td5t8b8+dAdf/cUfmdjknTd/hp6OuffMNTx0cegZE4ElWkoAh6ipIbEVDp9xyliJFI64RvcwcirCobVCV7wMYWCIp9z2L5+f94TmSsfFVSQSs/Fej4NNJoylnxpvSJXjTYAEIXMeISktbWdd+TIOoignGIX1XcIvV1LQikJOLjRZiSOstvSd48LlHo1miAXmWjFRKAkjRTMKCAOJNqPZmZzzoudAeFH00Myveh7GR1Wh+ZCyCEEa9q3Yp9i/rDxdCYeSUqALnUTZvCsJR3FokTMTV7KAPJxJVKNpcxLCsKsjRCcPKyuDtlyx9dPoankKYqsXbCvMhBn4Uf9XZXtrudwbj7ktkGmHkhIpYLHdoN2MGKSa9U6fJPVpka8IZVV4ibUONaUCdthYQKrRdIFSCgLkxFAno7PJHoh8jIrtGMkMT2tEF70GaOW9Z1j46Hl6z1pk7RUnd9VWkN/vHjMC60IOqcnX0k/81Wu4b+3YmN0jplT+vXnpImoCQZEIQqHI9lIvYoanHmqGgrD1hqgxkssbk5MJrOsWzTgjjjW3nT7Djccf5+zqEvedP0G4kCDDKxs7Dh+q1IwypHC+GvYE9AYR2gwrYANoreglIa24PqmAzoLJJoR0OAXCzO7fTwUcaDJhHVRvq6IIbZKURrBzDlFELAhXWuXFLHygJNmWWV0BBEoyH4ccnWuyFEd5hidwwtHvZWhtME6gAkWgwnLGVEoxSg1yi7sqRSg1EjXXQBGRtXV96W0pSEjFXVF4H6pzUw7fF2eGYU/lCobewlEKxdA6ddXgK1f+qYsKq3pAhn0sKlnMLvSrDWPdiCahCjHBuO8YjVABUY2eItGGP/nMY7zqplGDKtMu1wX5z4FS/iUlxlh6g3EPCEDYWibrrdZP9wuJlD7c0HqXRpk1aiukCmuZk5ICZx397nrNXlNCmfLRK1XNbdClMx78eYbo/IDo/IDw0gBhYfVV9YTiX3/01fzoS/6UZk1WpQ0Ljxj/V6AQNmJF1l8X9146yUY6LoZ1Ag63N/lnt/3Z2LpQTTb2BIKOjfibZHFs3WtaqxP32zP2c87o8/GaEzDxxCfMsJuWn/iTNTZ4kob88cefz6tf/Dcjy9d1k4ENS/3EQrPPQrPPXGOAahg+11up74IVnuDWIJCWZpSVdSeUtJgJhELbUSIBYJ0gzQJwAlXnDdluPCg37tkDGFzFCP7ZeK/FgdZMFLarJxDC/83HqnPg7PBV7lPMhEqBsRYlRaX2gr8hB0qy0PBEYiGMkLkYumjTGEuWGrrdhM1uQpp50beQIi9INww3qsYE2mq/t56L22prbZnXHyEWorJV9d/RVsu+VA6y47FbfI+V1qteiZpu+R6MujxmuMpIjCE1BmNt7WsSUmsnZivS1vLZi6NVe7XxWqO6ARQoRSOcPC+hwma9+6QgEjmhcfiikXXejSCaQ0yJCZcCdNYfe0mpJoalCCFzgqLGXn55/bFSZ+kaXfvq7XN2rRmeeISXEpqfrSOmHr/78DPHBNkA6xYezYkE+PHcsQFrdrz41i998k4uDtoTj9EKU1516pNjrz7ZxHCmSzbib5NlHs7mx14fHSwz6W5gjCRJw9rXjuD2+fX5BLG7k7bRBCMa0EbymUdGifCmadC3Ua0Qe66RcGxx8nif1LtQGRphNlLATgmHqilo10/DyfoLJ0i1Qls59ora6WTPu8BbsMqNvWzLTI0hcmLya1s8yeP9gx/8IG94wxs4efIkQgj+1//6X1O3P3v2LN/0Td/ELbfcgpSSt7zlLWPbvOtd78rt4NHXYDA9c2MVB9ozoZ2vA+Fyb8PwB5pq8SJy74GxRciGwOQWvhKCSEmaYUA79C42mxMQKVypZ3AObKbZ7CQstELiIBxmbyInOfj6DlLmHouRwV0X2uTKVaWMotA1MPQ7bPUyjJ6mKMXZBUkqtp00bt2UT+UiN25bVT8PyZCnNPtTH3OG7ZAZg55S6Xm3cA4eX/UZYw4tNNF6/5/yooxDrBwXTygEDlnxUATRBEICOGtIBvXFuqSUWGtqh7UQEiHrCYqQAdI5Nmp2Da0gnPCdJ3YWYvL5ik3nCUUVDli3IRJYqEwj/879z2MtadW2c6S5yeuu/0Ttup61tJWq5bnrJuKhrJ6g3JPM0xCGux++Hr2FCH2se5w0G78ObHag5xo/r+EQnBksA7AS9uiaeGyyca8IpCWs8SYo4WtdVat6p1kwMbWxEM4LrWsQtjLSXjjZyp9AGFxscVYQXxBjxohpCnTz4LLWbrfL85//fL7t276Nr/3ar912+yRJOHLkCD/4gz/IT/3UT03cbmFhgfvuu29kWaOxTRrhCg40mci0RakAo00uooZyfr7wCFQjbdxwmXO+/oNTLickPnY6lD4jU2YsmTY5QRAIWeEqlfZ05mPShXNY64XWMndzyEIoXYkUmlQVeuxSKQwnV/GmDAOKwI2GU1XtLCl8THvBLsuGKCOYAF+Z25UHd8PjbWEJpZhauCFhqPSveDM2Y+YYXzbDrqHH3VdX5duVQnAojnjsYm6gO8FiO95TmypsYtLesP8jY3MUDtAWmnGzsnTyg9AYw6A/uXCfr5xty5TRw+NM//Z6hKw5MZbOcMFJdjhnO8PTFL9/5kbeePrTtPJQp46D3pQZlFUb8dFHbio/D8zkEXSivc7X3/yxieuTPN2zZPQa2s5U/OUHnssf3fs80i0Zf+R8hpi78kJ45XHd1EngK27raYu6meir4L0X0rFwdJP7e0cA6DU2WAh2PsNcB+dGJ0MDaVETCECxfmN9SJanFp4T1Ic4FW3FBp0EOC1GxoeTbmpsTTBwxKvAFk1FsuLQzfp9doIne7y/7nWv43Wve92Ot7/++ut529veBsB/+2//bXJfhOD48eNX3qEcB5pMaGtpBAIycNblhrsY0UyUKIxohxdb5Ja9sY5ACSQSlRvsmbb0MPQjQxQGlEXeKq0WSyIlCaUvCKczP43pRaQC4URZG0C4nIELr70YRWHojxr+xTtfQXvLyeSfReEGwWsUvNfFr3f4eHJNTs5z70vR8NZCfRSrc+7iClY2EuI0/AaK78Pm4mtrQbphsb4Z9heJsegtLuRJoUoFqj/51hXaOhJnUUIQ5F4AKQQrccSNC0MR32OXOigpaDfCiQQA6n1tBaLmEqmzlXoP299Fo8bC2LnsBkopssz6QpbV9qzNCzvWeycu6nEiMcMMAP/urpfTDDSHG957J1uriGhykS8H/F8f+4rRBbvEhjXESqKEHLnTzknHYZVy0US1+/3hPc8f80rM8ASijkzkCU8mQmyd3Rsud4HDRiCMQOQOUakcC4c7XPusx8tNzw0WUA1LK0gnP5etwKYKGdV7VgNpRrwHcaBrvRJVbJyfK9+rhdS3vQvDIJ5PMImCTI58F0I5nLQwgdS0HlJTM6PNMIpOp8Pp06cxxvCCF7yAf//v/z233377jvc/0GTCuIJAUOolqhPmpYeCnGzkMUoOB1bghMMIRxxIGlJiLSSZQRsf+9/LDIsRlZtATkKKCtYOokBhjWOjn9BPNAJvwFtL7lUowqL8hzAQFJfriANg5EOxgRhmWGLc6C9DmQrmUHFe2Lx/gZKk5XcybKtKIkbnaoePJ5+ZyY5s5WcYfLYqi8M4R2oNmfVenDkXMR/6L01MmX2eYb/gv+NJGYsMWy7ywjFgHF2d0QWagaIVBgRSshxH3Ly4MNbOmQubnDq6QCsORn5TYyzaGDKTe/Eq9VmGPQScJWouDffL+phs4Os5jJ0RY1mbiuUjpLf4VwhUEGJ0/eyqcw7r7Nhz3FpDplOiaHyaKnVXx+szw1Mbej7ELIRkh7Zx7wv4P//y1eXHr77547zqhntqi8k5BA+tjRenmzTA+ibk4c1DnJq/VLs+FALFuBboZDDgJY01/qB7dGyfxzcX9z3MpUSdkbyXtmaYjEoUgWlbTBvkQKK6EqUs84s9Tj337Nhujw6WuLa5RlONEopBGtJPIzY2WmSrMeGKzz5WzeoUSMtSq7+ldlYx0VI/ptJk1LQ0GxFsIRSlt8KCtWJiqJNNJSIdF29jhF/eGCdAqi+u3li6CuN9Y2NUoxjHMXG8t2iAK8GznvUs3vWud3HbbbexsbHB2972Nl72spfxN3/zN9x0003bN8ABJxOF0awCCdaWqVQLpu/AZ3KqLi9qSpSz764kAGlmyPK0rtpYBpnGOovKqz+XhrjzbQoEvUHGI49vkqba15wwufldY9wVF58QOcvIiY7NB+fIrCnFvL8ox+5QJO5DzaXImXrZtdw7ISjTwSpVGPR+Ix+y5EYP5LvlHzau4iUpH3i5sSq8l8U4R2YNfWPoak0/1WhrPbFyMB+GJdGZZW27ugiUQuMwdTH8o5a3f1sjou5rQ18bjjRjbqkhEgUePr/B6WMLNCNPKIy1XN7ssbrRLQ8jRD66qqSihjCosAkITNYbuVY8kVDMLdTn+y9PpVIjIwwj5hcOs7F+Hrv1exCCJB1MqRvhyhDHKh5LxnybMzzNYVqK9VecYPWV26SFrQmt+F+ffjEDE/LGm+5iLhqGlFgnON9d5N/92deP71R1RIvh58+sH+Pf/MVX85Nf/D853BwN37uYtbm1YQkm3FeVcLSkobfFA/HLH/7iGZl4KsLis0dsF+9S/nQ1dkXDYhuWRnvA6esfm9jEI/0lrmuu0lAZAkh1wKcePcm9Z64pt0nON32BuWOeFKvQsDI3TpCFcEiKlPSj40pnivMPj2eGMhsRLKbI0GCMxFW8BiaTNJrZWNYoZySD8y3clJSzdd6d+U8GY/3aN1yF8X7dddeNLP6hH/oh3vrWt+7TQbbHHXfcwR133FF+ftnLXsYLX/hCfvZnf5af+Zmf2VEbB5tMWEAI4lAyyBzejnDlj+3KCtD+c5kMxrsKfPYlfKYaKRyZdXlcusBZSI1loA3tsiyvK7UDPg7bV8AujmMKjwD1Y63QaUhBWcPBCZFrxyuz/1QvA1H2V8oiFGo0HCpfXZKNwiXi2xEoKTG5KKr01tReDIX3wb8rz9p5MZW23ujsZCmdNCPVFuOGNTWscfQCDVKQOcdAZ2wMJudZn+EqwoHp+8xCqhUgs/25+z30+Aanjs7TjAIurnVY7/THtilIBfjZ/0lQYQMhBDrt5uQchFTMLRyZuM8kT5dSAUtLx1hdPTdCTnTQgjSFCbn3jbXopE8Ub/VOTH4QVa+3GQ4+bCxxUnDp9afZuGN8Vn8EU2yaP/zc8+mmMd9824eIgwzrBBd7C/yrP/6myTtVb+cVPNZd5jv/9B/xrte8Y8TA+hf3fR2//Kw/4Nq4M15NGDgkMl4arvO73WM1B5qAIo3N01qwcABRGNsVb8Recaa/zIlog1hm3H3/aT57bus48fe2wTmvdzj97HMT2/KEghGhtc4U5x6snwgCMFrWJmdxTjDoRzRaoym5e+dbTEuxJDTIVOKaO098UWgenkoFss+cOcPCwnAi74n0StRBSslLXvISPvOZz+x4n4NNJpw3eedbEXrTYrT2RnSlOF3x1BcU0/V5diXhDXudWqx0RA3p9Qai8AQ4MmPpZpq2CnwbeVYmlRMJbV1uuLj8f/9kKOtIFCElwwn/XKMhsXlIkbM1wuXyHlKZHXV5+FTekMxDugriYcnrblSqUVvnMBbCQKD18OIRbniOZdgXlQPhvxukxDhLYgwbiWYzTehnPnuQLRhH3l8p/VkPtKaTZaTOh8A8ha7Xpy1cZjGDySlJ056mEe5frPQj59fYr3l7GcQEQqAHm0gVMLdwePudJkBIxfLKSc6vr44sD1pL6N4arobYbBq4bwB0R0nRte0WkwywzcRXvV9qjIdizSpnHzw89h3PZnD95EJfV4IPnXkWm2mDN7/kvVzoLvB9f/L3d93WWtLia37/u1m8YXQ8f8O9r+fXnvN7XN/YGNvnYxdO8m1/9lVXdBzbCRAW5OLWMMGd3b2fbEHqgUc+KToR45P/e8KffuI5dLo7z9IzDV6iarFOkqWKxx+aTCS2g3PQ78S4zS33VUVR5Gtsn/gyHP2YZesXtHH9ZLIQr4LUgv6R8cE2pWD9cJurMN4XFhZGyMSTDeccd999N7fddtuO9znYZEIKgkDSakR0eimJ1ViTz8qXE/2i1Bco4VO1WueJgivExVbkHoNK/LnwqWe7WqOU31flGZ0KwXFeXjvXcxfMwR9RVGztaoCsLcmNy3UN1RrTYuye4gmDK4mBX+aQeRViY72I3ObhWw6GWXKdJxgqz1A19GQUW1b9ISL3ZuT9xKGN5WK3z8YgIdV53HlJoIbnCuCsw0rI8vAwFSgcoGbZBWfYBlJFNOYOE02pVbETWGe5sL62L316pNvjmnZrLC4dIMGykWrOpePFyLJslhr28x13P3493/6737HnyWShLIvXr9Wum9T01ENOW9kJsJ3R688OZlNBM2wPIUAPFI8/vHsiAXgda2fnefImOPUAWHhQs3F9gKshaY1LhuX76u/TWmc8tOMePDnodDp89rOfLT8/8MAD3H333aysrHDq1Cm+//u/n0cffZRf+qVfKre5++67y30vXLjA3XffTRRFPOc5zwHgh3/4h7njjju46aab2NjY4Gd+5me4++67+fmf//kd9+tgk4kcG4OMOAoY9DOMtmWYU6Et8BV1BdZZjHGloT1UJjgGqSEKFYEUpLlHwzpfDTh1lpZUZWaXYlcnhkXayoCjnByIgsHkHSmP5MA560Odih5UPBgir2dRhc1PyZTVgUWuiXBDIlEUpBOVvpBrShAoKTCmLtwvzwftLNo5EmPoZpqezrAI+mmGtgaczLUnwwxQfm83JC95wbFupjkUBd5zs5cfdoYZ9glBawndX8dVispd0nB/Mpnt/u3qeAgXwFJDsdyYZcWZ4cnD37/3K3n7zX/M7XPny2W//dDN/KuPvmbiPje99ROImnoxl155jMuvGg932THGHyp7a2uGGbaixjvResxx6G8nuxIGhwSu5vYe1t/Wd44nebx//OMf55WvfGX5+Xu+53sA+JZv+Rbe9a53cfbsWR5++OGRfapZme666y5+9Vd/ldOnT/Pggw8CsLa2xj/7Z/+Mc+fOsbi4yO23384HP/hBvuALvmDH/bqieeMf//Ef5yUveQnz8/McPXqUr/7qrx4rcvGt3/qtY1X0qsIO8EU03vzmN3P48GHa7TZvfOMbeeSRR66kKx4OBklGP9UszDVoxGHuXYBA4VO+5ulftfZEwpZMoPI7Oj+jLhwEuffChyZ5D8Z6kpUExBUWO8OZf5eH/BQpWQt2UBANgciL1hWeB4Eq3Bx5c8PvK3cd5v1wZRc9cXB5PQttLJm2GEuZbwn8DypFcVQPax1hUHgnhiftnENbS19nXBwkPLLZ5eH1Do9v9tnopfTTDCl9uLnVFjee03YEArDW0kkypPAkTtbMDMywf0h7Cdlg9zninxrw5HiQapKrOLOvmovIwKfNPJcJHphCJGaYYddwsCUJ3lXBmz7zKv5k9RQA77jvdr7vL7/06h1sCoqwj/16fd7hgD8iM6Pou4CF69aZv2Y89G7foCgHyMIDlkOf2CYm6Sp9r0/2eH/FK14xnNitvN71rncBvpr1Bz7wgZF96rYviATAT/3UT/HQQw+RJAnnz5/nve99L3feeecV9euKPBN/9md/xpve9CZe8pKXoLXmB3/wB3nta1/LvffeS7s9rLz55V/+5bzzne8sP0fRaN7rt7zlLfzO7/wOv/Zrv8ahQ4f43u/9Xl7/+tdz1113odTOZ/yKcB3nHElmUEoSRgqjvVFrbfHFVXcqZvBHAxhs7o1QeTiUcV4crZ1jI8k43s6FD1s8EdW2CxGpFAIhJcIJMmsRhfBZCQSSMFAESqCNzVPI+ixLWx88Qw1Esc6LvEf0WIVg3A01FNVvRziBwRHlxMriv5fMGvpa00k1/cyn9izIStFGQUKkrNTGEFuOv6XbxvrfIjUWKXyNixn2B4cXWoRbQoHcfIu19S7rG+MZN6oYaEMjmH5tpdbxeH+6YP54Q+besfz4TNYJ+Orv/pjGmgl21egdv7iW4y0aD10WfHC7JqkC+ERP8HhPEElBPHMufN7j4X99K8nJdpmrXhgxVjF3BMW6STy0jkBUXbkF9sHQsU7wn/7zK/i5z0ou3RBibz7gVunTHEFHIXVNpfHYYuNtrEorJtZTKGCcYDObLtx9dHWJZM4Rtv30vO2FmE69GSiWMs487rMyXXNktTZ1a6oVvczbdz4SxDF/zQabj47G/zePdX0iAeHTxhq9u4mcxiVJ0BFEa27yg2eGJwVXRCb+8A//cOTzO9/5To4ePcpdd93Fl3zJl5TL4zieWElvfX2dd7zjHfzyL/8yX/qlfiblV37lV7juuut4//vfz5d92ZftvEPOp8ZcaDdoNUNCKdHG0MlMHvpD5cZeZKsYrRwNQ6+ANo4g8MaSzjNDOecYaENqDLFUFYtdjPSjaLvIlCYFvhCYENj8aaLKgnqUuoxSAD3CGYoPebanynE8aRh19xWnN9y30GEMM3Q4QAWCzsCwkaR0kozEaHSeCtfl/Sg8I94D4rUQUslKwa9KTQM3+kx0OKzwwvRupllqxriZaGLfUBcjWvxek2ArVdfcNg+j2mQAO+lThWAXQ6PkG/lfVSkM5zOA1VlYeTs5oQC8B49xwmpweTIEQWYdl1O/hY0WkGn97NhdlzpcGGQYBMb6GhytCYRiNZ38pa4PDNbBoeaMjRx0uEiNEAOn3MhnoSeMgyrhGCb7217MsIPbYePBTY6/49P+9t2E1f96Q+12c+9pwIOKvhY0Pw2HBppLz6t/pD/jP9xbG+IEsPy/LyBTy8UvP7F95+qwnx6Yp7N9uJvvqTL8RCan7i/CmloMW2BHMkSBbGXIpp/yc1qgV2M/7hYyEMPJ0scuLpVdObTUoRFlJDpgkAVjfZI5oQAwxg/4gkgARLGG2Gd+ylKFkI6wKJbXyEgutqhD45wk6HlDJ1nytljrXL0n++ILgokC7M5JhVOChQd2OdU5G++12JNmYn19HYCVldGcwh/4wAc4evQoS0tLvPzlL+dHf/RHOXrUp9y76667yLKM1772teX2J0+e5NZbb+XDH/5wLZlIkoQkGc6YlgU+nC/K1ogCWo2IqBWTphmDQUZqbPlDjZAH54aVnSsCYgDtHKGAQErSSrVcay2dNKPRVKWnwNdyEKX2QlRto8KqEuSZm/JldlinwdphmtaCJIyiYrBXNnRl/4us4cN/yzFe9LE8ZZ821+K40B/QTTIybbygujTqCi9OHsKVt5/lOg2dF6/Y1th0DoujqzWHZYNxieoM22HieJ+AhXmfeWh1veszmD1JqBKL2pU5JLJ8UNkJs0sFYa1bW/WcJc7R0ZR6JoTARj4zj0yHOfo/drHDpSQrPWwOSHODsEooNopnk3QTq6c6IBOSVAVEZuZ72w5XOp6fdFTniYL8XjqJVMB0T8YVovWpNY78+v0Emz500W3C0j9/EIC1n7++JCNzv9UgeFhB3i9hYO6MRRjNxdv9Y10aOPmBPATy+uvgngdrZ3Nlaln4y/PQ6XPx656xfyfzeYorHe8ylUDunZjGBa7Grb0alh06gkO+RorZUtfBVu6Fl9baSOkIQkMY1hvzhRdjvFRoPhkKBKFBKotzolyGguiQ95qkl4bpuhtnJUGlEJ2TkCwKnFC0zw77oJu+3/MPO9afIWoJhVOCwbJEJgFzj83u3/uFXZMJ5xzf8z3fwxd90Rdx6623lstf97rX8fVf//WcPn2aBx54gH/7b/8tr3rVq7jrrruI45hz584RRRHLy8sj7R07doxz5+pzGv/4j/84P/zDPzy2XEhfQ0E4R6eX0o4Dmo2QRhygM4PJlcFDIrFl/y3tmTLtqij9FwJvV3TTjMOtBs5SpmItDPE80ig3pkSR5KmITMrFya6c+RUF8yhqTYx0bpjdqdA+SFl851TeiNGHXs25laQJT2JU7iXR1pZEYihEp/J+2AdjHEEgyqxSQ9pSkI6tx/X7DvL0seZJNG4PKiaN90lQ0mtynkwicSUoyPGkqt07Rc7PGZXyCIqCMjaaA+Cvzj4+QiSq+6fW7184HIuvUOAfiLaGUDQaIe1WhJGCgRjNPqKfSsnLnyK40vH8lMIT/HPKgSFcHU7BCAfBI/7z4vefAcDediPqkhojOFJD+6wl7GblvmEnv7c3Y/SzThF8+gxlWsAcTmtEP2Pub1Kic0N1qrbpzjLbzGZqR3DF492CeCrU+RAgcvI8bRbQWImxIJXD+3d3eTjha2fZLWRcBn5BtOyJjfpUs7aitZOCdB6cVDQvFS5x/0cljvmHLJun5JgIW6UgM0G6IFmPR+/fJt3B+czGey12HYPy3d/93fzt3/4t7373u0eWf+M3fiNf+ZVfya233sob3vAG/uAP/oBPf/rT/N7v/d7U9uqq0Bb4/u//ftbX18vXmTP+pirz2fLNbsLl9S6b3YRGFNBuRsgizqL6w29pftSWGYqbEb5ugvRRSTgHm6kmy9eV5MAxLLYlfH+U9C+BKIXSxcvYodtQ4EryMeycGHknyPsghn/LlLNFP6h4C6pTw2L4sXCUKCnKegPVMhHF1zT+yZXicukr5pU9LDJPDUXjAiklQgmEAisc2tkrDpuZYfJ4n+EKIQIQAWupGSMSBRygnX9t3aYgFFU0cyKhlMQhsEKOvWYYxWw87w/Ce/uE9/YJzoiJnhKZQeOSo3HJEV/eclefb2JuPImr6K6c1rgsA+dQPUPzgc3h68HOjvol9vl10LGb8T57To5DRgYZGVQyTiQKOCUwDYFT4LZEnYY9x9wjFlkJ71MpqASE9fvqlhx9Nbe/f8/Gez125Zl485vfzG//9m/zwQ9+kGuvvXbqtidOnOD06dNlJb3jx4+Tpimrq6sj3onz58/z0pe+tLaNOI5rKwIqIci0QVs/y94IA1YWGsy1Yi6v9dC6TvRZDQiqzo76n9VYh1IQK4ExApzA4LMZ9TLNfByNGOJF9qiqKNRZn/Me64vMuTykQxQqaSr8RjDMICtGulIa6QiQ5KJwKJmAKDwEW0hRZU15rtpZ0swSKVkRrw63Kr6VovlqyJZ1vq6FL+iXu0SlQEgxdIEIv0wqiQolKMEgT4E7w5Vh0nif4YmHAKTw6ZObjZBWMyKY6YCuCLPx/NSBXZqD644iH70A3X5JJGbYP8zG+1MHUcfhHof+UcAJTyRmpYCuCq7oqeic47u/+7v5zd/8Tf7kT/6EG264Ydt9Ll26xJkzZzhxwou7XvSiFxGGIe973/vKbc6ePcs999wzkUxMg6+z4AiUQkpJHAa0GxFxFOSGeOGhcBPZLfiZAR8C5LeLpETlRME4v3wzyUa8EEHuhSiMc2t9WI82FpN7IqxzW8I58ljxES/FsFidKDwKFWt+mIJ2+PJrKBooP5feCud89WrtBdfnuwPObvQxxqHUMEXtCD0ueEmFADh8qFORLlcKH1IjQ0kQS8JYEUQSFXgSIUOJDLwXo28s4czwmuGAw99GHHEcEASz8TzDwYY9vIA9cQgXqv0hEm6fXzPMsI+I1x2Ni46w6/aHSMzGey2uyDPxpje9iV/91V/lPe95D/Pz86XGYXFxkWazSafT4a1vfStf+7Vfy4kTJ3jwwQf5gR/4AQ4fPszXfM3XlNt++7d/O9/7vd/LoUOHWFlZ4V/+y3/JbbfdVmZ32imcg0YY0GqEPt1qIMm0JZCCZhTSEQnllL+f0qf49Ur/RMVwFnjiYJ0jEF44rfEz80JAJ9N5UTm/txO5XiInNOURct4iKqlkq30uBNkFMfHdq0rBK96L/B9HpfK2G3oeqtsUFaytxad+zXz6180kpZdkaONYbscESiKlyNPhVg7ptrzNz9NaEIFAKgG5e1Aq74UQItepusJbQSmsHRhDGM1maGY4+PBOuKfRnX+Gz2vYo0vI85cQ3b1W8Jphhqc+GquO/orANJ7snjx9cUVk4u1vfzsAr3jFK0aWv/Od7+Rbv/VbUUrxiU98gl/6pV9ibW2NEydO8MpXvpJf//VfZ35+vtz+p37qpwiCgG/4hm+g3+/z6le/mne9611XVGMCoBGGLDRj5puhr1ZtDKubfRqBohEFyLzqM1Ax6nMiMNLS0JR3zhe280TC13XwWgiZ148AhS+yZS0Y62tFiIol7m37CjUQFYKRk4HiuIV3QBQeB5Evr3ofivdDBXZZV6KYWfJiZ5/CdqAt3TSjk2T0M402phRbDzJNFCkGokoahsco+pof0J9P/llK6b+53JvhnMMVKXgLkbjFVwaXkFrrCcgM+4JQyomenmYU0m5E9JPxAna2Mkaq7HYuCogrtSdaQTByXTRqYtQKr9pOyjxM0kBV1zsH2RQbXeZphidNoGoHXe1IzeQpJz+Mp1OB6joxQQiprUVMOQ6A3mb9DE8OnITeLcvjy5VCGOHTJk8brj7hzrYIVxOix6bUfNnmuonPdLc9hri8AcEOH90CzPGl+nXLcz5UdQKsTeHCDg7h2Dft8JOtQb6a+JJrHiZqRbXrXOB4nAZ/u35kfOWWdK7D5aPfl8kk3fVhBiRZk6jIbQYIK7GxG9MYDDcCNyGTXRVGS0wgUcHkC0MIh9kImZinFbZPZxvgbaQJt1YbQjo3bCParB9EwcCN6CfqINPtL/LZeK/HFZGJ7bKvNJtN3vve927bTqPR4Gd/9mf52Z/92Ss5/BjmG6H3GPQzn7s+LzLXCBXNRkgUKm9Ij4wPb1CN2jli5N+CagRKoQREStEKI5abETivXTB2WJG6+F5E4QGpa7vURYjyfbHeyw5c6daoEoiyz1vaLepUGOfQxpEYTS/zBKKbaFJtMNaO9A9gkBlajcALqsvYqcrhRq2q8nsy1iGDvAidcLkuJD/vXD/hH0zDThpr6etZ6rX9QjsMCMOwft1iSEMpHnp8dWxdYeBmdtSvemyuxZF2c3Tb/K8ElmqIoLMODXg9/vSHQLCNYEYITwY2ptnfFj692i0zrdUh1YbL3cGURiRKyFxzNKGdkXFf36EkzUiNnnreRs/IxFMRLpA8/i3Pql0nB2Ab+BoTk/ZXDrEDA6v1qTWO/MYDu+7nTiA/9dCOt3UCspu+sHadePY1SOOYdEnobAB/tJODsH/hGk8j42or3vYl72NhfnKY5Hsfv57v/Oua6Iy85k2RpriAHIwK8bMs4uzm4fJzuFF/LAHYIxrT2ltO41RLBNCam3zvDaQjPdPanpxMiR61LQCHTETtrdlEgqw1tOHiT9bfgxuXjScTU8aY3om9MhvvtdhTnYknG4NM0zPk2ZPACUFT+Bna+ThidaPHINEYYSvGeC6YFgIrqKTTHBrCAkkcBLSURDrBYhzRCkNC6QvbkWd9KutHVCGKvmydSPDuB1EzNSUKz0SFZHhCMQzRGsoaht4C4xzdzLDRz9gcpPSzjMyYkUxTQ8+Cb1gb70oIlPRVr7eeQ9GXyiJHXg1bSEzOQbAOcu2EUlUxdjF77et2dNIZmZjh6QGjLUr4jGUzzHDQ4QLvGRSTUp3NMMPTCDaS4Oy23okZdocDTSZwDuEcmbYIIXJxpKObZDTDgPl2zKX1nq/kXAiOGYZ8VHPKU4iqA0W7EXJsocV8HKIzh8QncvViapsbzG64YwWjh6m4J3OvBKLQhHsPSLG9kAJpCz3FkPoWqWfLU87XGwe9NOV8J6EzyHIPjPXeghFPQ14dIicr1loGmSUOJKkpKlu7kWxO5YGKInZiWEm50HkgvW7CayQczuTeCpN7fgCUZGNWtm6GGWaY4emNmX02w+cTZuN9DAeaTGTGEShBM1AI4QuldZMUt+E4NN+g1QyJowBj7HB23nnFRGmi5zFHQgiiSHF0scWplXkW4oh+P0M7O/RA5NWdy5n7ugGVOzhExZdQeBNEudPQC1KY3uU2lYbKKsAur3rtfM4pbR19a+ibjMz6cCZr8pCmikC76tIoT19AL8lYmYsIpPAFVF0e2lV4RUrvSCWnlAWjfZEZk89kFX9HiqW5vO6E9LNe/QNSSG2GGWaY4WmHK9QhzjDDgcY+VqOf4cpwoMnEQjNChd4o7meaUCmQgkYYsNhqECnBpbUe/YHPpV0mdQK8oe2zEUkpkUrSagQcWmjQikPS1NdlqBrKQ/2qJyD1QUs5fRCUVS19jLXIZ/VFSRpyfuKX58Y3hXeikGvnx7TOkVpN3xhSZ+lpjXGm9HS4vEdU9h3t05BQZMaitctF5RZTdWWMuSegIDbaGCIVINxoattiu6JqeOEFEhK0nl3dMxwcCDnTPMywO4j9jKXeB7hA0n/ji6/6cWaC1BmeChAWVu67+vfv2Xivx4EmE80woNGIAK9fiKRASWiEiiTRGClZajc4f7mLczaPPHJeLCwEQkpEISQVgm5meHS9h9GwoLxHw5bRTJXaDDlElVCIQlydk4V8ht4Vng8qIUKVStK+6WHIlNdPuJIcWHyK1U5q6JuURqQwODJr0MYihU/z6jPjVIvwjY7SET2GdfRSTTMO0EpiTaW4X0UzIYpMU/kpW4snZVAKt8nfF8/R4rtyzvolbkYmZqhHRzs29+He7xxo67YVfM8ww9XE8nvPsPJHjz7Z3XjiMROkfl6i2U5otPYhjFn4jE112aeekpiN91ocaDLRyzJWFudIjCVyjsxaJIKGCmgEisQYMusIA+WFx+Dj/FUZWOQ9A3kmIid86I7ODNrJMtkRDIXPJXPIxdGeB4x6KAQCZO6ZoJpGs0ohIBdSUPotpN8+s47UGhJjSZwlMZrE+irWOrEYa9HOYa1FSIFSAqUoiY8r9RpbtBA5aXEIBtrQbgQEUpBW88EW5ysK8uPZRSHo1nmok7XD0KiR6C2KL9XzCGdnZGK/sBRHRNEwm1Mn02T599sdpGwmKStLbYyxrG8O88c3JqQjVDUF2EIhOZrXBnGAMMk+ngEEahjLtxQIwsxxOd39HbWfai52BoAjy/U64QSBdCBtOUSNA7NNSsIZnj6QqeWGH/wID/zoHVftGJe//DrMQsSR//uBq3aMKswLb8YtzQEgH3oc+bnPQyJzgLBmehgzvOfOyZhQ+DC0X37oOfzQJ++sBgOUENmE+1TN/ctJsHmWJjNnaTy2vyZe2MqQyrdvgTQLiMI9sACZp35l+HcSqQg3HSrPbGUaoGc1I55SONBkom8Ml3oJoVI0g4BDYUAUKjJnOd8ZsNYdoDNNFCsSbbxRXAqboWLlI4RAKUkrVMRSUkyslxmKoDT6hfAXkrfZy4ClYcfEcLvRuwK5X8sLxUv/hBQoIQiUZGAdvdSwmWXe3yIEibFkpjDofWVtI3zKV2ssoZQoJdG5NqQIwqLaq5JgiJILpdYSSEmgfKG+omvVECzrhoREOIfJq1oP09u64bkV21W+1/0osDpDPdphwGNrHdb6g5Hhp5RkZbGFAzYHk8nA/RsdsjnHjXNzLAT1KWediq+IUAgB8db0tWKUUFYfge1QIAVcTK58oHQGGWv9vDDlsMdkubejSiqEMCPHVQLUFh+zw7HdY9Fk/hqrI2IzPLUhjOP6f/MRHvq/vpDRtBZT4BhJv7kdNu44imkHHP/vn9llL3cG8wXPxs01Ka4me+oY9rqjoxvtoNs29M+pvWS4mYV97A4dm/Cj976K3zv7bLQTo/UWisdqb7LmxaeKFaAcNqr/4gYn9Z4JRTSXVkyl0eNoI3EExLsgFE5RW+uijlQ0LghkpYSSGoDa+ljagT7TxhKERU4rbrQNZuO9Hgf6idiKA1ZaDa5dbHO03UQ7x2PrHR66uMFmd0AoHKH0WZjKGgiVmfdSaWD9KxCChlQEQpVi5q3346JidVEvYrwUltjyotRIjIY25QXwlEDmaVUdIKVABoLMWYzw6V8DJVhqRTQjhbHe8C+KxVnnfA5+mbeDqH1QFqLo0uh3jkFiUEIQK4nK9y84gnWjCoyqONu64ffgz6j4r9BNVJ5jMzZx1VB1BI19y0XI3RQ4YF4FLATh1hE7up2KQUAYNQnjFmHcQoUtZNBEyAAlBY0ooBEFxGEwdgnUXBEj59BUgiONK/MSbPRT1vrJhNo3/rrOjH9tJRKTsNMeWGPRqZ74muGpC6kdp37k4whtue4n/prTP/IxTv/Ix7jhBz7OM77vLlb+8FFfDCwT/nUFRALASUH31hUe+476mhb7AXPHc3HtIZEAyMV/468dIF2QbF4bjL061xycucZf+IVf4IYbbqDRaPCiF72ID33oQxO3/c3f/E1e85rXcOTIERYWFrjzzjt3VB/raiBzkoFRaLs7U8xFdiKRKJCc0CAgOZmRXOtfpml3HGIjSjFQ/Q7GSJK0fjJqYr8nEIkqbOBfjQuMEIlhI6OvnV+pM4/01cDBuVvUYK4Z0wgVvUyz0U9J8oIjDSnppb72QqpNLhbeIhKGEc+E308RC4moWmeV0CZRLhKIahsVwcFWg6kw6Ipq1SUZyScVHAKs10Y4NyqGVgIMEAcKa2GQ+UxOPivT0CNg8aFHKtc/wDDAaZI96azzhe1CXylcSoE2tpIMQYy8c4Iy9slah1KeRo0FMVXCnYQQeejWDE9VFOFs2yEIm2PXC4CQIUKoMe/DFfdBgJbjD6tPXl4ntePCitTZbYtoXnlAqiAA9LT9iu9r0iYz7vyUh+pprv2JuwnWkrGZwaU/OYvsWy69/tSu23dKYBtX8dEaqNprcbwjEG5osoXJfUnbAt0StQWK3U7t2yc5hvzXf/3Xectb3sIv/MIv8LKXvYxf/MVf5HWvex333nsvp06N/44f/OAHec1rXsOP/diPsbS0xDvf+U7e8IY38NGPfpTbb799H07iicNOIjWdgORENlb0zq9kX2xrnSiyR1tjy6UWWCFgK3G4Au6000eLE4LeEUnrwuQdZLo3r4Q/EDPNRA0ONJmQVtBLNFJAHAi0EXQGKb0kY5DqvPZCTiREJV0qDI1cJ8D5UKH5OCRWAdgiDMpvUkYriWEIEFSuwWL2tcokRN16UQqwccN0tUWVapMbVZEQSCFItfEZl5Qs2xeioDE5Iym4jPDaCS0Fzha+iXLuelTYUHonINGGKFAE0odJla1vucGIyj7WOoJAIgXDyt3V8xbDL2pGJZ4emOblqM9ptnP0reNCZmsfjIk1tffbKA5wwGBQN2W1ewgEQTD5tmityZMLzHCQEa7Wh+6pvkF19jammp/beMJ0E9tBGEfzzz89cb25/TjZDUt7O8aTHPbxkz/5k3z7t387/+Sf/BMAfvqnf5r3vve9vP3tb+fHf/zHx7b/6Z/+6ZHPP/ZjP8Z73vMefud3fufAkYmdopZI7FfbicJejnF12o5swmxVjTZkP2ADQX9lMlNprLo9k4kne7w/VXGgyYTKDevNJKPTT+klmiTzJKL0RlRjdYqZz2Jq0QnvLXCCVhTQDALUCF3IN69M3/psr66yRcXNIERFK1GQkMrFlJMG7/koqI2orkYAgZA0A8V6omkoSSNQLEQh2ujc0yJwIi8olzclJAgpCQJLlhXcoXrFVs6p8p1kxhIHilBJEl0J2qrO+grAiuHIdz5MSkjygn6VMKpyV4ezezUzZ9gtnHN0khTjHGoCETjeahAGkq7VtOXkW0Go9hYN6SjSHYyjZxyXteVK7++yDOubjsPtCClhM0nLwotTESiEmHK+YufhATN8/qH1yTUO/cEZosf722+8C2QveiauHfp48u3GobUEn3wYsd6buIlInppheRsbGyOf4zgmjuOx7dI05a677uL7vu/7Rpa/9rWv5cMf/vCOjmWtZXNzk5WVld13+CpAJNPvu0ILZCawocOFUwaD2tsNK+uHhA1da/m6gcKuRfVEYhuMW1rjaFxiZ+6Xok3rSs1FHWY5N64eDjSZ2Bwk6F5GP8tIUkOmbTlr6LYO03KyXAyDzHP3g1KS+Sgk9uWcx8L8h0LqPMTIDUOlyqxHxauYmS+CoQQgXC7odiVjKAvf4Shk4UXYhhK+EF8nFQRS0gwVzSigHYf0Mk2a+WxOw6AtDyn9uWhtRr0rI6Qi/y7yytbG+mMrIVBS4IpCdNXti++gYpRaC0GQZ8FiGO3lijCsqidkhn3DZ8+ve41Mjl6aAa40+K119DM/s1pkerLOISu/3TXtpvfERSFKCDaNNygmEYrttBfbY/JjQwO70F4DEASSOA5IxgwiwUrLx/A2Qj89QBTRSVPMNEIh8Kx8hhl2iXAtIX6ku+/tZs+/AQB7bNmHmgqQ2tbEmQ4hnEOsdfa9L2O4CmEf11133cjiH/qhH+Ktb33r2OYXL17EGMOxY8dGlh87doxz587t6JA/8RM/Qbfb5Ru+4Rt21eUrwX+47+UMzFBfcPf6idHbowORSf/Z1N93RZZP0hn/HJcuTwgziVDscfrbajnxSe60xKW7vGdO8U7Eq/6vGuQTlGKHp/FETPTMwpxqcaDJxKXNPtpKLxbODfWtv00RhlOG/YwwBS9SbUUB7TD3Sgwn3xGMl6WrirJL0bGo/BViLETIFQXeytytlKTCudHYqTwii1gpAqUwrghq8tmeQiUx1qewLY5ZGEhKCkSgSFM7SqYqug4x7Hx5HibXQPi2i7CwocNleMKiUiBvaGS6XBSOIxeGXyUf5uc5Hry0yfnuYCxpRSAFWvn8YtY5EjOqMfAV3B3XzrUQwOFmg7AySLW1bFJPKNQ+aF6c9eNRyNGrqWcdXbP7u6lSkkYem14QCoFgoRnQjkaDdONA0csEW4Om4lBxeM7H+loHZ7uDXfdnhs8TVKJHq2h9ep32Jy7v66GcEJhbrsFee3h0uQKnx++woj9APHYp3+jgWipnzpxhYWGh/Fznlahi64SHc25HkyDvfve7eetb38p73vMejh49uu32e8EvPvCFvOfSc0nt6L1JiNyLr3MSMUH0L7R/+AojRgxrYQQynUAo9iGORmQS2wmRc1kuxvZwA4Xr763CejmpWjnlaB2C7tY46+Kgo4udAt0crotGHVozPIE40GSi289QQTiM5x/9h6FWoB5C+GxKrUZArGTJ8Kso7f6REB9Kw7rM6iRAVorWFRa3c64sGOfILx4B01ITCgQKQSglg8zQU5pQKgaZwZQibt+oyrUgLmdMRXYoa4a+BVf5SzUMS/hjGesQoSAWikTbkZ55EbVvQQrKWhjVRp11PoSk8l0X3ooZ9g+PrnVQNfH82jq0NVMfHBY41mxMDHnS1rLpNCIQzFWOIff4IzpbEUrbIcUdOFg3jt5OQo+mQEpJFAVkqaEVKYSAhbj+thYHirlGRKjUyLIjC23Ak+rtyIQUXlC4vfh7hqclRP371qfXWfrAY7Q+tb4vh3Ghwl5zGCcF5sYT9dsogby4huhW9B+9AfLRC8PP2xjh0dlN9KEm2ZH2HjrLvs/ULiwsjJCJSTh8+DBKqTEvxPnz58e8FVvx67/+63z7t387v/Ebv8GXfumX7rrLO8X/ePgFyGaN8S1AWOH1BVMgtJh4ixdGIJOcUERbrJgdT+vXQPt+mSzwbeROCGHB9fdOJoCycnyQR+OFm5O/BxMzkgXKKdCtoW22HZnQTYlKHWq37vD8ODPPxDgONJkowpVKEXDVnh1zUQwXCpl7FfI0rE5SGvxV43v8yVFKn4eeiLwuw3ACNw9pyr0g1cJuo237/ruiGvZIJIinGrGSrA9S3MDR15ZekpJmxpOWfEspBdI6tB1WAQ6UxOhqBitKT8SQiAzfO0BJSawEvcyUWZ2EwBf4y9MOFpkGfTE631+JyGe+q1+2QAg3Kkif4SkPi8MwrrHYbpbPFQx7zCXnRozuqv2dWke2Twa5FNCOFEvN6ekJW2HIynyLVly/nRCw3IxZ7U+uqyGE8jOJbh9Kd8/w1MXkyLxaBBcHBGv7UA0YcFGAueYQ5jnTM0q5QMDjl5Fnp3hDjIUpmqf4wVX0UmNPZOLJFKRGUcSLXvQi3ve+9/E1X/M15fL3ve99fNVXfdXE/d797nfzj//xP+bd7343X/mVX7nb7j7lUCvpsvib5IQvVxjhw6K3ejWMQFRCmEw3HNlH7NMtUFhfNyJam24sOAGmCSaePEhME9QUuVLWFqhMopLdd34mwK7HwSYT5GFHVSJRY6CUxrQUPo5USf9eCZCCrtEkzhKKYTG2YXCRP4qoNCSEn6UXsprL31XCrKpxS0OyM+ohyD+NsIt8l3wCoJGHHW0OMqTQeTVpH2gl8RfXsHyGwzgIkESRIs1sqYuAYciSlLLUeciceDTCkMVWjJTQSbX3fuANSF8xvPgmHNaANZ4wWeErb0spcsF7fqyctYg8K9UMBwORlKyE9dWy6whFKap2PryqTGsvPJG2U6qfz0uBcbA2hVBslKJpN1UUHSpJcxsisRNIIbh+eX4qmZjh6Yv0SAO9GJEea47ek3cQtbnx0mMEGykr5yZXoXaLc+V7sdGdGIbk5prbEomdwukMoaZ7Jw46vud7vod/9I/+ES9+8Yu58847+S//5b/w8MMP853f+Z0AfP/3fz+PPvoov/RLvwR4IvHN3/zNvO1tb+OOO+4ovRrNZpPFxcUn7Tz2DAm2MeGeW0MoChIhU4lIBWbOeFsidJ5ITBGAO5XbR1P0+8KKHV07ItueSOwIApJlaF2d3AczbIMDTyaAMpyozjAXkBdrE0iVv1dFqJE3/lNjSaylrbwQ2YrRhkQ+re+1EYWYNQ8uclsy1eTkoRodXl5P1WbL91sE3+XGglAoQinJjEFbb5yFchimZK0jdRZjhgQkCCQKQX+gcXbIJGROhKSQSCUIlS80ttCMOLrQ5PBcg16q2RhkDLQpM0VZk892OEeZzjZXdjvrEEFe7K5iaBahXkIIwmDvbtAZ9o44UHv2EhWEohjvAoOsBAYW2ZKkZCqRGGuzKuDJ0cs0n7o4nHENg4DSXzhk9gRS0AoUkXMMnoCCcc1IEUqFral9AfjkBzMcKGSHYmwkWX3NNXReWNEmjN2rdw/XbuCed9NwwSc+C2megjbNENVxYwyim+DaTwAJcA7ZSwkuj2d8EtkO9UNPctjHN37jN3Lp0iV+5Ed+hLNnz3Lrrbfy+7//+5w+fRqAs2fP8vDDD5fb/+Iv/iJaa970pjfxpje9qVz+Ld/yLbzrXe/a6xlcFchM7HUIloRCFFEFPYmsEIZgLQAJeknDTkTVU34r4byOo9x0a3PVk5G+OJ18IhKLCbAKbFT/bdod1m+ZhTmN4+CTiQkEwr/xhrdUAhlIUD6UowyLgjIMo2c0CyoglAqVm0ulEDl/SSHyfYvwDU8q6saf9x9sDZOyuW5ClN4E3KhguzpOlYBmGNDPMmweSRLkxMgYmy/z/ZBlBimQSnrxtrZlZikpRO6JCGg2Qg61I04eanN8scVyMyZQgsc3+pxd77PaTzG64lkpMlzlkSxFaFbhu5HK6y4KnUZBJKJQsRDVz3TPcOVQUkwRREtETdG3AqeOz0MmyvTDJUTt24lwzqGEZlKqV2BHKVitc17sb7ymqEjz6nCkxnLP+Ysj22d6+KQJlEJKiZKSY/MtnnVkmUGmufeR8/m2ezPoQyXJzDgZigPJ869Z4fpDczV7eQySjL94/917Ov4MTywe/4fPZHDD/OQNJNs+9GVfIwf14841ItwLnz267LZnlu/F5x7BXVzzJMJY5HqP8GP3kd7xbH9RTgjL2zHqQhDz5U5rGp94jMYnHhtbrd3+1nC5mviu7/ouvuu7vqt23VaC8IEPfODqd6gOlsnZtyxTw4biC5Js0Y0Z5UJZZJ761Upf5Ha7PqgNNbmyu4XgcoCe22YyyPlJRqEFSHDVZ4/z+o2RftqR1fnCPHSpAYMjjub5fLJoj/MxTk1oQ4CTgmRZkSzXT3KadDYZtFscbDJR1GqouNJKXYDMw3OUD2dyInfxDW3k8r1w0NeGLHS0ZKEpcDivOEbmSRacK/QQDAXGriAOeTBUNepJlN1ia54pV/aj2iFRvhXO96MdBlwuiIhzuQjbZ8eR1TCnwkgUgjBUNBshmTaltiMMFK0o5MhCi1NH5jg632C+HRFKnzrTOmjFIStzMY+sSrIyJjwnVBQu0oonxnnDUSqRC1OHnqAwUJxYanHtUoMPXvEPO0Mdjiw2CcL6SzYMBXE0fTZpLTQsZ2qENFQJSpDrZ56IwLRLmWWzIJ9uSES1dfzNhQtT9gRtDNJZrl1Y5JYjywA0woAX3nAS6xx/df+jtSlgi6xr0yAE3HZsmb85d2nMfvzC649wcmm8yusMMxz+7YdZ+Mj5seUuULiXPHfqvu7Ga+EZJxGPXoAHvFEvugnxH9+NU5L0S1/gq15vhbFMCpUa2UwaRFTj5egliB16EKdBFLWT9gH71c5TEpsh6HpiGPQg3Jh+/w7XBXrFjBCKpZMbzB/xqYgHg5BzZ5exdh/u4Ns8CGQmEIVg3OYhTcW6bTwMZVi6ohR0uwB6J7191n5M1JOuStTUNAwOQasmK7AdOrf3hNl4r8fBJhNFOA34cKM8lEkqgQxzxszQq4AQaG1z+3ioXLD4dJqpMzgRoNQwKawQeH2AtaMXWJGWKf88MiQc+f7VGMWCbvhCe8M6DOM3kIJSCKAZKJQUZMZvrQsjqbiOK1wkEJIoULTjCIWiP9AI4UnCyeU21620OTzfohGFBCqvK4Eon0dxELDQionDgEGqfc2IMqJr6KWphpuUOoncfSoEhCrgxFKTl958nMw8NYsifb4iCgRywh01cZYLesDRoLEPRyoGzji2u32KHWRLuunwMs84tDS2XArBi2+8lr/87Bl/rLwZKQVHFtrEORlzbpzgF50b6C63HB7/DubiWcje0w1OsjMDY/JwRhRu44kHmeAZqLbx4FnEI+NkRBhL/Ed/RfK6F+cL8qeDgPCuTyMvd3BKgHW1Yk4bSh74919Qe8zj7/oU7b9bndqvHWEW9vGE4eRzziPj+tnzRiPj5DWXeeTMoT0fJ+jK6d6JPf5OTjGSlamEgO41jvYjWwwrAemiw27jpBMWrvlQveZt41RINr8P9/DZeK/FwSYTpTBaECgQgUCEPqQpkDKfaXUoKVhpxmhreXyzT2a8JsDlN3lPRhzaOWye6Ym83oIrJn9cSQNK4lIJdKIcYSXBcEPRaqXOQxHaNOIWgeHsP5XxVVB4Kllx8oM6nM+4lNN1mWspbO7RWJlvkKaGw3MxxxeaHF1oEYcBSikQnkBY56lM8ZgLlKQdhTTDgE0hMJW+Vfs8rFUhyr9S+lj5UCmOL7a5/fpDHF9u0+3N8vY/nRBsE+K0EzyemIkpYQMpuP3IYf7q/HTvxHb4gmf6olcf+9wjWOv4F698LkfmmuX6v370Mn/x4GgoFc4x0PtfcGyGpy4e/r7nkx1tbr/hFBz/r/fR/uRa7TqhDeLDf4N92Qt2fwAH8e9/HIDky1+EU5LHv1ChXzn0eCz96WMc+t2HR3azDTWRSMzw+YlgLRgJOdoNZCImh0mxP/qH7rX++dB+xNs3nesNthIxrQYC1Rvtg9CTicQMVx8HnEzkxCGUiNCH2bTjkOPzTY62GkRSkebx00txQD/TSARnNjo444toFWFKxkFPGxJlCGtmRodhfmI0fKkaLwW+HkURsrTleiv8EoXDotAeVOs+uJw4DIymk2n62qeCZWTyq2AUuSBW+uxS1jp6g4xWHHHD0UUON2MagSIOJFIqvD9GFD0vCXYRhi+FoBEqFlsRFzs9rBtuW3S0FFdXvhQf2iSJAjgy3+TFzzjM4nwDbS2Z3rsbfYYnDpmznMt6nJygzbCAVGrXVbEfTQzJHmtLXAlecuO1fPnNR7wAvYLbr1nh9mtWeGStx2//3SM450hmROJpCb0Q8uAPv+iqtH3tT32CxsNP3LiJ//AuHnzrizCt0fG89sqTrL3yJM3PrHPyP38SvRjx0L954RPSp1mqzKcOokhz+tRFHv3E8foN9hjmowZyatX1/Ub3Wodp2rF+m4bDNBwiE4SbApXAiQ8/MURiNt7rcaDJRNgKCeIgT18qWAxDbju5zC3HlgilotPTOGeJQ4kUsNod0Ek1Zzd7aGF91WYoK1cnxpBYS0tREVVIb4KLCkeoyhwK7wjVZcUHN9RWbF0rctM+F4kjQDtLTxvWBimbSUaqDRYIVcWoB+8lyY16R67jkL5f1ln6iSYzlsPzTSS+fZULt4uWKETZgBTSe2FwBEqx3IoJA+VTwFY7nP9beFCKIn1SSBpRwJG5Bs+7bplbrllEBZJ+alBze0/ZOcP2eM6RZW441Ob9948LKa8EIXBsP6peO7h7YzxH31wYTCycd/Uw+XjXLLX4zpfeRCfJ+K8fuWdqKw9dWOWalQVW5ma6iYOC9FiTM//n8/bcjjCOZ/yrvxxfsYcK7lcD/Wcu8rn/+IX5p+nX2ePffAuHf+v+Wq3HFWEW9rFnfPlz7+aFc4/wn973xj21kw0Czn5yfyp5y0HN+MkzQT1V4EJHuuwI+tt3av5MRvcEE8XXOz8os/FegwNNJmRRjEcIIiG5YWmOw80GzdDH/s/Fls1+ymY/Y62bstYf8MDljs8i4zxNqAqmjXMYqlKIoT+CPMip9CSIwj9QCXHKF7rSZVFkanIjoU6lcFuAFY7UWjbTjM1E09eazJq8j34jGQRe4Gwr++eddjnDqSSXQhvLINXIdpMg74qUsjT+RR6WpKQow6QKhFLSjgNCJUmrogh8gT5ZeEKkRClBHCiW2hGnj8xx8/EFjiy2CAOJkD6N5mJjZnhdbdx5+ghfcN1hpIBve8FNrCcpv/nJh8a2u9gdcNHBzc02sZws9tvO1LfGTPVOGOe4Z6Nfq3voZJpWEBDugrAEeY0U2Hll7i+7+QhxMP1ci7ox26FIJT3DAYLAawqmoaqFq4EcaK5/618j9pk4dE9EZYrKxqWAnSSCffCtL8JMm6AR+DSAsO0MspOi+jCZ4UnCP7jlL/jGm/8SJSz/4x+/jbPry/zL/+ebx7aL1x0bf3iM+VeeRy1MiCPKQ7KnwSnK9LCTYAOouyic3H7fSQg3RRlipdsOvQPToM4rMQax7Sn7zWY376uKA00mRGZABvjSEYJWECCQOATNSBFIyVo35XInRWvL2c0e62nm77fSawa8cNkbxe0woBHIEWO9MJiGNrUfuUXa2KHDYNSgL/b3m1Vz83ujJMPQSTWbiaaXZaTGYq3Lib8dCpuBuUhhLXSt2VKTIu+oc7lWosjx7+gnGcZaVKVIHRRhTT7gylqLKQrQOUdmDGlmiANFMwrpJzonMD6trAoUi+2Y44sNDs03aISKlXbEXCtgoR1xzaE55hoRF9cTkI5mGNCbFQC76lBS+JTBQKQEh5oN/uFtN6Kd49fuuR/wRMLmnrLPDrpcH7doq93N0JzXjjT1BY4WA8lSODTWU+u4r9PHTCrIVeQYnvqE8MUUx5fWv5+GcAppmmEGgOPvuI/GIz5Uae2Lj7H26mvKdWo95bqf/MTEtK87gRPQuW6cKlgFxUjeiTEEYOO914vZb8zCPvaGSGki5clBK0q5/tAF/us//M+kRvFd7/6nfpt156tUW0Hng0do33mJ4NDuKq5HayBTP4hMc9yot3u0CgUQbUzwajwNMBvv9TjQZELl+gVn8dksrKMdBsw3IqIgQBuNlJ4oePLg8tAjP+Mf5usC4WdTe5nmkhOIAFpC5RSg0DX4GXxROBnGBkEl7UDFWCp9GgKccHSNYTPJ6KQZA63RxnnDK0+76io1LITwxp82bsy4GhbeHpXDCsBYy0bfE5RWFCJxZWiJcRaroaMNTjicdUh8BevUWASOUEnmGiFrHU8KpIS5RszNx+e57fplbjg2j8hrXcShot0IiGNFGATEYYBzvjJ2b6Cfcg++g4wT7SZRNDor+ZzjizzzyMLIMimgHQU4B1/37Ov5L3fdVxIJgMw5Hk76SAFHw5jlwLcZAYd2MEVvcy8eDtYySyfXxRjn6BpNto0moq8NBENDfzPLeLSzObLNdr14aHUDB1y/sjhxm69+wSkWGgEbm/Vekt3gpS8+xUtvPz1x/WZnwA+97T37cqwZ9obBqTaP/8Obtt0u6GQEa94wW/7Ts8x//FK5ThhLsH5l9Rb00QWSF14/ssxu4x1Jn30CgMbfTQ5TPPM9z8NN8bLtBpdfcw1rX3ysdp1JBvDTs7G8X3CRxUWjFvW33PRhvvzUaHilkpZDc5s4J/ipr3sX//q/fcuIaNoOJN2/XEEEjsbNm0SnfcHBtBty8aGVbfshzNBDoPpebwBgA0e6vIPz2OKdUOl4BeuxInVbEPS8nTTNOxF0BEFPkqzYuqSXu0LQdzg5mdWY9GnCeJ4EHGwyEUq0EJBZhIDVTsLJFUOkJFEgSbWgEUrmWwHayDI9bCwVofCj01pHz3r9RDFp2haKVkWwKYqwpVJwUAltqkwpidIFUAmSEl7U2s00G/2Uns4YZBZtLdZZX2lauLJo15C953oLBwNtCAJVpswUQhAphXFmJKe0yGOwrHMMMs1AG5QSCCcIpCTVlvPdAcL5GWypJMb6943YVxFO04zECBabEecCLx45sdzkedcd5vpjLa4/Ok+7GdJPNdY6AiWYa0W0m2Ep8l6ck2hr6WeW9l4LLs1QIpKSaMtM+2IjohXWexiEgJVmTFaTSz5xPtXxuTThsk6ZUwGnw3jbG8JFDWnFLrfOlZ+Ncwxqir1thXWOx3s9BnkhOu1s+X7Y9+lPj9QY5uKAa5dbPLI6Wr1XCPjy517DStun/1iYa+CAbi/B7KB/k/D1X3YbX/KSG1hemJz9Z7taHzM8cXCRIjsyPc3xsf/xWaJzQ22P6mhU58pT0aS3nECfXPLHjUPs4pWFd9pmhGvVF/h0As5+53NIT+ZtVuet9gLp0MsRfhqhpk+DHY7lWQz5zjAULJY43OywGI9XHwcQwnH60MXaAmy26+/5g08ukDzYIjyawLUpejD9Dh6tj2ZaEpVCeiLPfrkThB1Q/aINgdzCt812MXsW5hd7yKMplx5dGlsddPHnbQTRqvR21LzF7cGcSOcVNpLIKU5Gt5PHw2y81+JAk4kwlBgHMp8pXR2kdFNDZiydQcZmP0NJQTtSJMYbGQtRgLYWrS1pTiJMbmwJIdDOoXNPghjhD8MMT1VBdqmjgHJjRx42ZC1dbeiZlH6mGaQGY42vFVGZKfZcxW3VZ+eZpiAzlijXTTjhQ1oCJXBG5Olh/T9SiFIXAQJtLVJ6kbU2vtBdK1Js9DVCSJpxwFIzYqUdIYVjo5OQSkErcvSN5sJmwvGFmGsOtzh9dJ4jixGtRogBgkCipCAOFXGkcAhSbfM6Sv7cW3FAb1Zn4qrigYubhEpycnF36S0TZ0kMhEhMKFjNJ4EWa+yISxp61tV45TykEDRVQH8Hv7nPVrY7N32BKJAcnW/SjIa3MYEXVZ+ofB9BPjHQbsX0+im6pkJ2uxnx3X/vxVOPd/MtJ6YSiRmeWgjP9Tj2S5/BtgIufN0NY+uP/M/7aX/iMjLZ+2ykXWhijk72ku0WTgnOf9Mz6d+4ULOSqYTCBU+MpTIL+9g9fu/M85gLB7z02Od2tb/pKOgoMh2gZTyVaIYbPqXqJANWGIg2IK0ZalshNahkb2w2jAzzRzaJm0Mm4qzg/D2HR1LPFiFZIRI957DR+Ak4Jeic3I5piH0ZX7PxXo8DTSYiIdEOwjyEZ6ANfZ0x0IZQSzJtGKSabppxuZfQy3xYUWI84fBbnrhMAADJKElEQVQF4EZ/TeMc2lksrkzJWjgipIDCESDclj3z5dpZBsbQTY3vj7OkTmOMxVo7DGNyUAqzi1Ctiq5ia58C5XULzgmiQA3T0+ZMwuslBEpJ4jzUqxEGWOdDpJLUE6dAKhZakvlGRLsdsdCMWG6FZJlGZ4ZQCoRzONGiGQUcmY9ZWohYajfK9p1zhKEiUpI4VISBRFtHP/VkQiJQgUAGgiSbuQ2vJi73UjYHGeySTFRhHfTJPcq57m2hQiqmEQnw24dS0N8mvHwzS0nM9I3KGi0TcPPRJZ51fJkokBwKhtNgUghuODxXu08YKFqNiP4gJasQijBSnDi9yOHj9fuVaM68bAcJQUcz/9eXsJH0ImwBF7/6+nL93D4RiezGo5hD08eONG5qqFP4yGXChy+PLXdS0Hn+FRYhEz7MZDsdhhh//M3wBONTa8d5uLOyazJRwKSKZFONaCOBEWNiGpEA76VQAwEL0wdF2AG5jRRS6unai9axHq3jXYLIML8yTK3sjOBidqS+zUQQAHqOEUIhMmhcFKQL0wd82AORzQb81cKBJhOtIIDMEUpIrcU4y8Yg5XKnj7OGjV7K2fUej2/2udQdsNZPSFKNdrZ053kPhCu1ERZfvM7gCMs8sKIkFHXD1WDRxpIYS19rulrTz4wvgicAlRe7GxFh5xAVDYYrQpWGbRdvlRCEuSEvpch1FkV2Ju9ViULJXDPi8HyLQ3MNjIHNfkYrDnASYhUQ4kOa2nGIkxKZh80o6UPCAikIJMzPBVxLm1ZDcXgxZrPvy+QZ689DCEkUKqQqaleAkhJVeEgCRz8xrG7ubfZ5hquPtlQsBUND2QLdfKzLIoTJbm93ZM5xMUlIrWExnGx497KMbBsyMW3a9aajS9xx/XFOLc9v08Y4wlDhiGCQopoBi8fnCAPJ4cMzj8PTFTK1LH3wHE6AmR+OS7FP8dH6muVtw5qEASbkOwgfuUx871mCxzeu/OCVy8SJLe+fKMzCPp5U2Jgx7cFo+noIejuYBXcgNESbkE65tQZ9kNn0ASYME63L1rEeC89YJz505QVtZSIIBGgA4VB9H2IVrT6BA3423mtxoMnEqUNzPHqph9EW7QSZsax2Bzy22mWtO+D8Zp8za10u9wY+xMh57wAyz7I0Mv7yIm7OG+rG547NL8BSRl3JAOsL3SVWk2hfXK6XeRKROZtnTZJ+mtfmlbTz4ww12kONRSG2Jic1pSA7fzpY52iECuusz0KVG+1CSZT0HoKFVsiR+SZH5lsEUjHILFJKLNCIAtpRgAoUUvkaEr2BRiBohxLpvPA6DmG+HdJu+lmOQAmW5kIubnSJI+glmiCQhIFfJ4TA5ILbQIkyZWdmLGudlM3ejExcbVweJNy/ulm7bif3qjkZsKzGjX8HbOT21nZkInWWS0nK2UEfwXAczAfDW8zAZDmlthOSGOwMzzm+wqmVKycSBaJQEbXbtI+3OXz9MlgLvRTSbcKztPXuyX2owzHDEw/h4NDvntm39jrPW8HGiuxUjFKgrtw2AiB88NLuiESBglBUyMTIhNUMT2l8bvUYf3z/c2vXuQkTKlWYGHS7fl1BILZqGmoO5MN3jBdTu3wWKau0G20CFlSSR2bs8jbYOtHdFZEoIAeCILfLgq4Xk9sQ5DZeBxt470udBmWGveNAk4mbr1nm/EbKIEsweJugP9D0Bhn9TPO5Sxs+Jaa1WOsFTU5UMyGR2/ZiOMHjHNp674RAVEItCk+GXz8wmq42dNKMvtak2pT1K/yULkPy4fLCctV4xlwUIcqbRaUadk4w3PAtqXFeVG586lspBGEsiYKAZhgw1wxZbEUsNmPiIMQ5uPZQg2YzyHmJRClFuxEyyBxCOOLAeyGMMVhniSLB8lzEkeUG7WaAFJLuQLPWS8iMpSEU1kEcSCLlBe0uf2xpbclMUePb0c8MqxsJNRk+Z9hnnFnvcv9GPZkAaIVeJzQJwQ6MYyXBTrgJV4kE+HF/IfF+cCUEKk8dsp72sLnCTUmR62vG2xNCcMux5ZEwp8+eX0dby8nFNvONyV4PB3QSzVw8+dYWtkIWrp1nrghrkhLase9MNuVJkxmfw1/usejRDAcavVsWcUJw8WtvQOeejtY5aD0+gVA4R3BuHVkZtvrYIk5J1KUOsj95wkU4R+tTa/SetTS5Q3lY04jdmU+WTTOvynpK+xRHPsPu8L8fvpm/+PSz6lc6aDah+em1ib+TvTaGleme1WwB5MUJv1OFSBSf40t+MDnlyuXNx73nAsCFDhuIekIhHM1jfWxlvPcvNnFWEC8lqMaUSRsBrcM9ehcne/oEeTaowvsiwTQAJ5B68kA0EQgjUPtQL2Y23sdxoMnEfKuBUJLE+UKkxWz9QjNC5M/7IiWm2+bXF6UlTz536lOiFtoGgw+BSq1hfZCxnqb0MoPJdRDk2aDK+hDDynfDQU9BGdzogSuzSQV5GGaL9WFMmbUEKJRSBErRjEOW2iELjYhWGBKHiiBQRIGiGQUstCJW5mLObw5oBhInFM1Qec1DqmlFkiCQYMEYTRwKDi02uOZQk8X5BplxdPuaxFgurCfMNQJasWKuGRAEohSD5xX6cHiRt9eWOzp977FZmMWZX1U4sX0ptRPzLTYGkw2WeFL8xRb0tSFWaiRLnw9tSjk3GK92DXBuMKApxo+thBchbSUUUghOrczzT7/o1pHt3/G/72UzSXnts05xcnHCNBx+7J1Z7fLs44sTt5k7MTckEgWEgLkGrHbrdxqDGDXequ3M8LTG2X/yrLFCeL3jgITWY5SpNgFwDnWpQ/ODnxrZvvuqZ2EbIc2/fIDgYmfisYR2HH/Hp7j/P90xcZtqeNPoignLaw9Us+1O960++PaK/WrngMBnU5ryRQvoH4Vjb/vkSHrYEXzxCXrPuH7bY6nM4eQWAuDy2foJbTfOC19desvPIjKQzmHD0faEcEQrCce+6OzI9mc/egKTKlZuvUS0NFlwIaTj+Ase5/733zD5RGqK5jkBpgly8pza6HFSjeyOP5dctgOPyWy81+JAk4neIEMJnzYsxRduG1hLZi3NwAuES7hK1VznZ3xEMSYqxrwUkkBKokAhpRcWG2vpW8tGmrLWTxlkBosXUlvr2yqyOJWHy9uuzg6VPogiBVvF8BC5cVJ6rPObu6Cooi0Iw4C5ZsCh+QZHFpq0I4W2AqUUS62IpXaAEl7MvdBuEIaKIzgCKUmML4T3+NqA7kDTjiSthqAVSg7NhRxdbnBosUEjChhklm6i6fc0m72MdqxohCFzzSDvnK9JgRAoKTHWkeUpNxuh8mFPzms12jMusW/IrEVs8TBY5bDbEGW7DzesxFg+s77BDfNzRJVidxeShPPJ7lzWSjiEFGT5w0FKwYmFNm9+5QvGtv32lz0HgM4gQ09L7yqg2QgIwlGXmNH+elWRQk7L1S+FV6JPOwB5qFNd0b/gQN9SZ9gDekd9Ibr5h/KwEudQaz1af/x3Y9u2/+RT4w3UwAF6ZUqezUlEorJ626tf+Bnordmf7B7SKM8wDqlH07ICyIFETNMfOAhWkz17j2QKzYuOwRIlEXb5ZOlEkrINhAbJkFAI6QgXUk688tGxbU98oScXxg1DtydB9yffQ3PzoxYOn7BATLl/exJhCB9ZpXHPeE0X7a6spswMQxzoJ9+nz1wi0zY3+L3GweTvpYAoUOXNVCJQUqAQaGfKGXVvuBfZkCTNQHGoFbPYCEm14fIgZTPN2EwNaabL0KVyPriQURRSiC3XSTmsSy+FAyHxafTzy6rGVyjKNK+SIJS0g4ibji5yZKFJGEYYAc1IsNQIWWxGtGKJwNJNDP3UHzfVhl6qfb+cpJdYLm2mtCNBIBxxqLjmUMzx5SaNOMQJSSc1XmuBn+UV4IvYNUOkgkFqQLj8OxNoY+kNfJhXkLtyAinQ1odltWeeiX3DQ6tdgnD0kl2ej2i3gqm3504y/QaZR/tNbENbx99eXMM6x2fWK1M/Uuy5mJAUjlAKjBOcXJzj/3j17VO3z0vFTAiPgjgKePkXXjO27tzDHbLUsvLMZVqHJ7jQhYClFqz2Rg9Q/WKUhPBA3zZnuIoYHAKnYPEzjuBil9b77tl+pwlwAsxCxMPf98JxYzK3qMbCm8YaGV8/MjEdOJzam6U6S5W5MzTPBKgt4Ze65XxNhim/4XX/6a+mtisyh0gMLp5Qb0jD8icdwnpCUQymbE6gmxNClXYIoXMPRQOixZQTr35k94050InizIeuG/86ZD6UDZOJlfAaj7CzZRxV3jfuOUvzvgu77yOz8T4JB/qpeN/ZVebaLR+H7XycU6IN5zf6CBo0giKu39ekOLHQJHSCB9Y2cTav0CBEPskoaQSKY+0m18y3MMbyudVNNnsp2ngNhbV2qLOQFXujjG0SiDz+3A2v2fzCEHkWJOGJxEixO0rtRpHiVUpJoCSNKGShGXGo2SKMGsgw5rqjczRjyVzkCIR/mqTakGQWk9eWyHRGahy9JKOfwWIzwBjDclNyZDFkoRWwOB+w2IqQSqEdOOOF44H0omopJY1QIqSv52G0BWuJ4qD0RCgpaMWKKBAk2qeHVcITtxuOLXivzQxXDaubKdY5FvbgAupgsMDhCbeDuy5crr+B29xS2QdCcfrQPP/8S6YTCYC5RkQ/9eR1K+JI8Yo7xokEwPFTeVjT3Pa5yFluw+VK6MlCsyK6noUxzTAdyRJsHO1y7bt3TyQATDvkoX/zovqVxfOjKKY6BWNi2epM9Ez+86TCx/47zB6SyS185Byyr7nw9+urvR/6RP0zOOz4mdCsvbd7mjDQbCUcffW4R2IrAmmxzqe43wqdKc782an6He0O77wCsnlBtDE857BH6a1QUzQVM+wNB5pMnN8YIIJwKDYTPm6/009pR14sLKUgVgE3HVnkFbcc5cGzmzyy2aWIFqmKT1tRyNH5FkcX23T6CY1A0VeCxFQrZOeSYwdVBcTIQK8s9OFL/oYvbC6yLrM3lZ8QEoTwmZkaoWK+GbPUjJhvNWi3mqzMNVmZb3ByJWYuEkSBQ0qLRJFmlsxYglwUDYLDiw0sjjOXIOxrFhoK6SytKGC+HdKIFO1mSBwFBEFOGHKypJTEWEOaaqxzXv9hHak2RIFE5GQhzSxSQBhI4iig5bxnaLOvaTcD4ihkfbM+ln6G/cdewvUPion8rFsOs7Q4paqx3Sc39fKVVTCeYYanMiaGsuyHbVWZONuXtma4cuwonq0GT/D3fW1zjVZQr99LBiEPcXpfjhNt1p/YvpzubLzX4kCTidTYYT2HXAfhrGWzn6KtJRWWxWbMzUcX+eJnHmehGfDXn7uMwFeRts6HcDgcC62YW44t85wTy7SjgAsbiuO9PhtJ5rO4VIUPW1h1mXVmKIpAKk9kKDIeWV8MDlkII3w1RiEkUglCpWhHIUutBitzDeZaDRZaDZYXWhxebGO0YakpODrvyUYnydDakWT+rxD+O0iNY6EVEkUBUgoW25pmKBHAcrtV1pxYbIW0mgoplCc8ORHQxiFwbPQSOj2Nc475doC1ljDwVbN7qWajn9EIvSib3PtjHQxSX4tisR3jgGY0m/q62ljvZBxvN/nC04dr17/nUw9P3X8pijgSj8dlOwcf+uzZmj0qKOJTD0q61PW+73Mr2mUDrrx+Z5jhyYYwuf5ul97BotLwXqplTxPw7qatzzcEfYGYzzCnaoTJO/hZOi8+ycYrrie+NLpcOJh7ZPoXGvYcwjrShYORdnGvGcj6L7wO1whp/N02z7UpmI33ehxoMuGMIU0NQvkgIuF8yMXAWqzRHJ5vctvJFW46tkgrCnnsco+zG3209TP5Ah8vGIcBNx1Z4sYji8w1YwSCdiNiZa4B5zeGoUk29yaMcIfhlIAowpzy+gvDlLO5dwKBEgKXe0wEEIchi82Y5XaDxXaT5fkWhxZbLLSbBErgkIBkruE41BYoARfXE6zwIUxae0WIc44ohKNLMYvtBs04YHOgmW+GJEoSKkkjUrTigChU2FyQLZVAKe/NCJFYa+mnBmt9+AkSMu1DwizQTTRRqFhq+XNV0p+PNo40swxSTbsR0moExIFkQpKfGfYRt1+3zG0nlyeuf+OzTvE7953xWceuAELAFz/zBB/63NkrunkrIbj9+Gh/PnX+vPd8bcFX3HoD/+JVt9NNNJ96fH1qu8+79Rit9m5JwBXAPY3u8DPsGbahePgHvqD8rBIwTVcba77wkfMc+Y37n8De7QBPo9nPpyPMNSnmxIRsewIefPdtnP4Hn7hiw9MJ6FwrtyUUY4d00Lwwuk82J2qH0eItaxx76TksgoGZHkJ6ffsSsdqmls9e4WDu7Oz+/WTgQJMJnNcKxEEwTMAiBSg4sdji9lOHuf7QAoGSXO4k3PfYBuc2+2WRNXKtxDMOzXPt4hw4SadvaEaKVhwy1wiJlaIjNEIJnHXeu1DVZgpPEALpjW0jqrkKiioSPg5LCFBKIJykHXvh9EKzwXy7yaHFNkeW5lhsx4Shr0wdSoF1AomhqSCUjkubKWlmiWJFM5LYQKB1niq/oViai5lvRmjryLQlChX9xLCYG2HNKMi9IxYLJNqSaV9V2wGJNvQTTZYZlPBx6GGo2Oz672VzoFnvZyy1I6JcDBvk2SGMEYSBLAlLIAWN6GDMeBxsTJ8lF8Arr6/XEgBs9hPWuvUZmXY0AW9hIQp45uGFiZvccuQon714gdQYfuj1d/Li08cATzykEMw3Qm49ucw9j61OORGxzZnuACtt75UQkLsmKysdDDKYUqOi3G7mnXhao3/jIuf/QZ77XzA286/6oiQUx9/5aVr3rflNjXtiRZVFifpcArj1AnHFPNYUCO090y7cZcdnYR9XF1Lwuf98+8TvJlwNCC/Wr9uJuDoYQJBs48HoOrKWn3w9+epHaV+Ta8ryBAASRyPIGOirn3ClmnV/xBYzcPielP7h6ffvwbOP4eKA5l/tsoDlbLzX4kCTCYfP3BQriXUGI4rfWdAIAlaaMa0oILWQaceFbp+B0YUfAQQsNCKuW5xDCclmPwMEUSBxOBpBQDNSiL4PURpKIQRKQiAVofIhRNpaXzW7EGgXG+cCOSEkgRQsNiIOzbVYbsYgBStL85w4vMBiO2Iu9EJmg8M6g5L+SlVO01CCXuYYpJooUISBJM28TqIRKqJQMNcMaDcDnBBY52jGAf3MMN8MGKSGViPAIkgzg3AQ4nmFcGCtr61REKPU+WxPRQhTM1JEgWShGZBkGmEtFoGSCplXwXb41LAOR2+QIYFef5Zq7akAOcXw3auJvtKKOb3SnhrpJAT83P/nVSy3YtpxSFhTzbARKm4/dQh1pF4TEeykAqIMwNbMfh2dh0DlA77YNhePV6u0e0a9A0Ixw9MV3dsOcemNN+K2mQi59qc+gVpLUH2D2IdCWFuhuhmnfuyvePgHXji+UtZ4RvIuuK3dloyKrmc4cJg2Fl2wD5Ma2w1fB6fe+CDBfIaMLEKO7yBxtIKUdlBfRyKQ0wdhHGe8+ivv4o9/b0LSgWp3cvsq6loW7x/e733GKj2dUAiBOyhhuQcIB/qJKfIiDsZYpBC+9oN1GOPrJKz3Uw7NNUmMY3OQsT5I8yrVLtc5COYaEXONmHYjptPXrPcy0szSimUZgnR2vY9BlF6ISCliJdAWMmPReRakorq2c/jsA64gETDfbHB8vslSKyYIApwTGGdpNyMW2xHtSBJKz0SMMWhjEUrQCBUCizaCIPAhSa1GQBx7HUMcKNpxSKuhiEKJdV4o7fvhkDgy54ikr1q91st89WslwECoIJKCVDt6qcE5h7aWQAniUDHQhkGqaagA45yvvK2kt8OkN1K1dSSZxRpHGEq0NjgJSiqSaRWFZ7gi9AZZbTaKTF9dS+Elp45w18MXx+pVHJlrsdiIiQJ/XWyHhWbMUmtyznyBJwxba0SMYLuHXhhQpqhJUr/D0XmIggkOHDHe5k4IhRKenIwdf6YROuhwocQ2t/8dVVcTdK5e2IZwEKwlXPcf/xqAR/7PF/hCoXVEYgoc5GG6U45lBWw5lUJPsZN+zlJlbg8TATVRmu4q3zK6xyXtx+3Yfc4pTzyFZVj9egpUbFCN6RsK4Xx4dF0/dEQ7SFET4rUsggu0ufHlDwLwuQ+enu5ayQnF1todwkLjkmFwaPIXK5oN5NFxjaG0CWyT3XY23utxRTEob3/723ne857HwsICCwsL3HnnnfzBH/xBud45x1vf+lZOnjxJs9nkFa94BX/3d6MFe5Ik4c1vfjOHDx+m3W7zxje+kUce2V1uYmcdWlsGiSGQQ4PGOV+tt5Po0qi+tJmwkWQ+brzQPAhYaEa0GyHNOERKxSC1XO6kPL6WsNbVRCpAIQmEoBUFtGOf07+X6jxFpfdI2DL8yWslpJDEYcDhuSbXH1rkxiOLnFiaIwojUu37eHihybHlNs1QorAYY8i0RjpLO4D5SNAOIcrDiCIlfCG4RkgQSJqNgFYjIAwl5N4BbXwBOa1tqemQwpMQ43whIufLVJdelKJqdeElD6REKUE3MVjj8u9VkKSe5EgpkMpnnhLCkzlrLYEc6nADJQlD5b0bM+wLnHW1r+2qaA6yvd2xmhVD/NqleW44tMQNh5ZYbjXyWi6SzDxBMz2TDiPwhryAshhFFEEUD5dfCRyQTnhwKumJRHGcra8ZDjSa962y8vsPPtndALyxEV0YEF0YcPLn7uGan/sEsn/lBMbB5Ke9ACeHz4OR144ad/v7erpC1L+2I4Y62ducr61EHtnAf7ahL7DohPB/n4BpZYugZyK0HR+I2koe6y+SOUnUTonaKdff+QjXv/QMKrzyCUlpHI3LpnYMx+f7NB/tIYKg9rUtZuO9FldEJq699lr+w3/4D3z84x/n4x//OK961av4qq/6qpIw/Mf/+B/5yZ/8SX7u536Oj33sYxw/fpzXvOY1bG4OC1295S1v4bd+67f4tV/7Nf78z/+cTqfD61//eoy58gFjrcNaR5IapCMv8iZAesG0VIIgkMw3A7Q1pNVjCL99KwwIVF61WTjCQBIGKp/ht6y0YlbaMaHwmokksyTakhpbZoLKm/OaCOm9CcutmGuX5zi5NM/KfAspFJ2+Ya2TeQFzO+LYcotWrJDCkRkNztAKBe3IS7e1NvQSjbWORjQUUMeRQilBHEmCQJYhLNo6Em1xlrwqtSc52jqv1ci9CkoUdSQEQR6mBcMIEE8OKCsNKynoZyav6C1y/YcgDH2VcOc8AWlGyssxcnKSGXvFot8Zrhz3ndvg3sfWxpY7HPdc2OC+yxu7a9jB+c2E85sJh+aaXLu0wFwc0QwDmmGQFymkzOT1pEHkXoKtD2Up9pZlyrrxh1GVSMzwtITqasILT73MEY2HOzQe6uw6pKp2LwHu6TQ9egAh1wLE5RqtgYPwvgaNz+0u6YRw0D5naZ+zyMxhA3BS4IR/DW+YeytcdyWoq4CdWcX5ZJ7EjhryzaU+zaU+YpfjU9Z48eNzPZqPdFCDqywE/zzEFfHRN7zhDSOff/RHf5S3v/3tfOQjH+E5z3kOP/3TP80P/uAP8vf+3t8D4L//9//OsWPH+NVf/VW+4zu+g/X1dd7xjnfwy7/8y3zpl34pAL/yK7/Cddddx/vf/36+7Mu+7Io6X0yua2sx2iIj5UOBQi+gbjcipPJVmTPjPQhFrJ1gWPPBWId1PlQqjhSBBGfx2aHimOVWg4ubCZm2WOeNdVfoIor5fwGR8l6DhVbEfCOmGcYgJElmSVPjZ5ERaONQSjLfVDSVJRCQ4Y8v8cXxtLVo57cXkSIIZF43Q+ax445AgUL6mhl+U2wexgXk4U6iJBvOUZKKQPoK1VIKnPHhS4GSZK5g8/l6AcY5AimJQlF+llIQBIrMeDqlpEApibWOUDikkmTaDsXuM1w1POv4Il9y0wlOLPrKR5tJxh995jGcg4s9H7/64LoXzF0330ZtY2Bb61jtZzigl4epNcOQdhBOtKGtg8yKPFRvl5ACubBDAV9xmDx72lUrlKGNF2wX31lOoJ5OwrkZxhE+3mPxTx9h/ZXXPtld2V9svU5qRNtX3OQs7GNPOLqyzqHrVnEtf69NByEP/s014EBd9iZa44z/m5zU24ZFCQvNSz6sKexWvtBpv7PwYU87CXea2IRwxFtjjmpwtrdQZn6KpKYRavrbZILaLaJNi27JYY3HOMA2AtQuvHsFZuO9Hrt2bhlj+I3f+A263S533nknDzzwAOfOneO1r31tuU0cx7z85S/nwx/+MN/xHd/BXXfdRZZlI9ucPHmSW2+9lQ9/+MMTyUSSJCTJUNSzsZHPtOZswllIMkszDlCBYr4ZcXK5zfGlFo04YHVzQGqNF0gDxVWlpChDpeI8+5BzjkDiU7xaASjmGhHWMWIYV4m9ABphwGIzZqEV04qj/5e9f4+WJbvrO8HPb+8dEfk4j/use29V3Sqp9CgkhGRR4iHZYAMWuIxlTBuLtZiW6dW41wBr2ZYfy7bAHjReY2P3uBsxchvGa+HR0N1YzBpaeFYbZIu2BcYgjGQKJIQRQiWpVLr1uu9zTmZGxN57/vjtiHyczPM+995zK79rRdU9mZERkZk7d/x++/f7fr8UmcNg2Rh5AoGQvCDyzCIirHYd1kZiqLVa4FRitfLqYq2VDl1BcFbo5hq4d5xpKwTWqMd87bUmHYlUtcq6+hDxEfJMFZZ8BBujmvQZwZmUWJC8NhIfApLca9AqRkQTMOsMmRO819KcswYxQqxjK2wjIlirSdig0oxrJ+LvEvOxcLzPwdc/9gDf+Uce5fWXTrWPvbg54su3p9WZXtzSv60Il1Z6OCOc6hR0neNM0eHiSo+bw5JPP3eNECO3R/ubbCPgAyyiO3zrGy+z0ndtn+tcGMH03c5ljtn2ixh37xPYqqHnDlalyJ22SU2+dl7FYomF2M94vlfgbpX0P31tYTKx/ivPHqjd6Chw6t9/mevf8iD+AK73c38qaSFqiaPBfsb7+UvXeeRVz3Pq7Lh7Y0CHZ56f/m6zq5pBRAPlhVrbktI05LuR8rzHbUHvGUECUw7Qe0FEuTiLkomVJ64T852PGaOwWeecyhdX9a4Pe7wwWGmTCWcCq/mQfrZAGhc4+6rrXP3DM9TlwVqmJbQrv9QrOXWvJLs+X71wiYNj37qdn/zkJ1lZWaEoCr7/+7+fD33oQ7z+9a/nueeeA+DChQtT+1+4cKF97rnnniPPc06fPr1wn3n40R/9UdbX19vt8uXLAFPlsrIOWKBjLRdWOrzq3CoPnlmhcJbNYU2ZWm7awNdAZgxOLDEKeebIs7QSHwJl5RnVgTqg6jPOpgRi3BstIpi0Ir/azTnd79AviqRwZHFppd6gErTWCP2O48xawcXTBZ1MGFWeqlbic4iqTiUCuTP0Cku/4+jkjsyqmpK1WtloiOR1KnmHoETcslafiLIOhBSUmVSNCIl43sjAhjhuFQvo+UM6f5Kg0kqIGe8X43R7lBFRjkXqkYoIlY8Mylp7+pdtTvvGovE+D1//2PmpRAKgm1ne8vDZufs/tzlgJc841+tyod/j4kqfR0+v8fgDZ3nN+dM8sNLn1oIScB22k/gmUTjLq8+tbdv+2Fdc4k/9kcv0+w6TCdJszezjDLKSYXpud97B7Pn30mM1qA8e/HezOUnIMVZC7kPsZzzfS4gy0V8+sa3+5vOs//svYYZ3R1zi1EevYGeJ30dQYTgw4hFvJxz7Ge/nL92YSiQAbO65+Nh8rdf8RYtUklqJdcHTdyLlOU951hO7geLm/A/R1DDfLUIRRfAF27beV95i9Ws0mfDREKJK1jfxV4jCwGds1TnXRz1uV/PV+G6Mujw/WJ3yo6iDYbPauY3rzCuvT/EmooWQR0Ieibvk077TtHRNPNbPqNcO4Ve0HO9zse9k4vHHH+epp57iYx/7GD/wAz/A937v9/LpT3+6fV5mvrixctJi7LbPe97zHm7evNluzzwzqw+srUoO4eJKl1efW+fRc2ucWukQRRhWns2ybr83Y8aO070iAzHkztLJHN3C4awhiiDGYqy2TK12c4wYNaOTZDqXTOo6uVYl+p2cInfkmSNzKgWbO+URqJSsYa2fcel0wUph6DhD8IGNUd0axTkrdAtHNyUSK92MbqFVCSPCsAqJaB0YVZ5h5dt7iA8R79VfwiT+hjHj2KzyAU9SnAIqnxyvRdu9QlAXbUSrGUDLgfA+6DbBv9DqiErpNslFiHptmVH53LBsc9o3Fo13H6a3r7h4igdWu9tev5I7/vTji30lLq70uby2Si+bnolPdzt83aMXF75uFDxhwezXzSyvOrvCWx45t21751tfRd6MpwxsrptkguQG03fYU/m4xcksIDMvUqOJcX+kjUmytJXF5ZR8AXHbMCYYLbErdp+/7z3Uqxlbj68RirhtO/O/P42p7rLWqiz4NwdpnZBDBTVN28dRbScdi8a7qae3U2c26Ha3r8jnnYrHvnqxKE2TRMx+Z3Ufbr1m8bi0o7h4Dk2Jc9WTbdv6H38RcfpCH4U6Gupo2n8PfMZGVbBZ50SEF4d9NuuCzXqs3He77PDlzXVGfnszTIi7G95NJvO+E6m7UHehXIHh6fkTsc/mZ9jVqYLhgyvUKwfnoizH+3bsu80pz3Ne/epXA/CWt7yF3/zN3+THf/zH+dt/+28DWn24dOlSu/8LL7zQVisuXrxIWZZcv359qjrxwgsv8La3vW3hOYuioCi2S0q29KGWuyA8dm6NNz5ylgfPrtIpMiUwR9goq7TYrpKnZ7oFZzpdulnGsPSEGMkzQ5EZYnQMa5+Y9sKoilxY73FtYwtiIPrxOY0IK0VGJ1cid6/QhKSuIxtbPlU6tDLRzQxnV3PO9C0+eMqBBu+ZMWTO0C8cvUL5EbZNVgy5MwxGIS2QqnRrBKoQqDx4o70jpfdKtjaSHK8d1qmKQgzaDpVlEUErMLWP6nUUNAnwUSs2hXM4KwwHNT4EIiElUjr4c2cBrY7UIVVADJionIrCGcRrBcMs9Zz3jUXjvSpVNavB17/iPJdP9+/kpc1Fk0h87aNn9vU644DCQm/OjaQZN4GULOxwoAj4uLMs66KKhzHQzSHOKbOvdhYnDE2Vcll52xWLxvO9inrFsfHEOa5+x6N3+1J2xqKxGXd4auF0nMbycro+NBaNdzsEOzFdXDx/nZXVe4DoL6ry5PcZW4colN7N4TsIzw9WAXiwF/BB+OLt09TbDFAUdbBcH3Q5Pb+goft0SBzSaVQrwvWvsJz9lKe4OX2TCLlZON6rtQIehJXPXFt80iX2hUPbE8cYGY1GvPKVr+TixYt85CMfaZ8ry5Jf/uVfbhOFJ554gizLpva5cuUKn/rUp3ZMJhYiJQcmOeNWPpI5S7fIcc5qKTAo/8FYk3r6DZfW+rzp0nkeXl/DimVUNcpMwqiO+CgUeYZ1Dmst1hkePrNCUWRtgN/AGsNKkWOwbI48wyq0rUQhjhdZc2c4f6rgkbMFqx1HWQduD2r6Hcu5tZxzawXr/YxO4bBWrzd3hk5aNS2TglTlI1sjr0F84kD4EBiWNcPSU9Wh5VREtE0rAkWmCYs1ynUgVS2sNLFYTC7aGf1eTpY7jFEpWRGjRHcPndzpNRqjrVmpSlLV6TOc+L37JFG7xPHgJz/6+/ynz724r9esF/mePCEWYV7s/PCp3r4TiT3DyN4Mt0SUKL1o2ympNUYTh7Xu9LZbGbo55H0q9fdyxdbrT/PSn7vHE4ndEJVMu23b5WXiIdtI2+ZezxWPdnuZ4A8/cZmrz67v6zUhP1zCpyvh059xsPtPJPaKL2+t89mb5xcmEg3qYLiysbpwmycn2762K1z9KoupwtTWuVYpX2IBohXqnqM8NbGtL6VhD4p9VSZ+6Id+iCeffJLLly9z+/ZtPvjBD/LRj36UD3/4w4gI7373u/mH//Af8prXvIbXvOY1/MN/+A/p9Xp8z/d8DwDr6+t83/d9H3/jb/wNzp49y5kzZ/ibf/Nv8lVf9VWtutP+oL+qmCoIIajakXVWE4OyZmtQavvTWpfnN7awzvCGB8+y4gqeuzFkc1Ry8XSPfuG4vjHkpVsjYhS6Hcdq17HazekVqmKz1ssZlhUxdQuKEVY7Ob1cORXGWIpMDekqrz96Zw0Yy+m1nFdf7LPazzS4d7blUGjiYFtCdZaZRGiNDCqVh3UiZNZR+oCg3g910CSj9mBEydlNO5W1grOWPLdKlPaRbmbJMqu+GCFqUoH2UQqaGBW59q3XdcBHMFY5E3UiXZ9aLTCZVa+NUa0KWFniTKCJjfeeqvI4uxPbdonjhAh052hmv+M1j25rb5p9XW7ttIzy5PNGnaonE5JiL87Uh8Fuw0g4gmWRA0KAciLbWSbPS9zL0FvlXKjZV+TCf9IxXNeez925K1tiEgLk2+eSwWsqwg4LIw3Px1Tzn7chEDpCnCyRTMnEHj1CEETi3MIwNFP78ZxfAtsd4RPqtZxrX3+e24+Oz+2HQ/jtY7mU+x77Siaef/553vWud3HlyhXW19d54xvfyIc//GHe/va3A/C3/tbfYjAY8IM/+INcv36dr/u6r+Pf/tt/y+rqanuMH/uxH8M5xzvf+U4GgwHf8i3fwgc+8AGsPRhTP078f1h6bg8qhonUPBpWXN8YcXtYc3G1x2fzWzyw0uPSep8vXx1hRNgaVmQWbm2OeP7agM1RTbfIkEiqLkSctcRYc77f4aUbW0SUv2DEsN4t6OQZvlaewVq/oFNY7LBmpZOzNarJbOTVD62w3s9Y7Wp1Y2BU+Wh9pUPujLYcBcgyrWp4D6M6MKp01b/X09fVPpJbw7BWd+vSR6yY5EodMQKZU8O8LHcMfaBjoQz6Omu0ioMYPCpzG9J7dc5oNSLE9n27lIyIBNZWMrLMUcXIsPTUtcrYxhipkhEfKVFxmaFf5EkOd4njQmQ+XSA3lu987Su2Pd58t4tUtvp5xh9/1cP8u89+sX2sUTHLrOFdX/NqTs+4WNfeU1aL1TgOjcyhA2zOc4K2N63tUCM/DJpzzn5cTWvVImO7JZa4ByEesNvbnSRGei9Ezn9i/8nwUirz4IgomXkWwUV4281tj/eBzZtdfL2gZagnvPC1cOFj48cahaboIjf/1ICwOv0d2y/nuN89nvkzBOHqc+ucfuA21vmpaVQX5ZVM7g9hdCGwUIWq+1LJ4FxOcLMDHspV2Li8//Mux/t87CuZ+Kmf+qkdnxcR3vve9/Le97534T6dTof3v//9vP/979/PqRcg6QmkNqfae56/scmN2wNWc8uNjRFbQ+3772c5j184zavOrDGqoZc7VnLL5sBjRbi5WXJ7WGvbUiejVziqOjAsR9zeqhiMKvpZTuYsNipns8gzVjo5nTxjs/b4oKZ3l053yQyEOvKlawPOrWWsdB1nVnPyzFL6gHMq99oQlH1IiUMwFEFZ053MUPlIbrX9qqzVwdtaQ0dgcxQg6nEyJ6mfPrbEcGMEF7W30SYPDQzYlEiMqoivVW0qzxyd3GJEKEPAmkjRz+jllpdujVjp5XQ7TtWnvHI2jBHKKjIc1cQYyY0SsjNncZlRmdilNOyxQQRevDnic1c2tj230xy1VVZ0M21Vm8SgqvnyjS06zvKnv+KV7XF+4feeBiI/8EdfRy9fNGUcUxWqkXzKHFR+uixcOG1hOuwQa/gPizAvofBhuiKxxH2ESNujepIQNSkAtDVwwfXPJhQSIyvPRM5+8oDjebd2wP0e6+UCiTw3WOPGre0LqfMSjAb99QFbtzrU1czrvCAjgy/gy398/PCD/167D278uS1iZ8EHfMTTdzMMn/78BWKEq8+tceaBW7gJVabBZsHtmz1cXrN2Zmv/F5A+ouxW4NJ/XLyY1X2pZHA2I0wIbYxOweaDB/x9L8f7XNwBE/Xjg5EJRRVRH4ebtwdcvb7JmW7Grc2SL18b8NJGST93/JGHzrFaZFzbHBEz9VDoFDZJpkIvt6ldSbg9qNgqKyofCF4lTvt5xno3Z9MPQeDcSoe1fkHXZQQPq/2cB051WO1llKOK0gceOtNlbUWz782RxxPxMWJRWVgbhI1hjTPggzCqPcYI3dwwKDV40kpFpKw9nUwfH/oAAitdhzRGeCbxR8SQZ5YY9VwmBorCahUDoQoeX3uQSJ4JzljyTKVsax8ZljUm+UsMBDqFTS7h6ordkLW9V0JG3rj8xfHvbFTWVJWhrJYrt8eFv/wnvnKbLOxBsTGqeP7WdjKgAN/+ulfy+ksrCxNDZ7XtbXSU1QmZs/KWWehkSvSZRFMlmH186rUmaSFPzN4RmOzFzfY4s1dBtyXuS6z9p5dwtyq+/P2vu9uXshhzhurqJ17iwv/6WQDq9Zwv/F++ek+HWv9s5NRnluP5TuPU175E/sAR+R2kRGIevvxN0Lm0tdBJ2j9YEotA9p97R3IpMQp/+LkL2x6/9sLa3IWfunTcfKnP+rnti2IN+s/A1poSsQHVC8gDfiVQn4EvPGB5xf+2t1hjcF4YPLCnXZfYB050MgFMOVl3nIUY2RxWXNsYcWOzVvnTOiCF0M0cg5HHJznU6xs1Raayq7cGKs+6VQZubJZEIs6ZtjUocw4Ta3JruR6FU92c06t9Lqz3GY08Prc8sNZhrWOpyorbgwofhFef79DrCtc3qlQ9iNQh0skNmbNc36x1ASmqxGy/64hErm9VSNTWksZ0rpcJL22MGNZQ5JbTfUdhHVaMJj0x0MmMksetwVghiwYjqZQYVNo1aB7CqAoUmaPILJ3C4WPEV4H1XkbtPcHDoPR0c0nCNdpGVUdJ5njJe8IHTSZQgnuMSSWqsShf4kjgjEoMNzjMuumgqulkDmcMNwYlVzcOd1Oz1nKuu8LjD69sf7KecbNb72pVoYE6Qo7/npdI7AXzEoq1bPxBNSu1VYR5VhqVLE4oJj02lq179z16/+Umr/prH5v73N1sTfjcj34NMbdaVUjXce7nP8/6f3huaq51N0te+cO/ydP/4GvmHidmkZjc6qf65w+AZdvH3hDNdP/+ITp76K0NGWwUVCOH1ALl4Uhj4WzN4Js3GG1uZ2L/1uce4U2PPYM1Okd/9gsXubkxTjz6/SGXHrwOgPeGp7+w/0jd15YbL65y6vy054b8whnwqhLTuw0IbD0SGF6YTn7rnvC577Y89rPzE4r+R38fua2LZeEbLzF44MF9X2N7TcvxPhcnOplIUyERlVftOIMPkcqr+7IPSl42RluGupmwOVCJ1Ss3hjx3fUC3yNSgLhGdfVKEWuk6+p2MzGqq0s0tG1seZw3OWi6d6nN+vU/0sNqxPHS64MKZPiu9jJuDkohwbq3AOmGrVPWlGISNsubMSkGMusrvQ6TTcZzqZ6wUGQHh5qBqydi9TqZqTSNVbLJGOLeakWWWbiEIltxa8hiovcdawTqDtQaIWGcwRhgO9TOJaEBaVprQdHJLr+MICMOUaIUAmbNsDWsymwzxQsBY1DHca5JgUh0iGpLcrMFl2iplUuJx0joFThJ+4ld+j//6617N177i/IFef21ji0EVjoQzvNZ1PHapv7hbqApwYVUH3+w+RtDBhSYER4X1/TsEz0WcMeuzqSJa30d3gvsAz3/Pqyi+tMmpX1lsgLof3Gs3+s/946+datVosSi4WZQXd8JUUHvztUIo4OxT99gbvs9x8zfPsfrGa3Qf3jrQ6+1tix86ojv89+ZrS7mVLVz7+52nH4ZS5+g4kwVtbnb4w88mfyJziAXEmdfJvz4LE7mBzNlnLzC/9VlkMHYkP/WrV7CbNVf/9CMHuswl5uNuaaAcCVplrQhZMlLzabVcUBnTRx9Y4Y2vOMPD5/rkzrJSWL50dYsr17awIjgr1F4J21UdMEbodzO63RxE2Bx5ermhsLqviPDQ6T6vvHBKXbGNVgnOrnc5vdqhyNVw7qGzHV75QA9rDNc2RmxsVbx0a6Smcj5Q+8iojqx0Mrq5BVFeRFO16BWWtZ5WC0LUCgEIZ1Y7aqLXc6z2c6w1DKvAsFIeg3MqKSuiPhKlj5R1TCvaQh2UPG2tkOdqjDeqIzc2K8rao8WdSFkHfAhp0TgyHFVEn/72gdrXxBjIrPp2ZJm2hzWcDmflUBKkS+yOELXl7CDYHI4oqxpLwB5R1LSnxPG4h0STwa4dMJGoZluoFrh+G4FZUt8Sdw1Xvu9xNt58jmvf/gjXnnz4bl/OkSIKPP1/e8v8RGIHyMjzih/5+NRjoRO2rYhHA7cfEV74mgOO56Z98Ki2lwlilAOXJ0bP9vG3ckwpmNk566DXs8NzIapapjpfz3ltlHY7KEIwXH9hjevPryEfPjOVSOzp9Znw9F+Y5pHY//wHyHA0syOsPPUS53/ugFpld3m8/8qv/ArveMc7ePDBBxERfv7nf37H/a9cucL3fM/38Pjjj2OM4d3vfvfc/X7u536O17/+9RRFwetf/3o+9KEP7eu6TnQy0QxrSVyB0oekPCQMKg3WjbV41Fl6UHlubpWabIgqNTXKNjE2nhBCVQc2tiq2hjXrXcfFtYKy8vSLjAdPr/AVD51ltdfBiHBqpWB1pWB9rYNzhtp7+oXl/FrBxqDi2Zc2GZY1o5SsbAxrXro1YlR5ermlyC3WakWl9CEF8bE1rbOiAfpq13F2vUM3V6J0kTusEbqF1WQn02pETAlDmZyx1ZlaDebK2iv/A00AVro5iGFYemLw5KlFpPKBjWGlMrNWid3WWK1elCr7GoN6XBiTkovKt07mIcTkdxGXJkh3ESJm7rYxHFFNSL86ibgdEopvfd0FHju7cm8nh8J0K9XWIbg6kzbjO8319/DH8XLCl7//dWw9vk60QsgMN77hEi9+5yvu9mUdGSTCw//D7+y7UiKA2appYtY2dp0zbqOFeNA+hXjE2xLaxXCzO3cbfGGVsOnahVSpBFPuIBfb8ww3ikMF+ncKMWhCcv31/kB5ls+F4Zm83WLwc8eU+Ig5qIDGXR7vm5ubvOlNb+Kf/tN/uqf9R6MR58+f54d/+Id505veNHefX//1X+e7v/u7ede73sVv//Zv8653vYt3vvOd/MZv/Maer+tEtzkhGswaI1QxEupAr8joFRkhaqu2+EiRWfW+Cmr61s0dvY6n9pF+J1d+QKwQo6ZuRoTCCadXMh450yX4wFYVeGC94PK5VQqX0cuFta4jGEOvY8ms4EMNUU3jbm1VjEaeIhNykzEYeurKs9rPOL3aoZ8rVyGk9xCj+jxYK4QY8D4mMrYhRFjrZan9CDXWC5FYRST94owIYiFz6kIdRasUPkYGoxonhqoO5Lmjk1lWeg5jhM2tmuADReKGVF6TgI4zST400skdMVqtRoSASZrR3ofWldI5g3NOzfKS34fIzpzYJQ6Pwln6xfY+1xAjW/U8YoC2qs1OYkYiDuXDAFgjfOOrzwEqTCCoOd2Xb25RzaymrPccD5/rHvq9YAR6BdxewN/o5+BS393kNcwbaDut+DQrQmZ2LSWqMPleIUL60Pb+miWOHPVaTnTj7zJ0LBtvOUfMDA/8f+4Pp4Tsegk7mUTMQcgNz/7lr9zz/sOzwotvgfMfX47nOwWRyLy1fpFICPO/a1MZmHwugtSCIZnaNQ9304KKaJA+2swpeiVips/na0s1PIJQMKL8hkUcHJ+u2e6+yBh2MtGrZe55xMP53zDEPboMFM/c5vyHnubF73zl3l5wj+DJJ5/kySef3PP+r3jFK/jxH/9xAP7Fv/gXc/d53/vex9vf/nbe8573APCe97yHX/7lX+Z973sf//Jf/ss9nedEJxNNJUHQVhxjhFM99X0ovcYLndzSLyyZRF7arDBGyWvdTka/cBgxPPvSgLIO5JnVVf/Msta1nFtV2cmrmzV1gNtDTwAKGzi72sOLYWtU0y8sxKDBdQiMRoFB6bEIvcJxuyyxRig6jgunuqx0M+UYGFXCQbSVqSWTp2pE46TdyR3WWOpQExGMUX5CiDXBAwFMasMyxmBFE4MAiQOhZDtrhJVORl4oj2JQajWhcNrHPiiVOyKAJGtsY1QpyntPaphMlZxATNdnjcE5i7EWZwyFM3giVVmzXL49PnzXV7+KNz58NhkGTuNAq5gSWcstb3joNCJwqjvdKlQ4o+aPt4eUPnD+XI/19UJb3ZzAaH7ysveLEGWZrybJjsmkop+rmpOIErQN+gOPccxhmMXAQ3fmzlIGWlv4MJE4GEnMuplj7BS/OQudYtqhe1uCssTdgO86Nt94hhfgvkkoLv3z/8KV73t8KnE6/UvP0v/UtW37+r7j+b/4GkYP9aceN6Uh5GFBdUIYnja88IROHn5k4f/Y/bqEIySkHs1hTgRWH79BcX54NO+5SSgE/Gq6V89MRcEbRoOcvFNhbKAeZPiRJQYhIOCOgDzXJBQwHewnEnX7b1B+xQ7T5e3HPaufsVPrO4MHItVqVNJ5U3wW7VI589uGbJq/zfBrHqPzic8jw+0ufpIX5MVpzv3O+L5VV/WuRo3343j/9V//df7aX/trU49927d9G+973/v2fIwTnUw4Z3C2WUEXurljtZcDusKeO0NuhbKucZlhY+jV3brIWOtbYoi8dHPE5rAiIjhr6OaWXqFJRQA2ysBWrXyEURUQE1nvFJzqZQwD9AtDZqGsauo6UIeIj4HcCoV1ZM4glXDuVEHPapUhIOpWbZMfhGgFIXjtrKhDUNna3GpykAJ7ZzQBadpNVKEpYpLxS4j6+w1oAuGj8jO8D1igV2hblRgYVZ7BqMKm5KSqJ1ujtCLRSM7WQW0krVGTOpOSlix9/jLhoBlFe9atCMFpkrHE0SCzKtHb4LHzq9sM5A4DQblHF1YXH7ObWR66tEK0Qq/n6DSqTA13YzKhODej7LSTU7YxUKTkpQmW+s11xHEiASmhYKyNvmhGnq0YlEnStXl4km8SgP0SGUW0VDiJ4kRPqXcUZqWHkfESZBgMYYHz+kHge47hK1Z33/GEoPf7N9XRN/19+iPPsvax51PVYhrRGbZes779IEEDobktJFH5E8Nz+mQY3iuhzv2B6KZbydypElscoXR6U1jdQZ0r1IZqI9fKR2UIfnJONlMJhYym7907zo6TLTuzScPsi5t/hzSBL7gtVGvTizuDByKjM1GrFpGpQSw1FFe3H8Of03vV3JGcOej1KK6N37M9CjWSA+DWrVtTfxdFQVEc3b19Nzz33HNcuDAt53vhwgWee27vYhYn+s7nEqeg0b/vZFZVkERS4C34oOpNpYdOx2ERgji8h61ByfXbQ1Q1ybHazeh3XGpZUlM4n6Rcc2fwIXBhLefB0106uSUXjSe2hiXDUa1OwQLOCUXmIGigfWal4NRqBxciG2WtvgxEYtTKhBUh1Mm/IRnCOastV9ZpApJZNZ2LcXwzELQdpfkMBA38q1qVomKMRNQjI6aKQlWr5GtISYaIVhFi8rOwAtaKVkDEagtYiOpLYaOqRVlDlmkFxxrle/gQk9GOqj1Zp/stF2qPDjaZAjbY+VYvZFYlg48aa2sFNp/5YkXGJnINVmYmwxCSWtNsj5WB3I2TiAb5Lolok1TsREKvJ1Zh67D4jrjTMeYlLM5CfkRqUS9TSF4gZjxeZFQSjzCZuB8RZRx89T5zY24isRukFmI2HahJEF3tPdBFxZ1/P/s91n2KWWnY3ZalVY796K/DJ1WmbagFmfTdmRkPIqrcOLd6O+94u117mxAs3nG0Pq4ClKcXtz+JX/xhlq+5SPH7V5DBuDoRV7uEC6d3ucAFOIbxfvny5amHf+RHfmRH8+fjwKyPVNMds1ec6GQiRPUykKgfROEsIQqVj/QyQ+ZSuxBKTj6zWrA18AxrJRFfvTVkWHpWupmqJHVsIjyDj5FyVNNwiEW0N/yRsz1OreTYTIgCNzdLbm6W+NqTOQ2ys0wTgcpHMudYXVVjOWKkVyhXok7KUUQofaCqQ7soZ620K/pGDEYieWaxVisKRC3r2VQhaHgTMUblWlSBEFTByVrBoLyMOkTqUlulCH5igVb7Np0htVCJThohKTg0fhIGMqcJTuYMzhkkdXxOEtgjmlgYMePV5CWOHL/1zFVO9wseXJ9uZYgRSh9xKSlsUO8iu5o7y7mVLsM60lmgVOR6Tlvg5sEa9ZBYBGO214dF9HXZMVSwLGgf4MS5dr53zUfutq+eObdMJo4YkufEEI6sOuFulKz+5otHcqx7ATf+xEWik3ZBduPNZ7G3K/IX9ukR49U3aDqZ0J7zg2Cpu38wDJ/vYTuerD/dguODcHND59HJmXbXj8ZGQnen0hPT1YJZRKDaYfUvSmo5ipMPHRvslqGaLCwGHadxnwuUkmdIUSATPJO4vkI4N6dyt5fjHcN4f+aZZ1hbW2sfv5NVCYCLFy9uq0K88MIL26oVO+FEJxN1iMSgfgZWlFvQyJ8aoa0wGGtY62VsVJ5hqc7Wm5sVz10baCKxkrHez4lRqxBAS4DOncUZoZNbHjzd4fRKgcsMIoHN0nPt9ohhWdNxhm6h5m/GGmKE3FrWV3KMg8GwpmMEYyVxOZxWNapIVfv0PiT5REhSSjKpWqDtUJVXuVbvBZcJxli8pzWiQ7QNiaiJRJ5Zitzga48gVHVMC7UhtSvpakObDQiAqj15H6mrmrKqgYBBSd5KrNYEovYx8TuUWyFoi1WMqpSVWUO2U2vLEofCf/iDKzx2bnUqmQgRqhDVIR2mP/+oVa/ZlaVu7ugXGd3cceFUn0GtFatiTtKQr2aYg7LqG07EVBTD4XgGwjT5OpLM69jetmTTTXa/N4JOtl339qDGeksshHQKpK4PXZ3Inx9QPLtJ/tyA0//+y0d0dXcG1amc4WPjoEJCpP/UVTaeOMtLf+5RbSNNuPENF+n84a39JxMyZyX3ZRTE3yvYfHaF7NRoKpnwwXBrs8O1m6lFdHKqXPQduagmhC4S+z6tlyxIKPwB5r8GkcQPm6iOC2BSxewAMCXYGSWqaj1ihoK9bWb2FW0VM/s7V/HF65goym9rrju7txaC1tbWppKJO423vvWtfOQjH5niTfzbf/tvedvb3rbnY5zoZKIZUkoelXbVPzMqZ7o1ihSZ09Yl59i4NcIIVHXgSy9tEkLk4ukOhTOEEBjVAdC2ojK1RAjQLQyXz/Xp5xbnDJHI1rDm5rBiVHlWOo7cGXqFo9vNEKMr9qtFjs0sN7YGOJNW8g3Y5AWxOfLU6TzGgDOCc+pc7Yx6NYQ0J9TJLC6mlQFrLdAkF6reE1OSoKpPSo7OM6viBx5qXxOIqiARIwadDIzoBOMZJyWl91RlAAKZhRib5EbfgyYMWhkykhSkGsfrtOqVO0O+W6vKEoeCn0iAm78HC9SFstRG5KxFEAqnY+xMv8sD62NH0xBhswyYwpAdpeugnVkOhZTIhoMF500ikc0kE2VYTCZMN79t1zHn0nZGKnUvK293HZ0v3MbdHrf79J+6yvqvv3AXr+hgqE/l3P76B7j+9rFPhtSRi1s1z/3F18x9TXmpx9ZmvS1A9Cv7DJaaYXyQmHBRm8tB8DJLajq2pp+NfRA2hwUv3VjA80nfUbTpPmsBicQiEHvT853e0neoUBwEi1qZQrqWfcJUQnZTKK5OzP0C0daYzfkHFA/5VsQOpy/G1PucwKsaMywJnZ1koxbgLo/3jY0NPvvZz7Z/P/300zz11FOcOXOGRx55hPe85z08++yz/PRP/3S7z1NPPdW+9sUXX+Spp54iz3Ne//rXA/BX/+pf5Ru/8Rv5x//4H/Md3/Ed/Kt/9a/4pV/6JX71V391z9d1opMJGHctOGvoFxnrXYcRuL6pLtIXz2SM6kC5UbI5rCmHNV98YYObmyUXTncRhM1hraZwIhijwb2u4EaMgQfP9FjpZvRzg7WR24OKslbCddEqQBmKwtHNM/LckDuLwXJrUGMQOh1HkdqHOoVjlBIJk34DmVNyrTUCRrkOkAJ2ogrWJAfrRu1JE4mQqhOBOnhi8oQwYnApwPcBhqVWGDJn8T4AERFtabImJS0e2vp3FHJniDGSOUGsI8tFkxjTtH6lfdPE1bQRNsek3WeJ48DZfoE1hs1J0rOwY2AeAnTzDiFGHlhVIYF5alARuD0KnDs9M9kex9e564S6YIfZRAL0+gqjSgbz4EjtTnPeyKLEad7DsWU7zn/NEvuHD6TVkn3hgZ89WWpNo0u9uWNq46vPceObHpx6LDrhyv/5dQuPdf3bHub62zmS4CbKy6vN6G6j2x9yafUGD/Svt49dlT5/wA6tJSHJv2ZAHiCbr8wFKaG4Q3xiibKwOuEG86shbkPIr8/cqyL0Pu8Ynp9/rPwGnPqMp3dlunoZrTA8v/fEwNweAEJ45QN7fs29go9//ON80zd9U/v3X//rfx2A7/3e7+UDH/gAV65c4Ytf/OLUa9785je3//7EJz7Bz/zMz/Doo4/y+c9/HoC3ve1tfPCDH+Tv/t2/y9/7e3+PV73qVfzsz/4sX/d1X7fn6zrRyUTDvRTRdo6IGr9VoxofoL+SkVlD8JHboxHXbo24emPAjdsjeh1Hv5NxbaOEoDKnIap8qjF6rCK3nF7tcGG9Q6dw9HLhhVtbmCCq0tQxuCrQ6zhO9XOKzGGd8jPECHWlbVhrK7mu6gclJg9LNY+zJvEZrJA7wRqbYnmVivVRg3TvI7UP1LUnxEBmLcPSU9cVdZ0ULqMmCM7qteXpOjZHgbKscCKt8pVYo4u6VoN+Zw0BLVWGqGTqxBHHJZfvELTP1llpO0WcMek70IpGJGLE0M0sWG232RwtCZXHgdVOxl94y6t57NzeS6ONk3pMM/sLt0eIwJn+IlYb9F4501e6VSqReRH21eQ7sV8IO7Q7+QUHsywO5heQIxYlEgfFPHL2EvtHCPiNDVjgjXK/oD6V8+xf+UpCsWDldcFvZiHVJyx64s5BeYtHcxFHdZx7HUWn4g1f8znOnJ9W8TES6biKYT2nshSBgRt/32WaL/Md5uNZDsReSNEN9jqvNdWJ2elbtIVp/ffNXDfrkIFfQA0Qz1y/iFO/X9F77ohiihiQ2hP3qTh5t8f7n/gTf0K7QBbgAx/4wLbHdtq/wXd913fxXd/1Xfu+ngYnOploumoAlVhN/fxlrW0TndxROFUUurpRsTGouLVVIkY4u1ogooG3S2TpmIjcYgwuc5xe7/DQ+R69wlA44fagoqoD652cXteyVQbOrjlO9bP2GA3Js/KR6CHLtHWJaBCJDCuP95HoVf41yy2Zk0TCrjVA12V/5VEYoY6R2nsyUWO7jUGNcbFVAsisQcQCMSlsWpwVbg08pa/p5YZenlFWPhnTJY7WhEN1OqUmBTEm47vIqPT4qMeNIlgb8ShXIrfJebxSA8AstTVlmVFjs3jnVkZeTigyy1/6Y6/j0gzxGkiteYE4U52IEbZGi4Ly+ZjLjejl8xOKhvswSUoeTRALZ7kSUydivmxsBNiuD74nWAt+NjA9YNS/KGGYW51YZhb7Roz4W7ePVBb2XsUX/u6biQdoHZSabQ7Vx1IkNOzLtxHQQPKo5vmXwf3COc8T3/h7rK5vbXvudHeLb3jss3zkMzPVqAhs7jNcmzfVL8pKI0gQzNC0D4ROnHp+t3PN8nCijZz6lDlQsltck23VCakPVjmLNgnBzATUZnNE9sUXKR+7uL8DLsf7XJzoZKJBjElxKEYGZY0xlpWOo8j0hyGoUo2zwulTXW5sDul2Mta6OcZq0H5to8QH9VbwARBhrZdxftXRL4QvXx/hg6fILedPdQgS6RTanmStZVR56jpiUx86egg6mUMMVFVAfEwBuzbd5Uk7P0Rarwz1iwhkVrkTVQBBJVvrqBKtVlRC1hrInFPvgRjxwSeehKOOMChHnF5x5JklevWtCCEyKCMm6fyUUUuEDWnc+6CysUElYcWISsBah7Wo3CupghEDdRCiqGyttab9/HwUau/pLViBW+IASF1l7/6WN3Kmv1jtIc4EvxGmW6Fm950DY4SH33hu/pO9HAYV1BPBX5HBmZnkpphILMIOsqyLsHA5dj8HmMBBxQCGJXTyOSRsCzL7PdxbxL57Gqn32N+4OW0guMRcbPs5HLQqsTA5XrY5HSvSeH/r2z9Jd2W0YBdJEusz2G8iAcTRgntvM5Amvmvxk4mE7mQmfEYWGR3uhJ3kWveEmbH4wH8uKa7tf8Fh86sfpv9bz2JvTwsVhNUu1StOXpvTvYoTnUw0cr9RlIBsBVa7GadXu+S5az0nMiecXcn44jXLw2f6PPeZTQ3agV7ueOnGkBgimTHUQQP+Ux3DQ2uGXALXbteEGFhfyTizmiNiiMFT5A4R00qxZs7gMtMmm9ZqyF77iDOG3EIVAkaEzDqs1SrBqPYt/1MJ0YZR3RCpLSGRrKUxrFMtXIxEQgxIqi9mztDvZhjruH5jxHrP0ek4QoiUdU0nGWw16lcYENFqjveaiHkflFRtoNfNyZzFOCF6VbDKnCHEmHwsxv4WIUYkxLSaLTgLXefYCvf/auOdwtl+nyxz/NR//Azf+9bXcGF1uwxrAIZekp+Dwu+w4vvC7RE+RB5YmwmKd7sPnOpt94XYCcbMTyh0MO79OPtBN2PqjdRee73mYafWp15vDp/CcMKnz7sOf+MGIsvka8+YjecOGPjHImyT15RaMOXBfod3u+3jpKC4GbF55D/9zJt44r/6FKvntpjtK7q22eeXP/vaqdfJ1g4LcmVa+S/2l4yb0f58RXZyTj8u9J6fPpnZv6WKHufffRrZLKeKAOHiafwBE4nleJ+PE61v2LQ/C1B7T+nVx2Gl4wg+sjWq1cHZw7AOrK8W+AAWoaw9t7dKnr+2xbCsESPkuaHXcTx8tsvjD/VZ6xpuDkqu3ByQZ4ZOrmTrbpbae2pP7UMychMC2t7kQ2zbe0LUCoBzwsawYqus20WBwcirI3ZQ9+my8nglQLTE7KoOKpaQeBVN1UMJ4mo+F1IQXyTH7MHIYwg4Q6sWFaNK0BprKDJHkTtcZhERRnVgUNaaEFkhz4Qssy2XoqrVSbsOoVW5InlXOKucC9cYqokk5amAMYbnrg/u7KB4meD//et/wNNXb0895mNKJGZg7f6qQzYzPPymBVWJnbDbxBib5tojmkCb7HveDS63bHvC2fkkayMq/1pMbA36vaPlWCwxH8vPGNCFsXkL03O19Xf6yGRmSwid7YnEEncen/jf3sC1L03z0b58c51f/ux21a7Y2+eCXIQ4PEBHwG5lqZmxdFhEB74z34jOzHnLN19dMDo1/32ZOtK7Mmq3Bv1f/B3M5gGzkCX2hftgaU1rtlUduLU54trGCMQkPwUNcI04BqOa25sjbm2U9AtLWXrKMrDWL9TNOrOc6mesdh2n+o5+xzCoajJruHiqo0G4s4gxDMqg5Oig98Daq6eCs4KPSjw2Vlf/Q1JdGlYqN5tlwo3NEaudjNp7RkNPjCEt8gq+hJgJIkYXbI2QGUMEqrJmVNVKnjaNVIMypSV9FIOy5sZGDcFTiqWwytWwKTsxAi4zra9FHQMxJDK1jQTvW7fsgLooGwGfjI5CCIhruChCjNqLaMUqadxHrFVvjypEivw+GGL3KP6///lpnvzKy7zhwdPUEcpwsJl+9WyHR157evzAgvi8RSc7eMsQMF1j34FLAVAC8/jhU47ZEzI0IrDAcE9PN0PAVvWG7ZfQJhS7fRhLHBmOy/L3HsJjf+s3ePoffM1CAnaDqYRiv+Nv3v7HOYZnWmYOfayXCX7nFx/nK/7457j42hf53NXz/PazD3OQL0pMRLLxunsMO7Q4AWZgDmxQqCec+Pcu39f110dO/xfZRsCu+1B30sKo0aSiOV62nUoydeq9tOL1ntOEYt/8n71gOd7n4mRHelEThuYedG1Dk4nVboFzFu8jm8OKQVnx/I0hz9/cwkRdOfcSWO9m9ArDSsey2tVEYq2X4SyUtcc5w2o3Y3NUJ/MvVWLylRKXIzG1JWl1YRQiozrggU5m8cEzqAPRaGuTIVLVGtiPSq/qSUF7tYxV12xiQwRPbtPWIkBVRU1GnCYaUSK+Hr/3ENSQrqyjStamKoZzhsxA9IYQ1B+jUa3KclWdwqv3hJGGD6TO1x6tuhS5I7eGka+JMVD5gESDjcoxMalElAy99auJqkgV76dfyz2GGOHffPpL3Bp53vzI+QMd4zWvPs0rH13bvjBcBsgXJAw73e8WeS/4/ZG/9Roqfc0kB9sJdFxKZhZFXPtt7t3jY0scP+7zhEICvOK9n2j/vvJ9X8Hg1XfPrOpI0PQbH9WxXi6I8Jn/8Ep+5wuXGVzQtuH9QroeKaYjdTFg+hVh8wAthAvcs0NxQM6EwI3Hx9/pyheFiKiK03EnuMd27OV4n4eTnUxIIwmrf4xS21FZB6qgztDDzZKNoefWVkkVAqe7HZyLdDPLI2c79Hs5nUxVnUZ14NagJLOGbqGu2RElo/Y7WdshYUQYVjVijDoyCq2fg5qBCdYYQgAngkerFIbpBD23hkZooFGVEtRFmsb/IWg1oPYBZyW1P0kbpDc+Di7J0QY8mTN0CpNkZQM2Ebu1MhEJqC8FNQTfVDUEHwIignUGY016LOp7jZYYI86aVo1kUoQnhEhACCFSOKH0KtO7F0myJQ4OH7Tytdun/IZL0/yKp6+WPPrYKR681F+gyBrHCUUxc1Par8HcTolEQ7ydcuoGqmo80U6+tE5kp4PwLOZxNmKE0qe2qCWWOH6Y0Xi59OIHPsOL73yMjTee2f+BFv3oFxGsl7jnELzgazNJcZuLS698aeo7vfrldSojyAIew2RCIdXMDvu8Je+YSMj8402Sryfb6jYuR/JbytnYL9aeHpHfWnIw71Wc8GRCCcB5nnGq3+HSmRVWex3qEFMAHhmWAR8iBqGbOfpdx0rXsN5x1DFydWNEP29cp4XMWYrkZl3kVonPmZAnH4uqCrjUp50KCap6hK7SZ1avKQRPjJIUl5TLYK1QhaAxUgrMJQAmtSFFqLynjpFsor87xpjcpdXt2JqA14No25I1SowWTS66hSWzMCwDVeWpk6SaMwaDYKU5FhBTo1QyxMusIc8dCFixWNHJIHjlRRgj1G36NiEMIdLwwqlDpFM4jfeqAzhMLnFkEOC153OymeD7FWdzzqw63E4tQURNJGZ3UfmxHQKWbRH7DheYSntMJA5VvXjF5jC56X5fa5vls8laeVMRaR4/4kbiJV5WsFs1Ut0hJasIZmSmgkPx0rZtBBeRKPtugZEjVIFaqknNInLxwk2smx4jZy7d5OZml1G1uPogwlySdXQRalncAjT7Jew0vQWQ2fbaHfaPdj4naC8wddxX29LoTAZ/7LV0fuOzyEDL29IpkDzDlAH7B1eIRUb1yP74gcvxPh8nOpno5BkXz65xZqVLv8jpFBm1FzaGGrBXdWBU+9Y/olPYRLDOubFRsTWsMUbl6DuFpXCWIrf0OpZObpJMK/QKl4jIOglXIWKtSVvSUopoNcGpPXTtdYYWMcREOg0xEoPyLQxKzo5ADJHQtBnFpsqhbU2gjH/lMIAQibHhQagUqzH6XIgoEVra+gYAeap6WFEZVx/VTE9iVNZuc63GaIIjkhafhSzTJKqOalZX+UiWC5XXNiYn2ubUmOyReBZZZqiriNunIcwS+0eTykIzj+s3bwReeSajmJMw5LYZJ7tg7i47LH3Oe7hRclq0/+xrnNWE4iCIUY3P3CGnNpsz5ktMcDPmvkG34N9LLHEEWLD6uy/E8f9NMjuLZl7QuCxr3GnEKNCs5EtspxuRyPlzt8jc9uzOuYCZ/f7mHnzOY/ttV6pEE5B5FZB55zjEEBLADSJ193BjcHQqIzgDKx2GT7wS8ZHiC9eUjC1Gk6BhtX1RbDn0D4wTfed77OJpTq+vkVuLIHivCkmgCYQPaq5mjOCcKjGdXck4u5pxe6ukk+m4T/E/zgq9XJWOrNXA2hpd0S+9VhJ8DNqOZECMOkpbI8QQNKBOLSfeRwhCIGBknDQYIwgod6P2+HSnaJyo88zho3IsIrRKTEYawrPONKZpNUrO1iDUPiUfAnUVUkUjEIISrTEGl1ttn/JBXWej8iUkSc7KxDGrOrZqVUaEOugxBS3JSKqEqLRs0GQrCt3cMBxpW9ZSpeXo8IaHLlDk05WeU/2Mh0/3GacRceLf0F/EewC2rm+pj8jqvOqRJGnVBWjMLPYyES8aAyLbXa9lpwOh7VAeMHGm1WmCFRfi2AOjMcur4/xrFNEWp+YaYwSTo7rJiy9jzkXP+fcSOyIeJZPx5GL9V64QCsPmG2ZandJPI07+zNLHde5Dn+fWWy9QXpiRh57Nd+d9xCmvFxHiUSyNLnvI94T4RzaI3elFktFWTmXsxHckY/lqEYp88aJKvzsiRmFYznfLjjt4U0Sr8/deVvplkUVQAPYp+iFBydYS4pQUsXjIb6eOhxrsUP/tE0l7eDbiv7DAxWdyzIhQrjvCxH0vnFL/o/jCBmwdcJFq9nzL8b4NJzqZeODUCqv9LlvDOlUZEiHaSBvkNipLxlq63ZwzK7kKvljIrGVzVGPEkGeG9X7Oai+jmzs6mcU65SzEoKRoYzSo1moA7cQtiYAcvMq4No81XFQ74WrtnPpOtO1BUZMYYSI+S6/TuEraakUzhvU59Xdo3meI2toVU/tSVavsrEm8hyjKvYgmtEZ9Iio5m4lJqlQBH7QtzKHtW8ZJK8FrjaQkS/AhEa5jIqKjSUjzGZVVIHMOv0jXf4l949zqCt1iOvC/uF6w3pucYvc+uVeDGl/u0NOQ7cCNmJ0Ed0sCZqsTOqAWv8TZaVM80P2tripRB72RCeNZbPKamnPVqnaGZ/yjkrTKZmSOXOycBGeJJY4RnWc2Of3vvkzvMzcZPdzn1ter/v1kO0jz7/M//wWkDqx84iXc9RK/nrHxxrNK4k73o8nXzV05PmJI4MhUc45FfedewYUKetNzS33T4gczfLHmC9wl0cudx1rPIqPMWO4wj5m08CTa5ia75PXiRROQZmw17U37GFuSko9ooe6CySJ2CMV1Pb+d8JQzSXRj80Gt1FQrkRuPW9zA0n/W030xDZQ5wbg/ZqPc5XifjxN918ysw3vld9Y+UlaBqo7EKImjoIFv5iydwrG2UtDNDVulVi6s0UA9RPWnWOtlrHYzuoXFOW0hgkRyjU0n0zihgIZrECeqCIz9L4xehxq56a9VFRuUQG2tJjGZU2lKn/wZlPMREx8jtLyMhjvRBOgqfBLxPlL79Jqgak6hiZdSAqBqVLpvVQfKSjklU/FXarsKIWobU0h/J2UmTdJIDuFNgq58lCaBc84k74xATOTgJe5NFOsd3GoxJ3gWlV7dLTGZvAE1mfEimJQ8GBkb1S2sZDB9TU0SMang5IEq9dbttFLkGaseRMarac2KwiyRe1+VNAGWbXxLHB6dz2+w/qvP0/svNxZ6TQCs/drzrP/q89iBZ+WT11j/1ec59dEv0/3szW2JBOyzPz2y75XmewX/7J/9M175ylfS6XR44okn+A//4T8s3PfKlSt8z/d8D48//jjGGN797nffuQs9QgwGOaNBTpz1FgrApt3dgVrGW9xFoVu8JhRSp223RGKyWBDGiUSTHzUeE9GA2wK7wI6qWouUa5FoYPNBy81XWW681jE4b+bP+ftY6Y+Fw5/u73n/JXbGiU4mAG5vVW17TRPsO6ftQnlmyTPDSs9xeiXnzErWrsBrZUEoMksnd3Rz3T9zyi3wXo3afIhtZUAXM5VT0AxZYRzEN93rTWxjpCFpjx9TxaSmItFwFDSA98mAriFDE/XYIRHKI9ruF4NyL5rj+BDawF8lWfVam6qFNdKqRVmrf+t1q0pUlRSwJpOLJrForimkJ3xQv4wQdB+THMaNKPFaGPNzQwhzPcKWuDOIEa5tzU/mirUO/Yur5GudFFRPbLlT4nWcuNts7w9a0FIxZzJv9msSikbCbOGFM13FsEav66haiJof0lxFqIgKte/lQMtkYom7j/6nb9D7/RuLE4c9/mxkj20v29Dc3I5q2yd+9md/lne/+9388A//ML/1W7/FN3zDN/Dkk0/yxS9+ce7+o9GI8+fP88M//MO86U1vOsAbvnPY3CjmPj4YZNy61WW0lRNrGW+VwMDChtMEIMh2gjRoNWImIdgxoYgTiUStJP2dhpWEJgFJSYiXIyMbb100bF1YHLq6wd4UBGKR4c+u7v8C7vJ4v1dxopMJm1b0ax+TvKolTwZ0ea5k63NrOa94oMflcx3O9k0KtIVekdHNLaf6OWdWC1Ufskq6rtJKv09BtIiu7ktqk2hk3JrWpRCCbjESYmjbjaD5wY0rCfp/af+OUZObZkwJpGA/7Z/6ils/CmmqAxOtV8a0XIyYyiOpeqmVCq/ciJTvaMJlle/RHNuH8XU3lZVmn0ZwxyZyd+P7ZY2QO1WSAtqKSWaFInMYgcKd6CF2z2NUJ67KAgy9UMy0K+UrBSsPrpH1UsuUETVuyyYSiQZTy6QTicW8/AK2JxSL9luE5vX1hFJSM3DvFGI188AOCdWy53+JexwLHa/n/KwOqrRzN/E//o//I9/3fd/HX/pLf4nXve51vO997+Py5cv8xE/8xNz9X/GKV/DjP/7j/MW/+BdZX1+/w1c7DZt5jJs/f8coXLu+wmA03cY0GmXcvNmnTI9Hbwil1W1k4fa4e13qtAXGonRzEon2nPMSirmW7IsrExLA1NJud3qKzG5Nz9925LEDjzinC2fNdVYeszmaffkSB8SJ5kz0Oxml95RVwBpDt8iwbtzXv9a1PHq+y+VzXdRWIXBjoF4KKx1HkVl8iBSZoZf+jkIiJetKjbMmtfI0hnKxDfC1LjEdO8WIJhSAMYZWenXiun1oHKlJLdomBezJZyJVJIyR6UoFkRCU5xBILVc2EbPDuAUriBCjVl/EqFldVQdGlccFsJnK4E7yLqw0vI0kN5vaxIxERNSIL8SAwWhwGiFzkhIJ5ZY0n4tzqdpSRzBHQHhaYiGub1Y4I5xZGXMpjMBqRxPBN19Wgua1jVKfzC1rj57G7tdXYbKPd7cEIab9Zgnai/ad+jtCNWuXGnb2gYiya3/x3PM2BvJzIQv+3aC56y6TiSWODmazJn9ui/Jib1+vszcrspeGVOc6u+/cIGgrrvbOo2RsS6sstOfE4ihz/XScW7duTT1cFAVFsX2VvixLPvGJT/B3/s7fmXr8W7/1W/m1X/u1I7qo40OnVxKDMJysQAjtfCYucvXaKufP3kqLi3Dt6gp1vb/5W+p0f3dxx0QANKGQJBu/4yCIc2bGqInE1Lnj4sNEC74Au8+Y3neFakXINua/EVN6mqvLr5UYH6HbI65G5PYm1B7ZGuKeeWlaGnYvSvbHMN7vB5zoZGJQ1pQVWGvo5o5uxyFGyDJhvZdxYT1jpWO4uVkyrAK3hiWrmePCmQ6CsDms6BaOfsdS5Fla3W/I20DbzpSkN6MSmZV4rL8QSSSJcUVhhifQlhg0ORkznRqysiE0ZnHJtK7yHh8CzlitjEQwaALhvRKbnRUlTzsD0eAb1jaCpEAuzx15YfE+kBvbGuz5EAk+Yqz6SriGIO6hrr1WW9AukJj4IU2VxthAR9SfIHdarSlrTZ5yp9wMa4QqRG4NaqrRMpm4U7AGCid0M8MTj0wHI22y8cjpaYO4/WKvgXtg/7PLvESifY5xgsL4fwSBWhIHceK6Gs7Foop3o+3fmfwsdksg2oMzzkLucNVkifsavT+4xYX/9Q957r99LdXpcYC5209u7eMvIcBz73r1+DV7OWGTUDQnkBRwQlL82R0Sk8z4EaA5zuXLl6ce/5Ef+RHe+973btv/pZdewnvPhQsXph6/cOECzz333JFc0x1DWwCOiJv+PF+8qi7psZadA/zdTlHL4krVBKJhrkfF1LH8nLa4fV5a3Yeth6D/zJh0vRfcfkSTqQf+U9me108oOHVeGM0vnK/3IQbk+m192agi/4Mr6RhC/eqzu577OMb7/YATnUxcvTEk4MhSq40x6otwdi3j8pmC1Y7h2saIW1slt7YqhrXnwlqHlb5hpZtjrSYLg9LjoyHPLEVmWjJxbFqaIvqfGAmk4F7UkC4ybvtpM3VR9+uY5Jm0lcljQnLCTjv7gAb+KdnwPrR8jBiTLGtTnUgVihAidQh0MkeRG4wYfBAsek3RWBr2tXEqmRtjRKwhS61OddSExyRCbBRBjGDTz08laLUdzEgijcfYxk8+BBBDrLU9q6ySMaAxSUkqqOhO8GRL0sSRw818pkYEK3BhNeMND+5jZfIg2G/b0k6YnUebY8+bXyuvbVhtx5G0vxsiUAlk498S3RSIbaZkdqr1ajIhmWjhMjtI4e4ZS4fWJQ6Hzhc3efB/+j2+9Ne+ktDXMSlpGPu+I2YBM6jbQC7khpgbQseOf5pN5e2E4plnnmFtba39e15VYhJN63CDmNqT70nMFGxFImKSqLe7A8HlxJrMQSF+QYK74NgS5rTbpdfXHbj9KKw9zTbDRONRCpsb3xZMFfX8dSQkD6WQC1e/ciyT/MBvbuh++3lTMZL//pf384olJnCik4my8uRF1rbnAKx2My6f6XKqZ7g9KCkrT+YMncxydj3n0bN9eh1L8IHNUc3tKnC+n7PSs/Q7Wavw5ENMkqfSxiE+ao3CGoMY9X6QVI1oRnpEZVdDSiSIqq4kqbaguYnur14R0hK1iUlONh1LKxZNOTNS1+oJYdDVpMYYryFcZ9bgMi1hBmLbdh4ieO8RGTdcGdFqgyRduIYbYoxpFaliQy5HPTYCIVVOIj56XFr9bVq/fIyMaq0UOWOw6L+XOBo0QkiPX+yTz5CHL53KeNX5nW+4R4JMQIwy8XdaVdnRWXsRRBOGRXK1lYfCzZdujUBl4dRMnbqfpritenw3KiwUTXVhUbvAjj1QSyxxrMhfHPLIj/4OX/iRJ6Ye/+IPfzUAD//Y75C9oFqaL/25R7j5DRe0ynA3ctmjJJKm46ytrU0lE4tw7tw5rLXbqhAvvPDCtmrFvYKOq1P3QPr7dMVmUXPr1v5a2w6ChggdXdyxQmGq8fx9VDwaCYuPFXK49WpY//3px099Wl9w87WRkAMxcv4/bXHq00O2LhW8+Ob5Y+SFr1nh4sduH09CfQzj/X7AiU4muoXDZbZVZuoVlkfOdbiwnlPWNYOyZpS06l91cZVez9B1jtujirqODKtAL7OsdDL6HUeeGUIUJHkwQLNQmqoIqGeEyq2q23Wr1JQqEU0hw6aV/jrqaLYObDBgNElwxraGej6ElChIS3gWNKExotUEbb2KGGvoFBlF7hAT8cEQa+UzlHXEGzWVE4EQBRvH3sjWCsGDiZFoDIhyN7KUQNUhaDWiIWXHcQLhkipVCJGQ2qmCaLKl5PCkTmUMmRFMkuQ1YblSe1T4qgdX6HcPkTAc9qaQT/hC2OQbcVAfkYO8rMg4sDxYz213O11iiROKL/21NxKy+LLPd/M854knnuAjH/kI3/md39k+/pGPfITv+I7vuItXth2drMLtYCJ63BA/5kpILbBLQtG+rlkobWKiRVWJXXCYpGT9M8L6790kuz3dC7Vkrd07ONHJhA8RE5WLUGSGR851uLieEaKSja1RGdTT/QJjYKXntOcQbTdyxnBurcPptQ6dIlM/iQmZV4itjH2jZiQmqgmemWxjiknelSnTOmnqEaLBdll7TUSM/gRC1BaixitCAJIZpk1GdJiYqiEWE9S9Os8t1hl88Grg67SaUJYVg1FNTMTxPHc0qUTtQ5KiFSJG4yoTCcmjw5hUKYlNyTi5coth5D3eo6bAUcnbjcRsQxr3XonXRe7InUUcrPRzhlvD2a9tibuFR8+Ng/FWRGACRsC5iecTigV3HGOAOQnFgaoSdwMNy/BET4NLLKEwSqLerdf9yHGULVUHiAz/+l//67zrXe/iLW95C29961v55//8n/PFL36R7//+7wfgPe95D88++yw//dM/3b7mqaeeAmBjY4MXX3yRp556ijzPef3rX38U7+J4sOHatZCYhW2JpFSCu2U1csnGH+Si8SC1gI3EmeLsZFViav8xreaeQO/KCDu6wUtvOXVnT3yXx/u9ihN+F1VH6dV+wUNnCs6tOG5tlbx4a8jmqMQZ9ZEoMsNqN6OTZ2yWNaPSU3ltiVrpZORJ1ck3poqkVXjU/8Gm3mqh4UoYIr7lCURonbebFqOY+BWN2VvDndAgXlo5T+OUe+GcEEOj3hRaXwdtD1djO5W/1dapKvlCqMJSbCXzfQh4n67bqc+GtYY6SYgWhQOJWn2QRCAP+u6svkHyTJWrMmsQA4MNj7MgxmhiY6WtojgnWKs8jczqZxFiJFSaIN3a2geraokD48qNirKOvO7SAs7EK8/PNurStOFhJfk4zD4P5LvcOowZCxs1iIeYaUWgu4i7cIjb2IEqGpZxwrHEEvcOQh73/XOY27feYJH8516Oe5cJqd/93d/N1atX+ft//+9z5coV3vCGN/ALv/ALPProo4Ca1M16Trz5zW9u//2JT3yCn/mZn+HRRx/l85///KGu/6Dod0dYE7l+Y4GJ2sZ0qCZVajF2EVMKdmv8xQqaWMDuX2Hb9nRUJhCweLo8xPR9+pPXsXv0j2gvI1XPjzr5udvj/V7FiU4mPIIYy6nVDhdOFWyWnmFVk1k4t1pMeCEIeeYSAwI6haMbDadXCla6uRKHvQbB4x+CciFMIkQ35bSG1NUINvnUOz5uRUq/mUhrdKfcB1U6yjNDVet5Irqinxmr/ITYuE1ru5S1SjJt2qeKwmLVWlsfk+R+XQuRgBBaLwxJbtXOGmIIRGPwPlBWXuVikzJVJoJYSWpxulotgJlwAC8yQ5ZWocvkv+ESAdaHsbHdqE6St1WgIpIb4eZmeUfGwssdF88WPPZgj9a8ZJiSOAFecW7xRO7MfA7CfnBAesT+cUjm4NyXRqBm+1TYJDSTn03Do7hX1uaWWGIGogHm7Gp0Q9aeUt9RIcAT6S0xix/8wR/kB3/wB+c+94EPfGDbY/EeC+I2BwW3bvXGflOT38nG4jDNbpqFlYS9QH0l9vdZNIunC59cgB2T2b2cdA6KaxXnf+M6L37d6anHL3x8MxWdzfilPmBeuonc3jrgRSyxE050MuGshvgXVixWArfLikFZ46xQ5BkrHV1ttc7go3IkNkdeA/Pc0k1GdbrCTyLW0Ab6LaIG58aMCdAxmcRVXluFDMkoTrQyQVQ5V1VnUgnXDD1OzHQ1OAJ1kGTGaxCJ1F6IHmJa+Y9IK1xjrcU2hOqk7iQYXVVoCOOJpEtSg/I+4IwhiLpd+xBxyfy3TilIEx4pQTtxP2KSns2Uf2FxBDzloBqrZ6UZpQ4wqkKqwBi2hjXdrgWRHQ3Vljg6NJWi9Ad0Mv3/A6s7zPywa2BcRSVd7+tizOGqEztiIqGIcdop+8iUwxZNi8tEYomTh4Wu1hO+kIdCc+88CtxbMf6dwwynt00qtg4Xou3k8bDwUkyc75p9BJhKKOL02JQDqshPHSPC+d/aatuQJoeT2MT5O+xYXY73uTjR9K1ex3JmxXFxPSOzqm6UO0uvUB+GxiU6BBiWHivCKKk7dQtHlpnWXFfHxvTM2jQ4GNMo6YwlY40ZG9aJAWOl5UO4xik68Sk0KHcY27RESUvkzqyec9KhuqmgNPJ2zlqcNer7ECNl5RmVPpnfaTOGoXHDHm8hxFSJkLZKIyIqQQvJE4K2KgJK+G7eh7UGYwyjWh3BxRjWV3LyZFTXOINbK3QyQy+3rZu2M1o+zbMTPcROBB463+GRB2bam5oE4trm4Q6+22S36J4jx/i9h6BqUiG0yX/qr4PrExydRv5qtyQjMpGUOJYJwxL3AuxmxeV/8tvt3yGL7bYT8hcGPPT+3wUORpRd4s5iY6PD7Y3u3Odi5/gETHaqSkSzYOCEw8+O4tM2k+RGC7dfMf7blrHdNh5bw/fmJ1bBwfCBiITI2d/ZQuoF70nPfsirX2IRTnRlInfC5XMdhlXN5rDGGG3JKTI1U4tRuQiSyMxl5Sl94Exe0M0dIgYfmkxiPMhiyi4a8zdB249c+rcPIQXgelz1mZC0uq/BSwCtMARNCIL2MCGptFDWoQ3idVW5aayCyVpn06qUWYMPgbKqGZUBLxEbBeNsCvohRE/d+luY5Mat5+hkjko8QVJ7VYgtiVpSpSPZR7SfQZ0kYMvKY5yBIFQhMCg9vcKmKo1WMASDs9oulqXrrXygk+3TaXmJfeHyhS4XzxTJiXwO7mZl6DgqFM3vdd79IqL6zZPJw073jijTy3YhHGF1Y4klDgcJ4K6NiE3H3ezQnOn66336Bmd/4UtIGchfGPLQP/s0X/7+O0AoXkplHhi3N7psbeaERZWARUH9HcCxVCh2eDtRIGRgqxT2T1ZqMsPmIyv0vrSJ29AW3s2Hc66+uUt0QshheC5iR3fg81qO97k40cnEA6sZp3uO24MSI8Kpfq6BdKoiaHKh5m6bQ8+NzZLMWfLcavAlKbJOyUMY/xNI83RqMRK0fckKGEwrYKOKRhNzeipuSFI+IkIdItQeG7UlSluf9ABaOQlgtaKh6k96NGPUpyFL7OqyqqkqT4iihnMSEwm8qWSMW5RIC7I+QFV7XOZScqKtYT5EotfsQdrX6fvR42i1pKq0PUqSKmcdlNwdQpxY+FUH1TolSSGZZTgrrC0k0y6xXzz+YI+13nQFor/iKI67+lPHaYWmKUWoXTCvxeowE2hThdjxnLsdYzKJmNk5ViA7EcAn95+9EMcJn1KXuAexIzk2wvp/fIH+p67jbpQUz477wTufu8XFf/H7PPffPj7/pWnamJX+bLDnMLJplzoK3MddsYWtcTNCF7cD+HDM8/dhqGZ3IdZd1JYXCsvgwR6jU5HRKah7htGZ8Xzru/D8Wwsu/Ppo/nF9IPa7KjE+KJHbE1X7CHEwJMY9cDyX430uTvSd7+xqzqjWasN6N8MZoU6BsTXCSsfR6zhGtefaZslKN2O9k1NkbmymJkDU4F4N2hJbP2USje9DjEIIgRAkyajqY1ZU+ahh5UdI0rIpoDd67Jicq+sQyDLbNDKlQFz9K0TGMrONRKsYwTlDWQbqWmuMeWaxmSHEoHK0Qc/fJARiVPYWaczrlE9hRNQ1QpqEJpllpwqGvgFp478QI8PSq89ESl5MUnuyZpIgrspSdQjtZ5/lFglQ5cvKxFHhTC9jrT8T6O5FhvXmANZTGX3WRHAvLrFOFqz2y8ESA5nzutj+J/Gc512XcDR3tx0axeOiOv681yhHaE/HXWKJY0L+3ID+797Y9rgE6P2X6/NfNEn/mVw8m8D9s2Z6b8CaiJ2pNOxptigCjHSekVq2fTFRDtDOFvcxm86Zqhde9w4HFa/PH4bw77uO4QOw9cD2g0QRti7OT8zEB8RHyCwxsyqBHgJcvZFeHIm+JsalL9ZBcaKTiV7HUPlIkRk6uWuTvIYTUeQq+bpZKum6UzhWuioFq2Zxun/DfWiCcaAlMjcr73VMxGtSspASCm1NitMHkobQrJwCsRGJhiqEpPiUyLKx4WQoxyGmxEAvIHE0UMWnsvKECFlmMdZinV6/QW8aIRGySf4Z6lgd2xit9srEsIn4LUnS00Qh+NgmTWMZW217InE+SNcRSe1RVgnYMWo7VJnaaYpMW5yss8TKT/FjlzgGePROslN7zlYJp/sp9p032U7M/rPxMdDqDs9iJhjZ8bjbXisT7UpxZveYEoo512okkZmOMdSJSd1ptty4DfM+rCWWuIcQ4cwvPsO1Jy+PH1uk4HTAFeylVObB0e+NqGrLYLS4gh9dwGzqopx4tgf3ye6nrTDNTkmLqrkRNFiZ/5nv1OK0l4Ri1o1dvGjb1nEqiAlcf33G6U+PJenbRGLyQ8gsscig2r90/XK8z8e+7oQ/8RM/wRvf+MbW6v6tb30rv/iLv9g+/9/8N/9NGyw329d//ddPHWM0GvGX//Jf5ty5c/T7ff7sn/2zfOlLXzrQxWdOpVb7hf4QGyO6IrN0cjVv2Rp5oocz/Q4r3YxuJ2sVlprYP4Q44eugXIlGQUkXbjVBsIlkPV6QHScSDfFYvSQaYrL6Q2SZw2Ua4GeJvGxTAjFW4WkqCzElFNImE2XtW9K0afZP78EamYr1bKpkuESe1kRFk4nah+SToS1Vuo+0r8kzi3OmvS6B9lghXZc6fY8/Nx/0uDH5UnRyS6/jiCESfFwu1B43QlRl052cqFc7WpFYKAEr47jYME1c3o1D0GohHxRx+82uKZktOp9pf5gzz3E0hnkxLaFNbUsscfIgEU7/H8+mPzj0yvASR4t+d8SptS26xeKg1gwNUqNqR/OmRYmtxG/7/4ltIZoEZNFOu1js7BgGiyYPk5seU6YSn/0ddHdEhOtfkWG2RpjN0fxEYoljwb6SiYcffph/9I/+ER//+Mf5+Mc/zjd/8zfzHd/xHfzu7/5uu8+f+lN/iitXrrTbL/zCL0wd493vfjcf+tCH+OAHP8iv/uqvsrGxwZ/5M38G7/dfXrIpIHZWidTOaTCbO83iyzpQh0gnt6z1c7pFRuYsdWxW8huCskbIunCblJZSwuBTotEE8Y1p3VQsM3E8YwWbZFPHx5LERxhrHpuksNQ8F5LVtqSkguQtodcR25aphrDdxFptVQX9IUlKFppjO2O05QmtLNSJ7xCbMmccV1CsNThnKTJL7kz7+TYysKZJrFBJ3LpxDI+QWaGTq+oUoHwMGFdtljg+hAjGQq/YvvULrUrsBhGtQMxLHnb9Cg8RnRxkeEyWDa0Zb8aAs1AeshwmFtVIa3TSllji7kBCZOWpawd+fRTYeNOZqWDzyNGsLh3V9jJDvztipTsCL9s2qQXZ3EOr8ERCMf/5BY+HxFGYzUCOMeOUyYRidhMYrR/m6JHVPxxgb25hb21hNkdHP6aW430u9tXm9I53vGPq73/wD/4BP/ETP8HHPvYxvvIrvxKAoii4ePHi3NffvHmTn/qpn+J//p//Z/7kn/yTAPwv/8v/wuXLl/mlX/olvu3bvm1fF+8Der8HurlrA9/MqZLQsIo4a+l1M4oso8gdDZ0hME4UYlJzagJwQdvpQgzJ38Gk36J+8WZC9jKiyk1NAO9SMBZSW5SPgUigriLiPZ5InqUEIrV4hJCWAKK0/hFNQhFCJPjQJirt6lJMdZGQXK8TL6KZNfRv0YqIoI7ZdaSufStj2zh2S0qG6qiJV9Y4gvtAJkEldOvxe4yMORZG1BQQzDjZCZGmQjocLnsQ7wg6OZxfnf/cYRWVfNx9xX/epHicK6CSEonZ5CcCWzWYTJ/f9zUYkEmS+669XEsscWyQOnLx//UHPPuXX8fgVWv7Gs/RwOBVazz3va+deJCj/10u1W0ODy/I6Hj4hdGw2GsE5rYkHTckaFfHNgVxgY3Lgqkj2T5VzSVGus+WPPjhcfJtNocEEWLujm7cL8f7XBx4ncJ7zwc/+EE2Nzd561vf2j7+0Y9+lAceeIDXvva1/Hf/3X/HCy+80D73iU98gqqq+NZv/db2sQcffJA3vOEN/Nqv/dq+ryGESK9w5JkdS2OmDghjhG7hOLVS0OvkdFKy0azwA+OWohSYpzX1lFyktf6kCiUmmcX5FOxPtDgZQ2oLkjbQDjFSpfakukr/T6v1IUSq1LbUjqVIInjHNm4JITIqa/WKEEFEXalbrrQPVLWnqjWZAFrydnMNzYMhqFs2pEVd01Qx9F3XYey6rWRxbfXKXHLnTi1VRWbpFNpGlheOLDdtNaKq0/X4QFkHhpVfVibuBKxRJ+u7hgXf8XF+9bu1YG1UjKsLs1vzWc22Mhkw8/Tel30hS9w9SISH/x+/t3AF2a9mlBe727bRwyt8+QfmSMMup+R7Cr42+HqH+fs+LI7GxJ2YC4Fbj6U5d071wlTghnF6G0SKFyou/6uXth3ObAwQvyRvHjf2TcD+5Cc/yVvf+laGwyErKyt86EMf4vWv1wnrySef5C/8hb/Ao48+ytNPP83f+3t/j2/+5m/mE5/4BEVR8Nxzz5HnOadPn5465oULF3juuecWnnM0GjEajeW+bt26BcCwDvQirBUZt4cViDAKniJAt+PoZRlFri07zlptGY+ROmqP/3QYIePEIRGQJarLdmYNUQyh8ZdIs3FEMDKRfKRl+xCiOj8HwUeQTEPq2kcKZ3U3HzFOiEYgyITUrF6QTX1WIcSW02CTopImFhFP0w6V3K9JiZKM1anKylMJ+DqSOdH348atVw3ROrOGbkeTshAFSRdUh6iVh/TbNgZcZsGoCtVw4KkrVcCJYVyZMQLOWVY6S2nY/WLReF+I0z04u0Mr025+D4fp5hmX2O4t7JRoiIDMk3HdKWlIWfqe91+iwb7H8xLbUK9nC4fb9bc/xPU/+dD24XmnfpbLldop7He837je58bVBVVlIBQRM1jw5c+blu4DmB140b0r0H1+umXPlIH1396hHTAk6+2ZQrPMSPXKXtScluN9LvYdQjz++OM89dRTfOxjH+MHfuAH+N7v/V4+/elPA/Dd3/3dfPu3fztveMMbeMc73sEv/uIv8pnPfIZ//a//9Y7HbJyeF+FHf/RHWV9fb7fLl1WZopNZQoRh7THWUOSO06tdzp/qcXatx9pKTpFbbPKUaEnEqY1oslOicYh2iS9BUi3KM6tmKnHs5yBpRNpW+aipTEAdApUPydhOg29fB7z3bYt3c47QVBAg7asJg4jgQ6BKng2aiATK2lPWSnhuBqGf4C0Yo27ZWqmxOKtJSu21fWm9n9PJlJhe+cio1nOI6Pt01rSKUqGRYYqRsk4qV0Zw3QysMBp5BhsVVRmS4Z26ceeJaI5oArQ0Ads/Fo33uRirBOwfDsgTV+K4vqbd5srZ4sDkdhisdnc4xiI/iJ0udvaiDJqFHfWF33/Y13heYhuiwNN//wniot95s2o7i52G4rz9I9r/O7ktsW/sZ7zHIMS98BPm7BJN2mwTWB9TYLrT/DyP97BoPO4VEU7/Xlx4jOZ9TyLkhhtf/cDCQ5rbA6Ss22uTssYEkAcvTG8XFx9jiZ2x72Qiz3Ne/epX85a3vIUf/dEf5U1vehM//uM/PnffS5cu8eijj/IHf/AHAFy8eJGyLLl+/frUfi+88AIXLlxYeM73vOc93Lx5s92eeeYZQCsDGjw7nDN0Oxlr/YKVfkGR21RpkLGEaeJIqACNjNt9zFj5SNuU9HlNFpKZm0hLGAoT2aRP3gqQ2oqikpaL3GlFI/EiSJUPH/SvhjTenMslZSqtGtAmPCapNjWk69p7RmVNXQc1sEumdZlT8rQkXkOeuCPOigr0GDWciwjGpMdFKy8imqwMSnW3bpKTloAe9P3lVsDDYMszGNZkVugXmrxYI+ROEyFt4UqVl3tx1foex6LxPndGv7AGZ3q7H3SyOTUTTSKmEr0DJCWyx+DZmfmb3WW75yBoEpLRkrWW2BWLx/PLD9HI/O1u5KBHFfzNJiCH3U44FsYrcfv24vPr3Ly2susxQye2U220ujEzfcdjmpLapGVmA+ViLNruBhYm3Gi7k72xibm1hQz3YE63CMvxPheH9pmIMU6V9CZx9epVnnnmGS5dugTAE088QZZlfOQjH+Gd73wnAFeuXOFTn/oU//1//98vPEdRFBRFMfe5TmYZ1ZEizyiKDJdZIkpklqRl7ycI1g2poHGoFmgt6xvysxWwTmgcpsdqSIFAxPiIyTRB8T4SQwqexSCm8arQQDrGiHMWaw2h1hX/UQUdO+ZtGKP+D1aMnqOpoqWkxTmDNRZPAC/UdWQUPT4EREzbWlXX+trgUEUrEQpnCAYCQl15OkbPE6MK34Qagg8YK0gMVF5bs6IkxacULza+HCYEMgvRCcYZPWcIZFYTFB8iToSsUKKJuSeDwnsbC8f75Qd0xX0WNeD2EA3ke1kB098M7W8loZn0Zj0njGiiciw9qXGH9zXpunWUCOzYzLvEvrHT/P1yw9P/6Gu1tXUGZ//1Fzn177989CfcqQ1mpuXjwKeIS939SSwa71984Sym15l+UEAKT9wD+XpXJS6BaGMrwzqPVL1oBlv4qR9iyosu0n+GuTKwo1NQrR382HPPZ4Vrb73E2V+b/zsKvQ4SAtSHY5svx/t87CuZ+KEf+iGefPJJLl++zO3bt/ngBz/IRz/6UT784Q+zsbHBe9/7Xv78n//zXLp0ic9//vP80A/9EOfOneM7v/M7AVhfX+f7vu/7+Bt/429w9uxZzpw5w9/8m3+Tr/qqr2rVnfaDfjejjtAtHGfWuhSFMvYjtG7SMbUJ2eQmLRMr5U2w3Mi4CpKqDrq1HhJRZaOMki4w0lQc0nEzq4NCCxMai0RBDFhjMS5ijSUzkRiFURWovSYJEsbmd0S9hsYQTutxtlWTangdZahJvnlJlckgRlSIJsWCMV2Gs4Y6kAjaqcoQGrK5umi75DURUlISiek4cULWP5EirEn+Evp8kVuK3DYfJC6QHJMZX8QSdx8Z7LnBdr+taU2/4LyEIjuuAdCc604MsMnPI855bIklDoer3/4I9VrOuX/1+eM/2S6+lUvcg4gQszjXAXsWB6kKzL0zyB4SmAOiuKHJTnn6eI4/ibDaa+9pEe1YoaqP/8QvM+wrmXj++ed517vexZUrV1hfX+eNb3wjH/7wh3n729/OYDDgk5/8JD/90z/NjRs3uHTpEt/0Td/Ez/7sz7K6OiYX/diP/RjOOd75zncyGAz4lm/5Fj7wgQ9g7f5rdIMysLKScXa9S7dw1IlQbFMa0LhJN5KmTYDckonToqpJATxETOJAhKCvMyJUla7c55lQeY8zhijaomQzIfiA9xFjtV0piqi0bIgt8bX2gX7m8AGsRLJMXaJtumYlTIdxG5Y1mtEb9XvwISU66fK1E0T5Cc5oe9N4pSmtTKQ3LVbIjfZmWpf0+KMyNZwRTNQ40KcqiREhTChZFZkhBCHLHRjB+0i3sLjcUteRUAVVgPIRMUK/n4ExRCtUw+WP9thRA8j8Vfxt/Pc9JhT7xbyE4rCJxG7VFmchPw6Cf1OdWCYMSxwNIvD0P/66uVWJY0fzkz+uvHtJSD0UpOPBROJgTjg283FEt4eE4oAf4dSd4QgSiUVVickTzj3HYYaAwLW3PciZX/syYa1/PFP4crzPxb6SiZ/6qZ9a+Fy32+Xf/Jt/s+sxOp0O73//+3n/+9+/n1PPRb9XcGq1Q5ZZNVCLYEyqJ6SKhGGcSLSSqzG2j2ulQfBeFYlMY6QgY56DNdJKw2r3UVJwSqZwddQygTTPkVqmAoDyMMo6YKLyDBoX7JC8IGKMxBDbzpLG6I449sOo6lorLKjzdyBijJK2I5q8IFETpKQyZa1pyd6DoWelcESjbUzq0q0JU1mpe7dN7VYmVVZAKy+kOBEDVB6TuBzUEbyW/JTfAZlT343R7RJnhLK+j5oC71UUBvJJpYqoKy93WkhLjVaUnHO3UXnI7MzNxLG3JMGxt7v1MtlYYo8QbcM40EsjPPa3f5Onf/QtU8nIg//P/0Lnc7e5+o5HuPW2xZzD0AmY0Q6R4RG1Oy1xMMShJQ5mFlObyv4dxlEuNe2YSOxyEVe/Sjj7qTh1MbcfFeoedF6E4sbig7tB3DGRiLnThdZyB8moJfaNQ3Mm7iZOrXTodTNNHGITzGuyICQpephQipL2v81DgkltPRpExwl/hhAbw7iIawjcIVCJNkEh0npaSCJbx9QqpclBWw7BClSVJ7MOY83Y46JJYExzXcm/IkZ8DJS1SrfG2Ji8JFM9JheaUmIiEYyQJcUoSUlQVWq1wwetxBSZUR0aGyEI1gdClKQGpb1SRiImmpa366xQlT4lF6LxovfEKGMpXLR1qx55Yoi4TO6nxPvexhQZTyBzpJLFgp0XfDGHjo9FKwZ3PTKJKaHoTLynyagppr8n3/DkDf2YKjhLLHEA2KHnFf/X35oakW6jQurI2f/9i5z5yLNsvPEML33nK/RJgVCEqX/vmFAcBiEeInKcc6yXG+a95cDiYLjhRcy8TiJIdfgFDgHCXW5PjhauvU4QP/4YgtM1zsF5GJ4V8g3oPq8fgkT1nmiw+egK/Wc2F6/8H+ZjWo73uTjRyUSWaQBvJsoOEWhi+HH1IY0daRjF6e+oRGPSK2OUVH3QZCSkaoH6PTSqTeCrQE0gy1yqXGig3iQRUbRtylpDboRaUhtQctQWI+Cb1iZajkJTRahTcB5SkA+aZDTXoFURDYa0IqBVCsSoUI5tSjG6NUlWHQN9l2uLVYyIhejVLNhZVRSxyehCUstXIJI5gwRDDB4vmmx5H8msJHO+ME4mrFY4OoUGlMWx9cwvAYyrErOQ7TebmR1od5iNqQ87v7WuitxlzkyTMOz2fJNE7OcO0yQks1WYZVvfEscDd2O+Ao0deBh4Vn/zRcQHnv8/vUKfmFpg2OXgzX1ygpu65977ZdvHgREHdk/k6ynITELRhANR24YO5WadpjSTvvtwF22iQg4yZzpt1KzKNSAKq18M4+m42WcXE9doLRSC+JkPS/bwXSzH+1yc6GQihHGFASaIxyJMUgja5yIYtCXJkIzdoma7WtnQnSQlFClcT/GQtIF+09LjUtm69sm/IkTEGKxL7UXR4IHMCMEnYoIw5UZdJyWo5lghqtysKjWhXJIY8R5iUGWqmIK0EAKCVg+MEZwTcqckbiVmS6rKCLUPFI1ZHWirE9pCJYguJieJWZxpsg9AietlFZJCFu3/JX0+zf+bxMUZYViqr4a/f34r9x46RnkJB11lmU0iJh9f9L3ttmA/OznuJI50GDin25Fg0Qe405udl0g0jy+xxP6w9rEXWPuPi41b9wI78GRXhwt/bzEPSLnoyRSETmrU3hW92pcP4pYlluZgU0aamtqEr+28jEQrCxMKqRNPYRFXIYwXWkHN444joahWdTsMgtVrW5T0Di526Tw/mBLdadEoMs1KyR7Us2mJk51MIE2rUJJpbZSRhNZEjhhToAvNL6ThI7RjaaJNajJ8iDESEi9CrDpg07RQWUOr/hTHrUpBIHitQhiEOkRcLhSZS21SmhA05nnQdkK1vA2AzFlNCqyl9oG6VilYRBOOJikg/T+i/AflY5jULqXmd6AGdb2cpNBk2hkjQpKmNZpk5VZ7zWMgxgAh4utIWelxmgVvZ8ceHm1LmRGy3FJVgTqqXOwytjpGzGbM22CBHZapdnrtbBw92e+9qIqxaJWlmewnk5fGqfHAfbV7MES0xyVHuiiRWGKJgyG7OiR/aXis54imud/NPjEnkdjfkY9whfXlc8OIXjRgWLgDuy8Uzfu45iQUJq3wazUjgtfV/TapaCoc2w/VvjZMRIum1sTkoN0+we2epByqwgL4rpv/+YWITBj/7h/L8T4PJzqZCFEViJo2HqCVep3sjp4sBbYy+qlUYYxpjdVaOVnGx7KipOTGDEUVkvSAIUasGN2P5BERQlqNVzaG1yif3FqcM5TeE1OVw6dKhrZYqRO2EVECtmkqDCapS3lVmLKpMiFjt+wpiPpIBGKrZhWBsgrUPmjikNStoqhrtRXB2BTpNWULPRhl5QlRpWyt0dnN2qb6k1zF40RCEqGsPDYzSY52iSND4aCYmIHNLp+vGO1jm/vcHs7XBB6zBknz9tnL5DqZ04c9ZBJewM7sY136ke+h3GFmCdhHgWUiscT+IRHO/v++wNV3PDo1Jtd+/XmyF4d0nr51R65jW799YzC2rEIcO0IQndMaHOIzF79LG5pEXQDyKfCfOK+EiegocTNiE9bMO1Q6j6khupRE1JPHmY9yPZLfYmqar1Y1kfCdhS8b4wjCh/J0QX59hDQxzaETiSUW4UQnExr8N79J5S44K615blNJoFnAlZZBoK7WRn9BjQzqOC7XwNpIxFk1Xmt8TtpUI+j5XfKAiF7dqENo2qZim1hYDz4lBTGCGE0mQpR2pUgrBg2/QY8jJsnURr3uJgkwRhWdiszgg84ENq1ShxDBJF5DukaiGtrFGJPcrZ7TN5wQ0jUQCVXEJA+J4CObw1qN+IJBLElBStrPovLKlzACSMT7QOUj2NAec4kjQuYSsTpBAsSww/LQDnebvS4pqYLBXq9wb4h7SCRALz+fmaKsbUqPO6/cGcvR9FjNLuUux/MSB8OpX7mCX3FTv6e133iB7JgrEpOILqYV37Q4Fjl8IrHsId8TohetRiSoAAq7VyfmYQ4Be9tLJWK9TCUSk2iTAYnT2hMLIAHwe0skAKp+E9xMPLYyUZHYaf4+ovWaai0nu1m2yYSEIxiry/E+Fyc+mWhW5o2QSM9p1T2MR6NJ1YooIBLbwN1abUOC8ZiWxLdo5lgNnMfnaL57l85l0oOVV48IY9OKfYjEIASJ1D4gEloNfmMkyavOdokol6LWTAJrUjdIjDinnhLee6w1FLnFOYFaEudhXO3wiagd0nXG9L5yZ9o4rPJBncGj+l7oYrF+NlmTDNUwGGkts5/nam5nlaPRmuOF2H6+IXlNVLUHI+TOttWRJY4B0bRVsu1oZv5DnmMvuvhCCkj2WJ3Yz5BYxItoJ2GZX6mwbuKzmfceZnu1liuzSxw/zv7CM8dy3PJil9FDfcoHu0gtxAUeLVKl1prJKuFhsZcq476O9fJAzALi7bEWOqXe47y2xylQ/P5am0an9nDeeedprmfB824A2VbEDtjx2rOXNpDN4bjbYi/tsbthOd7n4kQnE61oTATjkkeCCCKxjTFgmowdEz/CpcCaFNTrQmdMLVKTo1hVlJqaBiRuQDYmM9d1IIRk+Oa0tcL7FDeFSB08UntMCCn+G/tcNP4SMaqxXQgRn5oXoxNVgCLSzSwSLcMQMNZgjGnbqaxRFScYJxNqyKcVi7pOlYykrxwiVD6OqyJoJSQ0nwWA0c9R94vkzpDlSi5vZhPvI1lukwFHZFRHRpWnqgJZZlMb1DEOgCUWILIjV2Kv2E9FYo+5xL5gd6kqNBOAtTuQsWcN6Cb/P9kwPPnc1Elm/j6ON7rEEgfD6MEefjVj401nuf21DwBgSggStSc+oQkqzVCQiUrEsrvpZGJqDWnBd7ioIrENUZAwPV6OBHvNOuIOu85Mt9mWksKL64HuS+MnIjL1ObjrWwB0PvvStO9Rt4BOsfu9ZYl944QnE+OVfmcNRowmEhOQ1NIkMm5viqQWp4ZxFJvkNrVNpeXTiCYfzfM+eU4Yk7gK0iQnsa1gNNKvJpUAQu0p64CHlpvRLkVMTAYxhKTwJMnNWtpWI4gEazX0SQpNeqjmqpvDNaRurZjkqZoxCBUr3QxJZnhlPW7/MqKtlRF9D5lTsjlWMN6TWUOWqcSryQ2SOW2tCYlvYdUBu6o8VR3YGtbJnVs/y720ti9xCEzGxA32unAyuzi/7bj7qDYkz5Q9nXOv8Xh3DzIixuxB1SkwJn4sMq2bvTPvdHdbJhRL3F2UF7pEZ7j67Y8weO369JMBzNAQOmnxKoDdmj8RSzyChCKmdsujwFEd535HnGxTgjjDn5Mg2OEBF4N2etk+pr2wh+hyYWF9aidwW7rvypcC+a3tL5AY24TCbozofvq5+ccdjHSRrLcX0sYCLMf7XJzoZII4ETQbGZOtm6C6bW1LrtSJrN20QgUfiVE9IEidEgLtKr3YxgBPUuUggmiA7pzBp0DeGKH2WhEgSKoIGHLjUhtUahuKGso0Sk6GRMBOpG+b+BlRlE+hErFx/BqCEp+NafkTIXEpjNH3F1PLU79wdDuWkdd0Y7WX4RpehddEIEzcSdokyggxqTn5OrDSdaz2rCpAeYgmQB00XvWRmBIs7yPD0jMsa071skT01jarJU4AZm8gbRa4S3CtfXjTuyy6GbWlPZl+3R3BTizyBrvU1lssk4kl7i6e+97XUj3QXbxDTAlFN2A399IQP2c8H5Ux1xLHi7i9CrG/RCJOVQfiLustmqAeRRa6d6z/YZgypZsHSV0nvaeevUNXtcQkTnQy0SQSuU2+CMQUIMf0w9DB13RrNCpOpuEMVJ46JNO3phKQji2iq+uaAERAEwhjDYXTyoTExrTNU/ugCauolKoRg8m1mmBScgExuWzrjzGi3hTWQO4s1lqMEaoQqarQtkBJSo5UElZbtPJMCaYhCFkK/NRgTugXGf1+RhSh2ijpFJZubug4w6jyRKK2QxFbrwlEcIVVjwkf8KOKECIrHYs4odzyZE7LoaXXJMcZ0SQuaIvWqPQ4A3lm9HvJLHW9TCbuOERAMgjVUR6UbQH0ooRgtod13j3nriQUe8EO1rMthMWMxaPuFVhiiQMigllQkZiCRA0gZ1++16l7SUg9GA76Vo/qI5L5B5PAdMvTvCn+LiQUe8Ge8t9G1WYe9tKXvRzvc3Gik4kic8kzQvv/Q2w4CJpYiIy5NurvoKvt0QhE5UIYY9qAv069/86YJAdLkpOVlFxYokSctcprICa+BNpiZbU6UAclZA9ilYjTmhLkmZKX6zogqV3JWNu2ZqlhnSYNTXUjxICzVq8nSGpVMm0VxlqjiYgBHw3GQLfIiAhV6ZO0bUok6sBW5bGG5NSNlgURstyQ5ZZYKuehDoHhKJAFgRJu3vZcPJ0xKgMYEFEVqxCVYO5D8rkoLJ3M0O049auojjKgXWIKdjd9wAWQPbYkbX9h+n+ajHeaB5uEYqfzNAoEcyfwe+smtcQSSyzAkpB6IMjQTkvF7hFmJDurKe25xXXxjtL4UOxwrGjQ2GsPyk73FZbjfS5OdDIxLD19H1RhKKoZXNMwbmhkT2PLa5CG+xD0eWdNMl5TAo8kQzfnDGKEEAORpvd/LB3ro7Y0lYkwba16OxDBxIiktqf2dVG5CBYhBE+RWUKlAV0dIt5ramIMiS/RJL8akeVOV/pTnYXMaQUjxkjmDHmuf7u0x8iDhEBdh/baRnXg9lYNBmLU9+oywYmQ5w5jDNXQU9ZeFZm8p64jZZ3anyJc3yjJnME4wdlAxBB8+jwNrHQdRWbpdy30HNFY4kv3z4/lRCEyXvWYIlI3qyqyOF7fjeiyV273bIViHpLZ43hSlTFXwsdps7wlllgCWHYg3feIY9J8zMZfdkugX9RpGcGOdpkzd0kk2t38HqpTia8xmVA0/I02IbnTWHah3hWc6B4U6wzOmLHSVxxzJdq/g26kwN4YwUBrDBfRSkDjPu1c4iIE5QU4qxwEIZI7NZ6TCHXtCV5J02XpKSuPCHQLR6dwGDGtVKpzFjGGrWHFqPTKMYiN8pEmEiLStkNJ0l7NnKUoHJEkZWtUxckYFSPIM0Mn017wSR8WJ2CjKjD1CkuMkVtb2rZkRcicsNKxrKxkdFdzjBF8HZJbti4YdzPL6V7OetcxqgIbQ8/GsG4N6jJrcUarLkVm6XccK92MXj+HTqaz0JZf/qiPC7ZeXJWIEUI5/bcKmjNufN2lsnAnIQLOQjffTrr2Cy7SOeh0IMvY/Y0EYMjOGowRqNJW7rDfEkvcfVz+v/82nc/d3nGfaHQLC2RiAaKd3+K0LzRtH0e1vQwgWztUJSYSCQCpBDsw2IGZUuK6Z4q30oyjuJ0IvmDhyZZCtiG4Tdk1+SluCBsPWerOzvtFI0Qr3P6jjy3+bPpd6B6CfA3L8b4AJ7oysb7aodE3FbTNZixCo6ZtIZGrtW0pKsE4OT8D2u4Ux54MoFUFaV6TSNsqxaoJhw/qJq2GbcmbIZnX1WFcIcmcUQ5FMoFzRqhDoA6xTR6MaIJgncFZS4xQeq9BujWJJ2H0WDTHSX4aJi3eGshsowIVU/uIStTWdeD6RoUVrbQUztHtZ4gz4CAOlFBt0MwyCnQKbasqR5FrtypiUHL1ei+jkysXwhpBbOp790pSNy5dQwCC1wO6e2XGuw+QCxTN55lBqNmmBhHj3rkSu1UoDosQ9uhUnZKJRZisUOT5+JhT1z2vDDKbPIyAnGleQwTqOSct075LLHFv4sGf+F2e/69fw+abzo4flPlt7MFFzF49B5Y4HpRWZaxJt+d53TIzicSuOMZV+N3anKZ3XvxUW+EQJYYbP72/eH3cd6YPUlyb/hw2HrL0n/Nkm9P7xTm+Ebff9kpWf/3z91Ub0b2OE51M1JWn09UV8hB8UjuNExWKsUGdoD4U3tdJuckQQiCkX2OjjtS0RNFyMEjHTy7SQKhqRmVNSMpKIbUkDUvtYTdOMIhyCeoIDjq5tjrhQyJRWxwGjAbmIZGxQ0pEjKhKk0UToqrWVqLG+NfHiEPIk7KU/pyCJruV8kYqrzyREAJGDKsdS6+wacIK4CMxrfxWtZrudQoHzjAc1ty4XdJxwmCkXhe9jiPPrCZdSRWqab/3MVJXILUnT4kKxlAOj8DvYAnFLAfBuOmEIgb9ez9oyGhTKyQe8gWyrKNqPEFbu7gNqTGNVDLN/q5pHnxUjfBGcm0u4sz/56EEMjTT3W1sVmnfJZa49yARLvzLz/LSZs2tP3phVy5scBGzB+fkfWOypfIojnW/YiZ5UDdyGa95hO2qTHuBqZVHMXWqBWszbqspaAu+AyGb/4G3rz+iZEWCtl8tkoKVAG4gqU1r8XG2Llg6LwWKW2FuEjE+oLDxdY/S//gXkeqI5VeX430uTnQyUWS6Ym9CSgkkpthIgyO1ekjJghV89ISoakg+hBTvJOnVGGlcfGNU92olcCunoqyDJiwkaVVnKDKHiNHkIwTKSgNydbEGgyEoSxlfe1yqnIQQqWIiYafRFFLbSYwxqStFvDRBPiCR3AnOaRIkwWAzja2C12qHD+pqHUM6rmgLV1M1GVYB4wLdbByQ1T4wGKitZbdwQGQ0rLi9VSVideTWVknXZfQ6DpdbEG2LUtfrQF37lKxpnFlWHgmwNSzZHCxbRo4NQkooKvDV0ZZMy1TdaJKKYfp78hzeA2acLETYVg2I7JxQ7FaVmMWRLK5W0NbidsJ9NNMvcV9C6sjZf/0F7KDi2tsf3v0Fc1bCD/2bWqrbHBjRKt9A6kMkeXEOh8Y3x9f/u83tVAk7RDsz8vGDc2Vhd0oo9nvNO+2/h7WgKDA8a4gOihs7nzxak3T+JxaNjmJ8Lcf7XJzoZMIQUkATknSqpr36W9DVfhHt8fc+MCk64BN/IAJ1HVO1IlUErLSE6+Ajw8rjo0AMan9laJMWZ4XMCKNRaNulJERiIkllRrBZUnSq/dj4TkCi4IzFh+RGTdS2rBiJopWNKihRPLN6Xc3vWosckTIG6rpp52rI5voe1Yci4n2grCO9zFDkFozBVzWjyjMY1MSAEryTMlNZBbwP5E6ovFZk1tczlY4FVcSKygdR/4vkw1FpZaSbW24Pa+oqkC3bnI4XMvl/2f/ktNvEWNVzKhcTCBF1yTL6/3m7tQnFbGll+5/3FhZVJXTOmY+letkSdxZmFJDR7quvZk7AKiHNGXPy6iXJ+w7igJ+1KcGU2yfR9rvzutK/6Lu0pcYhvjNWd5yLe4jU3HCBdkP/E3OqElsDGJXq7zUHEpaLnwfFiU4mfFWDs21LUxNPQbrVp6CdNIcqD8Jod4YxbULgUwVDkJaYDdoiVHlP8JEQBRFVagq1ejQEH/GhphJ9TDOJuO03Z5IjtCcmFSZtYYopmdHKRnPpKZkI4FEZ2m7hiAEq75O3g/4QYohUqFFeonuo1wWCkUgVkkxtiGwOK9Y6HQSoSk9deQalp/IRkzpdfAQT9Br7HQdBCKOK1Z6Sq/EQCK2E7fiNKh8DIHOGzaH6d6yv5Dw/3KFmucTh4evxyotAGxVMcimaSlQ1QcDeK5o2qB2fB6If6zDP3Q8dYM5s3y/GGcWpewU7XdOi4O3+cTRd4mWA5sY4b7Fgr1NFaMQdjgDh5fX7kVp25UiYKgUw8+LfeVWJyePHxTodzetNpTGD7+3yhcuCID4uJlrfTZhBybZBHHbxEdrL+FuO97k42cmE90k+dRyLNHOjSf9GwCCqkGSVaNw8Vqcv0lrT7qtciajtO95T1yqT5IMmGMZEVVRoKhchUoWgFAFRIzpEiciTP/LaB2Jy7JbkbYFIWtXXHa2I8pnReEurJKrW1JjNWSNjM71kGGdE2mvWyoRgRdSYLqlZ1bUmCVUdqFFTvKpWPgVIEtRRTwrjI6MqJFK60CscIkJZh5azEYJWcSSZ/VnR6sSo1Jazla6j8qoCtcRxYmZia+dJowlFNhG8u4k7gaoTHF3Zdy8lBmfnJxxH0Wpx5DjRU+MSS0xBjoMrscThscv6jqnHccSU1obRJOBISPW7JRzNboa5vJx7buoGur97ZUm+vsM40XfMGDQYbrgN+qAO+KblKMX2WAFjTRu4R1IwTqrgyZjPEGOkrj2197oCHyJ10NV+YxNXIlUWRpXHh6Au2Ym4LelYyr2IbRuSjRrD5flEY2JUroMRMNZhULla0/ArErG7qr16RqREgqgu3jEYJKYWq9gEh4YgetyIJjLWaALlk/N2aMne2uJUFBbjDFUdqSutPlgjdHJHiOqnEbzyPLSxKVVDkKRYpYTvEFSSdlQFbm1WbA33SQheYu+Yp+bUQNB+vMngfSqQN00Z685hp+rDbtUJZ4+werFTPR+SesARnWuJJY4XG3/kDJtfdWbh83JAb8s9Y9lDfiBIvbP5nKll6nub3DMGkB3UwY8DCwn+qWKx07XMa7E7KPJbgeJGSD4W26vcnc++iLu6cTQnm4fleJ+Lk51MJJ5EE4BHJlfoNQCW1ErUBPkhqtKRMQZJMrCItkPpa2kVnXwiIDc/AmMkuVGb5AIt1N5gSEkHIMa0FQub6NU+mds1mUvtI24illM+h5DZVB1o9f3USdv7kLwxtLJR+YhN1yvpWkPryhgRAogmHSLaDtUvHEVmMJklGjBElcgFOnmGdZayDpQjVcWyVnBGQIROdKmTRisQWpUxGL0I6kCSyQ1k1uBDZHNUU1WeXr4Myo4NwS9OJpBpBdRZtNbwMcXWCyoGsLgNIp2GvcjLuh1UmNrKxpyEoqmmNESluNO5Jhl8OzX/zmMZTmI5Zpc4Gdh40xlu/IkHGT66sv3Jhjt33A7Fy+DqQJAdqFfCzsF5S5FLLRjzWp1kD+t4wSVFp1R1WNQytZNSWATEpv/PXLNJ6lQy2V204Bwm0c0kLOZE5LcC3WsBO4jbKIIh8TOzKzcXX+xRYDne5+LEJxM6MFW1KIr28qvhnH5JhkaRSdtwZhkNMVUGJJGI04NMHDp5QqhZHAJl7TV+SvwKZ00iewvGGsSQAnX1pmiqIHYm6ApxXB0YE8g1yYmivI5BFZCoXIROblsZ2sa7QlB+RZNMiMTUPqVtSCEpWa33MvLCIUmxSXzAx0BhLcZqJWFUemJy9JbUwoREMmupo1YinDOIJRnrpSabEFtDPNDPJ8ZIkRlyOdFD7N6C90lwIOEwE5H384nVk/2Ccd7jEw82SUh7k9ihurCbPOxsQtHsbycyoqa/tD3v7N1p3t1XZv69WyJxNyxbl1hi/9j8ytNc/5aHGF3uL9znTq5cL7ELZufUw6BRAzeaACTtmTYZEK+SsTsewoHvREJjpxPbNcxtM+RuhOcIYNPrJiRuZxOadmG3+SPS+k6YCe5z29o1cSH57UD3asAOY3swqccfqIkR++LORo5LHB/ug0gvtourISbn6jYB0CSicb72KeCHJCGbOAV1rSv5TZgRYxOoN+RpA2K0+hHVCE7TlUDmLNaYcTu6qJkcCPhxjOSspWMtQfQB5TSoQ7Q1yrFoFKSMgKQkxUggd4Z+J8M5wyA5basClGY8TTWlmamEiDUGn95jJ7d0ckNMwVcMkarW2ShEGA1rRkn1oLkGmekEsdYoX8RI20bWfF4iaBUD2lYnZ4UQIuWyb/HoELwSrieRxvO+4AOU9binNNK26KWDLj5kU6WYTSQaTEqJNVjkRTGL5sdizWK52CahMDLhOTEvYpp9A40U7G7Xci92AC+xxDS2XrvG1T9zmfJib/FO2r97/BcTxveeoznWfYqZjynKwaZvQkoU0nfbqjDF8XNmF1G5bYkEjKc+GRe89zuEotWWpoWJzMRalYTE+5h3rc35U1zltgLdFwN2tPjDMlUke2lz7xd7UCzH+1yc7Hp+E/PElCS07T4aoDtrUtu4Bj2m3ZqEojG1a4Lnqa7E1qfCpBX5InNYa1KQry1TDTFaUuWjqTY0bVJG0nVYVYMCDfAFjbGU+GzIM0fmbEokmuDdUOSO9X7OSjdvk4PKJ2J1c770b6RZ1NVrHlUBa4VuYVXitfTEkScmg7oIDEvP1qBKXhFJshZJn5HgA1SJRzKqlbg9HNQMBzXeR8SAc4Kz6f0H9bWwoi1kMd4/P5Z7D+kuIvO2OC7Hzn4HZTV/EoukasVup23OscM+k+fdi4+EpOTACGR72D/EPapqNBP/XhIJmO+GvcQS9xZe+q9euXMikRDdcv69VxGdLspI3L616tNzprjJRGIK6XawWyIBcxKJWUzY8OxFhhXSdYe9nR/GycSOSO+//9zOiQRANEL5mguEfmdvF7DEkeJEVyZEW/2Uw0BqYZLU7+9M29pEIhwbh/7YjFBXiRORAn5jTBtETQbATeuSBvuCjxFjhbKuoQqMak8I40RBEu+CKFhjsc5g80hdRTarCmMNIaTfqhEyY8gykyomKWOXcUXl1EpONzPUHoal8hIiBknBe0ytJU07lzVC7oxK3obAmdUetwcVG4MaZy0u0yRpc1gzrDxWJJlVSxvPNVzXqtJWqCiRYRVwNlJWgTqoy3XecwRjqLxWNkJUI8FOZrg9qljpOLbCUs3pWGFkgWTgDLm6uffc6baH3ZLJJikRgexemI6aJb5FicdR9iosscQxY9eFgSM4RVSO4lHgqI5zUiAepJr+EoTplh+AsMjy5pixl0SiKQ5rNULGU+gdhgCIMHrdg3Q+9cyYM1TWE/ehXRbB9oDleJ+Pe+HufWA0TT36X/2/BsXSjpdmXHuvsqoECDFQe91C8qKIqX2i6f/XlX5pY4cqSbtGiWRiKTKLMVqdaJSSSApSgiYzmbGIESpfq6xqlFTp0EDfJg8JgDr1r4sARhMYZw2IsDEK1HXiNMSgvAWYeo/WCJkT8sxgxLA5qlnrZVhr2BrWDEc1spoTiWwNPbe2KjXps4YoqXIRAyvOtDKwIUjicgS8h0jTQqbGdM4IW1sV5bDGGaFrjTp0o59dkVmq0ckuft03aCoRowVVieNCU+2bJXE3j89raQpxZ8+KY0UzJc7LxEArFztVL+6fm8MSJxwxeRQsgjQtMoecD3bzotnvsZbYhnYF/yja1ppD7LRmstfD+MR5aBEJ2XwjveNEe7Y0DodvuNw+V/zes8ioRryaqy4yrNszluN9Lk58pDcmV8f2b5uc6hKfuW1VClHVmarap5ac0LYjlZVnOKqp63HAbJIiUlUHRiPP1rBic1CxMSjZGtVYa+gV2p4E6jYNTceGDu9hmQJ5IxS5JXdWHa2dbsaYVtGpcce2xrTvqayDOlWP6pTQpFYmq3GYoApQndzS6zi6hU3tXYaVbkZZB24P6raDZFgGyjrgvTpYK/E8tr8Nn1qoWm5u+gyMJFM/a5IfhUAdsDHSzQ3dXJOIa5sVz18ftp+ftUtC6z2FIts5UJeJbad92EM7FAK9fCxRO9mG5axey15aoO4YFi3/NdWIkmUb1BL3AqTaxSNmt0SCI0okljgwDvTR7/aiPRyz7tK2V+2KqO1I21Sa6uS+fQcaD/bM21gQ4I9e9xDDP/Io4czq4ROJewC/8iu/wjve8Q4efPBBRISf//mf3/U1v/zLv8wTTzxBp9Phscce4yd/8iennv/ABz7Qiu5MbsPhcM/XdaI/WVEtoza4aZSVjEkcCaN8hIbk5JMBnTFjvoIQ2yqFoC1TGvDbtiXKmMR5gJRceLaGJYPSt8kAjH+cMUaGo5qtQUkIkSwz5JmlU2TkWTKGE6EOka2Rx3uN3BseQ0zytj7EVlbW+0hmtfWplxnWuo6VjtW2otzS71i6HfWKQKCTW612oNWWXuEIUahrVYeq60BmhZWO4/RKztmVnNWuwxlpORNGaDkopMFlpPlMhVGpM4m1lsrDrUHNrY2K4GOqqky3jC1xxHARzD4/30G5eFWlyVIbctHcfWB8x9oloejPNOUagdxpErGbutORQtAkYFk1WOL+wOX/4ZN0//D23jhOx41JbtZRbC8TmIHZ1uK0GxqVpLnHqyHbSK1TC4L8ug/RpkXPHfYDto2rhuNgy+3JxXHCDiKD8xZf3K1q9Qzu8njf3NzkTW96E//0n/7TPe3/9NNP86f/9J/mG77hG/it3/otfuiHfoi/8lf+Cj/3cz83td/a2hpXrlyZ2jqdvfNPTnSbkw+aCASvq/k2ybKKaOuRNcpPqCr9xYgRYgyqdORTT3mUtIKur3emcXUGiyYRubWIsdTeY0MgVpEywKjyLRlbjBDE4IO2JIUAuc3IMofJoqo5ZY4oQa8xeEZ1xBNaaVdrTOuL4YMmOiGQjPkiVgwi6uVgUkDfATrGkhWWmAmx8m0SYVB1pSK3SGoEy5zgENZ6jlOrjm7uCEGJ1k7GMZ5BKMMEQb2RvhWhk5vWPTtGKCt1zK7rQJEpZ4MYKevIqF5yJu4ZDEoWtu806kiTsAK+SSYXTXqRKe8HSdWIw2KvrU67luonn/Rps0yvowgnfCpc4mWIh/6nTwPw4nc+ys1vvDR+Yg9ViSXuEeyDXyCTng0wVnFCg3y3Nbs/xFT4rVaYO4e3x5osEB9BPhfyeCStTm4Q28senNeLLG4Eso1xNqOcjZdPEvrkk0/y5JNP7nn/n/zJn+SRRx7hfe97HwCve93r+PjHP84/+Sf/hD//5/98u5+IcPHixQNf14m+g4qM1YzU6UQ5ETYZudQ+4EMyd0NJyoiklf6AT681TQUiPd80NTQVBOe0z84IFMYSXaQIltKHxMVQ8nddeaoQEGsoCkcnyzDOEEWrC6OyxjrIncXgEBvwQSiruiWON1WVtpMktRoVzmJMZFRpOORSe5IRgzjlVvhS27FC0DiwDpHSR3r///bOLkauq8r3/7X3Pqequ203gUhuGyWRLxMpA7IgCQQnESRoBnOj4Yn7AFyNhDQSKI8hvIB4sBH3IeKBCBMjJGTJ5AV4YUZCQoK8EBgRJL6MrICQUcI4g9JjbGz6qz7O3nvdh7X36ap2fblddru61y/qtPtUnVP7VK1zav/3+iot5psWzYZFAMEz4679JRoNg3Y3wntAOlaIaCicwXxDkrXBUgbXwsBYoFHI+9fqhNRxmxBjlOZ/kP4XnSqiaFgAebsyHbJlJjyunxcP4zohkY5n7OhJey7rOvJmnQSFJWBujJDwYXrdrPOYhpaeHbY9iwoDuQXO9G1Q2ePc/e//hbv/47+w9vDduPR//+GGV7tvmjggDma77KKE1K1Q7O94HZsM07k+AXvgvgM8EsSAbV+frN2/3yTjgtzCJ4g4ZQsgTCk6juU4w0KY3AYPvIN33mLQeYuB22DMXcn1928jM2bvr7zyCo4fP9637SMf+QjOnDmDqqpQFBLeu7a2hvvuuw8hBLznPe/Bl7/8ZTz44IMTv87Mf4tyuhAIPf0R0qRWQoZy1SSLSAEcUkM3a0CR6+dzjAjJI2GMPMd7yYKQCXFEiBGFM1goHRwZUBXQ7nrpcxElRKlwFq6QLtkEhvcBFXvxMBgD8kBZiBcgsPwQCGVBaBYOzkmjuxhZSsGydLmWWD9J3OY0iWp1IxzJBdetIjzHlEhuULHkPpSOMFdIRaicb+EMwRuDtXZEtxtRGMmD8BzRqSS8qigIBhLWtNAsYG0h1mIIvlOBOxJ6xQBiCtNiAK1uQMMRqlQlK97uC32vkb8sRgmKgUJi2oz4Vtgu7Z66gQ3XL0B6kwh7GhfB0ZYnjCIiS/PxeGy6QdSmlTuHvPC079eXYVc9lv/tH8fuw5b7r6GboafH0U2zx74vYiOVYx+xij8qtGla5HK0kwiKiY/Z21+157iu1V8StleY5K8Q1xosJHrx84QNYzF/aXweW+MvKzCRpGJgdZN5b7fA3ldWVvo2NxoNNBqNqbzE8vIyDh482Lft4MGD8N7j8uXLOHToEB544AGcPXsWR48excrKCr72ta/h8ccfx+9+9zvcf//9E73OTIuJHI+fRUTuFSfhQrnBb/ZcAIYMAkluRE6QFq8FgCwsDINzEjKk3Kn3DCYDjhFdn55rCGVpUbKF9wExRmk+Z41Ui+pE2LTqS5YkRwNpKhIZVRI8gQkNR5gvLQonjeZCRN1ML0izbYQQpGkcJFyr66P0hrAWFTOYIyJiSqxiMBiNgjDXcLi2VgGIIoAsoV0FRB+x2q5gQJifF89FpxKvw8KcRWOuADoRBAu72ABQgCgC6xVWN0K6HqkWNsaQiAowmEmSyUGa33c7yIsbvfkTudvPRhu3ZfJrDdCcYv3CvnJ+ADrpC6B0o5vgZWGRL7ipUGHzPZzWDExRpgsxQBN4gvuEBKD6eIeJBcMGwK31rAhtvd3cYpgwcT+JSbCt/oFnYWE7oztz1x28p2iPzf/+Oyh9f3BZShn+7oTNMG4T99xzT9/fJ06cwMmTJ6d2fNoSCbA5d5btx44dw7Fjx+rHH3/8cTz00EP4+te/jlOnTk30GjMtJuqGckS1eKC8eEioJ7pSSpVgHcAeaFceBCMhTobqfYyRSlDSW0JCQGJkcJr0R5JJfqcKqQKSdHo2hDpUJIQgVZdAaBY29XZIvbhIPAAgSYAOMaYmdxKSFH2EjwyfvA91iVqkXJ0QQSQlYDcqcclUVZQocCvnEBkwqeGeMwbrnYCuD5gvHaoUllUFqcLkI6NhCc5aGGNAJCFOzTkHalpwkNeM617eIxPx16ttVCHKeYNAVprUAYT1tpceF3EzfIw16fXWYzA8EXuuAbSGVGSoO0hPiUlCl5iBqmfJyqak780nAN0Bruv677FJEjeIeB2Hu3Z6hURGBYVyZ8LEYMcgP/gauU5IZG5CUHCM4CmFfeymuvuTYlsEt0GD3/8RtzuKsuIf3egJ+sRMcFs1HkBPqJbMtfpdC7Yz4iWmfMukwHCtAD832KUiQqLn+4YALgo51W0Kilth72+88QYOHDhQb5+WVwIAlpaWsLy83Lft0qVLcM7hbW9728B9jDF43/vehwsXLkz8OjMtJpyVzst1s7m6E3V/d2gHgjUS45M9Et7LhMU5C8Qo0wkjfRIohecwIF4FZ0BkEaOXsKTI2OhUWGtV2D9fApxKu0YGg9LrSNlXqY4kSdZkOfW1MCishB35TgAzoVNJy0tONdtyd265l6Sk8AiUjmDJIHKFkMrYFgYwTBK0EVka4TmSRnc+whgkTwYDRrqCh0qS10trwSz/BqQKlDEGccNjbc1jZb2Dtx4oMFeKZ6bd9XAGaDgnDe9SlatWN8h7Q4QqBDSimarLVNkmwyb4xmw+luPfhuF7bpxb59y50yFBRMIk3at7hYLE8uX4OznGbQ91yIIik08yhzYNQgWFcgeSVpi52LTLnIw9VEj07KvmfPuhiP4J+qT7cPq4Ctl9WDdpdpJbARBCE30zejY36JFg6jMhifjZ9ALbDm67DZGPcOvZpQH4eZnWNno8Ev07AFw4WZXvjEg4uY0cOHCgT0xMk0cffRQ/+MEP+rb9+Mc/xnvf+946X2IrzIxz587h6NGjE7/OTIuJHM4EyCSW0kQ5J2bnXhLdKInDJlVNkopJuUqRJB4bkpKyzCm8iDn1jTAyeS6teAUswbL0j+j6IFWhYu4RARhn4AoDay0azsI5C89S6QhRxIS1BoW1sMkTYkguyhAZlMrWMnOdgM0QD0hM+RztKqDTlTCn0hKMJTAkEZrSeYGBTggAizeiwyJobMqZWO1KcrrL71eU0KjIhLX1ClUVwV5K1JallQkjMwprsK9p0Gy6Olej1QnoVAGGpHlejBKO5Yz00lB2mEYD6PQsF/UKicwwQRG21LPPX3rSqRGb1QLSc4HhgoL5+i+anNhEDFQ8vaocMU7geckJ2Hkg9c5bfg9DBYVy57Bx/wFc+Zd75Y8eu2c3uX2yAbiU50+c76Y5E7eWLd6JLCQ2F1EB2ORf3SIo2Ka5frqV2TakWEuTEVM0Q786GD4MM2Btpb4D5qiQKX18oUGwndEHc+sR8/8jYoB6vjdcSzwRpjsi+5wI7CwQLPhv1+rNkScQFzts72tra/jTn/5U//3666/j3LlzeOtb34p7770XX/jCF/CXv/wFL774IgDg6aefxgsvvIBnn30Wn/70p/HKK6/gzJkz+M53vlMf40tf+hKOHTuG+++/HysrKzh16hTOnTuH06dPTzyumRYTMU+AUt4Dpf8xpyTl9EHlsBufJvNS7pRSaI/sk/tIVKmhmxSGkhXLGBlkLKrKw1jCvJN+DLkPQwxJdhjpJ+FK6UJtjUz0HafQnyCv72NEDEjdqpOYQE6kyyIihziJ8LHSBQ4hMtZaHq2uhzNczws51Sw2lHMy5FyYgHY3oFlIedjCSEJ55SOahcFC08KQHBeQClhVqlBVFgbWFnCFlUVaAhaaDnNzFrYw6HYC2pVUbCoLaZTX7gQ4Y9AsLPbPORhMUE5CmYytN/5Jsaa/7OswLwTzZq5FZuvkPt/86gtuC1lQbK0QlY18GFlUTIuxhzKQUliD3gud0Cizxfo/vgVX//kwOvfuu+6xvPI8LjIjezRyH4L8eyx1fPEU2MViggINDj+boHBFncycvUdbb8sEuaVtXSPacjunQQ7YvifIsbd+nBQARBr69TPt1I5x3pJiLWDurx6udb1RU/akjzOlyoNX1sA9CdnME8xXdtjef/WrX+FDH/pQ/fezzz4LAPjUpz6Fs2fP4s0338TFixfrx48cOYIf/vCH+OxnP4vTp0/j8OHDOHXqVF9Z2GvXruEzn/kMlpeXsbi4iAcffBA//elP8cgjj0w8rtkWE6mDda86zk3W8kckIUKyWh8D14/nVXRjjfSfIOn+nD0Xxsh+kmQsk/UQGVWMaBib+llQ3VyOILkZWZSEEEExAoZgHKFwDpGDCJ0gXbiRPCPAZv4H5/9imseliztmzwVthhTNl1bCvLBpkwx5HqceHAEiEDiNzRCw3glwljDXNGgUsqRh0vnkClDWEmIgGGPR6ng0TU9yOAOtDY9W2yOk5nfNwsIYgg+MuYbFvnmHcqFEZw/GwN5+xtyQvO+524+Lc5jGcHjwov40ysHeEKO++iatqTuKKa5QKco2WX/XXbj25CG0/9f2wyS2CgnlFhAx+L445i2vO1Cn+cAo7THtgnq9x73dd+9BnhAAcBsBjasebuMmFio7XRESw/IJ72CefPLJkc2Az549e922J554Ar/5zW+G7vP888/j+eefv6lxzbSYyE3rHFG9osrJBcU9DddM6t4csdloDZBGc9YagKOs4gMwdQdtAnESE+AUkrQpODiizs8AADJUhxdJcjXAFECWEIlBMHDWwFdyNwkpmTq/Vg53yqIhJ2bLxSQlYX1gOEfwMaIsJC9C8js2rznxUMiYQwS6MXX2NoQi54sERqOwKHP/DAPYFO5ljeRB+CiejQjAtyOa+wjrG17CmTrA1bUuODLmSwllspZgjcFcCTScQXN/Q8p5tu6MmMRdDac4uUF3+xDkZ/PJGJ7RN6XxDBINkUdXYZqUOixqzLFGPj6pi2dUELkKCeXOQOLex9sz04gFVXMTQoLFgz8VdrFnYhhsMTRpniL6e0Wk2/xW0UA83vM02WCG2IiBfMQ3+fHkRnvjFvZtm2GqwU8yFWAmqFoW50uYjSFl0asKvNEaP+BBqL0PZKYD2rkvZInq2P+Yej4AMuF31uT1//TZSW6CSd6AXFWJCHBWwnWy50J+cjiSiIcqSCUma3K0R+ovzdhM3IaYsDSrC+h0vdST7jlOCAEhiscDtClOfIjiVUivw2kClcWKTNqtvEaqKtV3veTXMRI6XhYW8w0nXghIh+qFpkVR1CcgIibIa+TGcxIHyXBGHv/7WjflSQRstCuUljDfcChsqpZlCM2Gxf59JbhwCJ6x0dIwp1sOc66DvGV7FK/E9Ttcv4mGTLC3dsW+GcbdOGO8PqyqHgehTi4adK699CaFD34hTPZlMNO3R2WPsO/8VSy8enX8E4dFN95oEq4yVdjwwPf/OiFR7zBgMs6DnzvV6knE47XEsHWq5F1hA8CM9qDYLqPYGP5KfsGgmh9f6CPuawweT7cCd+6s0rC7gZn2TAAiCEQAyIq9iAuGSc0nDIlHQWKP8j6mFiCcJtE54KienEPyHQgEciQ5CxBxUPlYr/RHZhiWcqzGyliQjktspJSs9yAQGmnV3xBJrmlkGItN7wJLIzj5iWmeb0BOunCbKB6HspBEcEmWkNdijgBJDoVJ3hhrLDwDBxYc9i0UYM8IVcT+eYc5Jwm0lZfzqUUQkSSfM8OlfI65hsXGRhedbsB8aeCjCIz98w7GEDpeSsWSSe+XAcJGhY21Clcvb+yEWewh0gp5noT3fimFWOcUDd5vgtV5mxTpNBjmncjiIIX+oUi3pZQnVI+j9/nA5rlu9ULYSWZG2bMwiYdi2PunKHcG7moH5XIL3aW50U8c4GxjyzeUpL0Vjgye0qx1VPjGboQCYNsEm5rW9SZLGz9i0t3joRjplYiQiM4pwHZEknX+GuotU8v951I/Na3z5AjoPtNhoFgbbwPsCLE0MN3x301bTTNutMBr62P3G/raau8DmWkxEXu8EpxCj/KHwwTpgwAghzXkmr6Un58m7zH/m4DsvSAiWIhXojQS+kSQSToDaBRGKihJMddULt9KGVlDYCYgSidoawneA61OgCuoriDlLKFwBkyS14AoIiLGWF+wnK5SayRokZkkbTRVr5KCTclDY9L7YSn1fjC4qzRY3FcA1iBUAYWVsKQQA7qVdMB2yauQS8vmsTmIODKWcG2tA2sg4w0Rd+0rARBWWh4hROxrOrCTpHHf9miHiL+ttBGmNRFVhtCzSh+BuiV8RlxvGP4NQMO9EtthXPhRb4iSJDn1l55lSMM6AGiWw4VBTAIqeyxuOB8jv+aoWyADAwsI3O7oYUUZzf7fXgEM4X/+9R9GPi9F+E4XntTTN+mx9gYUAdeiunRv3tY78SYeLyiGejBuBSRNaeshDRAXMd1SbXd4/4vsoag9Kjc4p672iUKauzQ8jJp8GOztvtkJvNr7QGZaTGThYIx0XM7igmizupNEt0kYkLEm5V3msrESUhRjREwZRnkhVxKrU/nZAnCOUFgLZ6XEqnMWoFw5U7wIIUZEv5l3UVgLsgSKDpUB2IdUdlZCjeaaDhEGHe/FO5LClQhZ8MTa7rtefJvOknhCjHgpcoRT6nCRPDU2eRgAZ6108K6kfGuOfVpZq0BWenAUTpYKKp+FhJEUlCjCqtMR4XHXPof50sBFQhUYKy2PTjegWZg6PCrGiI12QCTJQyFtgT09Ytz0EpCRu/Akb68k+wx4YAIhMdGNlzZ/jYrdpp7jSZv30YedpKxwTixq9NbLnlLwMNQVruwiRl3KkzrplG1TJ1IDgAHcRr+QGLrfGEHBBMABNGjifiPrRIPCp7Y+JXsnJsifGNb3og8SYWF6NAEb6iv1uh0oRLjLa4O/v3L4xrTKkCsAZlxMxBBBhqRaUZQkZcmdkJ4IPgRJKrYEwKQKTKjDeWKMKb9CvBvGSG5FjJx6aaUKTj7Cc8B8YVHEgKojd4RWx6NbhdSvApLXYAxsYUVIOIJP/SrKwkn4T4ywZDCXEqDX2kG6WIcoi6y5AzdJorTkgEgOR1E4RI7gGLHR8bJoy4RUNArOGjhna+9JzvsAIGIq/e3TOe0vLSxJsnVu8Eep10a3YiCS9KEwUvp1caGEcVIS9upqB93Kw2XRBClBW/mIqgqIJO9dt6sX7C3hhlc0BsQ3jBUSGN4llFPsYL4x9z02LO8hiYPKT+9GPvAUcrbgzTDqmzCPXWdfyowwKsXIE4iBWG7vmtSwj20whWTmXpgATusp9SSeAL8w5Pm9oU+0+ZtHhUzVO+OWRnl29xPKFb6pfA93aWXoY2bfApgI8erft3VstffBzLSYAOXFTvlAbM49iLFOfpb8BwOi5IGoIkwKB/IRgKEUxiTVlphZGrZRrIOkfIwInmHJYq7hwEFERKdTwQdxJdje/IyevIvCEtppxWC+UaBVeQTIyn6MAd1KfpgjyloISLM4hozPGELhLIwltNss+4YIZwEfUjhSaVJpWulxYdI8zxVGwqYgJV05Sp+LxTkHGGCtLaVqDclitwXBp9wMB4v5hsV612O+4cBEWG15bHQ81lsVAMbcnINNvSu6PqLdDSAAVWrkt97W1d07Arsl3IkGFCXfSndEJS5rh3sOevM0BoYpDRA228VYoBzUxXMSQTEsjElRZgsmWdG9qctKvRN3LCO9E1uIBQACYjnuoIO3sZlAUEwJCoM9GN0DBuVKHC8obnu5cWUYMykmsnhot9potUtYBjpeuqpxihMi5noSTUaWLwMHlGQBE2EgjeRgpNeCMYQY0kUrucx1lScfGJ0qYmOdUZYGiJLk3e4GERNglCkJ3Pi8Uktouy6cM2j7CsYYxKZ4J3yQROgqyDG6lXgZYgqdiiwXkUy5CIYLgCMiGOstL/lUFlgPESEQmtYA0YCjQwwW1hhwZHRTV2sgwrCBDwE+5YM0DPC3jS5iECGUO2ebpCqsBQpj0WoRLq+2sVCWWFmX3I52FfDXa204AmxsgqNL3oyI9VZAYQmtELC6XmF1pdX3mSk3Tn7vVla3lLIbdKcd1YbU90yczQRiojNCTPg4OtF5XKnKHM86iknybewwMVEfZMj2cec/qcjoP8aK2vtY8nvjUWke+5S49sEl/O1/vx1o30TdfMN93omYjjXOlj13phb77XdhaGF+/+KWzya0CRy2enUBHpJn0DvpjsUYcUGjb58cuN87sWUMY8WEp7HPMZ0xx0CK1B1yvq0mhgqKYsWjuOoxZFdQHPPicxZM+xCvXO3b7Fne5FE2r/Y+mJkUE6urqwCAf/o//7bDI1EmZXV1FYuLizs9jJkk2/s9Dz67wyNRJkXtfThXrlwBAPwnfrjDI9lFvJx+bgHDbLksSywtLeE/l6f7OS4tLaEsxy2rzw75/v3Gl//fDo9EmZRBNq/2PhriGVxCizHij3/8I975znfijTfewIED2+/8eSexsrKCe+65Z1edEzNjdXUVhw8fhplmz4I9hNr77KD2Pp5r167hrrvuwsWLF3eV4Npt9jyJLbfbbXRHhUNug7Is0Ww2p3rMnUTv37PDOJtXex/OTHomjDF4+9vfDgA4cODArjHkzG47p900YdgJ1N5nC7X30eQv6cXFxV31uWd2kz2Ps+Vms7krJkK3Er1/zxajbF7tfTi6dKYoiqIoiqIoyrZQMaEoiqIoiqIoyraYWTHRaDRw4sQJNBqNnR7K1NiN56RMh91oG7vxnJTx7NbPfbeel3Lz7Ebb2I3npGyfmUzAVhRFURRFURRl55lZz4SiKIqiKIqiKDuLiglFURRFURRFUbaFiglFURRFURRFUbaFiglFURRFURRFUbbFTIqJb3zjGzhy5AiazSYefvhh/OxnP9vpIU3MyZMnQUR9P0tLS/XjzIyTJ0/i8OHDmJubw5NPPolXX311B0es7DRq78puQu1Z2UuovSt7gZkTE9/73vfwzDPP4Itf/CJ++9vf4gMf+ACeeuopXLx4caeHNjHvete78Oabb9Y/58+frx/7yle+gq9+9at44YUX8Mtf/hJLS0v48Ic/jNXV1R0csbJTqL0ruwm1Z2Uvofau7Bl4xnjkkUf46aef7tv2wAMP8Oc///kdGtGNceLECX73u9898LEYIy8tLfFzzz1Xb2u327y4uMjf/OY3b9MIlTsJtXdlN6H2rOwl1N6VvcJMeSa63S5+/etf4/jx433bjx8/jp///Oc7NKob58KFCzh8+DCOHDmCT3ziE3jttdcAAK+//jqWl5f7zq/RaOCJJ56YqfNTpoPau7KbUHtW9hJq78peYqbExOXLlxFCwMGDB/u2Hzx4EMvLyzs0qhvj/e9/P1588UX86Ec/wre+9S0sLy/jsccew5UrV+pzmOXzU6aH2ruym1B7VvYSau/KXsLt9AC2AxH1/c3M1227U3nqqafqfx89ehSPPvoo3vGOd+Db3/42jh07BmC2z0+ZPrNsD2rvylZm+fNWe1ZulFm2B7V3ZVJmyjNx9913w1p7neq9dOnSdep4VlhYWMDRo0dx4cKFukrCbjo/ZfuovSu7CbVnZS+h9q7sJWZKTJRliYcffhgvvfRS3/aXXnoJjz322A6N6ubodDr4wx/+gEOHDuHIkSNYWlrqO79ut4uXX355Zs9P2T5q78puQu1Z2UuovSt7ip3L/d4e3/3ud7koCj5z5gz//ve/52eeeYYXFhb4z3/+804PbSI+97nP8U9+8hN+7bXX+Be/+AV/9KMf5f3799fjf+6553hxcZG///3v8/nz5/mTn/wkHzp0iFdWVnZ45MpOoPau7CbUnpW9hNq7sleYOTHBzHz69Gm+7777uCxLfuihh/jll1/e6SFNzMc//nE+dOgQF0XBhw8f5o997GP86quv1o/HGPnEiRO8tLTEjUaDP/jBD/L58+d3cMTKTqP2ruwm1J6VvYTau7IXIGbmnfaOKIqiKIqiKIoye8xUzoSiKIqiKIqiKHcOKiYURVEURVEURdkWKiYURVEURVEURdkWKiYURVEURVEURdkWKiYURVEURVEURdkWKiYURVEURVEURdkWKiYURVEURVEURdkWKiYURVEURVEURdkWKiYURVEURVEURdkWKiYURVEURVEURdkWKiYURVEURVEURdkWKiYURVEURVEURdkW/x8l+rCWDzzK2gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wl = np.array(rdn.metadata['wavelength']).astype(float)\n", + "\n", + "state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_recon_subs_state')\n", + "state = envi.open(envi_header(str(state_path.expanduser())))\n", + "state_im = state.open_memmap(interleave='bip')\n", + "\n", + "fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(normalize(state_im[0:400, :, bands], 0, 0.25))\n", + "aod = axs[2].imshow(state_im[0:400, :, -2])\n", + "h2o = axs[3].imshow(state_im[0:400, :, -1])\n", + "\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Reflectance')\n", + "axs[2].set_title('AOD')\n", + "axs[3].set_title('H2O')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "af4360b8", + "metadata": {}, + "source": [ + "Finally, we can examine the final results at the end of the anlaytical line algorithm:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50c92071", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.11736042..1.7135264].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rfl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_rfl')\n", + "atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')\n", + "\n", + "rfl = envi.open(envi_header(str(rfl_path.expanduser())))\n", + "atm = envi.open(envi_header(str(atm_path.expanduser())))\n", + "\n", + "rfl_im = rfl.open_memmap(interleave='bip')\n", + "atm_im = atm.open_memmap(interleave='bip')\n", + "\n", + "\n", + "fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(normalize(rfl_im[0:400, :, bands], 0, 0.25))\n", + "aod = axs[2].imshow(atm_im[0:400, :, -2])\n", + "h2o = axs[3].imshow(atm_im[0:400, :, -1])\n", + "\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Reflectance')\n", + "axs[2].set_title('AOD')\n", + "axs[3].set_title('H2O')\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/html/how_to_run/functions.html b/isofit-tutorials/build/html/how_to_run/functions.html new file mode 100644 index 0000000..c1637a4 --- /dev/null +++ b/isofit-tutorials/build/html/how_to_run/functions.html @@ -0,0 +1,671 @@ + + + + + + + Internal Functions — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Internal Functions

+

When debugging issues or testing configurations, it may be advantagous to run Isofit in a more controlled manner than the end-to-end Apply OE pipeline. This notebook gives a quick introduction to the structure of Isofit and how it can be used more like a Python package.

+

NOTE: Isofit is actively developed, so while we try to make sure that Apply OE is stable from a CLI standpoint, individual functions are subject to change.

+

We’ll start with the medium example found at ~/.isofit/imagecube/medium. First, run Apply OE on this example, or for more adept users, run Apply OE with the --config_only flag. The objective here, is to generate an Isofit config file at ~/.isofit/imagecube/small/config/ang20170323t202244_isofit.json. This saves us the trouble of building the configuration file manually. We can edit the Apply OE generated configuration as needed.

+
+
[7]:
+
+
+
# Imports
+from pathlib import Path
+from pprint import pprint
+
+from matplotlib import pyplot as plt
+import numpy as np
+from spectral import envi
+
+from isofit.core.common import envi_header
+from isofit.core.isofit import Isofit
+from isofit.configs import configs
+from isofit.core.forward import ForwardModel
+from isofit.radiative_transfer.radiative_transfer import RadiativeTransfer
+from isofit.surface.surface import Surface
+from isofit.core.instrument import Instrument
+from isofit.inversion.inverse import Inversion
+from isofit.core.geometry import Geometry
+from isofit.core.fileio import IO
+from isofit.inversion.inverse_simple import (
+    invert_algebraic,
+    invert_analytical,
+    invert_simple,
+)
+
+
+
+
+
[2]:
+
+
+
# Load the input data
+rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')
+loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')
+obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')
+
+rdn = envi.open(envi_header(str(rdn_path.expanduser())))
+loc = envi.open(envi_header(str(loc_path.expanduser())))
+obs = envi.open(envi_header(str(obs_path.expanduser())))
+
+rdn_im = rdn.open_memmap(interleave='bip')
+loc_im = loc.open_memmap(interleave='bip')
+obs_im = obs.open_memmap(interleave='bip')
+
+wl = np.array(rdn.metadata['wavelength']).astype(float)
+
+
+
+
+

ISOFIT Configs and Classes

+

ISOFIT is built around object classes.

+

For example, the config object contains the full Isofit config. This is constructed directly from the config .json file via the configs.create_new_config function.

+
+
[15]:
+
+
+
# Initialize the config object
+config_file = Path('~/.isofit/imagecube/medium/config/ang20170323t202244_isofit.json')
+config =  configs.create_new_config(str(config_file.expanduser()))
+
+print('The config object:')
+print(config)
+print()
+
+print('Config attributes:')
+[print(key) for key in vars(config).keys()]
+print()
+
+print('Example:')
+print(f'Forward model type: {config._forward_model_type}')
+print(f'Forward model: {config.forward_model}\n')
+
+print('Forward model:')
+pprint(vars(config.forward_model), width=100, compact=False)
+print()
+print('Surface model:')
+pprint(vars(config.forward_model.surface), width=100, compact=False)
+
+
+
+
+
+
+
+
+The config object:
+<isofit.configs.configs.Config object at 0x15da2d060>
+
+Config attributes:
+_input_type
+input
+_output_type
+output
+_forward_model_type
+forward_model
+_implementation_type
+implementation
+
+Example:
+Forward model type: <class 'isofit.configs.sections.forward_model_config.ForwardModelConfig'>
+Forward model: <isofit.configs.sections.forward_model_config.ForwardModelConfig object at 0x15da2d8d0>
+
+Forward model:
+{'_instrument_type': <class 'isofit.configs.sections.instrument_config.InstrumentConfig'>,
+ '_model_discrepancy_file_type': <class 'str'>,
+ '_radiative_transfer_type': <class 'isofit.configs.sections.radiative_transfer_config.RadiativeTransferConfig'>,
+ '_surface_type': <class 'isofit.configs.sections.surface_config.SurfaceConfig'>,
+ 'instrument': <isofit.configs.sections.instrument_config.InstrumentConfig object at 0x15da2cfa0>,
+ 'model_discrepancy_file': None,
+ 'radiative_transfer': <isofit.configs.sections.radiative_transfer_config.RadiativeTransferConfig object at 0x15da2d930>,
+ 'surface': <isofit.configs.sections.surface_config.SurfaceConfig object at 0x15da2f520>}
+
+Surface model:
+{'_emissivity_for_surface_T_init_type': <class 'float'>,
+ '_select_on_init_type': <class 'bool'>,
+ '_selection_metric_type': <class 'str'>,
+ '_surface_T_prior_sigma_degK_type': <class 'float'>,
+ '_surface_category_type': <class 'str'>,
+ '_surface_file_type': <class 'str'>,
+ '_wavelength_file_type': <class 'str'>,
+ 'emissivity_for_surface_T_init': 0.98,
+ 'select_on_init': True,
+ 'selection_metric': 'Euclidean',
+ 'surface_T_prior_sigma_degK': 1.0,
+ 'surface_category': 'multicomponent_surface',
+ 'surface_file': '/Users/bgreenbe/.isofit/imagecube/medium/data/surface.mat',
+ 'wavelength_file': None}
+
+
+

The ForwardModel object contains the Instrument, Radiative transfer and Surface portions of the ISOFIT forward model. The three forward model components are object classes themselves, which contain the math and logic relevant to these features. For example, the Instrument portion holds functions for instrument uncertainty quantification and calibration, the Radiative transfer portion holds functions relevant for generating and sampling the radiative transfer lookup-tables +(LUTs), and the Surface portion holds functions relevant to sampling surface priors and formulating surface-specific forward model elements.

+

Note: if the LUT has not been generated at the expected location from the config, initializing the forward model class will immediately constructing the LUT at that location.

+
+
[18]:
+
+
+
print('The expected location of the LUT:')
+print(config.forward_model.radiative_transfer.radiative_transfer_engines[0].lut_path)
+print()
+
+# Initialized from the config:
+fm = ForwardModel(config)
+
+# Print the three forward model components
+print(fm.instrument)
+print(fm.RT)
+print(fm.surface)
+
+# Print an example method from RT
+print(fm.RT.calc_rdn)
+
+
+
+
+
+
+
+
+WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is
+WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is
+
+
+
+
+
+
+
+The expected location of the LUT:
+/Users/bgreenbe/.isofit/imagecube/medium/lut_full/lut.nc
+
+<isofit.core.instrument.Instrument object at 0x15da2ed40>
+<isofit.radiative_transfer.radiative_transfer.RadiativeTransfer object at 0x118544700>
+<isofit.surface.surface_multicomp.MultiComponentSurface object at 0x15dac57e0>
+<bound method RadiativeTransfer.calc_rdn of <isofit.radiative_transfer.radiative_transfer.RadiativeTransfer object at 0x118544700>>
+
+
+

and individual component classes can also be initialized from the config object:

+
+
[19]:
+
+
+
instrument = Instrument(config)
+rt = RadiativeTransfer(config)
+surface = Surface(config)
+
+
+
+
+
+
+
+
+WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is
+WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is
+
+
+

The optimal estimation inversion is handled by the Inversion class object.

+
+
+

OE Inversions

+

We will go into how to perform single pixel optimal estimation (OE) inversions from a set of input data and an ISOFIT config. To do this, we need to load in a radiance spectrum with paired observational geometry data. We’ll pull this directly from the rdn, obs, and loc files we loaded above.

+

OE inversions are run using the Inversion class:

+
+
[20]:
+
+
+
iv = Inversion(config, fm)
+
+
+
+

Next, we’ll select a pixel to run through the OE inversion.

+
+
[21]:
+
+
+
# Pick a pixel
+row = 175
+col = 50
+
+# Plot the input data
+normalize = lambda x, vmin, vmax:  (x - vmin) / (vmax - vmin)
+bands = [55, 35, 15]
+
+fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(8, 8))
+plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))
+plot = axs[1].imshow(loc_im[..., 0])
+plot = axs[2].imshow(obs_im[..., 4])
+
+axs[0].scatter(col, row, facecolor='white', edgecolor='black', s=100)
+axs[1].scatter(col, row, facecolor='white', edgecolor='black', s=100)
+axs[2].scatter(col, row, facecolor='white', edgecolor='black', s=100)
+
+title = axs[0].set_title('Radiance (RGB)')
+title = axs[1].set_title('Longitude (WGS-84)')
+title = axs[2].set_title('Solar zenith angle (Deg)')
+
+
+
+
+
+
+
+
+WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.1813465].
+
+
+
+
+
+
+../_images/how_to_run_functions_16_1.png +
+
+

Then we’ll load in the measurement and observational data for that pixel. The geometry object holds all of the observational information for a given pixel.

+
+
[27]:
+
+
+
meas = rdn_im[row, col, :]
+geom = Geometry(
+    obs=obs_im[row, col, :],
+    loc=loc_im[row, col, :],
+    esd=IO.load_esd(),
+    svf=1
+)
+
+# e.g.
+print(geom.solar_azimuth)
+print(geom.observer_azimuth)
+print(geom.cos_i)
+
+
+
+
+
+
+
+
+197.31315008280822
+71.53144734704047
+-0.3017277626279998
+
+
+

and finally run the OE inversion via the inversions.invert function:

+
+
[28]:
+
+
+
oe = iv.invert(meas, geom)
+
+print(f"Number of iterations to convergence: {len(oe)}")
+print(f"Data type of 'oe': {type(oe)}")
+print(f"Array shape: {oe.shape}")
+
+
+
+
+
+
+
+
+Number of iterations to convergence: 9
+Data type of 'oe': <class 'numpy.ndarray'>
+Array shape: (9, 427)
+
+
+

The oe variable is a numpy array where each row is a subsequent iteration of the OE procedure. It is often useful to examine how the solution changes during optimization, which can help debug potential issues with final statevector solutions.

+

The plots below show the trajectory of the reflectance solution throughout the optimization. The earlier solutions are lighter colors while the later solutions are darker colors.

+

The plots also show the prior mean selected for this specific pixel via the surface.xa function, which can be called directly using the initial guess of the reflectance solution and the pixel observation variables.

+
+
[30]:
+
+
+
# Set up a color map for the iterations
+n = len(oe)
+cmap_name = 'viridis_r'
+cmap = plt.get_cmap(cmap_name)
+colors = [cmap(i) for i in np.linspace(0, 1, n)]
+
+# Fit the prior mean
+xa = fm.surface.xa(oe[0], geom)
+
+fig, axs = plt.subplots(1, 2, figsize=(12, 4))
+axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')
+axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')
+for i, sp in enumerate(oe):
+    axs[0].plot(wl, sp[:len(wl)], color=colors[i])
+    axs[1].plot(wl, sp[:len(wl)], color=colors[i])
+
+axs[0].plot(wl, oe[-1][:len(wl)], color='black', label='Final')
+axs[1].plot(wl, oe[-1][:len(wl)], color='black')
+
+axs[0].set_ylabel('Reflectance')
+axs[0].set_xlabel('Wavelength (nm)')
+axs[1].set_ylabel('Reflectance')
+axs[1].set_xlabel('Wavelength (nm)')
+
+axs[1].set_xlim([725, 1200])
+axs[1].set_ylim([.1, .5])
+
+axs[0].set_title('Full spectrum')
+axs[1].set_title('Highlighting 725 - 1200 nm')
+
+axs[0].legend()
+
+plt.show()
+
+
+
+
+
+
+
+../_images/how_to_run_functions_22_0.png +
+
+

We can also look at the trajectory of atmospheric statevector variables:

+
+
[31]:
+
+
+
fig, axs = plt.subplots(1, 2, sharex=True, figsize=(10, 5))
+iters = [i for i in range(len(oe))]
+axs[0].set_title('AOT550')
+axs[0].scatter(iters, oe[:, -2], edgecolor='black', facecolor='green', s=200)
+axs[0].set_ylabel('AOT550')
+
+axs[1].set_title('H2O')
+axs[1].scatter(iters, oe[:, -1], edgecolor='black', facecolor='green', s=200)
+axs[1].set_ylabel('H2O')
+
+axs[0].set_xlabel('Iteration')
+axs[1].set_xlabel('Iteration')
+plt.show()
+
+
+
+
+
+
+
+../_images/how_to_run_functions_24_0.png +
+
+
+
+

Inversions with a constrained atmosphere

+

Scene-scale processing generally leverages superpixel algorithms that simultaneously speed up processing and enforce a spatially smooth atmosphere. Here, we’ll demonstrate the analytical line algorithm. The analytical line algorithm assumes there exists a closed form state-vector solution under the assumptions of 1) a fixed atmosphere, and 2) that the measurement can be modeled as a linear combination of state-vector elements. We can call the anlaytical line solution for a given pixel directly, +albeit with slightly more set-up.

+

First, we’ll set up a wrapper function to call the analytical line inversion. In practice, the analytical inversion is sensitive to the initial guess (x0 below). We generally use the “priorless” solution for the state-vector elemnents for a given atmosphere via the invert_algebraic and iv.fm.surface.fit_params functions.

+
+
[32]:
+
+
+
def invert_aoe(iv, meas, geom, sub_state, x_RT, n=1):
+
+    # This script sets up the initial guess for the inversion
+    x_surface, _, x_instrument = iv.fm.unpack(iv.fm.init.copy())
+    rfl_est, coeffs = invert_algebraic(
+        iv.fm.surface,
+        iv.fm.RT,
+        iv.fm.instrument,
+        x_surface,
+        x_RT,
+        x_instrument,
+        meas,
+        geom,
+    )
+
+    rfl_est = iv.fm.surface.fit_params(rfl_est, geom)
+
+    x0 = np.concatenate(
+        [
+            rfl_est,
+            x_RT,
+            x_instrument,
+        ]
+    )
+
+    # This script is responsible for performing the inversion
+    states, unc, EXIT_CODE = invert_analytical(
+        iv.fm,
+        iv.winidx,
+        meas,
+        geom,
+        np.copy(x0),
+        sub_state,
+        n,
+        None,
+        None,
+    )
+
+    return states[-1], unc, x0
+
+
+
+

Next, we will pull the superpixel state solution and spatially smooth atmosphere for the selected pixel.

+

Note: This assumes that these files already exist at the expected location.

+
+
[34]:
+
+
+
sub_state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_subs_state')
+lbl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_lbl')
+atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')
+
+sub_state = envi.open(envi_header(str(sub_state_path.expanduser())))
+lbl  = envi.open(envi_header(str(lbl_path.expanduser())))
+atm = envi.open(envi_header(str(atm_path.expanduser())))
+
+sub_state_im = sub_state.open_memmap(interleave='bip')
+lbl_im = lbl.open_memmap(interleave='bip')
+atm_im = atm.open_memmap(interleave='bip')
+
+idx = int(lbl[row, col, 0])
+sub_state = sub_state_im[idx, 0, :]
+x_RT = atm_im[row, col, :]
+
+
+
+

We can then call the wrapper function. Solutions are generally acceptible after one iteration, but n can be definted to explictely set the number of iterations to perform.

+
+
[35]:
+
+
+
aoe, aoe_unc, x0 = invert_aoe(
+    iv, meas, geom, sub_state, x_RT, n=1
+)
+
+
+
+
+
[37]:
+
+
+
# Set up a color map for the iterations
+n = len(oe)
+cmap_name = 'viridis_r'
+cmap = plt.get_cmap(cmap_name)
+colors = [cmap(i) for i in np.linspace(0, 1, n)]
+
+fig, axs = plt.subplots(1, 2, figsize=(10, 5))
+
+axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')
+axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')
+
+axs[0].plot(wl, aoe[:len(wl)], color='purple', lw=2, label='AOE')
+axs[1].plot(wl, aoe[:len(wl)], color='purple', lw=2)
+
+axs[0].plot(wl, oe[-1][:len(wl)], color='green', label='OE')
+axs[1].plot(wl, oe[-1][:len(wl)], color='green')
+
+axs[0].set_ylabel('Reflectance')
+axs[0].set_xlabel('Wavelength (nm)')
+axs[1].set_ylabel('Reflectance')
+axs[1].set_xlabel('Wavelength (nm)')
+
+axs[1].set_xlim([725, 1200])
+axs[1].set_ylim([.1, .5])
+axs[0].set_ylim([-.1, .5])
+
+axs[0].set_title('Full spectrum')
+axs[1].set_title('Highlighting 725 - 1200 nm')
+
+axs[0].legend()
+
+plt.show()
+
+
+
+
+
+
+
+../_images/how_to_run_functions_31_0.png +
+
+
+
[111]:
+
+
+
### Algebraic inversions
+
+
+
+
+
[ ]:
+
+
+

+
+
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/how_to_run/functions.ipynb b/isofit-tutorials/build/html/how_to_run/functions.ipynb new file mode 100644 index 0000000..167a6f0 --- /dev/null +++ b/isofit-tutorials/build/html/how_to_run/functions.ipynb @@ -0,0 +1,733 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fe75c48b", + "metadata": {}, + "source": [ + "# Internal Functions" + ] + }, + { + "cell_type": "markdown", + "id": "f0f4eaf6", + "metadata": {}, + "source": [ + "When debugging issues or testing configurations, it may be advantagous to run Isofit in a more controlled manner than the end-to-end Apply OE pipeline. This notebook gives a quick introduction to the structure of Isofit and how it can be used more like a Python package.\n", + "\n", + "NOTE: Isofit is actively developed, so while we try to make sure that Apply OE is stable from a CLI standpoint, individual functions are subject to change." + ] + }, + { + "cell_type": "markdown", + "id": "eee6abd3", + "metadata": {}, + "source": [ + "We'll start with the medium example found at `~/.isofit/imagecube/medium`. First, run Apply OE on this example, or for more adept users, run Apply OE with the `--config_only` flag. The objective here, is to generate an Isofit config file at `~/.isofit/imagecube/small/config/ang20170323t202244_isofit.json`. This saves us the trouble of building the configuration file manually. We can edit the Apply OE generated configuration as needed." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "75064908", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "from pathlib import Path\n", + "from pprint import pprint\n", + "\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "from spectral import envi\n", + "\n", + "from isofit.core.common import envi_header\n", + "from isofit.core.isofit import Isofit\n", + "from isofit.configs import configs\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.radiative_transfer.radiative_transfer import RadiativeTransfer\n", + "from isofit.surface.surface import Surface\n", + "from isofit.core.instrument import Instrument\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.core.geometry import Geometry\n", + "from isofit.core.fileio import IO\n", + "from isofit.inversion.inverse_simple import (\n", + " invert_algebraic,\n", + " invert_analytical,\n", + " invert_simple,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "04d04288", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the input data\n", + "rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')\n", + "loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')\n", + "obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')\n", + "\n", + "wl = np.array(rdn.metadata['wavelength']).astype(float)" + ] + }, + { + "cell_type": "markdown", + "id": "fe59a430", + "metadata": {}, + "source": [ + "### ISOFIT Configs and Classes\n", + "\n", + "ISOFIT is built around object classes.\n", + "\n", + "For example, the `config` object contains the full Isofit config. This is constructed directly from the config `.json` file via the `configs.create_new_config` function. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2ac3ee92", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The config object:\n", + "\n", + "\n", + "Config attributes:\n", + "_input_type\n", + "input\n", + "_output_type\n", + "output\n", + "_forward_model_type\n", + "forward_model\n", + "_implementation_type\n", + "implementation\n", + "\n", + "Example:\n", + "Forward model type: \n", + "Forward model: \n", + "\n", + "Forward model:\n", + "{'_instrument_type': ,\n", + " '_model_discrepancy_file_type': ,\n", + " '_radiative_transfer_type': ,\n", + " '_surface_type': ,\n", + " 'instrument': ,\n", + " 'model_discrepancy_file': None,\n", + " 'radiative_transfer': ,\n", + " 'surface': }\n", + "\n", + "Surface model:\n", + "{'_emissivity_for_surface_T_init_type': ,\n", + " '_select_on_init_type': ,\n", + " '_selection_metric_type': ,\n", + " '_surface_T_prior_sigma_degK_type': ,\n", + " '_surface_category_type': ,\n", + " '_surface_file_type': ,\n", + " '_wavelength_file_type': ,\n", + " 'emissivity_for_surface_T_init': 0.98,\n", + " 'select_on_init': True,\n", + " 'selection_metric': 'Euclidean',\n", + " 'surface_T_prior_sigma_degK': 1.0,\n", + " 'surface_category': 'multicomponent_surface',\n", + " 'surface_file': '/Users/bgreenbe/.isofit/imagecube/medium/data/surface.mat',\n", + " 'wavelength_file': None}\n" + ] + } + ], + "source": [ + "# Initialize the config object\n", + "config_file = Path('~/.isofit/imagecube/medium/config/ang20170323t202244_isofit.json')\n", + "config = configs.create_new_config(str(config_file.expanduser()))\n", + "\n", + "print('The config object:')\n", + "print(config)\n", + "print()\n", + "\n", + "print('Config attributes:')\n", + "[print(key) for key in vars(config).keys()]\n", + "print()\n", + "\n", + "print('Example:')\n", + "print(f'Forward model type: {config._forward_model_type}')\n", + "print(f'Forward model: {config.forward_model}\\n')\n", + "\n", + "print('Forward model:')\n", + "pprint(vars(config.forward_model), width=100, compact=False)\n", + "print()\n", + "print('Surface model:')\n", + "pprint(vars(config.forward_model.surface), width=100, compact=False)" + ] + }, + { + "cell_type": "markdown", + "id": "b5957a17-e65a-41eb-93e8-0df0c9abf8b9", + "metadata": {}, + "source": [ + "The `ForwardModel` object contains the `Instrument`, `Radiative transfer` and `Surface` portions of the ISOFIT forward model. The three forward model components are object classes themselves, which contain the math and logic relevant to these features. For example, the `Instrument` portion holds functions for instrument uncertainty quantification and calibration, the `Radiative transfer` portion holds functions relevant for generating and sampling the radiative transfer lookup-tables (LUTs), and the `Surface` portion holds functions relevant to sampling surface priors and formulating surface-specific forward model elements.\n", + "\n", + "Note: if the LUT has not been generated at the expected location from the config, initializing the forward model class will immediately constructing the LUT at that location." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "daf7e8d6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The expected location of the LUT:\n", + "/Users/bgreenbe/.isofit/imagecube/medium/lut_full/lut.nc\n", + "\n", + "\n", + "\n", + "\n", + ">\n" + ] + } + ], + "source": [ + "print('The expected location of the LUT:')\n", + "print(config.forward_model.radiative_transfer.radiative_transfer_engines[0].lut_path)\n", + "print()\n", + "\n", + "# Initialized from the config:\n", + "fm = ForwardModel(config)\n", + "\n", + "# Print the three forward model components\n", + "print(fm.instrument)\n", + "print(fm.RT)\n", + "print(fm.surface)\n", + "\n", + "# Print an example method from RT\n", + "print(fm.RT.calc_rdn)" + ] + }, + { + "cell_type": "markdown", + "id": "ddb76898-3e1a-4f9f-8ef2-3e916f14255e", + "metadata": {}, + "source": [ + "and individual component classes can also be initialized from the `config` object:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "420af4de-8a64-4624-91e4-56320dd7808f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is\n" + ] + } + ], + "source": [ + "instrument = Instrument(config)\n", + "rt = RadiativeTransfer(config)\n", + "surface = Surface(config)" + ] + }, + { + "cell_type": "markdown", + "id": "4b46aef7-7150-4447-be06-df47456dac7c", + "metadata": {}, + "source": [ + "The optimal estimation inversion is handled by the Inversion class object." + ] + }, + { + "cell_type": "markdown", + "id": "3b7e324d-8ef6-4832-9b54-b09fc2458d04", + "metadata": {}, + "source": [ + "### OE Inversions" + ] + }, + { + "cell_type": "markdown", + "id": "2daca64c-2f56-4aea-97a5-bbafe760ecd5", + "metadata": {}, + "source": [ + "We will go into how to perform single pixel optimal estimation (OE) inversions from a set of input data and an ISOFIT config. To do this, we need to load in a radiance spectrum with paired observational geometry data. We'll pull this directly from the `rdn`, `obs`, and `loc` files we loaded above. \n", + "\n", + "OE inversions are run using the Inversion class:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "451f496a-a7dd-435a-b69a-660ff487ecc4", + "metadata": {}, + "outputs": [], + "source": [ + "iv = Inversion(config, fm)" + ] + }, + { + "cell_type": "markdown", + "id": "1ac96a7e-c0e1-4210-bc9a-7919158c8ca5", + "metadata": {}, + "source": [ + "Next, we'll select a pixel to run through the OE inversion." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "15ad55ab-481f-4cc9-8eac-d049bb46bbba", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.1813465].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Pick a pixel\n", + "row = 175\n", + "col = 50\n", + "\n", + "# Plot the input data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(8, 8))\n", + "plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))\n", + "plot = axs[1].imshow(loc_im[..., 0])\n", + "plot = axs[2].imshow(obs_im[..., 4])\n", + "\n", + "axs[0].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "axs[1].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "axs[2].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "\n", + "title = axs[0].set_title('Radiance (RGB)')\n", + "title = axs[1].set_title('Longitude (WGS-84)')\n", + "title = axs[2].set_title('Solar zenith angle (Deg)')" + ] + }, + { + "cell_type": "markdown", + "id": "a238060c-b133-4c0e-a4e7-52c41b435716", + "metadata": {}, + "source": [ + "Then we'll load in the measurement and observational data for that pixel. The geometry object holds all of the observational information for a given pixel." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "be82abde-7b34-4e5f-b456-be34a50d5dc3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "197.31315008280822\n", + "71.53144734704047\n", + "-0.3017277626279998\n" + ] + } + ], + "source": [ + "meas = rdn_im[row, col, :]\n", + "geom = Geometry(\n", + " obs=obs_im[row, col, :],\n", + " loc=loc_im[row, col, :],\n", + " esd=IO.load_esd(),\n", + " svf=1\n", + ")\n", + "\n", + "# e.g.\n", + "print(geom.solar_azimuth)\n", + "print(geom.observer_azimuth)\n", + "print(geom.cos_i)" + ] + }, + { + "cell_type": "markdown", + "id": "6adf64c4-b09c-4f83-ba3b-34bee40e616c", + "metadata": {}, + "source": [ + "and finally run the OE inversion via the inversions.invert function:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "dca42de9-475e-4cf7-a3cb-3e11c40d121e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of iterations to convergence: 9\n", + "Data type of 'oe': \n", + "Array shape: (9, 427)\n" + ] + } + ], + "source": [ + "oe = iv.invert(meas, geom)\n", + "\n", + "print(f\"Number of iterations to convergence: {len(oe)}\")\n", + "print(f\"Data type of 'oe': {type(oe)}\")\n", + "print(f\"Array shape: {oe.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "89d8779d-b82b-4077-ac35-ebd705327d95", + "metadata": {}, + "source": [ + "The `oe` variable is a numpy array where each row is a subsequent iteration of the OE procedure. It is often useful to examine how the solution changes during optimization, which can help debug potential issues with final statevector solutions.\n", + "\n", + "The plots below show the trajectory of the reflectance solution throughout the optimization. The earlier solutions are lighter colors while the later solutions are darker colors.\n", + "\n", + "The plots also show the prior mean selected for this specific pixel via the `surface.xa` function, which can be called directly using the initial guess of the reflectance solution and the pixel observation variables." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "0a20094c-daf1-422b-a326-b7329781b092", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a color map for the iterations\n", + "n = len(oe)\n", + "cmap_name = 'viridis_r'\n", + "cmap = plt.get_cmap(cmap_name)\n", + "colors = [cmap(i) for i in np.linspace(0, 1, n)]\n", + "\n", + "# Fit the prior mean\n", + "xa = fm.surface.xa(oe[0], geom)\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 4))\n", + "axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')\n", + "axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')\n", + "for i, sp in enumerate(oe):\n", + " axs[0].plot(wl, sp[:len(wl)], color=colors[i])\n", + " axs[1].plot(wl, sp[:len(wl)], color=colors[i])\n", + "\n", + "axs[0].plot(wl, oe[-1][:len(wl)], color='black', label='Final')\n", + "axs[1].plot(wl, oe[-1][:len(wl)], color='black')\n", + "\n", + "axs[0].set_ylabel('Reflectance')\n", + "axs[0].set_xlabel('Wavelength (nm)')\n", + "axs[1].set_ylabel('Reflectance')\n", + "axs[1].set_xlabel('Wavelength (nm)')\n", + "\n", + "axs[1].set_xlim([725, 1200])\n", + "axs[1].set_ylim([.1, .5])\n", + "\n", + "axs[0].set_title('Full spectrum')\n", + "axs[1].set_title('Highlighting 725 - 1200 nm')\n", + "\n", + "axs[0].legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "36d20b3b-f06f-4aba-a731-99284b089cb2", + "metadata": {}, + "source": [ + "We can also look at the trajectory of atmospheric statevector variables:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3f0bfd77-470b-4e5d-bce8-1289e17d3041", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, sharex=True, figsize=(10, 5))\n", + "iters = [i for i in range(len(oe))]\n", + "axs[0].set_title('AOT550')\n", + "axs[0].scatter(iters, oe[:, -2], edgecolor='black', facecolor='green', s=200)\n", + "axs[0].set_ylabel('AOT550')\n", + "\n", + "axs[1].set_title('H2O')\n", + "axs[1].scatter(iters, oe[:, -1], edgecolor='black', facecolor='green', s=200)\n", + "axs[1].set_ylabel('H2O')\n", + "\n", + "axs[0].set_xlabel('Iteration')\n", + "axs[1].set_xlabel('Iteration')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1f1cc68c-59aa-44d1-ae46-94291e97fc2a", + "metadata": {}, + "source": [ + "### Inversions with a constrained atmosphere\n", + "\n", + "Scene-scale processing generally leverages superpixel algorithms that simultaneously speed up processing and enforce a spatially smooth atmosphere. Here, we'll demonstrate the analytical line algorithm. The analytical line algorithm assumes there exists a closed form state-vector solution under the assumptions of 1) a fixed atmosphere, and 2) that the measurement can be modeled as a linear combination of state-vector elements. We can call the anlaytical line solution for a given pixel directly, albeit with slightly more set-up.\n", + "\n", + "First, we'll set up a wrapper function to call the analytical line inversion. In practice, the analytical inversion is sensitive to the initial guess (x0 below). We generally use the \"priorless\" solution for the state-vector elemnents for a given atmosphere via the `invert_algebraic` and `iv.fm.surface.fit_params` functions." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "21b0f415-f11f-4aa8-9a27-0381f4e1c40c", + "metadata": {}, + "outputs": [], + "source": [ + "def invert_aoe(iv, meas, geom, sub_state, x_RT, n=1):\n", + "\n", + " # This script sets up the initial guess for the inversion\n", + " x_surface, _, x_instrument = iv.fm.unpack(iv.fm.init.copy())\n", + " rfl_est, coeffs = invert_algebraic(\n", + " iv.fm.surface,\n", + " iv.fm.RT,\n", + " iv.fm.instrument,\n", + " x_surface,\n", + " x_RT,\n", + " x_instrument,\n", + " meas,\n", + " geom,\n", + " )\n", + "\n", + " rfl_est = iv.fm.surface.fit_params(rfl_est, geom)\n", + "\n", + " x0 = np.concatenate(\n", + " [\n", + " rfl_est,\n", + " x_RT,\n", + " x_instrument,\n", + " ]\n", + " )\n", + "\n", + " # This script is responsible for performing the inversion\n", + " states, unc, EXIT_CODE = invert_analytical(\n", + " iv.fm,\n", + " iv.winidx,\n", + " meas,\n", + " geom,\n", + " np.copy(x0),\n", + " sub_state,\n", + " n,\n", + " None,\n", + " None,\n", + " )\n", + "\n", + " return states[-1], unc, x0" + ] + }, + { + "cell_type": "markdown", + "id": "01255d4b-036b-4b34-a958-1d7b7d19de1a", + "metadata": {}, + "source": [ + "Next, we will pull the superpixel state solution and spatially smooth atmosphere for the selected pixel. \n", + "\n", + "Note: This assumes that these files already exist at the expected location." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "2a668a70-b4c0-4b9a-a286-253374dd3eae", + "metadata": {}, + "outputs": [], + "source": [ + "sub_state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_subs_state')\n", + "lbl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_lbl')\n", + "atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')\n", + "\n", + "sub_state = envi.open(envi_header(str(sub_state_path.expanduser())))\n", + "lbl = envi.open(envi_header(str(lbl_path.expanduser())))\n", + "atm = envi.open(envi_header(str(atm_path.expanduser())))\n", + "\n", + "sub_state_im = sub_state.open_memmap(interleave='bip')\n", + "lbl_im = lbl.open_memmap(interleave='bip')\n", + "atm_im = atm.open_memmap(interleave='bip')\n", + "\n", + "idx = int(lbl[row, col, 0])\n", + "sub_state = sub_state_im[idx, 0, :]\n", + "x_RT = atm_im[row, col, :]" + ] + }, + { + "cell_type": "markdown", + "id": "fbd02d3f-26ee-4953-a489-bc154f24a79d", + "metadata": {}, + "source": [ + "We can then call the wrapper function. Solutions are generally acceptible after one iteration, but `n` can be definted to explictely set the number of iterations to perform. " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e0a8370a-44af-491e-b2ff-6b11308940c1", + "metadata": {}, + "outputs": [], + "source": [ + "aoe, aoe_unc, x0 = invert_aoe(\n", + " iv, meas, geom, sub_state, x_RT, n=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "ee7eefc7-183b-4321-9abb-e90389c455e3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a color map for the iterations\n", + "n = len(oe)\n", + "cmap_name = 'viridis_r'\n", + "cmap = plt.get_cmap(cmap_name)\n", + "colors = [cmap(i) for i in np.linspace(0, 1, n)]\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", + "\n", + "axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')\n", + "axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')\n", + "\n", + "axs[0].plot(wl, aoe[:len(wl)], color='purple', lw=2, label='AOE')\n", + "axs[1].plot(wl, aoe[:len(wl)], color='purple', lw=2)\n", + "\n", + "axs[0].plot(wl, oe[-1][:len(wl)], color='green', label='OE')\n", + "axs[1].plot(wl, oe[-1][:len(wl)], color='green')\n", + "\n", + "axs[0].set_ylabel('Reflectance')\n", + "axs[0].set_xlabel('Wavelength (nm)')\n", + "axs[1].set_ylabel('Reflectance')\n", + "axs[1].set_xlabel('Wavelength (nm)')\n", + "\n", + "axs[1].set_xlim([725, 1200])\n", + "axs[1].set_ylim([.1, .5])\n", + "axs[0].set_ylim([-.1, .5])\n", + "\n", + "axs[0].set_title('Full spectrum')\n", + "axs[1].set_title('Highlighting 725 - 1200 nm')\n", + "\n", + "axs[0].legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "adfffc32-8ef7-47c6-818f-d03acae7c50e", + "metadata": {}, + "outputs": [], + "source": [ + "### Algebraic inversions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0e5bf2f-cf60-409e-8c48-1573cf572c08", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/html/index.html b/isofit-tutorials/build/html/index.html new file mode 100644 index 0000000..17088cd --- /dev/null +++ b/isofit-tutorials/build/html/index.html @@ -0,0 +1,157 @@ + + + + + + + ISOFIT tutorials — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

ISOFIT tutorials

+

This contains examples, tutorials and notebooks for the ISOFIt software. +Included here are:

+
    +

  • A demonstration of how ISOFIT is run via the Apply Optimal Estimation (Apply OE) pipeline

    • +

  • Examples for how ISOFIT can be run through function calls akin to a Python library

    • +

  • Sensor-specific examples (NEON, EMIT, etc.)

    • +

  • Information for how to contribute additional examples.

    • +
+

This is a companion to the primary ISOFIT documentation +and source code.

+
+
+

Table of contents:

+
+

Running Isofit

+ +
+
+

Sensor examples

+ +
+
+

Information

+ +
+
+ + +
+
+
+ +
+ +
+

© Copyright Copyright 2018 California Institute of Technology.

+
+ + Built with Sphinx using a + theme + provided by Read the Docs. + + +
+
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/information/code_of_conduct.html b/isofit-tutorials/build/html/information/code_of_conduct.html new file mode 100644 index 0000000..ce0e44b --- /dev/null +++ b/isofit-tutorials/build/html/information/code_of_conduct.html @@ -0,0 +1,178 @@ + + + + + + + Code of Conduct — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Code of Conduct

+

Our Pledge

+

In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a positive experience for everyone.

+

Our Standards

+

Examples of behavior that contributes to creating a positive environment +include:

+
    +

  • Using welcoming language

    • +

  • Gracefully accepting constructive criticism

    • +

  • Focusing on what is best for the community

    • +

  • Showing empathy towards other community members

    • +

  • Scientific integrity and honesty, respecting the scientific method

    • +

  • Crediting other’s work where appropriate

    • +

  • Striving towards, and sharing, new scientific knowledge to benefit humanity

    • +
+

Examples of unacceptable behavior by participants include:

+
    +

  • The use of sexualized language or imagery and unwelcome sexual attention or advances

    • +

  • Trolling, insulting/derogatory comments, and personal or political attacks

    • +

  • Public or private harassment

    • +

  • Publishing others’ private information, such as a physical or electronic address, without explicit permission

    • +

  • Other conduct which could reasonably be considered inappropriate in a professional setting

    • +

  • Misrepresenting or manufacturing experimental data or test results

    • +

  • Failing to duly recognize the contributions of others in one’s work

    • +
+

Our Responsibilities

+

Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior.

+

Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful.

+

Scope

+

This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers.

+

Enforcement

+

Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at david.r.thompson@jpl.nasa.gov. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately.

+

Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project’s leadership.

+

Attribution

+

This Code of Conduct is adapted from the Contributor Covenant, version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html

+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/information/contribute.html b/isofit-tutorials/build/html/information/contribute.html new file mode 100644 index 0000000..3b6be51 --- /dev/null +++ b/isofit-tutorials/build/html/information/contribute.html @@ -0,0 +1,138 @@ + + + + + + + Contributing — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Contributing

+

We hope that these tutorials can be a community repository of software examples for +atmospheric and surface corrections using the ISOFIT software. If new functionality is added to the codebase, +it can be accompanied by notebook-style code examples.

+

Examples of potential contributions include:

+
    +

  • Tutorials for existing and new ISOFIT functionality

    • +

  • Examples of ISOFIT running on various supported instruments

    • +
+

Please feel free to draft notebooks, contact the maintainers, and open pull requests. +If you have have discovered an issue or desire a missing feature, please create a new +issue.

+

The primary ISOFIT documentation describes in detail how to begin contributing.

+

We use nbsphinx to display jupyter notebook examples on the readthedocs page. Contributed examples can be written, and hosted simply as an .ipynb file. +Notebook codes are executed locally and jupyter cell outputs are saved as image hashes, which are then viewable on the static html page.

+

The current notebook directory structure is subject to change as more examples are added. Place your example in the source folder under the most appropriate directory. We can always iterate through the PR process.

+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/information/project_support.html b/isofit-tutorials/build/html/information/project_support.html new file mode 100644 index 0000000..7363546 --- /dev/null +++ b/isofit-tutorials/build/html/information/project_support.html @@ -0,0 +1,136 @@ + + + + + + + Project Support — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Project Support

+

The ISOFIT codebase was made possible with support from various sources. +The initial algorithm and code was developed by the NASA Earth Science +Division data analysis program “Utilization of Airborne Visible/Infrared +Imaging Spectrometer Next Generation Data from an Airborne Campaign in +India,” program NNH16ZDA001N-AVRSNG, managed by Woody Turner.

+

Later research and maturation was provided by the Jet Propulsion Laboratory and +California Institute of Technology President and Director’s Fund, and the +Jet Propulsion Laboratory Research and Technology Development Program. +The project is currently supported by the Open Source Tools, Frameworks, +and Libraries Program (NNH20ZDA001N), managed by Dr. Steven Crawford.

+

Neural network radiative transfer is supported by the NASA Center +Innovation Fund managed in conjunction with the Jet Propulsion Laboratory +Office of the Chief Scientist and Technologist.

+

The initial research took place at the Jet Propulsion Laboratory, California Institute of Technology, +4800 Oak Grove Dr., Pasadena, CA 91109 USA.

+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/objects.inv b/isofit-tutorials/build/html/objects.inv new file mode 100644 index 0000000..57486ec Binary files /dev/null and b/isofit-tutorials/build/html/objects.inv differ diff --git a/isofit-tutorials/build/html/search.html b/isofit-tutorials/build/html/search.html new file mode 100644 index 0000000..8b0f9f5 --- /dev/null +++ b/isofit-tutorials/build/html/search.html @@ -0,0 +1,134 @@ + + + + + + Search — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Search
    • +
  • +
    • +
+
+
+
+
+ + + + +
+ +
+ +
+
+
+ +
+ +
+

© Copyright Copyright 2018 California Institute of Technology.

+
+ + Built with Sphinx using a + theme + provided by Read the Docs. + + +
+
+
+
+
+ + + + + + + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/searchindex.js b/isofit-tutorials/build/html/searchindex.js new file mode 100644 index 0000000..0cf4427 --- /dev/null +++ b/isofit-tutorials/build/html/searchindex.js @@ -0,0 +1 @@ +Search.setIndex({"alltitles": {"About": [[0, null]], "Apply OE": [[1, null], [7, "Apply-OE"], [8, "Apply-OE"]], "Code of Conduct": [[4, null]], "Contributing": [[5, null]], "Feature overview": [[0, "feature-overview"]], "Full image example": [[7, "Full-image-example"]], "How do you run Apply OE?": [[1, "How-do-you-run-Apply-OE?"]], "ISOFIT Configs and Classes": [[2, "ISOFIT-Configs-and-Classes"]], "ISOFIT tutorials": [[3, null]], "Information": [[3, null]], "Internal Functions": [[2, null]], "Inversions with a constrained atmosphere": [[2, "Inversions-with-a-constrained-atmosphere"]], "Loc file generation": [[7, "Loc-file-generation"], [8, "Loc-file-generation"]], "NEON": [[7, null], [8, null]], "OE Inversions": [[2, "OE-Inversions"]], "Per-Pixel Retrievals": [[7, "Per-Pixel-Retrievals"], [8, "Per-Pixel-Retrievals"]], "Project Support": [[6, null]], "Running Isofit": [[3, null]], "Running Per-Pixel Retrievals": [[9, "Running-Per-Pixel-Retrievals"]], "Sensor examples": [[3, null]], "Setup": [[7, "Setup"], [8, "Setup"], [9, null]], "Table of contents:": [[3, "table-of-contents"]], "The Analytical Line": [[1, "The-Analytical-Line"]], "What is Apply OE?": [[1, "What-is-Apply-OE?"]]}, "docnames": ["how_to_run/about", "how_to_run/apply_oe", "how_to_run/functions", "index", "information/code_of_conduct", "information/contribute", "information/project_support", "sensor_examples/neon", "sensor_examples/neon/neon", "sensor_examples/neon/neon_single_pixel"], "envversion": {"nbsphinx": 4, "sphinx": 62, "sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.intersphinx": 1, "sphinx.ext.todo": 2, "sphinx.ext.viewcode": 1}, "filenames": ["how_to_run/about.rst", "how_to_run/apply_oe.ipynb", "how_to_run/functions.ipynb", "index.rst", "information/code_of_conduct.rst", "information/contribute.rst", "information/project_support.rst", "sensor_examples/neon.ipynb", "sensor_examples/neon/neon.ipynb", "sensor_examples/neon/neon_single_pixel.ipynb"], "indexentries": {}, "objects": {}, "objnames": {}, "objtypes": {}, "terms": {"": [1, 2, 4, 6, 7, 8, 9], "0": [1, 2, 7, 8, 9], "00": [7, 8], "001": [7, 8], "002169": [7, 8], "0032": [7, 8, 9], "003357": [7, 8], "0036078691482544": [7, 8], "004571": [7, 8], "006142": [7, 8], "007333": [7, 8], "0078": [7, 8, 9], "0080": [7, 8, 9], "0086": [7, 8, 9], "008620": [7, 8], "008716": [7, 8], "01": [7, 8], "010138": [7, 8], "011365": [7, 8], "012555": [7, 8], "013311": [7, 8], "013812": [7, 8], "019084": [7, 8], "0192": [7, 8], "01_refl": [7, 8], "02": [7, 8], "024299": [7, 8], "029177": [7, 8], "03": [7, 8], "031": [7, 8], "034326": [7, 8], "0381": [7, 8, 9], "039202": [7, 8], "04": [7, 8], "043794": [7, 8], "045966": [7, 8], "048133": [7, 8], "05": [7, 8], "052300": [7, 8], "058111": [7, 8], "06": [7, 8], "067500": [7, 8], "07": [7, 8], "0769": [7, 8], "077814": [7, 8], "08": [7, 8], "085784": [7, 8], "08t15": [7, 8], "09": [7, 8], "0983623": 1, "0x109bb97e0": [], "0x109ed3d90": [], "0x118544700": 2, "0x15da2cfa0": 2, "0x15da2d060": 2, "0x15da2d8d0": 2, "0x15da2d930": 2, "0x15da2ed40": 2, "0x15da2f520": 2, "0x15dac57e0": 2, "1": [0, 1, 2, 4, 7, 8, 9], "10": [1, 2, 7, 8], "100": [2, 7, 8], "1009": [7, 8], "100901": [7, 8], "1016": 1, "105": [7, 8], "106960": [7, 8], "10742364": [7, 8], "109541": [7, 8], "1097916": [1, 2], "10x10": 1, "11": [7, 8], "111": 2, "111898": 1, "112476": 1, "117": [7, 8], "1171": [7, 8], "11728845": 9, "11736042": 1, "1182": [7, 8], "12": [2, 7, 8, 9], "1200": 2, "12002e": [7, 8], "120332": [7, 8], "12389879": 1, "125000": [7, 8], "127": [7, 8], "129110": [7, 8], "13": [1, 7, 8], "133107": [7, 8], "1360": [7, 8], "137875": [7, 8], "139": [7, 8], "14": [7, 8, 9], "1410": [7, 8], "145": [7, 8], "149": [7, 8], "15": [1, 2, 7, 8], "151340": [7, 8], "151416": [7, 8], "152223": [7, 8], "153": [7, 8], "1531": [7, 8], "16": [7, 8], "160": [7, 8], "166": [7, 8], "1689": [7, 8], "17": [7, 8], "17119": [7, 8], "17157": [7, 8], "17158": [7, 8], "17159": [7, 8], "17160": [7, 8], "173647": [7, 8, 9], "174150": [7, 8, 9], "1747": [7, 8], "175": 2, "1752013219": [7, 8], "1752013306": [7, 8], "1752013450": [7, 8], "17535": [7, 8], "17536": [7, 8], "17537": [7, 8], "17538": [7, 8], "17655": [7, 8], "17657": [7, 8], "18": [2, 7, 8], "1800": [7, 8], "1813465": 2, "183851": [7, 8], "184145": [7, 8], "187691": [7, 8], "19": [2, 7, 8], "190843": [7, 8], "1917": [7, 8], "192": [7, 8], "193": [7, 8], "197": 2, "1970": [7, 8], "197963": [7, 8], "198190": [7, 8], "19x": [7, 8], "2": [1, 2, 7, 8, 9], "20": [2, 7, 8], "200": 2, "2008": [7, 8], "20171108_pasadena": [7, 8], "2020": 1, "2021": 1, "2025": [7, 8], "21": [2, 7, 8], "210": [7, 8], "210090": [7, 8], "212932": [7, 8], "214": [7, 8], "215142": [7, 8], "216023": [7, 8], "219819": [7, 8], "21x": [7, 8], "22": [7, 8], "2205": [7, 8, 9], "2214": [7, 8, 9], "2216": [7, 8, 9], "2224": [7, 8, 9], "2225": [7, 8, 9], "2230": [7, 8, 9], "2231": [7, 8, 9], "2245": [7, 8, 9], "225": [7, 8], "2258": [7, 8, 9], "23": [7, 8], "230": [7, 8], "231807": [7, 8], "23248291015625": [7, 8], "235": [7, 8], "237000": [7, 8], "23965e": [7, 8], "24": [7, 8], "242991": [7, 8], "24x": [7, 8], "25": [1, 7, 8], "2500": [7, 8], "252628": [7, 8], "255": [1, 2], "257": [7, 8], "25x": [7, 8], "26": 9, "261": 1, "261347": [7, 8], "263": [7, 8], "2663318": [7, 8], "2663633": [7, 8], "268": [7, 8], "268372": [7, 8], "269": [7, 8], "26x": [7, 8], "27": [2, 7, 8], "271446": [7, 8], "275": [7, 8], "276815": [7, 8], "279": [7, 8], "27x": [7, 8], "28": [2, 7, 8], "280425": [7, 8], "280426": [7, 8], "284546": [7, 8], "286329": [7, 8], "29": [7, 8], "291537": [7, 8], "291772": [7, 8], "296599": [7, 8], "2x": [7, 8], "3": [1, 2, 7, 8, 9], "30": [2, 7, 8], "300": [7, 8], "3007": [7, 8], "3017277626279998": 2, "303": [7, 8], "31": [2, 7, 8], "31315008280822": 2, "3142": [7, 8], "3143": [7, 8, 9], "3151": [7, 8, 9], "3155": [7, 8, 9], "316": [7, 8, 9], "3160": [7, 8, 9], "3170": [7, 8, 9], "3173": [7, 8, 9], "3175": [7, 8, 9], "318248": [7, 8], "3184": [7, 8, 9], "3186": [7, 8, 9], "32": [2, 7, 8], "320": [7, 8], "3200": [7, 8, 9], "324": [7, 8, 9], "328": [7, 8, 9], "329660": [7, 8], "33": [7, 8], "332": [7, 8], "333": [7, 8, 9], "334771": [7, 8], "338172": [7, 8], "339639": [7, 8], "34": [2, 7, 8], "343": [7, 8, 9], "3430540561676025": [7, 8], "343262": [7, 8], "346": [7, 8, 9], "346920": [7, 8], "347710": [7, 8], "348": [7, 8, 9], "35": [1, 2, 7, 8], "350": [7, 8], "351629": [7, 8], "354": [7, 8], "357": [7, 8, 9], "359": [7, 8, 9], "36": [7, 8], "360": 1, "37": [2, 7, 8], "373": [7, 8, 9], "375031": [7, 8], "376": [7, 8], "38": [7, 8], "383": [7, 8], "386": [7, 8], "39": [2, 7, 8], "390030": [7, 8], "392020": [7, 8], "394693": [7, 8], "396394": [7, 8], "397": [7, 8], "3x": [7, 8], "4": [1, 2, 4, 7, 8], "40": [1, 7, 8], "400": 1, "4006": [7, 8], "407719": [7, 8], "408": [7, 8], "41": [7, 8], "412": [7, 8], "415069": [7, 8], "419": [7, 8], "42": [7, 8], "420": [7, 8], "425": 1, "427": [1, 2], "428": [7, 8, 9], "43": [7, 8], "4372": [7, 8], "437658": [7, 8], "437945": [7, 8], "44": [7, 8], "443106": [7, 8], "445": [7, 8], "445977": [7, 8], "4481201171875": [7, 8], "45": [7, 8], "455597": [7, 8], "459419": [7, 8], "459773": [7, 8], "46": [7, 8], "47": [7, 8], "48": [7, 8], "4800": 6, "481330": [7, 8], "49": [7, 8], "495530": [7, 8], "4x": [7, 8], "5": [1, 2, 7, 8, 9], "50": [1, 2, 7, 8], "500123": [7, 8], "5005": [7, 8], "51": [7, 8], "52": [7, 8], "522997": [7, 8], "53": [7, 8], "53144734704047": 2, "54": [7, 8], "5404001": 1, "541": [7, 8], "55": [1, 2, 7, 8], "56": [7, 8], "560121": [7, 8], "566979": [7, 8], "57": [7, 8], "573502": [7, 8], "576961": [7, 8], "58": [7, 8], "59": [7, 8], "5x": [7, 8], "6": [0, 1, 7, 8, 9], "60": [7, 8], "6004": [7, 8], "6025": [7, 8], "603308": [7, 8], "60519719": [7, 8], "605664": [7, 8], "607500": [7, 8], "61": [7, 8], "6123": [7, 8], "61252989": 9, "613957": [7, 8], "613965": [7, 8], "619314193725586": [7, 8], "63": [7, 8], "634": [7, 8, 9], "64": [7, 8], "643": [7, 8, 9], "64327": [7, 8], "64423": [7, 8], "64428": [7, 8], "645": [7, 8, 9], "650": 1, "65123": [7, 8], "653": [7, 8, 9], "654": [7, 8, 9], "657305": [7, 8], "659": [7, 8, 9], "660": [7, 8, 9], "660474": [7, 8], "660733": [7, 8], "660734": [7, 8], "6627": [7, 8], "667635": [7, 8], "67": [7, 8], "674": [7, 8, 9], "684": [7, 8], "687": [7, 8, 9], "692207098007202": [7, 8], "698": [7, 8], "6smulticomponentfn": [7, 8], "7": [2, 7, 8], "70": [7, 8], "7003": [7, 8], "7010": 1, "7092535881617": [7, 8], "71": 2, "7135264": 1, "725": 2, "728": [7, 8], "73": [7, 8], "737973": [7, 8], "738644": [7, 8], "74": [7, 8], "747": [7, 8], "7487": [7, 8], "758583": [7, 8], "76": [7, 8], "763372": [7, 8], "768149": [7, 8], "77": [7, 8], "772424": [7, 8], "78": [7, 8], "781": [7, 8], "785": [7, 8], "7x": [7, 8], "8": [1, 2, 7, 8, 9], "80": [7, 8], "80000e": [7, 8], "8002": [7, 8], "81": [7, 8], "8103": [7, 8, 9], "810682": [7, 8], "813383102416992": [7, 8], "8218994140625": [7, 8], "823216": [7, 8], "825": [7, 8], "83": [7, 8], "8370143526467": [7, 8], "84": [1, 2, 7, 8], "85": [7, 8], "86": [7, 8], "88": [7, 8], "882": [7, 8], "89": [7, 8], "8k": [1, 2], "8x": [7, 8], "9": [2, 7, 8, 9], "90": [1, 7, 8], "9001": [7, 8], "9006": [7, 8, 9], "908109": [7, 8], "91": [7, 8], "91109": 6, "92": [7, 8], "9385": [7, 8, 9], "9423": [7, 8, 9], "946926": [7, 8], "95": [7, 8], "9536": [7, 8, 9], "9580": [7, 8, 9], "9608": [7, 8, 9], "9612": [7, 8, 9], "9626": [7, 8, 9], "965367": [7, 8], "9675": [7, 8], "967955": [7, 8], "97": [7, 8], "9731": [7, 8, 9], "976911": [7, 8], "9771": [7, 8, 9], "98": 2, "986732": [7, 8], "99": [7, 8], "9902": [7, 8, 9], "9905": [7, 8, 9], "9978": [7, 8, 9], "A": [1, 3], "As": 1, "At": 1, "For": [1, 2], "If": [1, 5, 7, 8], "In": [1, 2, 4, 7, 8], "It": [0, 1, 2], "NOT": 1, "No": [7, 8], "That": 9, "The": [2, 4, 5, 6, 7, 8, 9], "Then": 2, "There": [7, 8, 9], "These": [7, 8, 9], "To": [1, 2, 7, 8, 9], "Will": 1, "With": 1, "_": 2, "__call__": [7, 8], "__init__": [7, 8], "_aux": 1, "_emissivity_for_surface_t_init_typ": 2, "_forward_model_typ": 2, "_implementation_typ": 2, "_input_typ": 2, "_instrument_typ": 2, "_isofit": [7, 8, 9], "_kei": [7, 8], "_loc_ort": [7, 8, 9], "_model_discrepancy_file_typ": 2, "_obs_ort": [7, 8], "_output_typ": 2, "_radiative_transfer_typ": 2, "_rdn_obs_ort": 9, "_rdn_ort": [7, 8, 9], "_rfl": [1, 7, 8], "_select_on_init_typ": 2, "_selection_metric_typ": 2, "_state": 1, "_surface_category_typ": 2, "_surface_file_typ": 2, "_surface_t_prior_sigma_degk_typ": 2, "_surface_typ": 2, "_uncert": 1, "_wavelength_file_typ": 2, "ab": [7, 8], "abov": [1, 2], "absl": [7, 8], "abspath": [7, 8, 9], "abus": 4, "accept": [2, 4], "access": 1, "accompani": [1, 5], "account": [0, 1, 4], "accuraci": [7, 8], "acquisit": 1, "across": [1, 7, 8], "act": [1, 4], "action": 4, "activ": 2, "actual": [7, 8, 9], "ad": [1, 5], "adapt": 4, "addit": [1, 3, 7, 8], "address": 4, "adept": 2, "adj_roi": [7, 8, 9], "advanc": 4, "advantag": 2, "advis": 1, "aerosol": [1, 7, 8], "aerosol_climatology_path": 1, "aerosol_model": [7, 8], "after": [1, 2, 7, 8], "again": [7, 8], "airborn": 6, "akin": 3, "albeit": [1, 2], "algebra": [2, 7, 8], "algorithm": [1, 2, 6], "align": 4, "all": [1, 2, 4, 7, 8], "allow": 1, "alreadi": [2, 7, 8], "also": [2, 7, 8, 9], "altern": 1, "altitud": [7, 8], "alwai": 5, "amount": 1, "an": [1, 2, 4, 5, 6, 7, 8, 9], "analysi": 6, "analyt": [2, 7, 8], "analytical_lin": [1, 7, 8], "analyz": 1, "ang": 1, "ang20170323t202244_atm_interp": [1, 2], "ang20170323t202244_isofit": 2, "ang20170323t202244_lbl": 2, "ang20170323t202244_loc_7000": 1, "ang20170323t202244_loc_7k": [1, 2], "ang20170323t202244_obs_7000": 1, "ang20170323t202244_obs_7k": [1, 2], "ang20170323t202244_rdn_7000": 1, "ang20170323t202244_rdn_7k": [1, 2], "ang20170323t202244_recon_subs_st": 1, "ang20170323t202244_rfl": 1, "ang20170323t202244_stat": 1, "ang20170323t202244_subs_recon_loc": 1, "ang20170323t202244_subs_recon_ob": 1, "ang20170323t202244_subs_recon_rdn": 1, "ang20170323t202244_subs_st": 2, "ang20170323t202244_uncert": 1, "ang20171108t184227_surfac": [7, 8], "angl": [1, 2], "ani": [1, 4, 7, 8], "anlayt": [1, 2], "anoth": [], "anylit": 1, "aod": 1, "aoe": 2, "aoe_unc": 2, "aot550": [2, 7, 8], "appli": [2, 3, 4], "applic": [0, 1], "apply_o": [1, 7, 8, 9], "appoint": 4, "appropri": [1, 4, 5], "ar": [1, 2, 3, 4, 5, 7, 8, 9], "arg": 1, "argmin": [7, 8], "argument": [1, 7, 8], "around": 2, "arrai": [1, 2, 7, 8, 9], "aspect": [1, 7, 8], "assum": 2, "assumpt": [1, 2], "astyp": [1, 2, 7, 8, 9], "atm": [1, 2], "atm_im": [1, 2], "atm_interpol": [7, 8], "atm_midlat_summ": 1, "atm_path": [1, 2], "atm_sigma": [1, 7, 8], "atmospher": [0, 1, 5, 7, 8], "atmosphere_typ": 1, "atmsopher": [7, 8], "attack": 4, "attempt": [7, 8], "attent": 4, "attribut": [2, 4], "au": 1, "avail": [0, 1, 4, 7, 8], "aviri": 1, "avng": [7, 8], "avrsng": 6, "ax": [1, 2], "axi": [7, 8, 9], "azimuth": [1, 7, 8], "background": 0, "ban": 4, "band": [1, 2, 7, 8], "base": [0, 1], "baselin": 9, "basenam": 1, "basic": 9, "becaus": 1, "been": [2, 7, 8], "befor": [1, 7, 8], "begin": [5, 7, 8], "behavior": 4, "below": [2, 7, 8], "benefit": 4, "best": 4, "better": 9, "between": 1, "bgreenb": [2, 7, 8], "bip": [1, 2, 7, 8, 9], "bit": 9, "black": [2, 7, 8], "blacktarp": [7, 8, 9], "block": 1, "bool": [1, 2], "both": [0, 1, 4], "bound": [1, 2, 7, 8], "braverman": 1, "broadcast": 1, "brodrick": [1, 7, 8, 9], "build": [2, 7, 8], "build_output": [7, 8], "built": [1, 2], "c": [1, 7, 8], "ca": 6, "calc_rdn": 2, "calcul": 1, "calibr": 2, "california": 6, "call": [1, 2, 3, 7, 8, 9], "campaign": 6, "can": [0, 1, 2, 3, 5, 7, 8, 9], "cancel": [7, 8], "candela": 1, "cannot": [7, 8], "carbon": 1, "carmon": 1, "case": 1, "caus": [7, 8, 9], "cc": [7, 8], "cell": 5, "center": [6, 7, 8], "chang": [2, 5, 7, 8], "channel": [1, 7, 8], "channelized_uncertainty_path": [1, 7, 8], "check": [7, 8], "check_surface_model": [7, 8], "chief": 6, "choic": 1, "choos": 1, "chttp2": [7, 8], "chttp2_transport": [7, 8], "chunk": [7, 8], "circumst": 4, "clarifi": 4, "clark": 1, "class": [], "clear": 9, "cli": [1, 2], "climatologi": [1, 7, 8], "clip": [1, 2], "close": [1, 2], "closest_wl": [7, 8], "cluster": [7, 8], "cmap": 2, "cmap_nam": 2, "co": [7, 8], "code": [3, 5, 6, 7, 8], "codebas": [5, 6], "coeff": [2, 7, 8, 9], "col": [2, 7, 8], "collect": [7, 8], "color": 2, "colorbar": 1, "column": 1, "com_github_grpc_grpc": [7, 8], "combin": 2, "comma": [7, 8, 9], "command": 1, "comment": 4, "commit": 4, "common": [1, 2, 7, 8], "commonli": [7, 8, 9], "commun": [4, 5], "compact": 2, "companion": 3, "compat": 1, "complaint": 4, "complet": [7, 8], "compon": [0, 2], "composit": 1, "compris": [7, 8, 9], "computation": 1, "concaten": 2, "concert": 1, "conduct": 3, "confidenti": 4, "config": [7, 8, 9], "config_fil": 2, "config_onli": [1, 2], "config_path": [7, 8], "configu": 9, "configur": [0, 1, 2, 7, 8], "conjunct": 6, "connelli": 1, "consid": [1, 4, 7, 8], "construct": [1, 2, 4], "contact": [4, 5], "contain": [0, 1, 2, 3, 7, 8], "contribut": [3, 4], "contributor": 4, "control": 2, "converg": [1, 2], "convert": [7, 8, 9], "copi": [1, 2, 7, 8, 9], "copy_input_fil": 1, "core": [1, 2, 7, 8, 9], "corner": 1, "correct": [1, 4, 5], "correspond": [7, 8], "cos_i": 2, "cosi": [7, 8], "cosin": 1, "could": 4, "coupl": 0, "coven": 4, "cpu": 1, "crawford": 6, "creat": [4, 5, 7, 8, 9], "create_imag": [7, 8], "create_new_config": [2, 7, 8, 9], "created_tim": [7, 8], "credit": 4, "critic": 4, "cube": [0, 1, 7, 8], "current": [1, 5, 6], "current_input_data": [7, 8], "custom": 0, "cw": 1, "d": [1, 7, 8], "darker": 2, "dat": [7, 8], "data": [0, 1, 2, 4, 6, 7, 8, 9], "data_prep": [7, 8], "dataset": [7, 8], "date": [7, 8], "datetim": 1, "david": 4, "debug": [1, 2, 7, 8], "decreas": 1, "dedupl": [7, 8], "deem": 4, "def": [2, 7, 8], "default": [1, 7, 8], "defin": [4, 7, 8, 9], "defint": 2, "deg": [1, 2, 7, 8], "degre": 1, "del": [7, 8], "demand": 1, "demonstr": [2, 3], "denot": 1, "depend": 0, "depth": 1, "derogatori": 4, "describ": 5, "descript": [0, 1], "design": [0, 1], "desir": [1, 5], "detail": [4, 5, 9], "detect": 9, "determin": [1, 4], "develop": [2, 6], "deviat": 1, "dict": 1, "dictionari": [7, 8], "differ": [0, 1, 7, 8], "dimens": [1, 7, 8], "directli": 2, "director": 6, "directori": [1, 5, 7, 8], "disabl": [7, 8], "discov": 5, "discrep": [0, 7, 8], "disk": [7, 8], "displai": 5, "distanc": [1, 7, 8], "distribut": [0, 1, 7, 8], "divis": 6, "do": [2, 4, 7, 8], "doc": [7, 8], "docstr": 1, "document": [3, 5], "doe": 1, "doesn": [1, 7, 8], "doi": 1, "don": 1, "done": [7, 8], "dot": 1, "down": [1, 7, 8], "download": [7, 8], "dr": 6, "draft": 5, "duli": 4, "dure": [1, 2], "duval": 1, "dynam": [7, 8, 9], "e": [1, 2, 4], "each": [1, 2, 7, 8, 9], "earlier": 2, "earth": [1, 6, 7, 8], "easiest": 1, "eastwood": 1, "edgecolor": 2, "edit": [2, 4], "effect": [7, 8], "elaps": [7, 8], "electron": 4, "element": [1, 2], "elemn": 2, "elev": [1, 7, 8], "els": [7, 8], "elv": [7, 8], "emissivity_for_surface_t_init": 2, "emit": 3, "empathi": 4, "empir": 1, "empirical_lin": 1, "emul": [0, 1, 7, 8], "emulator_aux": 1, "emulator_bas": [1, 7, 8], "emulator_path": [1, 7, 8], "en": [7, 8], "enabl": [1, 7, 8, 9], "encod": [7, 8], "encount": [7, 8], "end": [1, 2], "enforc": [2, 4], "engin": 1, "enough": [7, 8], "enter": 1, "entir": [1, 7, 8], "enumer": [2, 7, 8], "envi": [1, 2, 7, 8, 9], "envi_head": [1, 2], "environ": [1, 4, 7, 8], "err": [7, 8], "error": [0, 7, 8], "esd": 2, "estim": [1, 2, 3], "eta": [7, 8], "etc": 3, "euclidean": 2, "evalu": 0, "event": 4, "everyon": 4, "examin": [1, 2], "exampl": [1, 2, 4, 5, 8], "except": [7, 8], "excercis": [7, 8, 9], "exclus": 1, "execut": [1, 5, 7, 8, 9], "exist": [2, 5], "exit": 1, "exit_cod": 2, "expand": 1, "expandus": [1, 2, 7, 8], "expect": [1, 2, 4, 7, 8], "expens": 1, "experi": 4, "experiment": 4, "explicit": 4, "explict": 2, "ext": [7, 8], "extent": 1, "extern": [7, 8], "extract": [7, 8, 9], "extract_chunk": [7, 8], "extrapol": 1, "f": [1, 2, 7, 8, 9], "face": 4, "facecolor": 2, "factor": 1, "fahlen": 1, "fail": 4, "fair": 4, "faith": 4, "fake": [7, 8], "fakeloc": [7, 8], "fakeob": [7, 8], "fals": [1, 2, 7, 8], "faster": 1, "featur": [2, 5], "feel": 5, "fieldspectromet": [7, 8], "fig": [1, 2, 7, 8], "figsiz": [1, 2, 7, 8], "figur": [7, 8], "file": [0, 1, 2, 5, 9], "file_lin": [7, 8], "fileio": [2, 7, 8, 9], "final": [1, 2], "find": [7, 8, 9], "fine": 1, "first": [2, 7, 8], "fit": [0, 2], "fit_param": 2, "fix": [1, 2], "flag": [1, 2], "flexibl": 0, "flightlin": [1, 7, 8], "float": [1, 2, 7, 8], "flush": [7, 8], "fly": [7, 8], "fm": [2, 7, 8, 9], "focus": 4, "folder": [1, 5, 7, 8], "follow": [1, 4, 7, 8, 9], "forc": [1, 7, 8], "form": [1, 2], "formal": 1, "format": [0, 1], "formul": 2, "forward": [2, 7, 8, 9], "forward_model": [2, 7, 8, 9], "forward_model_config": 2, "forwardmodel": [2, 7, 8, 9], "forwardmodelconfig": 2, "foster": 4, "found": [1, 2, 7, 8], "framework": 6, "free": 5, "from": [1, 2, 4, 6, 7, 8, 9], "full": [1, 2, 8], "fulli": [2, 7, 8], "function": [1, 3, 5, 7, 8], "fund": 6, "further": 4, "fwhm": [7, 8], "g": [1, 2], "gamma": 1, "gave": 9, "gener": [1, 2, 6, 9], "genfromtxt": [7, 8], "geom": [2, 7, 8, 9], "geometr": 1, "geometri": [1, 2, 7, 8, 9], "get": [1, 7, 8, 9], "get_cmap": 2, "get_config_error": [7, 8], "getcwd": [7, 8, 9], "getlogg": [7, 8, 9], "getmetadata": [7, 8], "github": [7, 8], "give": [1, 2], "given": [2, 7, 8], "go": 2, "goawai": [7, 8], "good": [1, 4], "got": [1, 2, 7, 8], "gov": [4, 7, 8], "gracefulli": 4, "green": [1, 2], "grid": [7, 8], "grove": 6, "grpc_statu": [7, 8], "gt": 2, "guess": [2, 7, 8], "guid": [1, 7, 8], "h": 1, "h2o": [1, 2, 7, 8], "h5": [1, 7, 8], "ha": [2, 7, 8], "handl": [0, 2, 7, 8], "harass": 4, "harm": 4, "hash": 5, "have": [4, 5, 7, 8, 9], "hdr": [7, 8, 9], "header": [1, 7, 8], "help": [1, 2, 7, 8], "here": [1, 2, 3, 7, 8, 9], "heurist": 1, "highlight": 2, "hold": [2, 7, 8, 9], "home": [7, 8, 9], "honesti": 4, "hope": 5, "host": 5, "how": [2, 3, 5, 7, 8], "howev": [1, 7, 8], "html": [4, 5, 7, 8], "http": [1, 4, 7, 8], "http2_error": [7, 8], "human": 4, "i": [0, 2, 3, 4, 5, 6, 7, 8, 9], "i0000": [7, 8], "id": [7, 8], "ident": 1, "idx": 2, "ignor": 1, "imag": [0, 1, 2, 5, 6, 8, 9], "image_cub": 1, "imagecub": [1, 2], "imageri": 4, "immedi": 2, "implement": 2, "import": [1, 2, 7, 8, 9], "improv": [7, 8, 9], "imshow": [1, 2, 7, 8], "in_situ": [7, 8], "in_situ_path": [7, 8], "inaccuraci": [7, 8], "inappropri": 4, "incid": 4, "incl": 0, "includ": [3, 4, 5, 7, 8], "incur": 1, "indata": 9, "independ": 1, "index": [7, 8], "india": 6, "indic": [7, 8, 9], "individu": [0, 2, 4, 9], "infer": [7, 8], "info": [1, 7, 8, 9], "inform": [1, 2, 4, 7, 8], "infrar": 6, "ini": [7, 8], "init": [2, 7, 8], "initi": [1, 2, 6, 7, 8], "initializelog": [7, 8], "inlin": [7, 8, 9], "innov": 6, "input": [1, 2, 7, 8, 9], "input_loc": [1, 7, 8], "input_ob": [1, 7, 8], "input_radi": [1, 7, 8], "instal": [7, 8], "instanc": [4, 7, 8], "instead": 1, "institut": 6, "instrument": [0, 2, 5, 7, 8, 9], "instrument_config": 2, "instrumentconfig": 2, "insult": 4, "int": [1, 2, 7, 8, 9], "integ": [1, 2], "integr": 4, "interest": [4, 7, 8, 9], "interfac": 1, "interleav": [1, 2, 7, 8, 9], "intermediari": [7, 8], "intern": 3, "interpol": [1, 7, 8], "interpolate_bad_rdn": 1, "interpolate_inplac": 1, "intiial": 9, "introduct": 2, "inv": [7, 8, 9], "invers": [1, 7, 8, 9], "inverse_simpl": [2, 7, 8, 9], "inversion_window": 1, "invert": [2, 7, 8, 9], "invert_algebra": [2, 7, 8, 9], "invert_analyt": 2, "invert_ao": 2, "invert_simpl": 2, "investig": 4, "io": [2, 7, 8, 9], "ipv4": [7, 8], "ipynb": [5, 9], "isdir": [7, 8], "isofit": [0, 1, 5, 6, 7, 8, 9], "isofit_support": [7, 8], "isotut": 9, "issu": [2, 4, 5, 7, 8, 9], "item": [1, 7, 8, 9], "iter": [1, 2, 5, 7, 8, 9], "its": [4, 9], "iv": [2, 7, 8], "j": 1, "jet": 6, "join": [7, 8, 9], "jpl": [4, 7, 8], "json": [0, 1, 2, 7, 8, 9], "jupyt": 5, "just": 1, "k": [7, 8, 9], "kb": 1, "kdtree": 1, "kei": [2, 7, 8], "kilomet": [7, 8], "km": [7, 8], "knowledg": [0, 4], "known": [7, 8], "kokali": 1, "kwarg": [7, 8], "l": [1, 2, 7, 8, 9], "lab": [7, 8], "label": [2, 7, 8], "laboratori": 6, "lambda": [1, 2, 7, 8, 9], "languag": 4, "larg": 1, "last": [7, 8], "lat": [1, 7, 8], "later": [2, 6], "latitud": [1, 7, 8], "lbl": 2, "lbl_im": 2, "lbl_path": 2, "lead": 1, "leadership": 4, "learn": 0, "leav": [2, 7, 8], "legend": [2, 7, 8], "len": 2, "length": 1, "let": [7, 8, 9], "level": 1, "leverag": [1, 2], "li": 1, "libradtran": 0, "librari": [0, 3, 6], "lighter": 2, "like": [1, 2, 7, 8], "line": [2, 7, 8], "linear": 2, "link": 1, "linspac": 2, "list": [1, 7, 8], "ll": [2, 7, 8, 9], "load": [1, 2, 7, 8, 9], "load_climatologi": [7, 8], "load_esd": 2, "loc": [1, 2, 9], "loc_fil": [7, 8, 9], "loc_im": [1, 2], "loc_path": [1, 2], "local": [1, 5, 7, 8], "locat": [1, 2, 7, 8, 9], "log": [1, 7, 8, 9], "log_fil": [1, 7, 8], "logger": [7, 8, 9], "logging_level": [1, 7, 8], "logic": 2, "lon": [1, 7, 8], "long": 1, "longitud": [1, 2, 7, 8], "look": [1, 2], "lookup": [1, 2], "low": [7, 8, 9], "lt": 2, "lundeen": 1, "lut": [1, 2, 7, 8, 9], "lut_config_fil": [1, 7, 8], "lut_ful": [2, 7, 8], "lut_h2o": [7, 8], "lut_path": 2, "lutconfig": 1, "lw": 2, "m": [1, 9], "made": 6, "mahowald": 1, "mai": [2, 4, 9], "mail": 4, "main": [7, 8], "maintain": [4, 5], "make": [2, 4], "manag": 6, "manner": 2, "manual": 2, "manufactur": 4, "map": 2, "master": [7, 8], "mat": [1, 2, 7, 8, 9], "match": [7, 8], "math": 2, "mathemat": [7, 8], "matplotlib": [1, 2, 7, 8, 9], "matur": 6, "max": [1, 7, 8, 9], "maxi": [7, 8, 9], "maximum": 0, "maxx": [7, 8, 9], "mea": 2, "mean": [1, 2, 7, 8, 9], "mean_rfl": [7, 8], "meas_wl": [7, 8], "measur": [2, 7, 8], "measured_radiance_fil": [7, 8, 9], "media": 4, "medium": [1, 2], "member": 4, "memori": [7, 8], "messag": [1, 7, 8], "metadata": [1, 2, 7, 8], "method": [2, 4], "micron": [7, 8], "might": [1, 7, 8, 9], "miller": 1, "min": [7, 8, 9], "mini": [7, 8, 9], "minim": 1, "minimum": [7, 8], "minx": [7, 8, 9], "misrepres": 4, "miss": 5, "mkdir": [7, 8], "mode": [1, 7, 8, 9], "model": [0, 1, 2, 7, 8, 9], "model_discrepancy_fil": 2, "model_discrepancy_path": [1, 7, 8], "modifi": 1, "modtran": [0, 1], "modtran_dir": 1, "modtran_path": 1, "more": [1, 2, 5, 7, 8, 9], "most": [1, 5, 7, 8], "much": 1, "multi": 1, "multi_fm": [], "multi_iv": [], "multicomponent_surfac": [1, 2, 7, 8], "multicomponentsurfac": 2, "multipl": 1, "multiple_restart": 1, "must": 1, "mutual": 1, "mv": [7, 8], "n": [1, 2, 7, 8], "n_core": [1, 7, 8], "name": [1, 7, 8], "nan": [1, 2, 7, 8, 9], "narrow": 1, "nasa": [4, 6, 7, 8], "nbsphinx": 5, "nc": [2, 7, 8], "ndarrai": 2, "necessari": [4, 7, 8], "need": [2, 7, 8], "neighbor": 1, "neon": [3, 9], "neon_id": [7, 8, 9], "neon_subset": [7, 8], "netcdf": [1, 7, 8], "network": [0, 6], "neural": [0, 6], "new": [0, 1, 4, 5], "next": [1, 2, 6, 7, 8], "ng": 1, "nis01_20210403_": [7, 8, 9], "nis01_20210403_173647": [7, 8, 9], "nis01_20210403_173647_h2o": [7, 8], "nis01_20210403_173647_isofit": [7, 8, 9], "nis01_20210403_173647_obs_ort": [7, 8], "nis01_20210403_173647_rdn_ort": [7, 8], "nis01_20210403_173647_subs_loc": [7, 8], "nis01_20210403_173647_subs_ob": [7, 8], "nis01_20210403_173647_subs_rdn": [7, 8], "nis01_20210403_173647_subs_st": [7, 8], "nis01_20210403_174150_obs_ort": [7, 8], "nis01_20210403_174150_rdn_ort": [7, 8], "nm": [1, 2, 7, 8], "nn": 1, "nnh16zda001n": 6, "nnh20zda001n": 6, "no_min_lut_spac": 1, "nois": [1, 7, 8], "non": [1, 7, 8], "none": [1, 2, 7, 8], "normal": [1, 2], "note": [1, 2, 7, 8], "notebook": [2, 3, 5, 7, 8, 9], "now": [7, 8, 9], "np": [1, 2, 7, 8, 9], "npz": 1, "num_neighbor": [1, 7, 8], "number": [1, 2], "numer": 0, "numpi": [0, 1, 2, 7, 8, 9], "o": [1, 7, 8, 9], "oak": 6, "ob": [1, 2, 7, 8, 9], "object": [2, 7, 8, 9], "oblig": 4, "obs_fil": [7, 8, 9], "obs_im": [1, 2], "obs_path": [1, 2], "observ": [0, 1, 2, 7, 8], "observer_azimuth": 2, "obtain": [7, 8], "occur": 1, "oe": 3, "offens": 4, "offic": 6, "offici": 4, "offlin": 4, "offset": [7, 8, 9], "often": [2, 7, 8], "okin": 1, "olson": 1, "one": [1, 2, 4, 7, 8, 9], "onli": 1, "onlin": 4, "open": [1, 2, 4, 5, 6, 7, 8, 9], "open_memmap": [1, 2, 7, 8, 9], "optic": 1, "optim": [1, 2, 3, 7, 8], "option": [1, 7, 8], "order": [1, 9], "org": [1, 4], "other": [1, 4, 7, 8, 9], "otherwis": 4, "ouput": [7, 8], "our": 4, "out": 1, "output": [1, 2, 5, 7, 8, 9], "output_path": [7, 8], "output_surface_fil": [7, 8, 9], "over": 1, "overid": 1, "overrid": 1, "overview": 1, "p": 1, "packag": 2, "page": 5, "painter": 1, "pair": [1, 2], "paper": 1, "parallel": [1, 7, 8], "param0": [7, 8], "param10": [7, 8], "param9": [7, 8], "paramet": [1, 7, 8], "part": [7, 8], "partial": 1, "particip": 4, "pasadena": 6, "pass": [7, 8], "path": [1, 2, 7, 8, 9], "pathlib": [1, 2, 7, 8], "pbrodrick": [7, 8], "penalti": 1, "per": 1, "perform": [1, 2, 7, 8, 9], "perman": 4, "permiss": 4, "person": 4, "phase": [1, 7, 8], "physic": 4, "pick": 2, "pid": [7, 8], "piec": [7, 8, 9], "pipelin": [1, 2, 3], "pixel": [1, 2], "place": [1, 5, 6, 7, 8], "pleas": [5, 7, 8], "pledg": 4, "plot": [1, 2, 7, 8], "plt": [1, 2, 7, 8, 9], "poi": [7, 8, 9], "point": [1, 7, 8, 9], "poitn": 1, "polici": 4, "polit": 4, "portion": 2, "posit": 4, "possibl": 6, "post": [4, 7, 8], "posterior": 1, "potenti": [2, 5], "pprint": 2, "pr": 5, "practic": 2, "pre": [1, 7, 8], "prebuilt": [7, 8, 9], "prebuilt_lut": 1, "predict": [7, 8], "preliminari": 1, "prep": [7, 8], "prerequisit": [7, 8, 9], "presid": 6, "presim": [7, 8], "presolv": [1, 7, 8], "pressure_elev": [1, 7, 8], "primari": [3, 5, 7, 8, 9], "primarili": 0, "principl": 1, "print": [1, 2, 7, 8], "prior": [0, 1, 2, 7, 8], "prior_mean": [7, 8], "prior_sigma": [7, 8], "priorless": 2, "privat": 4, "procedur": 2, "proceed": [7, 8], "process": [1, 2, 5, 7, 8], "profession": 4, "profil": 1, "program": [1, 6], "project": [3, 4], "propuls": 6, "provid": [1, 6, 7, 8, 9], "ptimiz": 1, "pub": [7, 8], "public": 4, "publish": 4, "pull": [2, 5], "purpl": 2, "py": [7, 8, 9], "pyplot": [1, 2, 7, 8, 9], "python": [0, 2, 3, 7, 8, 9], "quantif": 2, "quantifi": 1, "quantiti": [7, 8], "quick": 2, "r": [1, 4, 7, 8, 9], "radi": [0, 1, 2, 6, 7, 8], "radianc": [0, 1, 2, 7, 8], "radiative_transf": [2, 9], "radiative_transfer_config": 2, "radiative_transfer_engin": [2, 7, 8, 9], "radiativetransf": 2, "radiativetransferconfig": 2, "radiometr": 1, "rai": [1, 7, 8], "ran": 1, "rang": [1, 2, 7, 8], "raster": 1, "rate": [7, 8], "rather": 1, "ravel": 1, "ray_dedup_log": [7, 8], "ray_temp_dir": [1, 7, 8], "rcc": [7, 8], "rdn": [1, 2, 7, 8, 9], "rdn_d": [7, 8], "rdn_factors_path": [1, 7, 8], "rdn_im": [1, 2], "rdn_path": [1, 2], "re": [7, 8, 9], "readthedoc": 5, "reason": 4, "rebuild": [7, 8], "receiv": [7, 8], "recent": [7, 8], "recogn": 4, "reconstruct_sub": 1, "red": [7, 8], "refer": 1, "reflect": [1, 2, 7, 8], "regard": 4, "region": [7, 8, 9], "reject": 4, "rel": [7, 8], "relev": [1, 2], "remain": 1, "remot": 1, "remov": [1, 4, 7, 8], "repeat": [7, 8], "repercuss": 4, "replac": [7, 8], "repo": [7, 8, 9], "report": [4, 7, 8, 9], "repositori": 5, "repres": 4, "represent": [4, 7, 8], "request": 5, "requir": [1, 7, 8], "requri": 1, "resampl": 9, "research": 6, "resolut": 1, "respect": [1, 4], "respons": [2, 4, 9], "result": [1, 4, 7, 8], "ret": [7, 8], "retriev": 1, "return": [2, 7, 8], "review": 4, "rfl": 1, "rfl_alg_opt": [7, 8], "rfl_d": [7, 8], "rfl_est": 2, "rfl_im": 1, "rfl_path": 1, "rfl_rgb": [7, 8], "rgb": [1, 2], "right": [4, 7, 8], "roadew": [7, 8, 9], "roadn": [7, 8, 9], "robust": 1, "roi": [7, 8, 9], "root": 9, "round": [7, 8, 9], "routin": 0, "row": [1, 2, 7, 8], "rse": 1, "rt": [2, 7, 8, 9], "rte": 1, "rtm": 0, "run": [0, 2, 5, 7, 8], "run_set_of_spectra": [7, 8], "runsimul": [7, 8], "s_ep": 1, "same": 1, "sampl": [2, 7, 8, 9], "sartur": 1, "save": [2, 5, 7, 8], "sb": 1, "scale": [1, 2, 7, 8], "scatter": 2, "scene": 2, "scienc": 6, "scientif": [0, 4], "scientist": 6, "scikit": 0, "scipi": [0, 7, 8], "scope": 4, "script": [1, 2, 7, 8], "sea": [7, 8], "section": [2, 7, 8], "see": [1, 7, 8], "segment": [1, 7, 8], "segment_chunk": [7, 8], "segmentation_s": [1, 7, 8], "select": [0, 2, 7, 8], "select_on_init": 2, "selection_metr": 2, "self": [1, 7, 8], "sens": 1, "sensit": 2, "sensor": [0, 1, 7, 8], "separ": [4, 7, 8, 9], "serial": 1, "set": [0, 1, 2, 4, 7, 8], "set_titl": [1, 2], "set_xlabel": 2, "set_xlim": 2, "set_ylabel": [1, 2], "set_ylim": 2, "setlevel": [7, 8, 9], "sexual": 4, "sez": [7, 8], "shape": [1, 2, 7, 8], "share": 4, "sharei": [1, 2], "sharex": [1, 2], "should": 1, "show": [1, 2, 4, 7, 8], "shutdown": [7, 8], "signific": 1, "sim": [7, 8], "simpl": 1, "simplenamespac": [7, 8], "simpli": 5, "simul": [1, 7, 8], "simultan": 2, "singl": [1, 2], "situ": [7, 8], "six": [7, 8], "sixs_dir": [7, 8], "size": [1, 7, 8], "skip": [7, 8], "skip_head": [7, 8], "slic": 1, "slightli": [1, 2], "slope": [1, 7, 8], "slow": 1, "small": [1, 2], "smooth": [1, 2], "so": [0, 2, 7, 8, 9], "soa": [7, 8], "social": 4, "softwar": [3, 5], "solar": [1, 2, 7, 8], "solar_azimuth": 2, "solut": [1, 2], "solv": [1, 7, 8], "some": [0, 1, 7, 8, 9], "sourc": [3, 5, 6], "soz": [7, 8], "sp": [1, 2], "space": [1, 4], "spatial": [1, 2], "specif": [1, 2, 3, 4, 7, 8], "specifi": [1, 7, 8], "spectra": [0, 1, 7, 8], "spectral": [1, 2, 7, 8, 9], "spectromet": [0, 6, 7, 8], "spectroscopi": 1, "spectrum": 2, "speed": [1, 2], "src": [7, 8], "srtmnet": [0, 1, 7, 8], "srtmnet_v120": [1, 7, 8], "stabl": 2, "stage": [1, 7, 8], "stage_fil": [7, 8], "standard": [1, 4], "standpoint": 2, "start": [1, 2, 7, 8, 9], "state": [0, 1, 2, 7, 8, 9], "state_im": 1, "state_path": 1, "statement": 1, "statevector": [1, 2], "static": 5, "statist": 0, "stderr": [7, 8], "step": [7, 8], "steven": 6, "still": 1, "store": [7, 8], "str": [1, 2, 7, 8, 9], "streamsimul": [7, 8], "string": [7, 8, 9], "strive": 4, "structur": [2, 5], "style": 5, "sub_stat": 2, "sub_state_im": 2, "sub_state_path": 2, "subdirectori": 1, "subject": [2, 5], "subplot": [1, 2], "subs_loc": 1, "subs_loc_im": 1, "subs_loc_path": 1, "subs_ob": 1, "subs_obs_im": 1, "subs_obs_path": 1, "subs_rdn": 1, "subs_rdn_im": 1, "subs_rdn_path": 1, "subsequ": 2, "subset": [1, 7, 8], "subset_data": [7, 8], "subset_dir": [7, 8], "substanti": 1, "substr": [7, 8], "succesfulli": 9, "successfulli": [7, 8], "suffici": [7, 8], "suggest": 1, "sun": [1, 7, 8], "superced": 1, "superpixel": [1, 2], "support": [3, 5], "sure": 2, "surfac": [0, 1, 2, 5, 7, 8, 9], "surface_categori": [1, 2, 7, 8], "surface_config": 2, "surface_fil": [2, 7, 8, 9], "surface_model": [7, 8], "surface_model_path": [7, 8], "surface_model_ucsb": [7, 8], "surface_multicomp": 2, "surface_path": [1, 7, 8], "surface_t_prior_sigma_degk": 2, "surfaceconfig": 2, "surrog": 0, "susilouto": 1, "svf": 2, "swap": 0, "swayz": 1, "sy": 1, "system": 1, "systemat": 1, "t": [1, 7, 8], "tabl": [1, 2], "take": 4, "team": 4, "technologi": 6, "technologist": 6, "tell": 1, "temp": 1, "template_construct": [7, 8], "temporari": [1, 4], "temporarili": 4, "term": [1, 7, 8], "termin": 1, "test": [2, 4], "text": [0, 1, 7, 8], "than": 2, "thei": 4, "themselv": 2, "thermal_downwel": [2, 7, 8, 9], "thermal_upwel": [2, 7, 8, 9], "thi": [1, 2, 3, 4, 7, 8, 9], "thing": [7, 8], "thompson": [1, 4], "threaten": 4, "three": [1, 2, 7, 8, 9], "through": [1, 2, 3, 5, 7, 8], "throughout": 2, "tight_layout": 1, "time": 1, "titl": [1, 2, 7, 8], "tmp": [1, 7, 8], "tmpl": [7, 8], "to_writ": [7, 8], "took": 6, "tool": [1, 6], "torward": 1, "tostr": [7, 8, 9], "total": [1, 7, 8], "totempl": [7, 8], "toward": 4, "traceback": [7, 8], "trajectori": 2, "transfer": [0, 1, 2, 6, 7, 8], "transport": [7, 8], "troll": 4, "troubl": 2, "true": [1, 2, 7, 8], "try": [1, 2], "tupl": 1, "turmon": 1, "turner": 6, "tutori": [5, 7, 8, 9], "two": [1, 7, 8], "txt": [1, 7, 8, 9], "type": [1, 2, 7, 8], "typic": 1, "u": [2, 9], "unaccept": 4, "unavail": [7, 8], "unc": 2, "uncert": 1, "uncert_im": 1, "uncert_path": 1, "uncertainti": [1, 2, 7, 8], "uncertan": 0, "under": [2, 5], "understand": 9, "uniqu": [7, 8], "unit": [7, 8], "unknown": [7, 8], "unpack": [2, 7, 8, 9], "unus": 1, "unwelcom": 4, "unzip": [7, 8], "up": [1, 2, 7, 8, 9], "updat": [7, 8], "upp": [7, 8, 9], "us": [1, 2, 4, 5, 7, 8, 9], "usa": 6, "usag": 1, "user": [0, 1, 2, 7, 8, 9], "uss": [], "utc": 1, "util": [0, 1, 6, 7, 8], "v": [7, 8, 9], "v2": 0, "valid": [1, 2], "valu": [1, 7, 8], "valueerror": [7, 8], "vapor": [1, 7, 8], "var": 2, "vari": 1, "variabl": [1, 2, 7, 8, 9], "variat": 1, "variou": [0, 5, 6], "ve": [1, 7, 8], "vector": [0, 1, 2, 7, 8], "veg": [7, 8, 9], "veri": 1, "version": 4, "via": [1, 2, 3, 4], "viewabl": 5, "viridis_r": 2, "visibl": 6, "visual": 1, "vmax": [1, 2], "vmin": [1, 2], "w": 1, "wa": [6, 7, 8], "wai": 1, "walk": [7, 8], "warn": [2, 7, 8, 9], "water": 1, "wavelength": [1, 2, 7, 8, 9], "wavelength_fil": [2, 7, 8, 9], "wavelength_path": [1, 7, 8], "we": [1, 2, 4, 5, 7, 8, 9], "welcom": 4, "well": [7, 8], "wettergreen": 1, "wg": [1, 2], "what": [4, 7, 8, 9], "when": [1, 2, 4], "where": [2, 4, 7, 8, 9], "which": [1, 2, 4, 5, 7, 8], "while": 2, "white": 2, "whitetarp": [7, 8, 9], "who": 4, "wide": 0, "width": 2, "wiki": 4, "window": [1, 7, 8], "winidx": 2, "within": [1, 4], "without": [1, 4, 7, 8], "wl": [1, 2, 7, 8], "wl_nan": [7, 8], "woodi": 6, "work": [1, 4, 7, 8], "worker": [7, 8], "working_directori": [1, 7, 8], "would": [7, 8], "wrapper": 2, "writabl": [7, 8], "write": [1, 7, 8], "write_spectrum": [7, 8], "written": [0, 5, 7, 8], "wv": [7, 8], "www": 4, "x": [1, 2, 7, 8, 9], "x0": 2, "x_alg": [7, 8, 9], "x_instrument": [2, 7, 8, 9], "x_rt": [2, 7, 8, 9], "x_surfac": [2, 7, 8, 9], "xa": 2, "y": [7, 8, 9], "you": [5, 7, 8], "your": [5, 7, 8], "zenith": [1, 2, 7, 8], "zero": [7, 8], "zip": [7, 8]}, "titles": ["About", "Apply OE", "Internal Functions", "ISOFIT tutorials", "Code of Conduct", "Contributing", "Project Support", "NEON", "NEON", "Setup"], "titleterms": {"The": 1, "about": 0, "analyt": 1, "appli": [1, 7, 8], "atmospher": 2, "class": 2, "code": 4, "conduct": 4, "config": 2, "constrain": 2, "content": 3, "contribut": 5, "do": 1, "exampl": [3, 7], "featur": 0, "file": [7, 8], "full": 7, "function": 2, "gener": [7, 8], "how": 1, "i": 1, "imag": 7, "inform": 3, "intern": 2, "invers": 2, "isofit": [2, 3], "line": 1, "loc": [7, 8], "neon": [7, 8], "oe": [1, 2, 7, 8], "overview": 0, "per": [7, 8, 9], "pixel": [7, 8, 9], "project": 6, "retriev": [7, 8, 9], "run": [1, 3, 9], "sensor": 3, "setup": [7, 8, 9], "support": 6, "tabl": 3, "tutori": 3, "what": 1, "you": 1}}) \ No newline at end of file diff --git a/isofit-tutorials/build/html/sensor_examples/neon.html b/isofit-tutorials/build/html/sensor_examples/neon.html new file mode 100644 index 0000000..016149d --- /dev/null +++ b/isofit-tutorials/build/html/sensor_examples/neon.html @@ -0,0 +1,1633 @@ + + + + + + + NEON — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

NEON

+

Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.

+
+

Full image example

+

This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.

+

Prerequisites:

+
    +

  • Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the ‘data’ folder which includes the ‘subsets’ directory.

    • +

  • Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)

    • +
+
+
[1]:
+
+
+
import logging
+import os
+from pathlib import Path
+from types import SimpleNamespace
+
+import matplotlib.pyplot as plt
+import numpy as np
+import scipy
+from spectral.io import envi
+
+import isofit
+from isofit.utils.apply_oe import apply_oe
+from isofit.utils.surface_model import surface_model
+from isofit import ray
+ray.shutdown()
+
+
+
+
+

Setup

+

ISOFIT needs at minimum three pieces as input:

+
1. Radiance measurements (rdn)
+2. Observation values    (obs)
+3. Location information  (loc)
+
+
+

This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can ‘fake’ the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:

+
Radiance
+├── 173647
+│   ├── NIS01_20210403_173647_obs_ort
+│   ├── NIS01_20210403_173647_obs_ort.hdr
+│   ├── NIS01_20210403_173647_rdn_ort
+│   └── NIS01_20210403_173647_rdn_ort.hdr
+└── 174150
+    ├── NIS01_20210403_174150_obs_ort
+    ├── NIS01_20210403_174150_obs_ort.hdr
+    ├── NIS01_20210403_174150_rdn_ort
+    └── NIS01_20210403_174150_rdn_ort.hdr
+
+
+

These files have corresponding in situ data as well, and below we’ve encoded the locations of each, which we can use to help subset data files.

+
+
[19]:
+
+
+
# Enable the ISOFIT logger
+logging.getLogger().setLevel(logging.INFO)
+
+# Find where we're running the tutorial from
+home = os.path.abspath(os.getcwd())
+
+# Path to the input NEON data
+subset_dir = str(Path('~/.isofit/neon_subset').expanduser())
+print(f'Data subset directory at: {subset_dir}')
+
+# Path to write isofit output
+output = str(Path('~/.isofit/neon_subset/output').expanduser())
+if os.path.isdir(output) is False:
+    os.mkdir(output)
+
+if os.path.isdir(subset_dir) is False:
+    os.mkdir(subset_dir)
+
+surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())
+print(f'Surface model at: {surface_model_path}')
+neon_id = '173647'
+
+
+# Optionally set some environment variables as needed
+#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'
+#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'
+
+print(f'sRTMnet emulator path (required): {os.environ["EMULATOR_PATH"]}')
+print(f'6s path (required): {os.environ["SIXS_DIR"]}')
+
+%matplotlib inline
+
+
+
+
+
+
+
+
+Data subset directory at: /Users/bgreenbe/.isofit/neon_subset
+Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json
+sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5
+6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs
+
+
+
+
[3]:
+
+
+
# Extract the image locations of each point of interest (POI)
+# These are defined in the NEON report as pixel locations, so we round here to convert to indices
+report = {}
+report['173647'] = {           # Upp L Y  | Low R Y  | Upp L X | Low R X
+    'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),
+    'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),
+    'Veg'      : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),
+    'RoadEW'   : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),
+    'RoadNS'   : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)
+}
+report['174150'] = {           # Upp L Y | Low R Y | Upp L X  | Low R X
+    'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),
+    'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),
+    'Veg'      : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),
+    'RoadEW'   : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),
+    'RoadNS'   : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)
+}
+# Converts numpy array to comma-separated string for ISOFIT
+toString = lambda array: ', '.join(str(v) for v in array)
+
+
+
+
+
[4]:
+
+
+
# Which NEON date to process - change this to process a different date
+neon_id = list(report.keys())[0]
+
+# Select the locations from the neon id -- roi == Regions of Interest
+roi = report[neon_id]
+
+
+
+
+

Loc file generation

+

NEON doesn’t distribute (?) a loc file, so let’s fake one for now. We’ll do this for the full file and for the subset.

+
+
[5]:
+
+
+
def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):
+    """
+    Retrieves the metadata from an envi header
+
+    Parameters
+    ----------
+    rdn: str
+        Path to the RDN header file containing metadata
+    remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']
+        Removes keys from the metadata dictionary
+    """
+    rdn_ds   = envi.open(file)
+    metadata = rdn_ds.metadata.copy()
+    for key in remove:
+        if key in metadata:
+            del metadata[key]
+        else:
+            print(f'Key {key!r} not found in the metadata, skipping')
+
+    return metadata
+
+def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):
+    """
+    Creates a fake LOC file
+
+    Parameters
+    ----------
+    rdn: str
+        Path to the RDN header file containing metadata
+    lon: float
+        Longitude value for location
+    lat: float
+        Latitude value for location
+    elv: float
+        Elevation in kilometers
+    output: str, default=None
+        Path to write the LOC file to. If None, will attempt to replace the
+        substring 'rdn' in the `rdn` path with `loc`
+    **kwargs
+        Additional arguments passed to getMetadata()
+    """
+    if not output:
+        if 'rdn' in rdn:
+            output = rdn.replace('rdn', 'loc')
+        else:
+            Logger.error('No ouput file specified and cannot generate a unique name')
+            return False
+
+    metadata = getMetadata(rdn, **kwargs)
+    metadata['bands'] = 3
+
+    ds  = envi.create_image(output, metadata, ext='', force=True)
+    loc = ds.open_memmap(interleave='bip', writable=True)
+
+    loc[..., 0] = lon
+    loc[..., 1] = lat
+    loc[..., 2] = elv
+
+    del ds, loc
+
+def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):
+    """
+    Creates a fake OBS file
+
+    Parameters
+    ----------
+    rdn: str
+        Path to the RDN file containing metadata
+    param0: int, float, default=0
+        Parameter 0
+    sea: int, float, default=0
+        Solar Azimuth
+    sez: int, float, default=0
+        Sensor Zenith
+    soa: int, float, default=0
+        Solar Azimuth
+    soz: int, float, default=0
+        Solar Zenith
+    phase: int, float, default=0
+        Phase
+    slope: int, float, default=0
+        Slope
+    aspect: int, float, default=0
+        Aspect
+    cosi: int, float, default=0
+        COS(i)
+    param9: int, float, default=0
+        Parameter 9
+    param10: int, float, default=0
+        Parameter 10
+    output: str, default=None
+        Path to write the OBS file to. If None, will attempt to replace the
+        substring 'rdn' in the `rdn` path with `obs`
+    **kwargs
+        Additional arguments passed to getMetadata()
+    """
+    if not output:
+        if 'rdn' in rdn:
+            output = rdn.replace('rdn', 'loc')
+        else:
+            print('No ouput file specified and cannot generate a unique name')
+            return False
+
+    rdn_ds   = envi.open(rdn)
+    metadata = getMetadata(rdn, **kwargs)
+    metadata['bands'] = 11
+
+    ds  = envi.create_image(output, metadata, ext='', force=True)
+    obs = ds.open_memmap(interleave='bip', writable=True)
+
+    obs[...,  0] = param0
+    obs[...,  1] = sea
+    obs[...,  2] = sez
+    obs[...,  3] = soa
+    obs[...,  4] = soz
+    obs[...,  5] = phase
+    obs[...,  6] = slope
+    obs[...,  7] = aspect
+    obs[...,  8] = cosi
+    obs[...,  9] = param9
+    obs[..., 10] = param10
+
+    del ds, obs
+
+
+
+
+
[6]:
+
+
+
fakeLOC(
+    rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),
+    lon = -105.237000,
+    lat = 40.125000,
+    elv = 1689.0
+)
+
+
+
+
+
+
+
+
+Key 'band names' not found in the metadata, skipping
+
+
+
+
+

Apply OE

+

The next part walks through running the ISOFIT utility script isofit/utils/apply_oe.py. This is the first step of executing ISOFIT and will generate a default configuration.

+
+
[7]:
+
+
+
output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())
+surface_model(**{
+    'config_path': surface_model_path,
+    'output_path': output_surface_file,
+    'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')
+})
+
+
+
+
+
+
+
+
+0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+
+
+
+
[9]:
+
+
+
kwargs = {
+        'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance
+        'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location
+        'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations
+        'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory
+        'sensor': 'neon',
+        "surface_path": output_surface_file, # Surface priors - often changes
+        'emulator_base': os.environ['EMULATOR_PATH'],
+        'n_cores': 4,
+        "wavelength_path": None,
+        "surface_category": "multicomponent_surface",
+        "rdn_factors_path": None, # RCC update used 'on the fly'
+        "channelized_uncertainty_path": None, # Channelized uncertainty - if you have an instrument model
+        "model_discrepancy_path": None, # Model discrepancy term - handle things like unknown radiative transfer model effects
+        "lut_config_file": None,
+        "logging_level": "INFO",
+        "log_file": None,
+        "presolve": True, # Attempts to solve for the right wv range
+        "analytical_line": True, # mathematical representation of OE given that the atmsophere is known
+        "ray_temp_dir": "/tmp/ray",
+        "segmentation_size": 10,
+        "num_neighbors": [5],
+        "atm_sigma": [0.5],
+        "pressure_elevation": False,
+}
+
+apply_oe(**kwargs)
+
+
+
+
+
+
+
+
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....
+INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647
+INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without
+INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns
+WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...
+2025-07-08 15:20:10,698 INFO worker.py:1917 -- Started a local Ray instance.
+(segment_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: starting
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn
+2025-07-08 15:20:11,728 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs
+(segment_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: completing
+2025-07-08 15:20:11,781 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+(extract_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: starting
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc
+2025-07-08 15:20:11,825 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2  0.84 1.49 2.13 2.77 3.42 4.06 4.7  5.35 5.99]
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.
+INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess
+INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json
+INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues
+INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.
+(extract_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: starting
+2025-07-08 15:20:11,882 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs
+(extract_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: starting
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions
+INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration
+INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file
+INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions
+INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations
+(streamSimulation pid=17119) INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini
+INFO:2025-07-08,15:20:14 || common.py:__call__() |  20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)
+INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:14 || common.py:__call__() |  30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)
+INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:14 || common.py:__call__() |  40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)
+INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:14 || common.py:__call__() |  50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)
+INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:15 || common.py:__call__() |  60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)
+INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:15 || common.py:__call__() |  70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)
+INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:15 || common.py:__call__() |  80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)
+INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:15 || common.py:__call__() |  90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)
+INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)
+INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions
+INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl
+INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size
+INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator
+INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc
+INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations
+(streamSimulation pid=17119) INFO:2025-07-08,15:20:18 ||| Loading LUT into memory
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+(streamSimulation pid=17119) INFO:2025-07-08,15:20:18 ||| Loading LUT into memory
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions
+INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores
+WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
+I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:"2025-07-08T15:20:19.280425-07:00", file_line:1171, file:"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc"}
+(Worker pid=17157) INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete
+(Worker pid=17157) INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11
+(Worker pid=17158) INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)
+(Worker pid=17159) INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10 [repeated 8x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete [repeated 8x across cluster]
+(Worker pid=17157) INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10 [repeated 8x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete [repeated 8x across cluster]
+(Worker pid=17159) INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11 [repeated 8x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete [repeated 8x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11 [repeated 7x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete [repeated 4x across cluster]
+(Worker pid=17160) INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11 [repeated 5x across cluster]
+INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete.  34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.
+INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology
+INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded.  Aerosol State Vector:
+{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}
+Aerosol LUT Grid:
+{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}
+Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt
+INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT
+INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json
+INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues
+INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.
+2025-07-08 15:20:53,541 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions
+INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration
+INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations
+INFO:2025-07-08,15:20:59 || common.py:__call__() |  10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)
+INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:03 || common.py:__call__() |  20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)
+INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:08 || common.py:__call__() |  30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)
+INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:13 || common.py:__call__() |  40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)
+INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:17 || common.py:__call__() |  50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)
+INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:21 || common.py:__call__() |  60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)
+INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:27 || common.py:__call__() |  70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)
+INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:31 || common.py:__call__() |  80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)
+INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:35 || common.py:__call__() |  90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)
+INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)
+INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions
+INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl
+INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size
+INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator
+INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc
+INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl
+INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations
+INFO:2025-07-08,15:21:43 || common.py:__call__() |  10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)
+INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || common.py:__call__() |  70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || common.py:__call__() |  80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || common.py:__call__() |  90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions
+INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores
+I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc", file_line:1171, created_time:"2025-07-08T15:21:46.660474-07:00", http2_error:2, grpc_status:14}
+I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:"2025-07-08T15:21:46.660733-07:00", file_line:1171, file:"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc"}
+(Worker pid=17536) ERROR:2025-07-08,15:21:47 |||
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (32,0).
+(Worker pid=17536)                     Results for this pixel will be all zeros.
+(Worker pid=17536)
+(Worker pid=17536) Traceback (most recent call last):
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv)
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv)
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic(
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2)
+(Worker pid=17536) INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete [repeated 4x across cluster]
+(Worker pid=17159) INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17538) ERROR:2025-07-08,15:21:52 |||  [repeated 27x across cluster]
+(Worker pid=17538)                     Encountered the following ValueError in (row,col) (27,0). [repeated 27x across cluster]
+(Worker pid=17538)                     Results for this pixel will be all zeros. [repeated 27x across cluster]
+(Worker pid=17538) Traceback (most recent call last): [repeated 27x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 27x across cluster]
+(Worker pid=17538)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 27x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 27x across cluster]
+(Worker pid=17538)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 27x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 27x across cluster]
+(Worker pid=17538)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 27x across cluster]
+(Worker pid=17538) ValueError: not enough values to unpack (expected 3, got 2) [repeated 27x across cluster]
+(Worker pid=17538) INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete [repeated 3x across cluster]
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17535) INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:21:58 |||  [repeated 25x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (55,0). [repeated 25x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17538) INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete [repeated 4x across cluster]
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538) INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11 [repeated 3x across cluster]
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:22:03 |||  [repeated 25x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (61,0). [repeated 25x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17535) INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17538) INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11 [repeated 4x across cluster]
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:22:08 |||  [repeated 24x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (99,0). [repeated 24x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 24x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 24x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 24x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 24x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 24x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 24x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17536) INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete [repeated 3x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17535) INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:22:13 |||  [repeated 24x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (105,0). [repeated 24x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 24x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 24x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 24x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 24x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 24x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 24x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535) INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536) INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11 [repeated 3x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17536) ERROR:2025-07-08,15:22:18 |||  [repeated 27x across cluster]
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (166,0). [repeated 27x across cluster]
+(Worker pid=17536)                     Results for this pixel will be all zeros. [repeated 27x across cluster]
+(Worker pid=17536) Traceback (most recent call last): [repeated 27x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 27x across cluster]
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 27x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 27x across cluster]
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 27x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 27x across cluster]
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 27x across cluster]
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2) [repeated 27x across cluster]
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17536) INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535) INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17538) INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17536) ERROR:2025-07-08,15:22:23 |||  [repeated 25x across cluster]
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (193,0). [repeated 25x across cluster]
+(Worker pid=17536)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17536) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537) INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete [repeated 4x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:22:28 |||  [repeated 26x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (210,0). [repeated 26x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 26x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 26x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 26x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 26x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 26x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 26x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 26x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 26x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 26x across cluster]
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535) INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete
+(Worker pid=17538)
+(Worker pid=17538) INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11 [repeated 4x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17538) ERROR:2025-07-08,15:22:33 |||  [repeated 25x across cluster]
+(Worker pid=17538)                     Encountered the following ValueError in (row,col) (230,0). [repeated 25x across cluster]
+(Worker pid=17538)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17538) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17538)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17538)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17538)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17538) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete [repeated 2x across cluster]
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17538) INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17535) INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17535) ERROR:2025-07-08,15:22:39 |||  [repeated 26x across cluster]
+(Worker pid=17535)                     Encountered the following ValueError in (row,col) (269,0). [repeated 26x across cluster]
+(Worker pid=17535)                     Results for this pixel will be all zeros. [repeated 26x across cluster]
+(Worker pid=17535) Traceback (most recent call last): [repeated 26x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 26x across cluster]
+(Worker pid=17535)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 26x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 26x across cluster]
+(Worker pid=17535)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 26x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 26x across cluster]
+(Worker pid=17535)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 26x across cluster]
+(Worker pid=17535) ValueError: not enough values to unpack (expected 3, got 2) [repeated 26x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535) INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17537) INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17535) ERROR:2025-07-08,15:22:44 |||  [repeated 24x across cluster]
+(Worker pid=17535)                     Encountered the following ValueError in (row,col) (275,0). [repeated 24x across cluster]
+(Worker pid=17535)                     Results for this pixel will be all zeros. [repeated 24x across cluster]
+(Worker pid=17535) Traceback (most recent call last): [repeated 24x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 24x across cluster]
+(Worker pid=17535)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 24x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 24x across cluster]
+(Worker pid=17535)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 24x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 24x across cluster]
+(Worker pid=17535)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 24x across cluster]
+(Worker pid=17535) ValueError: not enough values to unpack (expected 3, got 2) [repeated 24x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17535) INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17538) ERROR:2025-07-08,15:22:49 |||  [repeated 26x across cluster]
+(Worker pid=17538)                     Encountered the following ValueError in (row,col) (303,0). [repeated 26x across cluster]
+(Worker pid=17538)                     Results for this pixel will be all zeros. [repeated 26x across cluster]
+(Worker pid=17538) Traceback (most recent call last): [repeated 26x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 26x across cluster]
+(Worker pid=17538)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 26x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 26x across cluster]
+(Worker pid=17538)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 26x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 26x across cluster]
+(Worker pid=17538)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 26x across cluster]
+(Worker pid=17538) ValueError: not enough values to unpack (expected 3, got 2) [repeated 26x across cluster]
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536) INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete [repeated 3x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17537) INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17535) ERROR:2025-07-08,15:22:55 |||  [repeated 25x across cluster]
+(Worker pid=17535)                     Encountered the following ValueError in (row,col) (320,0). [repeated 25x across cluster]
+(Worker pid=17535)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17535) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17535)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17535)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17535)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17535) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17538) INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536) INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10 [repeated 3x across cluster]
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:23:00 |||  [repeated 25x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (376,0). [repeated 25x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537) INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete [repeated 3x across cluster]
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:23:05 |||  [repeated 25x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (383,0). [repeated 25x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17538)
+(Worker pid=17538) INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535) INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17536) ERROR:2025-07-08,15:23:10 |||  [repeated 21x across cluster]
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (412,0). [repeated 21x across cluster]
+(Worker pid=17536)                     Results for this pixel will be all zeros. [repeated 21x across cluster]
+(Worker pid=17536) Traceback (most recent call last): [repeated 21x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 21x across cluster]
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 21x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 21x across cluster]
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 21x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 21x across cluster]
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 21x across cluster]
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2) [repeated 21x across cluster]
+(Worker pid=17537) INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11 [repeated 3x across cluster]
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536) INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete.  91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core
+INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference
+INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json
+INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt
+INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided
+INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory
+(Worker pid=17536)
+(Worker pid=17536) ERROR:2025-07-08,15:23:16 |||  [repeated 19x across cluster]
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (419,0). [repeated 19x across cluster]
+(Worker pid=17536)                     Results for this pixel will be all zeros. [repeated 19x across cluster]
+(Worker pid=17536) Traceback (most recent call last): [repeated 19x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 19x across cluster]
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 19x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 19x across cluster]
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 19x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 19x across cluster]
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 19x across cluster]
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2) [repeated 19x across cluster]
+(Worker pid=17536) INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11 [repeated 3x across cluster]
+WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file
+2025-07-08 15:23:17,031 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores
+INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete.  1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core
+2025-07-08 15:23:18,445 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+(Worker pid=17655) INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4
+(Worker pid=17655) INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58 [repeated 8x across cluster]
+INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete.  51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core
+INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.
+(Worker pid=17657) INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60 [repeated 5x across cluster]
+I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:"2025-07-08T15:24:10.613957-07:00", file_line:1171, file:"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc"}
+
+
+
+
[15]:
+
+
+
from spectral.io import envi
+import matplotlib.pyplot as plt
+for _key, key in enumerate(report.keys()):
+  if _key < 1:
+
+    rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))
+    rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()
+    wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])
+
+    miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5
+    maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5
+    minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5
+    maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5
+
+    plt.figure()
+    plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))
+    plt.title(f'NIS01_20210403_{key}')
+    for k,i in report[key].items():
+        plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)
+
+    for k,i in report[key].items():
+        plt.figure()
+        in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())
+        in_situ = np.genfromtxt(in_situ_path, skip_header=3)
+        plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')
+        mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))
+        plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')
+        plt.legend()
+
+
+
+
+
+
+
+../_images/sensor_examples_neon_13_0.png +
+
+
+
+
+
+../_images/sensor_examples_neon_13_1.png +
+
+
+
+
+
+../_images/sensor_examples_neon_13_2.png +
+
+
+
+
+
+../_images/sensor_examples_neon_13_3.png +
+
+
+
+
+
+../_images/sensor_examples_neon_13_4.png +
+
+
+
+
+
+../_images/sensor_examples_neon_13_5.png +
+
+
+
+
+
+

Per-Pixel Retrievals

+

This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).

+

To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:

+
    +

  1. The ForwardModel object

    2. +

  2. The IO object

    3. +

  3. The Inverse object

    4. +
+

There is also an Isofit object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe).

+
+
[16]:
+
+
+
from isofit.core.isofit import Isofit
+from isofit.core.fileio import IO
+from isofit.core.forward import ForwardModel
+from isofit.inversion.inverse import Inversion
+from isofit.inversion.inverse_simple import invert_algebraic
+from isofit.configs import configs
+from isofit.core.geometry import Geometry
+
+import os
+import logging
+import numpy as np
+from spectral.io import envi
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+# Enable the ISOFIT logger
+logging.getLogger().setLevel(logging.INFO)
+
+
+
+
+
[22]:
+
+
+
# Now run actual retrievals
+config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))
+config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())
+
+#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))
+config.input.measured_radiance_file =  os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')
+config.input.obs_file =  os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')
+config.input.loc_file =  os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')
+
+fm = ForwardModel(config)
+io = IO(config, fm)
+inv = Inversion(config, fm)
+
+
+
+
+
+
+
+
+INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json
+INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt
+INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided
+INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file
+
+
+
+
[24]:
+
+
+
region = 'Veg'
+offsets = {}
+miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5
+maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5
+minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5
+maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5
+offsets[neon_id] = [minx,miny]
+adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]
+
+rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))
+obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))
+loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))
+
+geom = Geometry(obs=obs,loc=loc)
+states = inv.invert(rdn, geom)
+
+x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])
+
+x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument,
+                           x_surface, x_RT, x_instrument,
+                           rdn, geom,
+                           )
+
+
+
+
+
+
+
+
+WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line
+
+
+
+
[25]:
+
+
+
def closest_wl(mv):
+    return np.argmin(np.abs(io.meas_wl-mv))
+
+wl_nan = io.meas_wl.copy()
+wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan
+wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan
+
+fig = plt.figure(figsize=(14,5))
+print(states.shape)
+offset = 0
+for n in range(0,states.shape[0],4):
+    lab = f'Step {n}'
+    if n == 0:
+        lab = 'Algebraic inversion at initial guess'
+
+    plt.plot(wl_nan, states[n,:-2] + offset, label=lab)
+    offset += 0.04
+plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')
+plt.legend()
+
+print(states[-1,-2:])
+
+
+
+
+
+
+
+
+(13, 428)
+[0.10742364 0.60519719]
+
+
+
+
+
+
+../_images/sensor_examples_neon_18_1.png +
+
+
+
[ ]:
+
+
+

+
+
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/sensor_examples/neon.ipynb b/isofit-tutorials/build/html/sensor_examples/neon.ipynb new file mode 100644 index 0000000..516534f --- /dev/null +++ b/isofit-tutorials/build/html/sensor_examples/neon.ipynb @@ -0,0 +1,1610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "35412b86-171d-473c-8575-470b8fbed89d", + "metadata": {}, + "source": [ + "# NEON\n", + "\n", + "Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f81e3c4a-0bef-4cbe-a494-75c8e0d908ca", + "metadata": {}, + "source": [ + "## Full image example\n", + "\n", + "This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.\n", + "\n", + "Prerequisites:\n", + "- Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the 'data' folder which includes the 'subsets' directory.\n", + "- Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed8d9de0-a74a-4e6c-83b2-54f7bc32f593", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "from pathlib import Path\n", + "from types import SimpleNamespace\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "from spectral.io import envi\n", + "\n", + "import isofit\n", + "from isofit.utils.apply_oe import apply_oe \n", + "from isofit.utils.surface_model import surface_model\n", + "from isofit import ray\n", + "ray.shutdown()\n" + ] + }, + { + "cell_type": "markdown", + "id": "164060bf-3cad-4d58-811f-838158d7d967", + "metadata": {}, + "source": [ + "### Setup\n", + "\n", + "ISOFIT needs at minimum three pieces as input:\n", + "\n", + " 1. Radiance measurements (rdn)\n", + " 2. Observation values (obs)\n", + " 3. Location information (loc)\n", + "\n", + "This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can 'fake' the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:\n", + "\n", + "```\n", + "Radiance\n", + "├── 173647\n", + "│ ├── NIS01_20210403_173647_obs_ort\n", + "│ ├── NIS01_20210403_173647_obs_ort.hdr\n", + "│ ├── NIS01_20210403_173647_rdn_ort\n", + "│ └── NIS01_20210403_173647_rdn_ort.hdr\n", + "└── 174150\n", + " ├── NIS01_20210403_174150_obs_ort\n", + " ├── NIS01_20210403_174150_obs_ort.hdr\n", + " ├── NIS01_20210403_174150_rdn_ort\n", + " └── NIS01_20210403_174150_rdn_ort.hdr\n", + "```\n", + "\n", + "These files have corresponding in situ data as well, and below we've encoded the locations of each, which we can use to help subset data files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7b88339c-ac36-4aab-98b7-2a1dd07ab8a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data subset directory at: /Users/bgreenbe/.isofit/neon_subset\n", + "Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json\n", + "sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5\n", + "6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs\n" + ] + } + ], + "source": [ + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "\n", + "# Path to the input NEON data\n", + "subset_dir = str(Path('~/.isofit/neon_subset').expanduser())\n", + "print(f'Data subset directory at: {subset_dir}')\n", + "\n", + "# Path to write isofit output\n", + "output = str(Path('~/.isofit/neon_subset/output').expanduser())\n", + "if os.path.isdir(output) is False:\n", + " os.mkdir(output)\n", + "\n", + "if os.path.isdir(subset_dir) is False:\n", + " os.mkdir(subset_dir)\n", + "\n", + "surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())\n", + "print(f'Surface model at: {surface_model_path}')\n", + "neon_id = '173647'\n", + "\n", + "\n", + "# Optionally set some environment variables as needed\n", + "#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'\n", + "#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'\n", + "\n", + "print(f'sRTMnet emulator path (required): {os.environ[\"EMULATOR_PATH\"]}')\n", + "print(f'6s path (required): {os.environ[\"SIXS_DIR\"]}')\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "727dcd06-2a38-4020-8a15-b6707b8ed453", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a5656147-509e-41f4-9cac-c9b81117c5b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Which NEON date to process - change this to process a different date\n", + "neon_id = list(report.keys())[0]\n", + "\n", + "# Select the locations from the neon id -- roi == Regions of Interest\n", + "roi = report[neon_id]" + ] + }, + { + "cell_type": "markdown", + "id": "e9ec9046-3c9d-47bf-914c-68e67424065f", + "metadata": {}, + "source": [ + "#### Loc file generation\n", + "\n", + "NEON doesn't distribute (?) a loc file, so let's fake one for now. We'll do this for the full file and for the subset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5b51ea6-f2ba-4348-9ec9-4a3eadd6c1c0", + "metadata": {}, + "outputs": [], + "source": [ + "def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):\n", + " \"\"\"\n", + " Retrieves the metadata from an envi header\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']\n", + " Removes keys from the metadata dictionary\n", + " \"\"\"\n", + " rdn_ds = envi.open(file)\n", + " metadata = rdn_ds.metadata.copy()\n", + " for key in remove:\n", + " if key in metadata:\n", + " del metadata[key]\n", + " else:\n", + " print(f'Key {key!r} not found in the metadata, skipping')\n", + "\n", + " return metadata\n", + "\n", + "def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake LOC file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " lon: float\n", + " Longitude value for location\n", + " lat: float\n", + " Latitude value for location\n", + " elv: float\n", + " Elevation in kilometers\n", + " output: str, default=None\n", + " Path to write the LOC file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `loc`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " Logger.error('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 3\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " loc = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " loc[..., 0] = lon\n", + " loc[..., 1] = lat\n", + " loc[..., 2] = elv\n", + "\n", + " del ds, loc\n", + "\n", + "def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake OBS file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN file containing metadata\n", + " param0: int, float, default=0\n", + " Parameter 0\n", + " sea: int, float, default=0\n", + " Solar Azimuth\n", + " sez: int, float, default=0\n", + " Sensor Zenith\n", + " soa: int, float, default=0\n", + " Solar Azimuth\n", + " soz: int, float, default=0\n", + " Solar Zenith\n", + " phase: int, float, default=0\n", + " Phase\n", + " slope: int, float, default=0\n", + " Slope\n", + " aspect: int, float, default=0\n", + " Aspect\n", + " cosi: int, float, default=0\n", + " COS(i)\n", + " param9: int, float, default=0\n", + " Parameter 9\n", + " param10: int, float, default=0\n", + " Parameter 10\n", + " output: str, default=None\n", + " Path to write the OBS file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `obs`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " print('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " rdn_ds = envi.open(rdn)\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 11\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " obs = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " obs[..., 0] = param0\n", + " obs[..., 1] = sea\n", + " obs[..., 2] = sez\n", + " obs[..., 3] = soa\n", + " obs[..., 4] = soz\n", + " obs[..., 5] = phase\n", + " obs[..., 6] = slope\n", + " obs[..., 7] = aspect\n", + " obs[..., 8] = cosi\n", + " obs[..., 9] = param9\n", + " obs[..., 10] = param10\n", + "\n", + " del ds, obs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bac7ba6b-1c0e-41b7-97e0-d9e137a9e217", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key 'band names' not found in the metadata, skipping\n" + ] + } + ], + "source": [ + "fakeLOC(\n", + " rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),\n", + " lon = -105.237000,\n", + " lat = 40.125000,\n", + " elv = 1689.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "83bf8ace-3e19-4674-86df-d2f46e220a32", + "metadata": {}, + "source": [ + "#### Apply OE\n", + "\n", + "The next part walks through running the ISOFIT utility script `isofit/utils/apply_oe.py`. This is the first step of executing ISOFIT and will generate a default configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d0ec94f8-b1e7-4e4d-9b8f-450134ca5a83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n" + ] + } + ], + "source": [ + "output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "surface_model(**{\n", + " 'config_path': surface_model_path,\n", + " 'output_path': output_surface_file,\n", + " 'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3cbe6f39-6d6f-4182-abfb-30e95ce49ede", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns\n", + "WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...\n", + "2025-07-08 15:20:10,698\tINFO worker.py:1917 -- Started a local Ray instance.\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn\n", + "2025-07-08 15:20:11,728\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: completing\n", + "2025-07-08 15:20:11,781\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc\n", + "2025-07-08 15:20:11,825\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2 0.84 1.49 2.13 2.77 3.42 4.06 4.7 5.35 5.99]\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.\n", + "INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess\n", + "INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "2025-07-08 15:20:11,882\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:20:19.280425-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete\u001b[32m [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11\u001b[32m [repeated 7x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17160)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete. 34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded. Aerosol State Vector:\n", + "{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}\n", + "Aerosol LUT Grid:\n", + "{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}\n", + "Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt\n", + "INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT\n", + "INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "2025-07-08 15:20:53,541\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:20:59 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)\n", + "INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:03 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)\n", + "INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:08 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)\n", + "INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:13 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)\n", + "INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:17 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)\n", + "INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:21 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)\n", + "INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:27 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)\n", + "INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:31 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)\n", + "INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:35 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)\n", + "INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:21:43 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\", file_line:1171, created_time:\"2025-07-08T15:21:46.660474-07:00\", http2_error:2, grpc_status:14}\n", + "I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:21:46.660733-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:21:47 ||| \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (32,0).\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:21:52 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (27,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:21:58 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (55,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:03 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (61,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:08 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (99,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:13 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (105,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:18 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (166,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:23 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (193,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:28 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (210,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:33 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (230,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:39 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (269,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:44 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (275,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:49 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (303,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:55 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (320,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:00 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (376,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:05 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (383,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:10 ||| \u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (412,0).\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete. 91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core\n", + "INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference\n", + "INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:16 ||| \u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (419,0).\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n", + "2025-07-08 15:23:17,031\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores\n", + "INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete. 1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core\n", + "2025-07-08 15:23:18,445\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete. 51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core\n", + "INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.\n", + "\u001b[36m(Worker pid=17657)\u001b[0m INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:24:10.613957-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n" + ] + } + ], + "source": [ + "kwargs = {\n", + " 'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance\n", + " 'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location\n", + " 'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations\n", + " 'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory\n", + " 'sensor': 'neon', \n", + " \"surface_path\": output_surface_file, # Surface priors - often changes\n", + " 'emulator_base': os.environ['EMULATOR_PATH'],\n", + " 'n_cores': 4,\n", + " \"wavelength_path\": None,\n", + " \"surface_category\": \"multicomponent_surface\",\n", + " \"rdn_factors_path\": None, # RCC update used 'on the fly'\n", + " \"channelized_uncertainty_path\": None, # Channelized uncertainty - if you have an instrument model\n", + " \"model_discrepancy_path\": None, # Model discrepancy term - handle things like unknown radiative transfer model effects\n", + " \"lut_config_file\": None,\n", + " \"logging_level\": \"INFO\",\n", + " \"log_file\": None,\n", + " \"presolve\": True, # Attempts to solve for the right wv range\n", + " \"analytical_line\": True, # mathematical representation of OE given that the atmsophere is known\n", + " \"ray_temp_dir\": \"/tmp/ray\",\n", + " \"segmentation_size\": 10,\n", + " \"num_neighbors\": [5],\n", + " \"atm_sigma\": [0.5],\n", + " \"pressure_elevation\": False,\n", + "}\n", + "\n", + "apply_oe(**kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9d31291a-c036-4288-9114-cd772dda6748", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhx9JREFUeJzt3XlYVNUfx/H3gCxKirugoqK57+GG+5IolZppmgtqufzMJcnSXHOpXFNxSS03tMWw1DQ1FXMXXAOztHJNM0hxAVEBhfv74zIjwyYDw8wd+b6eZx5g5s6dM3MPnA/nnnuOTlEUBSGEEEIIDbOzdgGEEEIIIZ5GAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNC+ftQtgLklJSfz7778ULFgQnU5n7eIIIYQQIgsUReHevXuULl0aO7uM+1GemcDy77//4uHhYe1iCCGEECIbrl27RtmyZTN8/JkJLAULFgTUN1yoUCErl0YIIYQQWRETE4OHh4ehHc9ItgLL0qVLmTt3LhEREdSsWZOAgABatGjx1OcdOXKEVq1aUatWLcLDw40e27hxI5MnT+bixYtUqlSJTz75hK5du2a5TPrTQIUKFZLAIoQQQtiYpw3nMHnQbVBQEP7+/kycOJGwsDBatGiBr68vV69ezfR50dHR9OvXj3bt2qV5LDQ0lJ49e+Ln58fp06fx8/OjR48eHDt2zNTiCSGEEOIZpDN1tebGjRvzwgsvsGzZMsN91atX59VXX2XmzJkZPu+NN96gcuXK2Nvb88MPPxj1sPTs2ZOYmBh++uknw30dO3akSJEirF+/PkvliomJwdXVlejoaOlhEUIIIWxEVttvk3pYEhISOHXqFD4+Pkb3+/j4EBISkuHz1qxZw8WLF5kyZUq6j4eGhqbZZ4cOHTLdpxBCCCHyDpPGsERFRZGYmEipUqWM7i9VqhSRkZHpPuf8+fOMGzeOQ4cOkS9f+i8XGRlp0j4B4uPjiY+PN/wcExPz1PInJiby6NGjp24nRHbZ29uTL18+ubReCCHMLFuDblP/MVYUJd0/0ImJifTu3Ztp06ZRpUoVs+xTb+bMmUybNi3LZY6NjeWff/7BxDNgQpisQIECuLu74+joaO2iCCHEM8OkwFK8eHHs7e3T9HzcuHEjTQ8JwL179zh58iRhYWGMGDECUCd4UxSFfPnysXv3btq2bYubm1uW96k3fvx4Ro8ebfhZf1lUehITE/nnn38oUKAAJUqUkP9+Ra5QFIWEhARu3rzJ5cuXqVy5cqaTIAkhhMg6kwKLo6MjXl5eBAcHG11yHBwcTJcuXdJsX6hQIc6cOWN039KlS9m7dy/ff/89np6eAHh7exMcHMy7775r2G737t00bdo0w7I4OTnh5OSUpXI/evQIRVEoUaIE+fPnz9JzhMiO/Pnz4+DgwN9//01CQgLOzs7WLpIQQjwTTD4lNHr0aPz8/GjQoAHe3t588cUXXL16laFDhwJqz8f169dZt24ddnZ21KpVy+j5JUuWxNnZ2ej+UaNG0bJlS2bPnk2XLl3YsmULe/bs4fDhwzl8e8akZ0VYgvSqCCGE+ZkcWHr27MmtW7eYPn06ERER1KpVix07dlC+fHkAIiIinjonS2pNmzbl22+/ZdKkSUyePJlKlSoRFBRE48aNTS2eEEIIIZ5BJs/DolWZXccdFxfH5cuX8fT0lC56keukvgkhRNblyjws4tlUoUIFAgICrF0Ms7py5Qo6nS7NEhBCCCFskwQWDRswYACvvvpqjvZx//59PvjgAypWrIizszMlSpSgdevWbNu2zbDNiRMnGDJkiOFnnU7HDz/8kKPXBdi/fz86nc5wK1asGG3btuXIkSM53rep9AEmvdvRo0f5448/0Ol0aZaDaNy4MU5OTjx48MBwX0JCAgUKFOCLL76w9NsQQog865lZrVmkb+jQoRw/fpwlS5ZQo0YNbt26RUhICLdu3TJsU6JEiVwtw59//kmhQoW4efMmH3/8MS+//DJ//fUXJUuWzNXXTc+ePXuoWbOm0X3FihXDwcEBd3d39u3bZxg7FRsbS1hYGKVKlSIkJIQXX3wRgGPHjvHw4UPatGlj8fLbqq+//pqiRYvi6+tr7aIIIWxU3uxhURS4f986txwMGWrdujXvvPMOY8eOpWjRori5uTF16tRMn/Pjjz8yYcIEXnrpJSpUqICXlxcjR46kf//+hm1SnhKqUKECAF27dkWn0xl+Tq+3x9/fn9atWz+13CVLlsTNzY3atWszadIkoqOjjXoyDhw4QKNGjXBycsLd3Z1x48bx+PFjw+M7d+6kefPmFC5cmGLFivHKK69w8eJFo9c4fvw49evXx9nZmQYNGhAWFpZuWYoVK4abm5vRzcHBAVA/3/379xu2PXToEFWqVKFz585G9+/fv58yZcpQuXLlp753AZcvX6Zv37689NJL1i6KEMKG5c3A8uABPPecdW4pTi1kx9q1a3FxceHYsWPMmTOH6dOnExwcnOH2bm5u7Nixg3v37mVp/ydOnADU9Z8iIiIMP5vDgwcPWLNmDYAhJFy/fp2XXnqJhg0bcvr0aZYtW8aqVav4+OOPDc+7f/8+o0eP5sSJE/z888/Y2dnRtWtXkpKSDI+/8sorVK1alVOnTjF16lTef/99k8vXpk0bDh8+bAhL+/bto3Xr1rRq1Yp9+/YZttu3b5/0rpjg33//NWn7Xbt20bhxY3777bdcKpEQwhbJKSEbU6dOHcMikpUrV2bJkiX8/PPPtG/fPt3tv/jiC/r06UOxYsWoW7cuzZs3p3v37jRr1izd7fWnhwoXLoybm5tZyly2bFlADSyKouDl5UW7du0AdSJBDw8PlixZgk6no1q1avz777988MEHfPjhh9jZ2dGtWzej/a1atYqSJUty9uxZatWqxddff01iYiKrV6+mQIEC1KxZk3/++Ye33347TVmaNm2aZp6U6Oho7O3tad26Nffv3+fEiRN4e3uzf/9+xowZQ8uWLfHz8+PBgwfky5ePo0ePsmTJErN8NnmBqet3dezYEYAuXbqk6UkTQuRdeTOwFCgAsbHWe+0cqFOnjtHP7u7u3LhxI8PtW7ZsyaVLlzh69ChHjhxh7969LFy4kGnTpjF58uQclSWrDh06hIuLC2FhYXzwwQcEBgYaeljOnTuHt7e30aR+zZo1M6z9VK5cOS5evMjkyZM5evQoUVFRhp6Vq1evUqtWLc6dO0fdunUpkOKz9fb2TrcsQUFBVK9e3eg+e3t7QA2AZcuWZf/+/dSsWZOwsDBatWpFyZIl8fT05MiRIzg5OfHw4UPatm1r1s/oWZbdBUcjIiLMXBIhhC3Lm4FFpwMXF2uXIlv0Db2eTqczNOCZPadFixa0aNGCcePG8fHHHzN9+nQ++OCDLC/QZ2dnl2bhyKw2RJ6enhQuXJgqVaoQFxdH165d+e2333Byckp3kUv96+jv79SpEx4eHqxYsYLSpUuTlJRErVq1SEhIMNo+Kzw8PHj++eczfLx169bs27ePOnXqULlyZcPAYP1pIScnJ8qXL28Y2yOeLuV4JFPIyupCiJTy5hiWPK5GjRo8fvyYuLi4dB93cHAgMTHR6L4SJUqk+Y83O3Oc+Pn5kZSUxNKlSw1lCQkJMQodISEhFCxYkDJlynDr1i3OnTvHpEmTaNeuHdWrV+fOnTtp3s/p06d5+PCh4b6jR4+aXDZQx7GEhIQQHBxsNKC4VatW7N+/n/3790vviomyG1iy+zwhxLNJAsszrnXr1nz++eecOnWKK1eusGPHDiZMmECbNm0ynFGwQoUK/Pzzz0RGRhrCQdu2bTl58iTr1q3j/PnzTJkyJVuDIu3s7PD392fWrFk8ePCAYcOGce3aNUaOHMkff/zBli1bmDJlCqNHj8bOzo4iRYpQrFgxvvjiCy5cuMDevXuNVukG6N27N3Z2dgwcOJCzZ8+yY8cOPv3003Rf/9atW0RGRhrdUga3Nm3acP/+fVavXk2rVq0M97dq1YqTJ09y9OhRGXBrIgkeQghzkMDyjOvQoQNr167Fx8eH6tWrM3LkSDp06MCGDRsyfM68efMIDg7Gw8OD+vXrG/YzefJkxo4dS8OGDbl37x79+vXLVpneeustHj16xJIlSyhTpgw7duzg+PHj1K1bl6FDhzJw4EAmTZoEqAHn22+/5dSpU9SqVYt3332XuXPnGu3vueee48cff+Ts2bPUr1+fiRMnMnv27HRf+8UXX8Td3d3olnKSPE9PT8qXL8+9e/eMAkuZMmUoV64ccXFxElhMJKd2hBDmIGsJCWFmUt+MffPNN/Tp0wfI2nijlGOanpE/T0KITMhaQkIITUh5SkgCiBAiuySwCCFyVcpTQhJYhBDZJYFFCJGrpIdFCGEOEliEELnK1EG3qeflEUIIkMAihMhlpvawZHUyQyFE3iKBRQiRqySwCCHMQQKLECJXSWARQpiDBBYhRK6SwCKEMAcJLEKTBgwYwKuvvmrtYggzMHXQrZOTUy6VRAhhyySwaNiAAQPQ6XTodDry5ctHuXLlePvtt9Ms/peZK1euoNPpsrVQYevWrQ2v7+joSKVKlRg/fjzx8fEm7yunUn4WKW8dO3YE4I033sDX19foOT/99BM6nY7Jkycb3f/RRx9RunRpi5U9rzO1hyX1iuRCCAGQz9oFEJnr2LEja9as4fHjx5w9e5a33nqLu3fvsn79eou8/uDBg5k+fToJCQmcOHGCN998E4CZM2da5PVT0n8WKen/G2/Tpg3vv/8+jx8/Jl8+tVrv378fDw8P9u3bZ/Sc/fv3y3pAFmTqxHFySkgIkR7pYdE4Jycn3NzcKFu2LD4+PvTs2ZPdu3cbbbNmzRqqV6+Os7Mz1apVY+nSpYbHPD09Aahfvz46nY7WrVub9PoFChTAzc2NcuXK0a1bN9q3b2/0+vHx8bzzzjuULFkSZ2dnmjdvzokTJwyPJyYmMnDgQDw9PcmfPz9Vq1Zl4cKFRq+RmJjI6NGjKVy4MMWKFWPs2LHpNmz6zyLlrUiRIoAaWGJjYzl58qRh+/379zNu3DhOnDjBgwcPAEhISCA0NFQCiwXJGBYhhDnkyR4WRVEMDZilFShQINsTY126dImdO3cadZmvWLGCKVOmsGTJEurXr09YWBiDBw/GxcWF/v37c/z4cRo1asSePXuoWbNmjhqD06dPc+TIESpUqGC4b+zYsWzcuJG1a9dSvnx55syZQ4cOHbhw4QJFixYlKSmJsmXLsmHDBooXL05ISAhDhgzB3d2dHj16AOrq0KtXr2bVqlXUqFGDefPmsXnzZtq2bZvlslWpUoXSpUuzb98+mjRpwr179/jll1/Ytm0bS5Ys4ciRI7Rv356jR4/y8OFDCSwWJIFFCGEWyjMiOjpaAZTo6Og0jz18+FA5e/as8vDhQ0VRFCU2NlYBrHKLjY3N8nvq37+/Ym9vr7i4uCjOzs6GfcyfP9+wjYeHh/LNN98YPe+jjz5SvL29FUVRlMuXLyuAEhYWZvJn2qpVK8XBwUFxcXFRHB0dFUCxs7NTvv/+e8Pn6ODgoHz99deG5yQkJCilS5dW5syZk+F+hw0bpnTr1s3ws7u7uzJr1izDz48ePVLKli2rdOnSJd3PIuVt+vTphm169+6t+Pj4KIqiKNu3b1dq1KihKIqiDB06VJkwYYKiKIoybdo0xcPDw+TPwhSp61teN3ToUJPqf8uWLQ3bP3782AIlFEJYU2btd0p5sofFlrRp04Zly5bx4MEDVq5cyV9//cXIkSMBuHnzJteuXWPgwIEMHjzY8JzHjx/j6upqltfv06cPEydOJCYmhtmzZ1OoUCG6desGwMWLF3n06BHNmjUzbO/g4ECjRo04d+6c4b7ly5ezcuVK/v77bx4+fEhCQgL16tUDIDo6moiICLy9vQ3b58uXjwYNGqT5b1z/WaRUtGhRo8f9/f159OgR+/fvN5z+atWqFYsXLwbU00Sm9NyInMtJD0t8fDwFChTIlXIJIWxLngwsBQoUIDY21mqvbQoXFxeef/55ABYtWkSbNm2YNm0aH330EUlJSYB6Wqhx48ZGz7O3tzdLeV1dXQ2v/9VXX1GzZk1WrVrFwIEDDY1P6lNciqIY7tuwYQPvvvsu8+bNw9vbm4IFCzJ37lyOHTtmcllSfhbpadOmDffv3+fEiRPs27ePMWPGAGpg6devH7dv3yY0NJT+/fub/Noi+ySwCCHMIU8GFp1Oh4uLi7WLkS1TpkzB19eXt99+m9KlS1OmTBkuXbpEnz590t1e/8c/MTExx6/t4ODAhAkTGD9+PL169eL555/H0dGRw4cP07t3b0C9IuTkyZP4+/sDcOjQIZo2bcqwYcMM+7l48aLhe1dXV9zd3Tl69CgtW7YE1Abu1KlTvPDCCyaVr1KlSnh4eLB161bCw8Np1aoVAO7u7lSoUIF58+YRFxcn41cszNTAkjJsW+MSeiGENslVQjamdevW1KxZkxkzZgAwdepUZs6cycKFC/nrr784c+YMa9asYf78+QCULFmS/Pnzs3PnTv777z+io6MB2Lx5M9WqVTP59Xv37o1Op2Pp0qW4uLjw9ttvM2bMGHbu3MnZs2cZPHgwDx48YODAgQA8//zznDx5kl27dvHXX38xefJko6uIAEaNGsWsWbPYvHkzf/zxB8OGDePu3btpXjs+Pp7IyEijW1RUlNE2bdq0YenSpTz//POUKlXKcL/+tFDFihUpV66cye9bZJ+pgSUlCSwiyx48ADP8Yya0SwKLDRo9ejQrVqzg2rVrDBo0iJUrVxIYGEjt2rVp1aoVgYGBhsuZ8+XLx6JFi/j8888pXbo0Xbp0AdSxI3/++afJr+3o6MiIESOYM2cOsbGxzJo1i27duuHn58cLL7zAhQsX2LVrl+Fy46FDh/Laa6/Rs2dPGjduzK1bt4x6WwDee+89+vXrx4ABAwynjbp27ZrmtXfu3Im7u7vRrXnz5kbbtGnThnv37qW5fLtVq1bcu3dPeleswNSZblOGGgksIkO//w5Ll4KvL5QoAS4u4OEBAwbA/v3WLp3IBTrF1H95NComJgZXV1eio6MpVKiQ0WNxcXFcvnwZT09PnJ2drVRCkVdIfTPWpUsXtm7dCsCdO3coXLhwptu/8sorbN++HYBff/2V2rVr53YRha1ISoJt22D2bAgJyXzb114Db2+4dQtu34bISDh/Hnx8YMoUSP6nSlhfZu13StnqYVm6dKnhj7GXlxeHDh3KcNvDhw/TrFkzihUrRv78+alWrRoLFiww2iYwMDDdadfj4uKyUzwhhIaYekpIelhEGvHxsHo11KwJXbqoYcXODlq1gvHj4auvYNcuCAqCPn3UxzZtgjFjYNYs+OIL2LoVzp2DhQuhQgX46SdrvythIpMH3QYFBeHv78/SpUtp1qwZn3/+Ob6+vpw9ezbdsQEuLi6MGDGCOnXq4OLiwuHDh/nf//6Hi4sLQ4YMMWxXqFChNKco5L9TIWxfTgJLQkJCrpRJ2IizZ+Gtt+DECbV3BcDVFd5+G955B9zd0z6nRw/44AOYPx+uX1fve+45qFEDnJxg+XL491/o3h1CQ6FOHcu9H5EjJgeW+fPnM3DgQAYNGgRAQEAAu3btYtmyZemuL1O/fn3q169v+LlChQps2rSJQ4cOGQUWnU6Hm5tbdt6DEELDZNCtyJbjx+Hll0E/sL5MGXj3XRg8GDI5bQBA7dqQat0xg3Hj1P0GB6vf79hh3nKLXGPSKaGEhAROnTqFj4+P0f0+Pj6EPO18YrKwsDBCQkIMl5zqxcbGUr58ecqWLcsrr7xCWFhYpvuJj48nJibG6CaE0B4ZdCtMNn++Ov4kKgq8vODAAbh0Cd577+lh5WkcHGDZMrC3V08LhYaap8wi15kUWKKiokhMTDS6XBSgVKlSREZGZvrcsmXL4uTkRIMGDRg+fLihhwagWrVqBAYGsnXrVtavX4+zszPNmjXj/PnzGe5v5syZuLq6Gm4eHh6mvBUhhIXIGBZhkm3b1GCSlAQvvQQ//wwtW4I515iqVEm9mgjUAbjCJmRr0G1mM5tm5NChQ5w8eZLly5cTEBDA+vXrDY81adKEvn37UrduXVq0aMGGDRuoUqWKYTr19IwfP57o6GjD7dq1a08t9zNyQZTQOKlnxiSwWEBSEty8qQ4qvXEDbLUOLlkCnTur3w8fDtu3q2NWcsOkSWpvS3AwZGPmbWF5Jo1hKV68OPb29ml6U27cuJGm1yU1/bwgtWvX5r///mPq1Kn06tUr3W3t7Oxo2LBhpj0sTk5OODk5Zanc+pkzExISyJ8/f5aeI0R26VcCT7mqdl6W8pSQBJZsio+HX3+FP/5QB4xev65+1X8fEQEpT73VqAEzZz5p/G3BP/+oV/UoitqzMmdO7r5ehQrqFUWBgfDpp/Ddd7n7eiLHTAosjo6OeHl5ERwcbDSxV3BwsGFCsqxQFCXTP0SKohAeHm62+Rfy5ctHgQIFuHnzJg4ODtjZyXx5wvwUReHBgwfcuHGDwoULm209J1uX8kofGXSbjocP4b//1HlC/vvP+PvISLh6VQ0rWbliqlAhiIlRr67p0gXmzYPRo3P/PZjDhx9CXBw0b66eFnpKr71ZvP++Glg2bYKLF9VTRUKzTL5KaPTo0fj5+dGgQQO8vb354osvuHr1KkOHDgXUUzXXr19n3bp1AHz22WeUK1fOMA384cOH+fTTTw0rDgNMmzaNJk2aULlyZWJiYli0aBHh4eF89tln5niP6HQ63N3duXz5Mn///bdZ9ilERgoXLixXvKUgg25Rew3+/Rd++cX4dvOm2nuSFUWLQt266myupUurtzJlnnzv5qaO87hzRw0pgYHqWJB//lF7K/JpeOm4uXOfXNXz6aeWCSugzuvy0kvqlULz54OZ2hyRO0yuwT179uTWrVtMnz6diIgIatWqxY4dOyhfvjwAERERXL161bB9UlIS48eP5/Lly+TLl49KlSoxa9Ys/ve//xm2uXv3LkOGDCEyMhJXV1fq16/PwYMHadSokRneosrR0ZHKlSvLvA4iVzk4OEjPSip58pSQosCFC+qA0b174eBBtcckI05OUKqUGjpKlTL+3t0d6tcHT8+sNeRFiqiTrFWvrs5HsmABHDmiTlevxVPi9+7B5Mnq96+9BqlWns9177+vBpbAQDXY2ejCuHlBnpiaXwhhPWXLluV68gRe//77L+7pTfaVQrt27di7dy8Afn5+rF279qmD+jXhwQPYuVMdKBocDKkvBLCzU8eWvPCCeqtfH8qVg8KF1YGlufEev/wS+vVTv2/fXm2YtdbTsnatesVOsWLqgGFLn7JXFPVU0OXL8P330K2bZV9fZLn91ljNFUI8a3LSw/Lll1/SuHFjhg8fnitly7GkJDh0CNatUwdt3rv35DFHR3UukXbtoE0bNaQUKGDZ8vn5qaeSXnlFDVFdu8KWLZYPBRk5flydsRZg5EjrlEunU0PKp59KYNE4CSxCiFxlamBJ7ZdffgHUwbvz5s1DURR69+5NhQoVzFVE0/31l9p78eWXkHJcXIUK6mBXX19o0cLyASU9L7+sNsbjxqmDWZctUy8ZtravvlKn2I+NVedZef9965VFH1i2bVMH/sqyMJokgUUIkauyO+i2Xbt2/Pzzz9y4cQOA77//ngkTJgBw4MABdu3aZd6CPk1cnNqLsmyZ8eyohQqp69f06wfNmmmn9yKl995Te3zeeQfGjoU33lBPwVjLokUwapT6fdu2aq+PNceONGqkDmC+fl3tierUyXplERnS4G+WEOJZkt1TQiVLlgTg5s2bAJw5c8awzZUrV8xYwqe4ckXtnfDwUENJaKg6rbuvL6xfr156vGKF2qOixbCiN3w41KqljrUJDrZeOdaseRJW3n8fdu9WFye0Jjs7dcAvwMaN1i2LyJCGf7uEEM8CU+dh0W+jn4xSH1j++OMPwza3bt0yZxHTSkpSB9B26gQVK8Ls2eq6Nh4e8PHH6qXCO3aoPRUau/ImISGBHj16pJ0p3M4OmjZVv08R/izqzp0np34++EC9KkcrV9Xpx65s3Wo8CZ/QDAksQohck5iYaBRSstPDoj8llDKw3L59m8TERHMWVRUTo062VqWK2oOybZt6FUn79rB5s7oA38SJ6iXHGrVy5Uq+++473tEPZk1JPxlnRoHlzp3cK1h8vHrq7PZt9Wqpjz+23HwrWdG8OZQsqX4G+/ZZuzQiHRJYhBC5JvX4FVMG3eoDS2xsLPfu3ePChQtG+7l7965ZygiovSeTJ6uXGb//vjrrqasr+Pur0+Hv3g2vvqq9S4JTePz4MRMnTiQgICDjjZIn8CS9ZU9+/FG9omj2bPMXTlFg0CDYs0cdq7JmjVk+y127dtG7d2/z1AV7+ydLGezcmfP9CbPT7m+fEMLmmTrgFp6EGldXVxwcHHj06BHHjh3j8ePHuLi4YGdnx71794iKiqJYTgeORkaqpyU+/1wd2wHqhGvvvgu9e9vUJGLLly9nxowZmW+kn3r+8mX1tFfKMTd+furXcePU3oYmTcx3umbiRPWqIHt7dRp8M0wKmpSURMeOHQHw8PBgtjmCVps2sHKleqm60BzpYRFC5Jrs9LDot7Gzs6NEiRIAHDx4EIBq1aoZ7svROJboaHW13kqV1JlgHzxQ50nZuBF++w0GD7apsALw+++/P30jDw+1ZyM+Xr0iJqWU4aV5c+jQwTwFO3JEXYgRYPly8PExy24PHDhg+F5/6buiKJw+fTr7pwtbtFC/hoWpl1sLTZHAIoTINTkJLDqdzhBOjh07BsDzzz9P8eLFAYiKijK9QAkJakCpVAk++UQNKo0bw08/wcmT6pUiGrvSJzExMUunPPRjfTKVL586VwxAUJDxY8mfq8HPP6tXSP3zT1aKmbG5c9WvAwaop4VyYNiwYdSrV4979+4Z1qsD2LNnD3Xq1KFevXrUq1ePRYsWZe8FPDzU04KJiXD0aI7KKsxPW7+ZQohnirkCy6lTpwAoV66c4TSQyYFl50510Ono0XDrljqeY9Mm9TLljh21NQA0hffff5+SJUsaQltGstTDAupCiQBjxsD9++pq0Xfvpj9ZWo0aaiP+/femFVrvzz/Vq25AvSooh5YtW8bp06dZu3YtW/X7TXbmzBl+/fVXgOwHFnjSyyKnhTRHAosQItfkZNCtTqczDLzVn/7x8PAw9LBk+ZTQ3bvqeBRfX3WG2lKl1HEKZ86oU9VrNKjoBQQE8OjRI/r27ZvhNnFxcZxPNZBW/9mlMWzYk+9//VVdVLFIkfSvHHr4UP06b56pxX7yPEVRLw/XD/h9in379nH58uU09z/QjzECvvnmG27fvk3hwoV56aWX0mz777//8lBfdlM1b65+PXw4e88XuUYCixAi12RndfSUoUbfw6JXtmxZ03pYQkKgXj11gjd7e7V35a+/YOBATV/xk54LFy4YfTZ//PEHrVu3Zv/+/fzxxx8kJSUZbZ/hgpE9e6qfCaifS2arSOsdP276Jc8xMerSBaD25mTB+fPnadu2LRUrViQ6Otrosf9SlDM0eaZhHx8fPvvsM5YsWUJUVBTBwcG4ubmRkJDA0RSndOLi4ggODk4T6tKl72E5elQ9NWSqmBg4dUqdUfjll9XBzJs2mb4fkYYEFiFErkn5XzGYfkoo9crOJvWwzJ+vrlHz99/q5G+HD6v/8dvQau7x8fFGP6dscHv06MGBAwd48cUXDafMWrZsyYIFC4CnfNYVK6pfU08uB096GFJKSjJ9bhL9ujxVq6a/z3SkfH+jRo0iJiaG6dOnM2PGDCIjI9Ns7+vrS4UKFRg+fDjFihXjxRdfpF27dgDMmDGD3bt3s2TJEjw8PPDx8aFKlSq8+eab3L9/P+NCVKumTgb44AGkuJT+qR48UNeRcnWFBg3UsTs7dqhXR3XrBn37Gi+OKUwmgUUIkWtiU11pYWpgqV+/vtFjHh4eWethmTNHXT8nMVH9DzcsTL1M1wZERUUZlh5I3UgvWbKETz/9lHbt2hmWKkhMTGTHjh0AtGnThhdffPHpL5JZaPv5Z+OfBw9Wv4aEZKn8Bl99pX59/fUsn3a7ffu24fu1a9fi6urKlClTmDhxYpoxPPny5aNbOisrDxgwADs7O/bs2UOHDh0YOXIkUVFRODg4ABAYGEijRo2MJiI0Ym8Pdeqo34eHZ6ncrFihnmpMNa4Gb291jSKAr7/WxqKTNkwCixAi1+Q0sHh5eRk9VqJECUMPS4ZXxcyf/2SA50cfwbp1NtOrkpSURMuWLalRowb//PMP11Nderx48WLGjBnD3r17je7flHzKQT8vCTzls85s7R5HR/XS7s6d1VNB3t7q/cmXDmfJhAnqlVc6nbp8QbITJ07QunVrfvvtt3SflrLXzMPDw+ixzZs3pyiiI3v27KFgwYJp9vHiiy8SFBRE5cqVqVq1KmXKlMHf35/Y2FgOHjyIu7s7Z8+epVmzZpw7dy798utPmWUlsHz1FQwZol4GXaSIOrg7JkadjDAkRL3K6qef1KvPvvxSXUBTZI/yjIiOjlYAJTo62tpFEUIk++677xTAcPvjjz+e+pyGDRsqgLJt2zZFURSj5yuKopw+fdrwc2BgoJKUlKR88sknyoQJE5SI6dMVRR3mqShTp+bqe8sN+/fvN7y3VatWKRs2bFAApWnTpkrTpk0VQHFxcTH6TPS3IkWKKI8fP1Z+++03BVCKFy+e8QuNG/fkc0p9S+30afX+/PkVJTb26W/i6lVFsbNTnzN7ttFDdnZ2CqBUrVo13adOmjRJAZRhw4Ypf/31l+Lm5pbmffr5+Sn//vvv08uRgYiICKVBgwYKoFSsWFGJi4tLu9GyZWr5O3bMfGd//aUozs7qtl27KsqDBxlvO2mSul3x4opy82a2y/8symr7LT0sQohck7qHJSuUp/TC1KlTh/HjxwPwzjvvsGnTJiZOnMiMGTPw+PBDegH3xoyBDz/MTpGt6iv9aRQgJCTEcKlymTJl2LRpE0uXLuXvv/8mJCSEFi1a0Fk/lTzQuXNn7O3tDYNtM/0c0+mZyFCtWuppjYcPYcOGp2+/bJk65qVFC3XgaQr6gcF//vlnuk/V97AUL16cypUrc/HiRdauXWu0TYUKFdKMbTKFm5sbP/30E+7u7ly6dInAwMC0G2W1h+Wjj9RxOi++qF76ndlCmB9+qF5WHxUFyfVXmMgi8ckCpIdFCO1ZsmSJ0X/H586de+pzvLy8FEDZvn27oiiKMmbMGAVQXnzxRcM2iYmJStWqVdPtaQAULy8vm/tbsHHjRsXR0THd9+Pv75/uc+7fv69Mnz5d+fLLL5WHDx8qiqIoZ8+eVQClaNGiGb/YwoVPelSKFFGUs2cVpWRJRRkzJv3tP/xQ3bZp08zfxP37ilK0qLrtpk1GD0VERBjej4uLS7pPf/311xVAWbhwoeG+q1evGn0Wn332WeZlyKKAgAAFUMqVK6fEx8cbPxgbqyg6nfo+IiLS38HNm4ri6Khuc+xY1l708GF1e51OUS5dytkbeIZID4sQwupyOoYF4KOPPuLLL7/km2++MWxjZ2fHuwMGGH62B64AIUOHUqJECU6dOkXv3r3TXOqrVZcvX6ZXr14kJCTQPJ0rakrrJ3tLpUCBAkyePJm+ffvinDzxW5Z6WFKOYXntNXX9pIgIdbByerp3V78eOwaPH2e83y++UFdjrljxyUKC6J/6ZNDs/fv30529N2UPi56HhwfVUszhUqpUqYxf3wRDhgzBzc2Nq1evGs2aC6jLMlSpon5/+nT6O/jqK3Xm5Pr1oWHDrL1os2Zqb4yiQKqeI/F0EliEELkm9eWj2QksTk5O9O3b13hOlp9/pt8nn9ADaA+sLl6c8tu24b1sGdu3b8fZ2Znt27cbLvHVunHjxpGQkECbNm3Yv38/1atXN3q8cOHCWd5XlgJLynWSChRQv2a2JEHNmuDgoF519e+/6W+TkPBkGv5x49IsnJj6Kp/0rtLRX/mVelHLt99+2/C9uQJL/vz5GZt8yuqTTz5Ju/6Q/rRQWFj6O1i1Sv06eLBpkw++9Zb6NTBQPXUmskwCixAi12Snh+WpLl6E7t3JHxtLUOPG7N6+nX7//adO0gU0bNjQMDX7hAkTMrwixRoUReHEiROsWLGCoKAgvvvuO0aOHMmGDRvQ6XTMnz8fe3t7tm7dSnBwMFOmTKFKlSp06tQpy6+RpcCS8gor/dpCmbGzU6foB7h6Nf1tVqxQw4y7O/Tvn+bhn1NdLr1o0aI088zoe1hSB5Z+/fqlKG4WyptF//vf/yhatChXrlwxLLBpoL+kPr1xLH//rV5JZW8PvXqZ9qKvvqrO1fL336bPbWNhu3btYuPGjdYuxhO5e2bKcmQMixDaM2TIEKPxB7/99ttTn1OvXj0FUHbu3Jn2wYQERWnYUB0H0KSJoqR3hYeiKElJScorr7yiAEqFChWUNm3aKG3atFG2bt2qJCYm5vRtZcupU6eUunXrZjjuZs6cOWZ5nb/++ksBlEKFCmW80cWLT8awZPWKlTZt1O2/+irtY2fOPNnf/PlpHr5165ai0+kUQOnatavhPX/44YeGbZKSkhRnZ2cFUC5fvpxmHydOnFB++umnrJXVBAMHDlQAZejQocYP7Nqlvp9KldI+adUq9TFv7+y96Ntvq8/v0yd7z7eAxMREw3G6ceNGrr6WjGERQlidOcawGJk7F06cgMKF1fksnJzS3YdOp2PFihUUK1aMK1eusG/fPvbt20fnzp2pWLEi48ePJywsLPMZT83k8OHDNGvWjEaNGnH69GkKFChAhw4d8Pb2plmzZvTs2ZN169YxJovT1z9NlnpYKlaE69fVK39Sr9KckXLl1K9//218f1ycOsOrfr8jRqR56p49e1AUhZo1azJt2jTD/RdSzCT74MED4uLigLQ9LAANGjQwmmfGXHr06AGoc9k8Tjk+p1Ej9VTPxYtply/Ys0f9mjyrrsn060Jt2wap1tvSipiYGMP3+uNibba1mIYQwqaYNbCcOwf6xm7xYihbNtP9uLm5sXfvXvbs2YObmxunT582XBY8a9YsZs2aBUDNmjWJj4+nVq1alC5dmgYNGtCnTx/s7e2xTzUOQ+/x48fMnz+fX375hf79+/PCCy9w9OhRHB0dKVGihOE01IEDB1i3bp1h8G+XLl1YtWpVug2yuWQpsMCTVZuzSh9Yrl0zvv+77+DSJXXStN271bEuqegnuvPx8aF27dqsWLGCwYMHcy/FVPX600GOjo48l9nEdmbWpk0bihYtyo0bNzh48CBt27ZVHyhcWL2k+8wZOHJEHZwMaj+SfuK+7AaWxo2hRAm4eVNdMqJNmxy/D3NLOSjaIZ1jag0SWIQQ5peQAJGR3DdXYFEUGDpU3e9LL0GfPlkqRp06daiTPM167969mTp1Ktu3b+ebb75h165dPHjwwDDXScr/9ocOHUpiYiIlSpSgTJky3Lx5k5iYGEqVKoWnpydhYWGGxfiCgoKeWo7+/fszdepUs46/yEiWA4up9AEnIsL4fv3MrSNHQqVK6T71TvLCiZ6engCGGWpTBpaUA24zXLgxFzg4ONC1a1dWrVrFhg0bngQWUK/qOXNGDRX6wPLbb2qPS/78T2YBNpW9vVqP166FiRNNX/bAAlIuPmn2upRNEliEEDnz+LE6bXtwsDpA8fff4fx5ePyY2FT/mWX7D9++fXDwoHoKaPly067KSCF//vx0796d7t27oygKly9fZs+ePTx8+JAjR47w+PFjQkNDDWv4REZGGq3nc/fuXcOkZ4UKFeK1115j06ZNxMTEULVqVXQ6HRcuXKBRo0a4uLjg6enJgAED8M5uw5YNudbY6ydrS3mVUHQ07Nqlfp98aiU9qUOovgclZQ+cfh2h3Ox9ykiPHj1YtWoVmzZtYsmSJeTTr+TdvLla344cebLxjz+qX9u0yfCUZJZ07qwGltBQ9fScfs0hjUjZwyKBRQhhu/79V13obds2NUhksArt/Wycn0+3h0V/uezgwU+uVskhnU5HxYoVGTJkCKCuDgzqbKznz5/nxo0bTJw4kRIlSjB69GiKFi3KmTNnuHPnDnXq1KFu3boUKFCAJUuWcPPmTcqXL49Op0NRFIv2EGQk13pY9IHl4kV4/nn1++rV1Uufn1IW/eeSuodFURRDA2nKJdzmoj8tdPPmTQ4cOGBY8ZlmzdSvv/yi1vGCBZ8scKgft5Ndr76q9rQkJqoLI6aaFdjaJLAIIWzXf/+pk2UFBakDX1NydVXP5zdrBjVqqI1XsWLEFi0KKS5dzdYpoX/+efJfvL+/Od5Jpuzs7KhatSpVq1ZNc6lr6vlRAFxcXHBJMa+JtcNKrp8SioxUe9Bat37y2NChmT41dVn0gSU2Npbz58/TrFkzCiUvUGmNwOLg4MBrr73GypUr+e67754ElvLl1VB24QJs366+Z/18MiZcap4uOzt1LNawYWqvjcYCixZPCclVQkKIzP3xh9qzUb48vP++GlZ0OvX8/cyZ6n+ft27Bxo0wejRKhw58c+gQf167xn39pGTJshVY1q1Tx7C0bJnhGAnxRK4FllKl1OOemAgdO6o9LUWLwpYt6viVTGR0SujevXtMmTKFmzdvcvHiRQBcXV3NW+4sev311wHYuHHjk6uFdLonp7o2bAD9XDJeXk9OkeVEhw7q18OHYcAATV0xpMUeFgksQoj0RUbCoEFqj8nKlWpPSaNGsHSp2liFhKgzmtavbzSr6ebNm+nTpw/VqlUjNtXlkNkKLN9+q35NMRW/yFiuBZZ8+dTQAupVQXZ26pilzp2fOqYoo1NCsbGxT8aLJLNGDwuop4WKFStGVFQUR1KOWUkOMuzcCT/9pN/YPC9asaJ6agjU8Sx162pm9ttnpodl6dKleHp64uzsjJeXF4cOHcpwW/0cBMWKFSN//vxUq1Yt3emyN27cSI0aNXBycqJGjRps3rw5O0UTQuTUw4dqz0nlyur044qiNkqHD6vd4W+/DW5uGT495d+Dhw8fAqAfmqiknv78aa5dU6/SsLNLszaNSF+uBRYw7lVo2zbL44ky6mFJSkrCLtWSANYKLA4ODnRI7vHYvXv3kwfq1n2yWvXXX6v36XtGzOH775/0UJ07B19+ab5958Az0cMSFBSEv78/EydOJCwsjBYtWuDr68vVDKZrdnFxYcSIERw8eJBz584xadIkJk2axBdffGHYJjQ0lJ49e+Ln58fp06fx8/OjR48eadaeEELkoqQk9fRL1aowYQLExqo9KkeOqN3++gGIT3EvnQG4hlk1Ulw6nBGjxk3/H22TJmCFq0dsUa4GlpRzt6S8/PcpUgcWFxcXw/epF6i01ikhUOeJgVSBRaeD//3vyc/Nm5v03p/K3h4WLQI/P/XnWbM00cvyTPSwzJ8/n4EDBzJo0CCqV69OQEAAHh4eLFu2LN3t69evT69evahZsyYVKlSgb9++dOjQwei/sICAANq3b8/48eOpVq0a48ePp127dgQEBGT7jQkhTPDrr+qYlP791V4NDw81vISGQtOmJu1Kf9mvnk6nI3/ySsLKiRPw+efqpG+lS8OYMWoPTgpGjZt+zEAuzHD6rLJYYElnAHJGUgcWnU5n1MuSkrV6WOBJYDl16pRhXhhADfArV6qDZHfsyHyhyOxasgQKFVLHjOkHmVuRzfewJCQkcOrUKcNB1fPx8SEkixPfhIWFERISQqtWrQz3hYaGptlnhw4dMt1nfHw8MTExRjchhIkePlT/GHt5wfHj6h/M2bPhzz/V//iy8Yc59Sq8Li4u2OkDy4IF6hUl16+rE5B9+ilMnmy0vVHjFhqq3tm8eTbeXN5ksVNCtWpl+WnpXaquDyyp/3ZbM7C4u7tTu3ZtFEVhX8qFCe3tYeBAddmB5PE3ZleokDpmDGDGjDRB3tJsvoclKiqKxMTENMt7lypVymhypfSULVsWJycnGjRowPDhwxmkPzCokzOZus+ZM2fi6upquHmYaW4GIfKMvXuhTh11vMrjx9Ctm3oOfexYdRbPbLh165bxf6aoAyx1yfsz/NlLOUnWJ5+ol4wmMzRuUVFqb4+dHTRsmK3y5EW5Glj0/1hWqWLSFVvpBRb9wNvU9cWap4QAwz/TmY3NzDX+/lCggDpeTD/Y3EpsvodFL/U8A1mZKOnQoUOcPHmS5cuXExAQwPr163O0z/HjxxMdHW24XUu9voUQIn23bsGbb6rzply4oIaHH35QB/+Zur5MKvreFXd3d0aMGEHDhg0ZM2YMutQzgv78szoRl37+kkmT0v5HmbweD3XqgAXXlrF1uRpYmjVTG9MjR0yabdiUwGLNHhaAli1bAqSZg8ciPDzggw/U7+fPt2ovixYDi0kTxxUvXhx7e/s0PR83btxI00OSmn4Nidq1a/Pff/8xdepUevXqBaiLlJm6TycnJ5xyMi2yEHmNoqhXILz/vrromk4Hw4erPRzJk3bl1I/J05Y3aNCAxYsXG+5ftGiRWgQ3N3VOl6pV1Qf+/hsqVFAvj922DTp1etK4Ja/xQ5MmZilbXpGrgQWyPPg6pcxOCWmth6VFixYA/Prrr9y5c4ciRYpYtgBvv62eEjp5Eg4cMJ6gz4Js/pSQo6MjXl5eBAcHG90fHBxMUxMG5imKQnyK2S+9vb3T7HP37t0m7VMIkYnff1f/8PXvr4aVWrXUeVQWLzZLWHnw4AFTpkxh9uzZALz55ptGjxsa0c2bYfr0Jw8UK6aGJoCPPgJFSRtYLLgOz7PA2jPtpiezHhb9woh61u5hcXNzo0qVKiiKYjwfSzpiYmL45JNPWLNmTbpXx2VLiRLQu7f6farxXZaScqkE/c+aoJjo22+/VRwcHJRVq1YpZ8+eVfz9/RUXFxflypUriqIoyrhx4xQ/Pz/D9kuWLFG2bt2q/PXXX8pff/2lrF69WilUqJAyceJEwzZHjhxR7O3tlVmzZinnzp1TZs2apeTLl085evRolssVHR2tAEp0dLSpb0mIZ9e9e4oydqyi5MunKKAoBQooyuzZihIfb9aXGTNmjII6REXx8PBQHj16ZPR4xYoVFUAJCQlJ++T//lMUZ2e1fAcOPNlWX+a//jJrWZ91//33n+FYaIWvr68CKGvWrDHc16tXL0M5U94ePnxovYImGzRokAIoY8eOzXCb69evK9WrVzeUu2bNmsrt27fNU4ArVxTFzk6t/3/++eT+FSsUxc1NUUqVUpRt2xTlk08UZfNm87xmCg8ePDA6Jn/88YfZXyOlrLbf2arRn332mVK+fHnF0dFReeGFF5QDBw4YHuvfv7/SqlUrw8+LFi1SatasqRQoUEApVKiQUr9+fWXp0qVKYmKi0T6/++47pWrVqoqDg4NSrVo1ZePGjSaVSQKLECkkJSnKpk2K4uGh/tEDRXn1VfUPodleIkk5d+6ccuPGDcXFxUUBlOeee07Ztm1bmm0rVaqkAMqRI0fS39ngwWoZe/VSPD09FUAJBUUpUUJ9LyLLbty4YWhokjTy2XXs2FEBlMDAQMN9gwcPTjewaMG6desUQGnSpEm6jz969Ehp3ry5AigODg6Kk5OTAigtW7Y0X+Dq2FH9nfjkE/V34ODBJ7/LqW/796vPMdPx/ueff4yOyblz58yy34zkamDRIgksQiS7eFFRXn75yR+zChUU5ccfzf4yY8eONfqjVq9evQwbyKcGllOn1LI6OCie5co9CSyvvmr2cj/rbt68aTgmqf8xtJYOHToogLJ27VrDfaNHj9ZsYLly5YoCKPny5VNiY2PTPP75558rgFKwYEHl/Pnzyq+//qoUKlRIAZQWLVooH3/8sTJ//nxlxIgRSokSJZTKlSsrd+7cMa0QK1aovxMeHsa/z+ndevdWlHnzFOW55xRl4cIcv/9ff/3V6JicPXs2x/vMjAQWIfKax4/V0z360ysODooycaKi3L9v9pcKDw83+oP23HPPpX+6J9nzzz+vAMrhw4cz3mmjRooCSoUiRRRAOQqKMmeO2cv+rIuKijIcl8ePH1u7OIqiKIqPj48CKOvWrTPc9+GHH2o2sCiKopRLDs47d+5M81jbtm0VQJk1a5bhvn379hl6WtK7+fv7m1aA+/fVfzZSh5PwcEW5dk1RBgxQg0p6Aeaff3L03vfv36/JwCKLHwrxLLh4EVq1Ui+JjItTpw7/9Vf4+GN1XgczmzdvHgDVqlUzLL3hncng2CxduTJ0qLpN8mA/HcBLL5mjuHlKyoGtmX7eFqQvR3qDbrXK19cXgK+++sro/qioKA4cOAA8WeEZoHXr1oSHh9OnTx9ee+01OnXqRL9+/Zg1axYAixcvTnNxSaYKFIBvvnnys729Oi9R3brqTNFr1qizUae3rlfNmpCDy7Jv375t9LNW6pF24mwOSQ+LyLP27lUUV1f1P6uCBRVl9epcHfeRmJiolChRQgGU/fpz509RpUoVBVAOHjyY8Ub37ytKkSJKueT/6o5XrWqmEuctt2/fNvxnnJCQYO3iKIqiKC+++KICKF999ZXhvuXLlxv9F+/j46OEh4dbsZTGjh8/rgCKs7Oz0emcVatWGU6BZpWfn59hvEv//v2VuLi4rBdk2jRFKV5cUdavT//xLVsU5fnnFWX6dEXZs0dR7O3VvwX29ory++9Zf50UVq5caXRsfvvtt2ztJ6ukh0WIvODrr9WVY6Oj1TV/zpxRJ4XLxUtbw8PDuXnzJgULFsy0VyWlLPWwFCgAixYZZsPVvf12DkuaN9lKD8tzqSYDHDt2LHXr1rVouTLToEEDateuTVxcHN+k6OnYtGkTAN26dcvyvlasWEGnTp149OgRa9euZdWqVVkvyIcfqlMRvPFG+o937gznz6uXQLdrB5s3q/cnJkKq3qGsSn2puVbqkQQWIWzRw4fqH6i+feHRI+jRQ509tnz5XH/p7777DoC2bdvi6Oho3p337avOQwHZmqBM2E5gSX1KyDl5vSmt0Ol0hiVkVq5cCajzruhP67z22mtZ3peTkxNbt25lypQpgLqIcGJioplLnKxTpyfT+uuX3TCRVk8JSWARwpYkJan/NVWtqo5PAXXm2vXrIZf/4N+/f58PPvjAcE7elD/Ypsy+qiTPYK3FCdBsga0GFi3OXN6nTx8cHR0JCwvjl19+Ydu2bSQkJFC1alWqm7Batd6YMWMoWrQoFy9eZPz48blQ4mQvvwz6z7NcOZOfLoFFCJEzUVHg66uuonztmrruyPr1MHdu7ix3j7pC+7Zt2/jggw+oXr06c+bMAeC9996jb9++Wd6PSYElncZNZJ2tBJbUp4S01sMCUKxYMUMwX7VqFStWrADUwbbZqZ8uLi4sXLgQgLlz5/L111+br7ApPfccdO2qfh8RoZ5WMoEEFiFE9igKBAerKxbv3q2upDxjBvz5Z8bntc3g7t27NG3alE6dOjFnzhyuXbtG+fLl2bx5M59++il2JoQkCSyWYyuBxRZ6WADDaaGlS5eyf/9+7O3tGTJkSLb317dvXz5MDhDDhw/n8uXLZilnGl99BV5e6vcffaSu15VFWg0sJi1+KITIZUlJcOiQ2nOya5c6cC42FvSD4CpVUldWrlUrV17+2rVrhISE8Pvvv/Ptt99y/vx5ihQpQvfu3alXrx4DBgygQDYuk5bAYjla/NxsObC0adMGT09PQ7Do1q0bHh4eOdrn5MmTCQ4OJjQ0lJdffpmQkBDzr6Fkb68uoPjqq7Bli/p3o169LD1VAosQImPx8bB6NcyZA1eupH3cwUFdxXXaNDDTH7bExEQOHz7M4cOHOXnyJCdOnOD69etG2xQvXpw9e/Zo6uoNkXVaaWhs9ZQQgJ2dHVOmTOHdd9+ladOmLFiwIMf7zJcvH9999x1NmjTh3LlzzJkzhxkzZpihtOlo314NLNOmqXM1tWkDqKd7Mxo0L4FFCJHWw4ewciXMng36sODqCq+9pl75U6SIerlvpUpGE8A9evSIfv36cf78eVauXEm9p/znpCgKv/76K5cvX+bEiRPcvHmT7du38++//xptZ29vT7169ahfvz716tXDz8+PQmZYzVl6WCzHVk4JpQ4sWu1hAejfvz/9+/c36z7LlCnD4sWL6dq1K8uWLWP8+PG5M5leq1ZPvn/pJYiK4vjvv9OyZUumTJmS7uBfCSxCiCcSE+HLL9VLk//5R72vbFkYNw7eeksdp5KOu3fvoigKY8eO5dvkSxebNWtGaGgoderUSbP9v//+S1BQEF9++SVhYWFpHi9SpAg+Pj40atSIhg0b8sILL+Di4mK+95lMAovl2Epgsbe3J3/+/Dx8+BDQbg9LburcuTNVqlThr7/+YuXKlbz77rvmf5FataBfP3VW3Lg4OHmSoe++S3x8PBMmTEgTWB49esS9e/cAKFCgAA8ePNBMPZLAIoQlKQr89JM6hf5vv6n3lS0LEyeqE75l8F+moih8//33DBw40PDHRO/Bgwf06tWLTZs2kT9/fn799Vf+/vtvtm3bxu7du0lKSgLUBqFGjRrUr1+fUqVK0bBhQ3x9fS3yn60EFsuxlcAC6jgWfWAx+5w+NsDOzo4xY8YwePBg5s+fz4gRI3BwcDD/CwUGqpNLbtkCoaGGvwnpuXXrFqAeqyJFikhgESJPOnECxo6F/fvVnwsXhgkTYOTITOdQefz4Ma+//jo//PCD4T47OzsCAwPp0KEDderU4ezZs1SrVi3d5zdt2pQePXrQt29fihUrZr73YwIJLJZja4Hlxo0bODk55dnj3bdvXyZNmsQ///zDV199xZtvvmn+F9HpwMdHDSwff0xSJnOzXL16FYDSpUuTL58aEbRSj+SyZiFy24UL0LMnNGqkhhUnJxgzBi5dUr8+pSt89+7d/PDDDzg4ODBhwgRCQ0M5deoUfn5+lCxZkv3799O2bVtA7WavW7cuvr6+fPzxx/z1118cOXKEUaNGWS2sCMuypcCiH8ei5fEruc3Z2Zn33nsPgEmTJhEbG5s7L9S/vzqJ3P37JJ079+T+3r1h507Dj/qroTzLl0eXkABopx5JD4sQueXmTZg+HZYvV6fH1unUc8nTp5s0+6R+KvwhQ4bwySefpHm8WrVq/Pzzz8THxwPa/OMvPSyWY0uBRT/IVIt11pJGjhzJsmXLuHz5MkuXLmXs2LHmfxEXF3XSyU8+weiE0Pr16sruHTsCcCX5KsUKkZFcj4gAtFOPpIdFCHNLTFRDStWqsGSJGlZ8fdWJmwIDTQorCQkJhlNBKZeyT4+Tk5Nm//BLYLEcWwwseXHAbUrOzs588MEHAGzcuDH3XqhBAwCjwBIP8PvvEBMDpAgsly6hP1paqUcSWIQwp/Pn1csI335bneytXj3Yuxd27IB0ruJ5mpCQEO7evUvJkiVp3ry5+ctrIRJYLMeWAoucEnqic+fOABw/fpzIyMgsPefSpUucP38+6y/yyiswaRKP8z05uRKt/+bDD0FRDIHFEySwCPFMSkhQFyOsVQuOHIGCBWHRInWgbfJETdmxP3mAbrt27bC3tzdTYS1PAovl2FJgkR6WJ9zd3WmQ3AOyffv2p27/+++/U6dOHV544QUiIyMZMGAADRo0ICoqKuMn5csHH33E3RTzvdxN/vv0cOFClBEjuHz6NAAV8ueXwCLEM+f4cXXNjsmT1eDSoQOcPq1e/ZMvZ8PE9u3bB6jTgwuRFbYYWKSHRfXqq68C8Omnn/Lo0SOjx+Lj43n33XdZu3Yt8fHxvP7669y/f5/Y2FhKly7N2rVrOXXqFB/rV3HPQFJSEneiDf0q3K1WjUjAHXh96VL+Th63UuHhQwksQjxTZs8Gb291TpXixeGbb9R5Vjw9c7zrhw8fcvToUQBat26d4/1Zk/SwWI4WP7ennRKSHhbV8OHDKVGiBH/88QdLly41emz69OkEBAQwYMAAxowZw7kUV/qk/L1aunQpq1at4vHjx+m+xr1794zmYYn29WVV2bJEAxuBONRg4EGKU0KZzNtiSRJYhMiu8HB1ZtqkJPXSwHPnoFcv9WogM1i/fj0JCQmUKVOG559/3iz7tBYJLNahlf+MpYclawoXLsxHH30EwPz58w2h48KFC8yZM8ew3eLFiwFYvnw5xYsXR6fTsWDBAl577TUePXrEoEGDqFixIidOnEjzGnf0C6kmuxsXx71UA/rLAg6kCCxxceZ5gzkkgUUIU0VHw7x5UL+++nO9evD112oPi5ns3bvXcNWAv7+/zTfeElisQ+uBRQbdptW/f3+KFy/O1atX2bp1KwCLFi1K02PSuXNnhgwZwrFjxwgLC8Pf35+goCDmzJlDiRIluHbtGm3btuWdd94hOsUpoNTrBN29e5eI5Nlt9SokfzUEllSnp6xFAosQprh/X73a5/33n9yXPE+KuXz++ee0a9eOqKgoateuzahRo8y6f2uQwGJZpnzelpDRMW3VqhUlS5bkpZdeskaxNMnZ2ZkhQ4YA8NFHH3Hnzh3WrFkDwK5du1i0aBGrV69m8+bN6HQ6KlasaFhNPV++fIwZM4ZLly7Rpk0bYmNjWbx4MUuWLDHsP3VgiY6O5s8//zS6r0LyVwksQtiq+/fV6a2Tp66mfn24exfMeLpm1apVDB8+HIA333yTPXv25M7aIuKZZiuBpVatWkRGRjJixAhrFEuz/P39KVy4MOHh4RQtWpTY2Fhq1KhB+/btGTlyJG+++SZ2dhk338899xzBwcEMHToUMJ7bJfUpoTt37qQJLPoReIbAksF4GEuTwCJEVvzwAzz3HISEgIMDbN0Kv/wCrq5m2X18fDz/+9//GDRoEImJiQwYMIBVq1ZRsmRJs+zf2qSHxbJsJbBkdF9eV6JECaZNm2Z034IFC0z6rOzt7Zk+fTp2dnaEhYUZptxP3cNy4cIF7t69a3RfheSv0sMihK05cQK6dn3y8zffQKdOZtv9hQsXaNmyJV988QU6nY5PPvmEVatWPVN/yCWwWJYtBRaRvpEjRzJ37lwKFy6Mv78/Pj4+Ju+jRIkStGrVCoBt27YB8Msvvxhto78SMaUK06bBxInSwyKETdm7V120UG/tWuje3Sy7vn//PhMmTKBmzZocP36cokWL8tNPPzFhwoRMu3ttkQQWy5LAYvt0Oh3vv/8+t2/fZsGCBdneT9OmTQE4e/YsSUlJ/Pjjj8CTpT70qzOn5Nm/P3z8Mbrkv0NKYmK2X9+cnq2/ikKY0+HD0K6d+n2RInDlirp4oRkcP36c+vXrM3PmTBISEujYsSMnT56kQ4cOZtm/1khgsSwJLM+OnH5mlStXBtSelG7duhEREcFzzz3HgAEDjLbT98TY29tTpkwZo9eWU0JCaNmFC9CixZOfT56E8uVzvNvw8HAGDBhA06ZNOX/+PGXKlOGHH35gx44deJphsrlngVYaWVsmgUXo6QNLeHi4YSHVjh070qZNG6PLyQcMGICLiwtNmjQhX/IM3YZ6JKeEhNCoHTugRo0nP58/DxUr5miXN27cYNiwYbzwwgusXbuWxMREevbsya+//kqXLl2e+T/k2WlAn/XPJDdJYBF6VapUMfrZzc2NWbNmkT9/fsPl0AAdOnTg77//5ueffzbc90wElqVLl+Lp6YmzszNeXl4cOnQow203bdpE+/btKVGiBIUKFcLb25tdu3YZbRMYGIhOp0tzi9PI7HoiD5k7F15+GfRdoPv2ZfuyZUVRCAoKon379pQuXZply5ahKAo9evTg8OHDfPvttxQtWtSMhdcuOSVkWRJYhF6xYsWMFk49efIklSpVAjB8BXXxxWLFihn1uth8YAkKCsLf35+JEycSFhZGixYt8PX1TXfgDsDBgwdp3749O3bs4NSpU7Rp04ZOnToRFhZmtF2hQoWIiIgwusn6EsKivvoKxo5Vvy9WDCIjIRtr+CQkJLBw4UJq1arFG2+8wZ49e0hMTKRRo0bs3buXoKAgmjVrZt6ya5wEFsvS2mcnx9R6dDodiSkGzerHpwB88sknlC5dmokTJ2b4XNBOYDF5Kdn58+czcOBABg0aBEBAQAC7du1i2bJlzJw5M832AQEBRj/PmDGDLVu28OOPP1JfP7U56gfj5uZmanGEyD5FgZ074cgRdZ6V339X7+/cGTZvhmxcqRMcHMzIkSMNEzG5uLjw3nvv0a9fP6P/ZvIaCSzWIT0sAtSJ5GJjYw1rN+l5enpy/fr1DJ+ntcBi0l/khIQETp06leZ6cB8fH0JCQrK0j6SkJO7du5emKzw2Npby5ctTtmxZXnnllTQ9MKnFx8cTExNjdBMiyx4/hhEj4KWX4JNPnoSVDz6ATZtMDitJSUlMmjQJHx8f/vzzT0qWLMlnn33GtWvXmDZtWp4OK6bSSiNry+SUkEhp27Zt1K9fn3379pn0PMNlzfHxuVEsk5nUwxIVFUViYiKlSpUyur9UqVJERkZmaR/z5s3j/v379OjRw3BftWrVCAwMpHbt2sTExLBw4UKaNWvG6dOnDSOcU5s5c2aamQCFyJJr16BvXzh4UP25dWu4dQsGD4aRI03e3cOHD/Hz8zNMfz1s2DBmzJiBq5lmwX0WyKBby5LAIlJq1apVmgnjskKXPPZFK6s1m3xKCNJWOkVRslQR169fz9SpU9myZYvRlONNmjShSZMmhp+bNWvGCy+8wOLFi1m0aFG6+xo/fjyjR482/BwTE4OHh4epb0XkJY8fw7RpMGcOJCRAgQIQGAipllZP6dq1ayxfvhw3NzeqVKlCtWrVKJ/i8ua///6bHj16cPz4cRwdHVm5ciV+fn4WeDO2RU4JWZYEFmEOhh4WWwwsxYsXx97ePk1vyo0bN9L0uqQWFBTEwIED+e6773jxxRcz3dbOzo6GDRty/vz5DLdxcnKSJclF1igK/PQTTJ8Ox46p973wAnz5pfHly6nEx8fTuXNnwsPDje6fPHkyI0eOZMaMGaxcuZLY2FiKFi3K5s2badmyZS6+EdslgcWyJLAIczD0sDx8aOWSqEw6Ue/o6IiXlxfBwcFG9wcHBxum/03P+vXrGTBgAN988w0vv/zyU19HURTCw8Nxd3c3pXhCpLVvHzRtql6qfOwYFCyorgV08mSmYQVg2rRphIeHU6xYMbp27UqN5O0/+ugjSpYsSUBAALGxsXh7e3PixAkJK1kggcUyJLAIczAElkwG5lqSyZdBjB49mpUrV7J69WrOnTvHu+++y9WrVw3LWI8fP55+KaYvX79+Pf369WPevHk0adKEyMhIIiMjiY6ONmwzbdo0du3axaVLlwgPD2fgwIGEh4cb9imEyY4fh/btoW1bOHoU8ueHt9+GsDDo1Qsy+cP56aefotPpDFe9rVixgk2bNvH777/z5ptvGrarX78+O3fu5PDhw1TM4cRyzzpTGiqtNLK2TAKLMAed/uKYf/5Re6qtzOQxLD179uTWrVtMnz6diIgIatWqxY4dOwzn9SMiIozmZPn88895/Pgxw4cPZ/jw4Yb7+/fvT2BgIAB3795lyJAhREZG4urqSv369Tl48CCNUi46J0RW/PYbTJ6sXqYM4OAA//sfTJgAWeixi42NZax+LhagUaNGvPrqq4afFy1axPPPP0+tWrV4+eWXjSZkEhmTQbeWJYFFmEVyYFGmTMn0nzxLydag22HDhjFs2LB0H9OHEL39+/c/dX8LFizI0WqUQnDxIkydCl9/rf4nYGenLlQ4ZQpUqJClXWzfvp3u3bsb/rhWqlSJRYsWGf2Rfe6555gwYUIuvIFnmwQWy5LAIszBUI+sXA49WUtI2LbISLUHpVo1daZaRVGv+vntN1izJsth5cyZM3Tv3t2wHMSCBQu4cOECjRs3zsXC5x1ZbUBTPi6NW/ZJYBHmoLV6lK0eFiGsLjZWXfdn3jy4f1+9r2NHdRK4F14weXfDhg0jLi6OwoUL88EHH2TYgyhyRgKLZWitoZHAYpu0Vo8ksAjb8+OP6gBa/cj1Ro3U8JLNq3Ru3LjB4cOHAbWnpWzZsuYqqUiW1YZKK38YbZ3WgoEEFtuktcAip4SE7bhxA/r0Udf6uX4dPD3hu+/Uq4BycEmxfvXw+vXrS1jJJTKGxTq00tBIYLFNWgss0sMibMPGjerU+XfuqANqR49WJ4LLnz9Hu1UUhS1btgDw0ksvmaOkIh0yhsWytNbQaKUcwjRaq0fSwyK07bffoFMn6N5dDSv16qkTwM2dm6OwoigKX331FW3atDGsAdSpUyczFVqkJoHFsrTW0EgPi23SWj2SHhahTYoCn34KEyfCo0dPelVmzoR8Oau2ly9fZsiQIezZswcAe3t7ZsyYIVcEWYAEFsvQWkMjgcU2aa0eSWAR2nP/Prz5pjo+BdQelnnzIIOVu01x+fJlGjRowO3bt3F2dmb8+PH06dOHSpUq5XjfImMy6NaytNbQSGCxTVqrRxJYhLZcuQJdusCvv6qz1C5eDEOGmGWWxdDQUIYMGcLt27epV68eGzZsoLIZQpB4Ohl0a1laa2gksNgmrdUjCSxCO0JD1SuAoqKgVCn4/nto3twsu/7jjz9o1aoVjx49olixYmzZsoVy5cqZZd/i6WQMi2VpraGRwGKbtFaPZNCt0IY9e+DFF9WwUr8+nDhhtrACMH/+fB49ekTz5s355ZdfJKxYmAQWy9JaQyOBxTZprR5JYBHW9+OP8PLL8OAB+PjAoUPg4WGWXSclJbFq1SrWrVsHwKxZsySsWJEEFsvQWkMjgcU2aa0eSWAR1rVrF3TrBgkJ8OqrsHUruLiYZdenTp2iadOmDBo0iPj4eHx9fWnatKlZ9i1MI4NuLUtrDY0EFtuktXokgUVYz+HD0LWretly9+6wYQM4OeV4t3/++SdDhw6lYcOGHDt2jIIFCzJ//ny2bNkifzCtRAbdWpbWGhoJLLZJa/VIBt0K6wgPV08DPXwIvr7w9dfqVUE5cPfuXT788EMWL15suK93797MnTuX0qVL57DAIidkDItlae2zk8BimySwCPHvv+ppoJgYaNFCvRrI0THbu4uKiuLjjz9m1apVxMbGAuo0+2PGjKF169ZmKrTICQks1qGVhkYCi22SwCLytpgYaN8eLl1SB9Zu3QoFCmRrV/Hx8Xz//feMGzeOf/75B4CaNWsyd+5cfH19zVlqYSYSWCxDaw2NBBbbpLV6JIFFWE5iIvTqBWfPgru7eilz4cIm7yY+Pp6FCxcyd+5coqKiAKhatSoLFy7Ex8dH/ihqkAy6tSytNTQSWGyT1uqRBBZhOePGwY4d4OwMW7ZAlSom7+Kvv/6id+/enDp1CoCyZcsyZMgQ/P39KViwoLlLLMxEBt1altYaGgkstklr9UgCi7CMwEB1MUP99w0bmvT0kJAQpk2bxu7duwEoVqwY8+bNo0+fPuTL4WKIIvfJGBbL0lpDI4HFNmmtHslfepH7jhxR1wMCmDwZevY06ekHDx6kQ4cOxMXFodPp8PX1ZenSpZQvXz4XCitygwQWy9JaQyOBxTZprR7JPCwid/3995O5Vrp1g6lTTXp6REQEr732GnFxcfj6+nLhwgW2b98uYeUZJYHFPLTW0EhgsU1aq0fSwyJyz6NH8MYbcPMm1KsHa9eCXdYz8r179+jbty+3bt2iXr16bNy4kfz58+deeUWuyU4Pi8g+rTU0Elhsk9bqkfSwiNwzbRocPQqFCsGmTSZNuX/hwgW8vb3Zu3cvzs7OfPnllxJWbJgMurUsrTU0Elhsk9bqkQQWkTv27oUZM9TvV6wAT88sP3X37t00bNiQ33//HXd3d/bt20etWrVyqaDCEmQMi2VpraGRwGKbtFaPJLAI84uKgr59QVFg0CDo0SPLT12wYAG+vr7cvXuXJk2acPLkSZo0aZKLhRWWIIHFsrTW0EhgsU1aq0cSWIR5xceDnx9EREC1ahAQkOWnTp06ldGjR5OUlMRbb73F/v37ZQ2gPEYCi3lo7bOTwGKbJLCIZ5eiQP/+sHOnuuryt99medzK1KlTmTZtGgCzZs1i5cqVOJlh5WahDTLo1jq08nlKYLFNWgsscpWQMJ8lSyAoSF11+YcfoG7dpz5FURSmT59uCCtz587l/fffz+WCCkvT2h++Z53WPm8JLLZJa/VIAoswj5Mn4b331O/nzoWOHZ/6lISEBIYMGcLatWsBmDNnjoSVZ5SpPSzSsOWM1hoaPTmutkVr9UgCi8i5O3fUgbWPHsGrr8I77zz1KYqiMGLECNauXYudnR3z589n1KhRuV9WYVUSWCxDaw2NnhxX26K1epStMSxLly7F09MTZ2dnvLy8OHToUIbbbtq0ifbt21OiRAkKFSqEt7c3u3btSrPdxo0bqVGjBk5OTtSoUYPNmzdnp2jC0pKS1HErly9DhQqwejVk4Y/Snj17WLFiBTqdjs2bN0tYecaZulqzNGw5o6WGRgZS2y4t1SPIRmAJCgrC39+fiRMnEhYWRosWLfD19eXq1avpbn/w4EHat2/Pjh07OHXqFG3atKFTp06EhYUZtgkNDaVnz574+flx+vRp/Pz86NGjB8eOHcv+OxOWMXcu/PijOsh240YoUiRLT/vpp58AGDBgAJ07d87NEgoNkEG3lqWlhkYCi+3SUj2CbASW+fPnM3DgQAYNGkT16tUJCAjAw8ODZcuWpbt9QEAAY8eOpWHDhlSuXJkZM2ZQuXJlfvzxR6Nt2rdvz/jx46lWrRrjx4+nXbt2BJhwSaywgv37YcIE9ftFi+CFF7L0tPj4ePbv3w+Aj49P7pRNaIqpf/ikYcsZLTU0Elhsl5bqEZgYWBISEjh16lSaRsbHx4eQkJAs7SMpKYl79+5RtGhRw32hoaFp9tmhQ4dM9xkfH09MTIzRTVhQRIS6TlBSEvTrB4MHZ+lpS5cuxdnZ2dDD1qpVq9wspdAIGXRrWVpqaCSw2C4t1SMwMbBERUWRmJhIqVKljO4vVaoUkZGRWdrHvHnzuH//Pj1SzH4aGRlp8j5nzpyJq6ur4ebh4WHCOxE58vixGlb++w9q1YJly7I0bmXt2rUMHz7c8HOxYsVwd3fPzZIKjZHAYhlaamgksNguLdUjyOag29SVTlGULFXE9evXM3XqVIKCgihZsmSO9jl+/Hiio6MNt2vXrpnwDkSOTJwIBw9CwYLquJUCBZ76lIMHDzI4uRemSpUqlClThg8//DC3Syo0QgbdWpaWGhoJLLZLa8fLpMuaixcvjr29fZqejxs3bqTpIUktKCiIgQMH8t133/Hiiy8aPebm5mbyPp2cnGQmVGvYsgXmzFG/X70aqlR56lPOnTtH165defToET169GD9+vXY2ckky3mJDLq1LAkswpy0UI/AxB4WR0dHvLy8CA4ONro/ODiYpk2bZvi89evXM2DAAL755htefvnlNI97e3un2efu3bsz3aewgkuX1EuYAfz9oXv3pz4lKCiIhg0bcvv2bRo2bEhgYKCElTxIBt1alpY+PwkstktLwReyMXHc6NGj8fPzo0GDBnh7e/PFF19w9epVhg4dCqinaq5fv866desANaz069ePhQsX0qRJE0NPSv78+XF1dQVg1KhRtGzZktmzZ9OlSxe2bNnCnj17OHz4sLnep8ipuDg1oERHg7c3zJ6d6eZJSUl8+OGHfPLJJ4A6uDYoKIj8+fNborRCY2TQrXVooaGRwGK7tBZYTP5Xt2fPngQEBDB9+nTq1avHwYMH2bFjB+XLlwcgIiLCaE6Wzz//nMePHzN8+HDc3d0Nt5QThTVt2pRvv/2WNWvWUKdOHQIDAwkKCqJx48ZmeIsixxQF3n4bwsKgeHHYsAEcHTPZXOF///ufIayMGTOGn3/++amnDcWzTwKLZWipoZHAYru0VI8gm1PzDxs2jGHDhqX7WGBgoNHP+vk2nqZ79+50z8IpBmEFixdDYCDY2cH69VC2bKabf/bZZ6xcuRI7OztWr15Nf/1pJJFnyaBby9JSQyOBxXZpqR5BNq8SEnnIvn0werT6/dy5kGrAdGq7d+/m3XffBWD27NkSVgQgg24tTUsNjQQW26WlegQSWERmrlyB11+HxETo2xeSg0h64uLiGDRoEB06dODx48f06tWL9/SrN4s8TwbdWpaWGhoJLLZLS/UIZLVmkZEHD9SVl2/dAi8v+OKLDCeHu379Ol27duXEiRPodDoGDBjAkiVL5I+TMJBBt5alpYZGAovt0lI9AgksIj2KAm+9BadPQ4kSsHkzZHB1T0xMDK1ateLixYsULVqUoKCgNPPsCKEngcUytNTQSGCxXVqqRyCBRaRn7lwICoJ8+dSZbDNZ9mDUqFFcvHiRcuXKsW/fPipWrGjBggpbIYNuLUtLDY0EFtulpXoEMoZFpLZ7N4wfr36/aBG0aJHhphs3biQwMBCdTsdXX30lYUVkSAbdWpaWGhoJLLZLS/UIJLCIlC5fhl691BWYBw6E5MkA03PlyhXD2kDjxo2jRSbBRggZdGtZWmpoJLDYLi3VI5DAIvQePIDXXoPbt6FhQ1iyJN1BtoqisHHjRjp06MCdO3do2LAhU6dOtXx5hU2RQbeWpaWGRgKL7dJSPQIZwyJAHWQ7dCiEh6uDbDduBGfnNJvduXOHfv36sW3bNgBKlizJ999/j2Mms94KkZIEFsvQ0ucngcV2aS2wSA+LUHtTvvwS7O3VafdTDbK9fv06J06coGnTpmzbtg1HR0cmTpzImTNnKFeunJUKLWyJDLq1Di00NBJYbJfWAov0sOR1hw4Zz2TburXhocTERFavXs3QoUNJSkoCoGzZsvz444/Uq1fP8mUVNksG3VqWlhoaCSy2S0v1CKSHJW+LiFBnsn38GN54A/z9AXj48CGTJ0+mcOHCDBkyxBBWmjVrxrFjxySsCJPJoFvL0lJDo4UyiOzRUj0C6WHJu5KSYMAA+O8/qF0bVq4EnY5Lly7RrVs3wsPDAciXLx8jRoxg5syZOKczrkWIrJBBt5alpYZGjqnt0lI9AgksedfixeqcK87O6iRxLi789NNP9OnThzt37lC8eHGWLVtG165dsbe3t3ZpxTNCAotlaKmhkWNqu7RUj0BOCeVNZ87ABx+o38+bR1LVqkybNo2XX36ZO3fu0KhRI3755Re6d+8uYUWYhQy6tSwtNTRyTG2XluoRSA9L3pOYCP37Q3w8vPwyd954g76dOrFjxw4A3n77bRYsWICTk5OVCyqeJTLo1rK01NBIYLFdWqpHIIEl7/n8cwgLg8KFebB4MR19fTl+/DjOzs4sX76c/v37W7uE4hkkg24tS0sNjQQW26WlegRySihHFi9ezFtvvUVoaKi1i5I1N2/CxIkAJE6bRi9/f44fP07RokUJCQmRsCJyjQy6tSwtNTRyTG2XluoRSGDJkZ07d7JmzRr++OMPaxclayZPhrt3oW5dxly6xNatW3FycmLr1q3Ur1/f2qUTeYAEFsvQUkMjx9R2aakegQSWHHFxcQHg/v37Vi5JFly4oF66DPzQowcLFi4E4Msvv6RZs2bWLJnIA2TQrWVpqaGRY2q7tFSPQAJLjthUYJkyBRITudu+Pf9LDitjxozh9ddft3LBRF4gg24tS0vhQAKL7ZLA8gyxmcDy+++wfj0K8F6BAty4cYNq1arx8ccfW7tkIo+QQbfWoYWGRgKL7ZLA8gyxmcAyfz4oCjNq1mT1li0AfPbZZ7LKsrAYGXRrWVpqaLRQBpE9WqpHIIElR2wisNy4AV9/zZ/A1OTBwYsXL6Zt27bWLZfIkySwWIaWGho5prZLS/UIJLDkiE0Els8/h/h4PihcmMeJibzyyiuMGDHC2qUSeYwMurUsLTU0ckxtl5bqEUhgyZHnnnsO0HBgiY+HpUv5Fdhy9y52dnbMnTvX2qUSeZAMurUsLTU0Elhsl5bqEUhgyRF9D0tsbKyVS5KBH36AyEhm588PwOuvv061atWsWyaRJ8mgW8vSUkMjgcV2aakegQSWHNH8KaFVq7gEfBsXB8AH+gUPhbASGcNiGVpqaOSY2i4t1SOQwJIjmg4sV65AcDDzgCRFoUOHDjKbrbAauUrIsrTU0MgxtV1aqkcggSVHNB1Y1qzhP2C1nXqIx40bZ93yiDxNBt1alpYaGjmmtktL9QgksOSIZgNLYiKsXs0iIC4picaNG9OqVStrl0rkYTLo1rK01NBIYLFdWqpHkM3AsnTpUjw9PXF2dsbLy4tDhw5luG1ERAS9e/ematWq2NnZ4e/vn2abwMBAdDpdmltc8tgLrdJsYAkO5v4///BZcmUbN26c/LEQViWDbi1LSw2NBBbbpaV6BNkILEFBQfj7+zNx4kTCwsJo0aIFvr6+XL16Nd3t4+PjKVGiBBMnTqRu3boZ7rdQoUJEREQY3ZydnU0tnkWlDCxaOaAArFzJ90C0olCxYkU6d+5s7RIJAcgYFkvR0ucnx9R22XxgmT9/PgMHDmTQoEFUr16dgIAAPDw8WLZsWbrbV6hQgYULF9KvXz9cXV0z3K9Op8PNzc3opnX6wJKYmEhCQoKVS5Psxg3YupVVyT8OHDgQOzs58yesSwbdWocWGho5prbLpgNLQkICp06dwsfHx+h+Hx8fQkJCclSQ2NhYypcvT9myZXnllVcICwvLdPv4+HhiYmKMbpamDyygodNCX37Jn48ecQiws7NjwIAB1i6REDLo1sK01NDIMRXmYlJgiYqKIjExkVKlShndX6pUKSIjI7NdiGrVqhEYGMjWrVtZv349zs7ONGvWjPPnz2f4nJkzZ+Lq6mq4eXh4ZPv1sytfvnw4OTkBGpk8TlFgxQpD78rLL79M6dKlrVokIUAG3VqaBBZhDlqqR5DNQbepK56iKDmqjE2aNKFv377UrVuXFi1asGHDBqpUqcLixYszfM748eOJjo423K5du5bt188JTQ28PXSI+D//ZG3yjwMHDrRqcYTQk0G3lqWlhkYCi+3SUj0CyGfKxsWLF8fe3j5Nb8qNGzfS9LrkhJ2dHQ0bNsy0h8XJycnQu2FNLi4u3L59WxuBZcUKFgI3gDJlyvDSSy9Zu0RCGJExLJahpYZGjqnt0lI9AhN7WBwdHfHy8iI4ONjo/uDgYJo2bWq2QimKQnh4OO7u7mbbZ27RTA/L7dvc3rCBj5N/nDFjBg4ODlYtkhB6MujWsrTU0MgxtV1aqkdgYg8LwOjRo/Hz86NBgwZ4e3vzxRdfcPXqVYYOHQqop2quX7/OunXrDM8JDw8H1HEeN2/eJDw8HEdHR2rUqAHAtGnTaNKkCZUrVyYmJoZFixYRHh7OZ599Zoa3mLs0E1i+/JKvExK4B9SqVYu+fftatzxCpGDqoFuRM1pqaCSw2C4t1SPIRmDp2bMnt27dYvr06URERFCrVi127NhB+fLlAXWiuNRzsqRcw+bUqVN88803lC9fnitXrgBw9+5dhgwZQmRkJK6urtSvX5+DBw/SqFGjHLw1y9BEYEkebLsm+cfBgwfLpcxCU6SHxbK01NDIMbVdWqpHkI3AAjBs2DCGDRuW7mOBgYFp7nvam12wYAELFizITlGsThOBJTSUsN9/JwxwcHCgd+/e1iuLEOmQQbeWpaWGRgKL7dJSPQJZSyjHnnvuOcDKlzUvXszC5G+7d+9O8eLFrVcWITIhPSyWoaWGRo6p7dJSPQIJLDlWuHBhQD2tZRVXrxK5YQPrk38cNWqUdcohRCbklJBlaamhkWNqu7RUj0ACS45ZPbAsXsyUpCQSgKZNm9K4cWPrlEOITMigW8vSUjiQwGK7JLA8Y/SB5c6dO5Z/8ZgYflu2jJXJP86ePdvyZRAiC6SHxTq00NDIMbVdElieMUWKFAGs1MOyciVj7t8nCXita1eaN29u+TIIkQUy6NaytNTQSGCxXVqqRyCBJcesdkro3j32TZ/OTsDB3p7Zc+ZY9vWFyAbpYbEMLTU0ckxtl5bqEUhgyTGrnRIKCCAgOhqAQYMG8fzzz1v29YUwgazWbFlaamjkmNouLdUjkMCSY1Y5JXTrFpfmzOHH5B9Hvfuu5V5biGyQ1ZotS0sNjQQW26WlegQSWHLMKj0ss2ezNDYWBfBp356qVata7rWFyAYZdGtZWmpo5JjaLi3VI5DAkmP6Hpbo6GiSkpJy/wWvX+f+okWsSv5x5Dvv5P5rCpFDMujWsrTU0EhgsV1aqkcggSXHXF1dAfWAxsTE5P4LfvQRX8fHcxeoWLEivr6+uf+aQpiJ9LBYhpYaGjmmtktL9QgksOSYs7Mzzs7OgAXGsVy4gLJyJYuTfxw+fDj29va5+5pCmIEMurUsLTU0ckxtl5bqEUhgMQuLDbydMoXNiYn8BhQoUIC33nord19PCDORQbeWpaWGRgKL7dJSPQIJLGZhkYG3p0+z+Ztv6JH848CBAw2vK4TWyaBby9JSQyPH1HZpqR6BBBazyPXJ4xSFv4cO5U0gEejduzdzZKI4YUNk0K1laenzk8Biu7QWWPJZuwDPAv0podzqYXm8YQN9jh4lGmhSvz6BgYE4ODjkymsJkZukh8WytNDQyDG1XVoLLNLDYgb6HpZbt26Zf+cPHvDhkCEcAQo6OvLNxo0SVoTNkUG3lqWlhkaOqe3SUj0CCSxmUblyZQB+/fVXs+97bZ8+zEy+XPrzzz/H09PT7K8hRG6TQbeWpaWGRgKL7dJSPQIJLGbRuHFjAI4dO2bW/R7euJHBP/wAwIRXX6XXgAFm3b8QliKDbi1LSw2NHFPbpaV6BBJYzKJRo0YAnD9/ntu3b5tln/Hx8Qzo149HQPfixfno++/Nsl8hrEEG3VqWlhoaCSy2S0v1CCSwmEWxYsUMqyWfOHEix/u7cuUK3Zs35+KDB7gBq7dvx04miBPPAOlhsQytNTQgx9QWaa0eSWAxE/1poZwGluvXr9OsaVO2nTwJwNxOnSiY3IMjhK2SQbeWpaWGRo6p7dJSPQIJLGZTo0YNQD0tlF3Lly+ndu3a/BsRQTVgt5sbfb/91kwlFMJ6ZNCtZWmpoZHAYru0VI9A5mExm0qVKgFw8eLFbD3/6NGjDB8+nKSkJKoA24GKa9ZAgQLmK6QQViKDbi1LSw2NHFPbpaV6BBJYzCargSUiIoLff/+dGzduMHv2bG7duoW3tzcHDhwgKSmJ3s7OrIuLw/7tt6FjR0sUXQiLkUG3lqGlhkYCi+3SUj0CCSxmow8skZGR3L9/HxcXlzTbHDlyhBdffJG4uDij+79PvgKomosLi+7fx75GDZg3L/cLLYSFSA+LZWmpoZFjaru0VI9AAovZFClShCJFinDnzh0uXbpE7dq1jR6PjIzkjTfeIC4ujnLlyuHm5kaDBg1o3bo1v/32G0UPHWLIvn3kd3aG9eshf34rvRMhzE8G3VqWlj4/Oaa2SwLLM6xSpUqcPHmSOnXqsGbNGvr3749Op+PgwYOMGjWKf/75h6pVq3LixAkKFixoeN7rN2/Cvn3qD2vXQp06VnoHQuQOGXRrHVr4PCWw2C4JLM8wNzc3w/dvvvkmp0+fpnbt2gwcOBCA4sWLs23bNqOwwg8/wIgR6vcffQQ9eliwxEJYhpwSsiwtNTRyTG2XluoRyGXNZtWiRQujnwMCAgxhpVevXoSEhBgmmAPg6FHo1QsUBQYPhokTLVlcISxOBt1ahpYaGgkstktL9QgksJjVO++8w08//cSDBw8ICAjAzk79eHv06MFXX31lWCQRgAsXoFMniIuDl16CpUtBfqHFM0p6WCxLSw2NHFPbpaV6BNkMLEuXLsXT0xNnZ2e8vLw4dOhQhttGRETQu3dvqlatip2dHf7+/ulut3HjRmrUqIGTkxM1atRg8+bN2SmaVTk7O9OxY0fy58/PqFGjuHbtGufPn+fbb781hBcAHj6Erl0hKgq8vCAoCPLJ2Tnx7JJBt5alpYZGjqnt0toxMzmwBAUF4e/vz8SJEwkLC6NFixb4+vpy9erVdLePj4+nRIkSTJw4kbp166a7TWhoKD179sTPz4/Tp0/j5+dHjx49zL76saWVLl2a559/Pu1Bf+89+O03KFkSfvwRnnvOOgUUwkJk0K1lSWAR5qSFegTZCCzz589n4MCBDBo0iOrVqxMQEICHhwfLli1Ld/sKFSqwcOFC+vXrh6ura7rbBAQE0L59e8aPH0+1atUYP3487dq1IyAgwNTiad+mTaD/rL78EtzdrVseISxATglZlgQWYQ5aqkdgYmBJSEjg1KlT+Pj4GN3v4+NDSEhItgsRGhqaZp8dOnTI0T416eZNdXAtwNixkOo9C/Gsk0G3lqGlhkYCi+3SUj0CEy9rjoqKIjExkVKlShndX6pUKSIjI7NdiMjISJP3GR8fT3x8vOHnmJiYbL++xYwdC7dvq/OsfPyxtUsjhMVID4tlaamhkWNqu7RUjyCbg25TVzxFUXJcGU3d58yZM3F1dTXcPDw8cvT6ue7gQQgMVK8E+vxzcHCwdomEsBgZdGtZWmpo5JjaLi3VIzAxsBQvXhx7e/s0PR83btxI00NiCjc3N5P3OX78eKKjow23a9euZfv1c11CArz9tvr94MHQpIl1yyOEhcmgW8vSUkMjgcV2aakegYmBxdHRES8vL4KDg43uDw4OpmnTptkuhLe3d5p97t69O9N9Ojk5UahQIaObZs2bB2fPQokSMHOmtUsjhMXJKSHL0tLnJ8fUdmktsJg8+cfo0aPx8/OjQYMGeHt788UXX3D16lWGDh0KqD0f169fZ926dYbnhIeHAxAbG8vNmzcJDw/H0dGRGjVqADBq1ChatmzJ7Nmz6dKlC1u2bGHPnj0cPnzYDG/Ryi5ehOnT1e/nz4eiRa1bHiGsSAbdWpYWGhoJLLbL5gNLz549uXXrFtOnTyciIoJatWqxY8cOypcvD6gTxaWek6V+/fqG70+dOsU333xD+fLluXLlCgBNmzbl22+/ZdKkSUyePJlKlSoRFBRE48aNc/DWNEBRYPhwdTbbdu2gTx9rl0gIq5AeFsvSUkOjhTKI7NFSPYJsLn44bNgwhg0blu5jgYGBae7Lypvt3r073bt3z05xtGvDBti1CxwdZep9kafJoFvL0lJDI8fUdmmpHoGsJZR77t6FUaPU7ydOhCpVrFocIaxJBt1alpYaGgkstktL9QgksOQORVHDyn//QdWq8MEH1i6REFYlp4QsS0sNjRxT26WlegQSWHLHihWwbh3Y2anfOzlZu0RCaIIMurUMLTU0Elhsl5bqEUhgMb9Tp2DkSPX7Tz6BFi2sWx4hNEB6WCxLSw2NHFPbpaV6BBJYzOv2bejeXZ0ornNndSp+IYQMurUwLTU0ckxtl5bqEUhgMZ+kJPDzgytXoGJFWLtWPSUkhJBBtxampYZGAovt0lI9Agks5vPJJ7BjBzg7w/ffQ+HC1i6REJohp4QsS0sNjRxT26WlegQSWMxj3z6YMkX9ftkySDFRnhDiCRl0axlaamgksNguLdUjkMCSc/fvw6BB6qXMgwbBgAHWLpEQmiM9LJalpc9PjqntksDyrJk8GS5dAg8Pda0gIUQaMujWOrTQ0MgxtV0SWJ4loaEQEKB+//nnULCgVYsjhFbJoFvL0lJDI4HFdmmpHoEEluyLi4O33lJPBfXvD76+1i6REJolp4QsS0sNjRxT26WlegQSWLLvww/hjz/AzU1OBQmRRTLo1jK01NBIYLFdWqpHIIEle3btgk8/Vb9fvhyKFrVueYTQOOlhsSwtNTRyTG2XluoRSGAx3f790LWreipo8GDo0sXaJRJC82TQrWVpqaGRY2q7tFSPQAKLaXbvhpdfhocP1TErixZZu0RC2AQZdGtZWmpoJLDYLi3VI5DAknWrV0OHDvDgAXTsCJs2qbPaCiGyTE4JWYaWGho5prZLS/UIJLA8XXw8DB0KAweqP/fuDZs3S1gRwgSm/uGTxi1ntNTQSGCxXVqqRwD5rF0ATUtIgG7dYPt29ed33oEFC2RRQyFMJINuLUtLDY0cU9ulpXoEEliezslJ7U35/HN1NWb5pRPCZDLo1rK01NDIMbVdWqpHIIElc46O8O23cOYMvPCCtUsjhM2SQbeWpaVwIIHFdmktsMi5jadxcJCwIoSZyCkhy9JCQyPH1HZJYBFC5Dky6NaytNTQSGCxXVqqRyCBRQhhATLo1rK01NDIMbVdWqpHIIFFCGEBMujWsrTU0MgxtV1aqkcggUUIYQEy6NaytNTQSGCxXVqqRyCBRQhhQXJKyDK01NDIMbVdWqpHIIFFCGEBMujWsrTU0EhgsV1aqkcggUUIYQEy6NaytNTQyDG1XVo7ZhJYhBC5TgbdWpYEFmFOWqhHIIFFCGEBMujWsiSwCHPQUj0CCSxCCAuSU0KWoaWGRo6p7dJSPYJsBpalS5fi6emJs7MzXl5eHDp0KNPtDxw4gJeXF87OzlSsWJHly5cbPR4YGIhOp0tzi4uLy07xhBAaI4NuLUtLn58EFttl84ElKCgIf39/Jk6cSFhYGC1atMDX15erV6+mu/3ly5d56aWXaNGiBWFhYUyYMIF33nmHjRs3Gm1XqFAhIiIijG7Ozs7Ze1dCCE2RMSzWoYWGRo6p7dJaYDF5teb58+czcOBABg0aBEBAQAC7du1i2bJlzJw5M832y5cvp1y5cgQEBABQvXp1Tp48yaeffkq3bt0M2+l0Otzc3LL5NoQQWiZXCVmWlhoaOaa2S0v1CEzsYUlISODUqVP4+PgY3e/j40NISEi6zwkNDU2zfYcOHTh58iSPHj0y3BcbG0v58uUpW7Ysr7zyCmFhYZmWJT4+npiYGKObEEKbZNCtZWmpoZHAYru0VI/AxMASFRVFYmIipUqVMrq/VKlSREZGpvucyMjIdLd//PgxUVFRAFSrVo3AwEC2bt3K+vXrcXZ2plmzZpw/fz7DssycORNXV1fDzcPDw5S3IoSwAulhsQwtNTRyTG2XluoRZHPQbeqKpyhKppUxve1T3t+kSRP69u1L3bp1adGiBRs2bKBKlSosXrw4w32OHz+e6Ohow+3atWvZeStCCAuQQbeWpaWGRgKL7dJSPQITx7AUL14ce3v7NL0pN27cSNOLoufm5pbu9vny5aNYsWLpPsfOzo6GDRtm2sPi5OSEk5OTKcUXQliJDLq1LC01NHJMbZeW6hGY2MPi6OiIl5cXwcHBRvcHBwfTtGnTdJ/j7e2dZvvdu3fToEEDHBwc0n2OoiiEh4fj7u5uSvGEEBolg24tS0sNjRxT26WlegTZOCU0evRoVq5cyerVqzl37hzvvvsuV69eZejQoYB6qqZfv36G7YcOHcrff//N6NGjOXfuHKtXr2bVqlW8//77hm2mTZvGrl27uHTpEuHh4QwcOJDw8HDDPoUQtk0G3VqWlhoaCSy2S0v1CLJxWXPPnj25desW06dPJyIiglq1arFjxw7Kly8PQEREhNGcLJ6enuzYsYN3332Xzz77jNKlS7No0SKjS5rv3r3LkCFDiIyMxNXVlfr163Pw4EEaNWpkhrcohNAK6WGxDC01NHJMbZeW6hFkI7AADBs2jGHDhqX7WGBgYJr7WrVqxS+//JLh/hYsWMCCBQuyUxQhhA2QU0KWpaWGRo6p7dJSPQJZS0gIYQGmNlbSuOWMlhoaCSy2S0v1CCSwCCEsQHpYLEtLn58cU9slgUUIkefIoFvr0MLnKYHFdklgEULkWdLDYhlaamjkmNouLdUjkMAihLAAOSVkWVpqaOSY2i4t1SOQwCKEsAAZdGtZWmpoJLDYLi3VI5DAIoSwAOlhsSwtNTRyTG2XluoRSGARQliADLq1LC01NBJYbJeW6hFIYBFCWJD0sFiGlhoaOaa2S0v1CCSwCCEsQE4JWZbWGhqQY2qLtHbMJLAIIXKdDLq1LC0FFgmhtivlMdNCXZLAIoTIddLDYlkSWIQ5SGARQuRZMujWMiSwCHOQwCKEyHOkh8WytPT5yTG1XRJYhBB5jgQW69BCIyPH1HZJYBFC5Dky6NaytHhKSNgeCSxCiDxHelgsS4uBRY6p7ZHAIoTIs2TQrWVIYBHmIIFFCJHnSA+LZUlgEeYggUUIkedIYLEsCSzCHCSwCCHyHBl0a1kSWIQ5SGARQuQ50sNiWRJYhDlIYBFC5Fky6NYyJLAIc5DAIoTIc6SHxbIksAhzkMAihMhzJLBYlgQWYQ4SWIQQeY4MurUsLX1+EliEuUhgEULkOulhsQ4t/Fcsx9R2SQ+LECLPkkG3liGnhIQ5SGARQuQ50sNiWRJYhDlIYBFC5DkSWCxLAoswBwksQog8RwbdWpYEFmEOz0RgWbp0KZ6enjg7O+Pl5cWhQ4cy3f7AgQN4eXnh7OxMxYoVWb58eZptNm7cSI0aNXBycqJGjRps3rw5O0UTQmiQ9LBYlgQWYQ42H1iCgoLw9/dn4sSJhIWF0aJFC3x9fbl69Wq621++fJmXXnqJFi1aEBYWxoQJE3jnnXfYuHGjYZvQ0FB69uyJn58fp0+fxs/Pjx49enDs2LHsvzMhhObIoFvLkMAizMHmA8v8+fMZOHAggwYNonr16gQEBODh4cGyZcvS3X758uWUK1eOgIAAqlevzqBBg3jrrbf49NNPDdsEBATQvn17xo8fT7Vq1Rg/fjzt2rUjICAg229MCKEd0sNiWRJYhLlpoS6ZFFgSEhI4deoUPj4+Rvf7+PgQEhKS7nNCQ0PTbN+hQwdOnjzJo0ePMt0mo30CxMfHExMTY3QTQmiTBBbLksAizEVLdcmkwBIVFUViYiKlSpUyur9UqVJERkam+5zIyMh0t3/8+DFRUVGZbpPRPgFmzpyJq6ur4ebh4WHKWxFCWJAMurUsLTUyElhsm5bqUrYG3aaueIqiZFoZ09s+9f2m7nP8+PFER0cbbteuXcty+YUQlpXVxkoaN/PQUiMjx9S2aaku5TNl4+LFi2Nvb5+m5+PGjRtpekj03Nzc0t0+X758FCtWLNNtMtongJOTE05OTqYUXwihAZn9M6KFP4rPAi2FAwkstk1LgcWkHhZHR0e8vLwIDg42uj84OJimTZum+xxvb+802+/evZsGDRrg4OCQ6TYZ7VMIYVuyerWBNG7mpYVGRo6pbdNSYDGphwVg9OjR+Pn50aBBA7y9vfniiy+4evUqQ4cOBdRTNdevX2fdunUADB06lCVLljB69GgGDx5MaGgoq1atYv369YZ9jho1ipYtWzJ79my6dOnCli1b2LNnD4cPHzbT2xRCWJMEFsvSUiMjx9S2aakumRxYevbsya1bt5g+fToRERHUqlWLHTt2UL58eQAiIiKM5mTx9PRkx44dvPvuu3z22WeULl2aRYsW0a1bN8M2TZs25dtvv2XSpElMnjyZSpUqERQUROPGjc3wFoUQ1iaDbi1LS42MBBbbpqW6ZHJgARg2bBjDhg1L97HAwMA097Vq1Ypffvkl0312796d7t27Z6c4QgiNkx4Wy9JSIyPH1LZpqS5lK7AIIUR2jR49Gju79IfPhYWFWbg0zyZ9I3Pv3j38/f2tWpbffvsNkMBiq/THbdq0aRQqVAh/f38qVKhglbJIYBFC5DpnZ2ccHR1JSEhg8eLFT93e1dXVAqV6duk/v7i4OBYuXGjl0qjkmNqmwoUL8/DhQ9asWQPAG2+8IYFFCPHsKlCgAJs2bcp09mq94sWLy+nhHCpbtizr16/nzJkz1i4KACVLlqRTp07WLobIhqCgIHbu3Gn4uXTp0lYri07RwokpM4iJicHV1ZXo6GgKFSpk7eIIIYQQIguy2n5na6ZbIYQQQghLksAihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNy2ftApiLftHpmJgYK5dECCGEEFmlb7f17XhGnpnAcu/ePQA8PDysXBIhhBBCmOrevXu4urpm+LhOeVqksRFJSUn8+++/FCxYEJ1OZ+3imE1MTAweHh5cu3aNQoUKWbs4IhU5Ptomx0fb5PhonyWOkaIo3Lt3j9KlS2Nnl/FIlWemh8XOzo6yZctauxi5plChQvILrWFyfLRNjo+2yfHRvtw+Rpn1rOjJoFshhBBCaJ4EFiGEEEJongQWjXNycmLKlCk4OTlZuygiHXJ8tE2Oj7bJ8dE+LR2jZ2bQrRBCCCGeXdLDIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8BiYVOnTkWn0xnd3NzcDI8risLUqVMpXbo0+fPnp3Xr1vz+++9G+4iPj2fkyJEUL14cFxcXOnfuzD///GPpt/LMOHjwIJ06daJ06dLodDp++OEHo8fNdUzu3LmDn58frq6uuLq64ufnx927d3P53dm+px2fAQMGpPmdatKkidE2cnxyz8yZM2nYsCEFCxakZMmSvPrqq/z5559G28jvkPVk5fjYyu+QBBYrqFmzJhEREYbbmTNnDI/NmTOH+fPns2TJEk6cOIGbmxvt27c3rJUE4O/vz+bNm/n22285fPgwsbGxvPLKKyQmJlrj7di8+/fvU7duXZYsWZLu4+Y6Jr179yY8PJydO3eyc+dOwsPD8fPzy/X3Z+uednwAOnbsaPQ7tWPHDqPH5fjkngMHDjB8+HCOHj1KcHAwjx8/xsfHh/v37xu2kd8h68nK8QEb+R1ShEVNmTJFqVu3brqPJSUlKW5ubsqsWbMM98XFxSmurq7K8uXLFUVRlLt37yoODg7Kt99+a9jm+vXrip2dnbJz585cLXteACibN282/GyuY3L27FkFUI4ePWrYJjQ0VAGUP/74I5ff1bMj9fFRFEXp37+/0qVLlwyfI8fHsm7cuKEAyoEDBxRFkd8hrUl9fBTFdn6HpIfFCs6fP0/p0qXx9PTkjTfe4NKlSwBcvnyZyMhIfHx8DNs6OTnRqlUrQkJCADh16hSPHj0y2qZ06dLUqlXLsI0wH3Mdk9DQUFxdXWncuLFhmyZNmuDq6irHzQz2799PyZIlqVKlCoMHD+bGjRuGx+T4WFZ0dDQARYsWBeR3SGtSHx89W/gdksBiYY0bN2bdunXs2rWLFStWEBkZSdOmTbl16xaRkZEAlCpVyug5pUqVMjwWGRmJo6MjRYoUyXAbYT7mOiaRkZGULFkyzf5Lliwpxy2HfH19+frrr9m7dy/z5s3jxIkTtG3blvj4eECOjyUpisLo0aNp3rw5tWrVAuR3SEvSOz5gO79Dz8xqzbbC19fX8H3t2rXx9vamUqVKrF271jDISafTGT1HUZQ096WWlW1E9pnjmKS3vRy3nOvZs6fh+1q1atGgQQPKly/P9u3bee211zJ8nhwf8xsxYgS//vorhw8fTvOY/A5ZX0bHx1Z+h6SHxcpcXFyoXbs258+fN1wtlDqN3rhxw/DfiZubGwkJCdy5cyfDbYT5mOuYuLm58d9//6XZ/82bN+W4mZm7uzvly5fn/PnzgBwfSxk5ciRbt25l3759lC1b1nC//A5pQ0bHJz1a/R2SwGJl8fHxnDt3Dnd3dzw9PXFzcyM4ONjweEJCAgcOHKBp06YAeHl54eDgYLRNREQEv/32m2EbYT7mOibe3t5ER0dz/PhxwzbHjh0jOjpajpuZ3bp1i2vXruHu7g7I8cltiqIwYsQINm3axN69e/H09DR6XH6HrOtpxyc9mv0dMsvQXZFl7733nrJ//37l0qVLytGjR5VXXnlFKViwoHLlyhVFURRl1qxZiqurq7Jp0yblzJkzSq9evRR3d3clJibGsI+hQ4cqZcuWVfbs2aP88ssvStu2bZW6desqjx8/ttbbsmn37t1TwsLClLCwMAVQ5s+fr4SFhSl///23oijmOyYdO3ZU6tSpo4SGhiqhoaFK7dq1lVdeecXi79fWZHZ87t27p7z33ntKSEiIcvnyZWXfvn2Kt7e3UqZMGTk+FvL2228rrq6uyv79+5WIiAjD7cGDB4Zt5HfIep52fGzpd0gCi4X17NlTcXd3VxwcHJTSpUsrr732mvL7778bHk9KSlKmTJmiuLm5KU5OTkrLli2VM2fOGO3j4cOHyogRI5SiRYsq+fPnV1555RXl6tWrln4rz4x9+/YpQJpb//79FUUx3zG5deuW0qdPH6VgwYJKwYIFlT59+ih37tyx0Lu0XZkdnwcPHig+Pj5KiRIlFAcHB6VcuXJK//7903z2cnxyT3rHBlDWrFlj2EZ+h6znacfHln6HdMlvSAghhBBCs2QMixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNO//mpsDdofvaw4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "for _key, key in enumerate(report.keys()):\n", + " if _key < 1:\n", + "\n", + " rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))\n", + " rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()\n", + " wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])\n", + "\n", + " miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5\n", + " maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5\n", + " minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5\n", + " maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5\n", + "\n", + " plt.figure()\n", + " plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))\n", + " plt.title(f'NIS01_20210403_{key}')\n", + " for k,i in report[key].items():\n", + " plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)\n", + "\n", + " for k,i in report[key].items():\n", + " plt.figure()\n", + " in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())\n", + " in_situ = np.genfromtxt(in_situ_path, skip_header=3)\n", + " plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')\n", + " mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))\n", + " plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')\n", + " plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "85419744-2391-48f0-b6c2-239390d4b994", + "metadata": {}, + "source": [ + "## Per-Pixel Retrievals\n", + "\n", + "This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).\n", + "\n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f60f1ae9-754b-4c25-bc51-70b792debed7", + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5efac6d4-c9f5-4292-a8e1-739939056ac1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n" + ] + } + ], + "source": [ + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')\n", + "config.input.loc_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "467786f7-35a6-4472-92c5-1fa753da9e3d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line\n" + ] + } + ], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fdbd8001-530b-497f-a2c8-fdda0a2206d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(13, 428)\n", + "[0.10742364 0.60519719]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def closest_wl(mv):\n", + " return np.argmin(np.abs(io.meas_wl-mv))\n", + "\n", + "wl_nan = io.meas_wl.copy()\n", + "wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan\n", + "wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan\n", + "\n", + "fig = plt.figure(figsize=(14,5))\n", + "print(states.shape)\n", + "offset = 0\n", + "for n in range(0,states.shape[0],4):\n", + " lab = f'Step {n}'\n", + " if n == 0:\n", + " lab = 'Algebraic inversion at initial guess'\n", + " \n", + " plt.plot(wl_nan, states[n,:-2] + offset, label=lab)\n", + " offset += 0.04\n", + "plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')\n", + "plt.legend()\n", + "\n", + "print(states[-1,-2:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8fcb0f-cd8e-47b9-9146-2e1335afcfd2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/html/sensor_examples/neon/neon.html b/isofit-tutorials/build/html/sensor_examples/neon/neon.html new file mode 100644 index 0000000..c34f178 --- /dev/null +++ b/isofit-tutorials/build/html/sensor_examples/neon/neon.html @@ -0,0 +1,1614 @@ + + + + + + + NEON — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

NEON

+

Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.

+
+

Setup

+

This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.

+

Prerequisites:

+
    +

  • Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the ‘data’ folder which includes the ‘subsets’ directory.

    • +

  • Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)

    • +
+
+
[1]:
+
+
+
import logging
+import os
+from pathlib import Path
+from types import SimpleNamespace
+
+import matplotlib.pyplot as plt
+import numpy as np
+import scipy
+from spectral.io import envi
+
+import isofit
+from isofit.utils.apply_oe import apply_oe
+from isofit.utils.surface_model import surface_model
+from isofit import ray
+ray.shutdown()
+
+
+
+

ISOFIT needs at minimum three pieces as input:

+
1. Radiance measurements (rdn)
+2. Observation values    (obs)
+3. Location information  (loc)
+
+
+

This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can ‘fake’ the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:

+
Radiance
+├── 173647
+│   ├── NIS01_20210403_173647_obs_ort
+│   ├── NIS01_20210403_173647_obs_ort.hdr
+│   ├── NIS01_20210403_173647_rdn_ort
+│   └── NIS01_20210403_173647_rdn_ort.hdr
+└── 174150
+    ├── NIS01_20210403_174150_obs_ort
+    ├── NIS01_20210403_174150_obs_ort.hdr
+    ├── NIS01_20210403_174150_rdn_ort
+    └── NIS01_20210403_174150_rdn_ort.hdr
+
+
+

These files have corresponding in situ data as well, and below we’ve encoded the locations of each, which we can use to help subset data files.

+
+
[19]:
+
+
+
# Enable the ISOFIT logger
+logging.getLogger().setLevel(logging.INFO)
+
+# Find where we're running the tutorial from
+home = os.path.abspath(os.getcwd())
+
+# Path to the input NEON data
+subset_dir = str(Path('~/.isofit/neon_subset').expanduser())
+print(f'Data subset directory at: {subset_dir}')
+
+# Path to write isofit output
+output = str(Path('~/.isofit/neon_subset/output').expanduser())
+if os.path.isdir(output) is False:
+    os.mkdir(output)
+
+if os.path.isdir(subset_dir) is False:
+    os.mkdir(subset_dir)
+
+surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())
+print(f'Surface model at: {surface_model_path}')
+neon_id = '173647'
+
+
+# Optionally set some environment variables as needed
+#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'
+#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'
+
+print(f'sRTMnet emulator path (required): {os.environ["EMULATOR_PATH"]}')
+print(f'6s path (required): {os.environ["SIXS_DIR"]}')
+
+%matplotlib inline
+
+
+
+
+
+
+
+
+Data subset directory at: /Users/bgreenbe/.isofit/neon_subset
+Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json
+sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5
+6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs
+
+
+
+
[3]:
+
+
+
# Extract the image locations of each point of interest (POI)
+# These are defined in the NEON report as pixel locations, so we round here to convert to indices
+report = {}
+report['173647'] = {           # Upp L Y  | Low R Y  | Upp L X | Low R X
+    'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),
+    'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),
+    'Veg'      : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),
+    'RoadEW'   : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),
+    'RoadNS'   : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)
+}
+report['174150'] = {           # Upp L Y | Low R Y | Upp L X  | Low R X
+    'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),
+    'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),
+    'Veg'      : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),
+    'RoadEW'   : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),
+    'RoadNS'   : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)
+}
+# Converts numpy array to comma-separated string for ISOFIT
+toString = lambda array: ', '.join(str(v) for v in array)
+
+
+
+
+
[4]:
+
+
+
# Which NEON date to process - change this to process a different date
+neon_id = list(report.keys())[0]
+
+# Select the locations from the neon id -- roi == Regions of Interest
+roi = report[neon_id]
+
+
+
+
+

Loc file generation

+

NEON doesn’t distribute (?) a loc file, so let’s fake one for now. We’ll do this for the full file and for the subset.

+
+
[5]:
+
+
+
def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):
+    """
+    Retrieves the metadata from an envi header
+
+    Parameters
+    ----------
+    rdn: str
+        Path to the RDN header file containing metadata
+    remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']
+        Removes keys from the metadata dictionary
+    """
+    rdn_ds   = envi.open(file)
+    metadata = rdn_ds.metadata.copy()
+    for key in remove:
+        if key in metadata:
+            del metadata[key]
+        else:
+            print(f'Key {key!r} not found in the metadata, skipping')
+
+    return metadata
+
+def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):
+    """
+    Creates a fake LOC file
+
+    Parameters
+    ----------
+    rdn: str
+        Path to the RDN header file containing metadata
+    lon: float
+        Longitude value for location
+    lat: float
+        Latitude value for location
+    elv: float
+        Elevation in kilometers
+    output: str, default=None
+        Path to write the LOC file to. If None, will attempt to replace the
+        substring 'rdn' in the `rdn` path with `loc`
+    **kwargs
+        Additional arguments passed to getMetadata()
+    """
+    if not output:
+        if 'rdn' in rdn:
+            output = rdn.replace('rdn', 'loc')
+        else:
+            Logger.error('No ouput file specified and cannot generate a unique name')
+            return False
+
+    metadata = getMetadata(rdn, **kwargs)
+    metadata['bands'] = 3
+
+    ds  = envi.create_image(output, metadata, ext='', force=True)
+    loc = ds.open_memmap(interleave='bip', writable=True)
+
+    loc[..., 0] = lon
+    loc[..., 1] = lat
+    loc[..., 2] = elv
+
+    del ds, loc
+
+def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):
+    """
+    Creates a fake OBS file
+
+    Parameters
+    ----------
+    rdn: str
+        Path to the RDN file containing metadata
+    param0: int, float, default=0
+        Parameter 0
+    sea: int, float, default=0
+        Solar Azimuth
+    sez: int, float, default=0
+        Sensor Zenith
+    soa: int, float, default=0
+        Solar Azimuth
+    soz: int, float, default=0
+        Solar Zenith
+    phase: int, float, default=0
+        Phase
+    slope: int, float, default=0
+        Slope
+    aspect: int, float, default=0
+        Aspect
+    cosi: int, float, default=0
+        COS(i)
+    param9: int, float, default=0
+        Parameter 9
+    param10: int, float, default=0
+        Parameter 10
+    output: str, default=None
+        Path to write the OBS file to. If None, will attempt to replace the
+        substring 'rdn' in the `rdn` path with `obs`
+    **kwargs
+        Additional arguments passed to getMetadata()
+    """
+    if not output:
+        if 'rdn' in rdn:
+            output = rdn.replace('rdn', 'loc')
+        else:
+            print('No ouput file specified and cannot generate a unique name')
+            return False
+
+    rdn_ds   = envi.open(rdn)
+    metadata = getMetadata(rdn, **kwargs)
+    metadata['bands'] = 11
+
+    ds  = envi.create_image(output, metadata, ext='', force=True)
+    obs = ds.open_memmap(interleave='bip', writable=True)
+
+    obs[...,  0] = param0
+    obs[...,  1] = sea
+    obs[...,  2] = sez
+    obs[...,  3] = soa
+    obs[...,  4] = soz
+    obs[...,  5] = phase
+    obs[...,  6] = slope
+    obs[...,  7] = aspect
+    obs[...,  8] = cosi
+    obs[...,  9] = param9
+    obs[..., 10] = param10
+
+    del ds, obs
+
+
+
+
+
[6]:
+
+
+
fakeLOC(
+    rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),
+    lon = -105.237000,
+    lat = 40.125000,
+    elv = 1689.0
+)
+
+
+
+
+
+
+
+
+Key 'band names' not found in the metadata, skipping
+
+
+
+
+
+

Apply OE

+

The next part walks through running the ISOFIT utility script isofit/utils/apply_oe.py. This is the first step of executing ISOFIT and will generate a default configuration.

+
+
[7]:
+
+
+
output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())
+surface_model(**{
+    'config_path': surface_model_path,
+    'output_path': output_surface_file,
+    'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')
+})
+
+
+
+
+
+
+
+
+0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']
+
+
+
+
[9]:
+
+
+
kwargs = {
+        'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance
+        'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location
+        'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations
+        'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory
+        'sensor': 'neon',
+        "surface_path": output_surface_file, # Surface priors - often changes
+        'emulator_base': os.environ['EMULATOR_PATH'],
+        'n_cores': 4,
+        "wavelength_path": None,
+        "surface_category": "multicomponent_surface",
+        "rdn_factors_path": None, # RCC update used 'on the fly'
+        "channelized_uncertainty_path": None, # Channelized uncertainty - if you have an instrument model
+        "model_discrepancy_path": None, # Model discrepancy term - handle things like unknown radiative transfer model effects
+        "lut_config_file": None,
+        "logging_level": "INFO",
+        "log_file": None,
+        "presolve": True, # Attempts to solve for the right wv range
+        "analytical_line": True, # mathematical representation of OE given that the atmsophere is known
+        "ray_temp_dir": "/tmp/ray",
+        "segmentation_size": 10,
+        "num_neighbors": [5],
+        "atm_sigma": [0.5],
+        "pressure_elevation": False,
+}
+
+apply_oe(**kwargs)
+
+
+
+
+
+
+
+
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....
+INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647
+INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without
+INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns
+WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202
+INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...
+2025-07-08 15:20:10,698 INFO worker.py:1917 -- Started a local Ray instance.
+(segment_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: starting
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn
+2025-07-08 15:20:11,728 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs
+(segment_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: completing
+2025-07-08 15:20:11,781 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+(extract_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: starting
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc
+2025-07-08 15:20:11,825 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2  0.84 1.49 2.13 2.77 3.42 4.06 4.7  5.35 5.99]
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.
+INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl
+INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess
+INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json
+INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues
+INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.
+(extract_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: starting
+2025-07-08 15:20:11,882 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs
+(extract_chunk pid=17119) INFO:2025-07-08,15:20:11 ||| 0: starting
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions
+INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration
+INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations
+INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file
+INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions
+INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations
+(streamSimulation pid=17119) INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini
+INFO:2025-07-08,15:20:14 || common.py:__call__() |  20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)
+INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:14 || common.py:__call__() |  30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)
+INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:14 || common.py:__call__() |  40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)
+INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:14 || common.py:__call__() |  50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)
+INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:15 || common.py:__call__() |  60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)
+INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:15 || common.py:__call__() |  70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)
+INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:15 || common.py:__call__() |  80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)
+INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:15 || common.py:__call__() |  90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)
+INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)
+INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions
+INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl
+INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size
+INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator
+INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc
+INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations
+(streamSimulation pid=17119) INFO:2025-07-08,15:20:18 ||| Loading LUT into memory
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+(streamSimulation pid=17119) INFO:2025-07-08,15:20:18 ||| Loading LUT into memory
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() |  90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions
+INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores
+WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
+I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:"2025-07-08T15:20:19.280425-07:00", file_line:1171, file:"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc"}
+(Worker pid=17157) INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete
+(Worker pid=17157) INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11
+(Worker pid=17158) INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)
+(Worker pid=17159) INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10 [repeated 8x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete [repeated 8x across cluster]
+(Worker pid=17157) INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10 [repeated 8x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete [repeated 8x across cluster]
+(Worker pid=17159) INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11 [repeated 8x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete [repeated 8x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11 [repeated 7x across cluster]
+(Worker pid=17158) INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete [repeated 4x across cluster]
+(Worker pid=17160) INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11 [repeated 5x across cluster]
+INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete.  34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.
+INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology
+INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded.  Aerosol State Vector:
+{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}
+Aerosol LUT Grid:
+{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}
+Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt
+INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl
+INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT
+INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json
+INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues
+INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.
+2025-07-08 15:20:53,541 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions
+INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration
+INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions
+INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations
+INFO:2025-07-08,15:20:59 || common.py:__call__() |  10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)
+INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:03 || common.py:__call__() |  20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)
+INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:08 || common.py:__call__() |  30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)
+INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:13 || common.py:__call__() |  40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)
+INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:17 || common.py:__call__() |  50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)
+INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:21 || common.py:__call__() |  60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)
+INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:27 || common.py:__call__() |  70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)
+INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:31 || common.py:__call__() |  80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)
+INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:35 || common.py:__call__() |  90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)
+INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)
+INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions
+INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl
+INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size
+INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator
+INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc
+INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl
+INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations
+INFO:2025-07-08,15:21:43 || common.py:__call__() |  10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)
+INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:44 || common.py:__call__() |  60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)
+INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || common.py:__call__() |  70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || common.py:__call__() |  80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || common.py:__call__() |  90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk
+INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions
+INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores
+I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc", file_line:1171, created_time:"2025-07-08T15:21:46.660474-07:00", http2_error:2, grpc_status:14}
+I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:"2025-07-08T15:21:46.660733-07:00", file_line:1171, file:"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc"}
+(Worker pid=17536) ERROR:2025-07-08,15:21:47 |||
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (32,0).
+(Worker pid=17536)                     Results for this pixel will be all zeros.
+(Worker pid=17536)
+(Worker pid=17536) Traceback (most recent call last):
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv)
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv)
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic(
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2)
+(Worker pid=17536) INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete [repeated 4x across cluster]
+(Worker pid=17159) INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17538) ERROR:2025-07-08,15:21:52 |||  [repeated 27x across cluster]
+(Worker pid=17538)                     Encountered the following ValueError in (row,col) (27,0). [repeated 27x across cluster]
+(Worker pid=17538)                     Results for this pixel will be all zeros. [repeated 27x across cluster]
+(Worker pid=17538) Traceback (most recent call last): [repeated 27x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 27x across cluster]
+(Worker pid=17538)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 27x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 27x across cluster]
+(Worker pid=17538)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 27x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 27x across cluster]
+(Worker pid=17538)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 27x across cluster]
+(Worker pid=17538) ValueError: not enough values to unpack (expected 3, got 2) [repeated 27x across cluster]
+(Worker pid=17538) INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete [repeated 3x across cluster]
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17535) INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:21:58 |||  [repeated 25x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (55,0). [repeated 25x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17538) INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete [repeated 4x across cluster]
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538) INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11 [repeated 3x across cluster]
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:22:03 |||  [repeated 25x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (61,0). [repeated 25x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17535) INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17538) INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11 [repeated 4x across cluster]
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:22:08 |||  [repeated 24x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (99,0). [repeated 24x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 24x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 24x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 24x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 24x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 24x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 24x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17536) INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete [repeated 3x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17535) INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:22:13 |||  [repeated 24x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (105,0). [repeated 24x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 24x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 24x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 24x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 24x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 24x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 24x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 24x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535) INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536) INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11 [repeated 3x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17536) ERROR:2025-07-08,15:22:18 |||  [repeated 27x across cluster]
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (166,0). [repeated 27x across cluster]
+(Worker pid=17536)                     Results for this pixel will be all zeros. [repeated 27x across cluster]
+(Worker pid=17536) Traceback (most recent call last): [repeated 27x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 27x across cluster]
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 27x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 27x across cluster]
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 27x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 27x across cluster]
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 27x across cluster]
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2) [repeated 27x across cluster]
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17536) INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535) INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17538) INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17536) ERROR:2025-07-08,15:22:23 |||  [repeated 25x across cluster]
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (193,0). [repeated 25x across cluster]
+(Worker pid=17536)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17536) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537) INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete [repeated 4x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:22:28 |||  [repeated 26x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (210,0). [repeated 26x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 26x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 26x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 26x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 26x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 26x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 26x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 26x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 26x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 26x across cluster]
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535) INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete
+(Worker pid=17538)
+(Worker pid=17538) INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11 [repeated 4x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17538) ERROR:2025-07-08,15:22:33 |||  [repeated 25x across cluster]
+(Worker pid=17538)                     Encountered the following ValueError in (row,col) (230,0). [repeated 25x across cluster]
+(Worker pid=17538)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17538) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17538)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17538)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17538)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17538) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete [repeated 2x across cluster]
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17538) INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17535) INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17535) ERROR:2025-07-08,15:22:39 |||  [repeated 26x across cluster]
+(Worker pid=17535)                     Encountered the following ValueError in (row,col) (269,0). [repeated 26x across cluster]
+(Worker pid=17535)                     Results for this pixel will be all zeros. [repeated 26x across cluster]
+(Worker pid=17535) Traceback (most recent call last): [repeated 26x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 26x across cluster]
+(Worker pid=17535)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 26x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 26x across cluster]
+(Worker pid=17535)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 26x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 26x across cluster]
+(Worker pid=17535)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 26x across cluster]
+(Worker pid=17535) ValueError: not enough values to unpack (expected 3, got 2) [repeated 26x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535) INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17537) INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17535) ERROR:2025-07-08,15:22:44 |||  [repeated 24x across cluster]
+(Worker pid=17535)                     Encountered the following ValueError in (row,col) (275,0). [repeated 24x across cluster]
+(Worker pid=17535)                     Results for this pixel will be all zeros. [repeated 24x across cluster]
+(Worker pid=17535) Traceback (most recent call last): [repeated 24x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 24x across cluster]
+(Worker pid=17535)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 24x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 24x across cluster]
+(Worker pid=17535)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 24x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 24x across cluster]
+(Worker pid=17535)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 24x across cluster]
+(Worker pid=17535) ValueError: not enough values to unpack (expected 3, got 2) [repeated 24x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17535) INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17538) ERROR:2025-07-08,15:22:49 |||  [repeated 26x across cluster]
+(Worker pid=17538)                     Encountered the following ValueError in (row,col) (303,0). [repeated 26x across cluster]
+(Worker pid=17538)                     Results for this pixel will be all zeros. [repeated 26x across cluster]
+(Worker pid=17538) Traceback (most recent call last): [repeated 26x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 26x across cluster]
+(Worker pid=17538)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 26x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 26x across cluster]
+(Worker pid=17538)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 26x across cluster]
+(Worker pid=17538)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 26x across cluster]
+(Worker pid=17538)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 26x across cluster]
+(Worker pid=17538) ValueError: not enough values to unpack (expected 3, got 2) [repeated 26x across cluster]
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536) INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete [repeated 3x across cluster]
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17537) INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11 [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17535) ERROR:2025-07-08,15:22:55 |||  [repeated 25x across cluster]
+(Worker pid=17535)                     Encountered the following ValueError in (row,col) (320,0). [repeated 25x across cluster]
+(Worker pid=17535)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17535) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17535)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17535)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17535)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17535)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17535) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17538) INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536) INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10 [repeated 3x across cluster]
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:23:00 |||  [repeated 25x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (376,0). [repeated 25x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537) INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete [repeated 3x across cluster]
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17536)
+(Worker pid=17537) INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17537)
+(Worker pid=17537) ERROR:2025-07-08,15:23:05 |||  [repeated 25x across cluster]
+(Worker pid=17537)                     Encountered the following ValueError in (row,col) (383,0). [repeated 25x across cluster]
+(Worker pid=17537)                     Results for this pixel will be all zeros. [repeated 25x across cluster]
+(Worker pid=17537) Traceback (most recent call last): [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 25x across cluster]
+(Worker pid=17537)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 25x across cluster]
+(Worker pid=17537)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 25x across cluster]
+(Worker pid=17537)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 25x across cluster]
+(Worker pid=17537)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 25x across cluster]
+(Worker pid=17537) ValueError: not enough values to unpack (expected 3, got 2) [repeated 25x across cluster]
+(Worker pid=17538)
+(Worker pid=17538) INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17537)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535) INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete [repeated 2x across cluster]
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17537)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17536) ERROR:2025-07-08,15:23:10 |||  [repeated 21x across cluster]
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (412,0). [repeated 21x across cluster]
+(Worker pid=17536)                     Results for this pixel will be all zeros. [repeated 21x across cluster]
+(Worker pid=17536) Traceback (most recent call last): [repeated 21x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 21x across cluster]
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 21x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 21x across cluster]
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 21x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 21x across cluster]
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 21x across cluster]
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2) [repeated 21x across cluster]
+(Worker pid=17537) INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11 [repeated 3x across cluster]
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536) INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete
+(Worker pid=17538)
+(Worker pid=17536)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17536)
+(Worker pid=17538)
+(Worker pid=17535)
+(Worker pid=17538)
+(Worker pid=17536)
+INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete.  91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core
+INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference
+INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json
+INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt
+INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided
+INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory
+(Worker pid=17536)
+(Worker pid=17536) ERROR:2025-07-08,15:23:16 |||  [repeated 19x across cluster]
+(Worker pid=17536)                     Encountered the following ValueError in (row,col) (419,0). [repeated 19x across cluster]
+(Worker pid=17536)                     Results for this pixel will be all zeros. [repeated 19x across cluster]
+(Worker pid=17536) Traceback (most recent call last): [repeated 19x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/isofit.py", line 263, in run_set_of_spectra [repeated 19x across cluster]
+(Worker pid=17536)     self.io.write_spectrum(row, col, states, self.fm, self.iv) [repeated 19x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 747, in write_spectrum [repeated 19x across cluster]
+(Worker pid=17536)     to_write = self.build_output(states, self.current_input_data, fm, iv) [repeated 19x across cluster]
+(Worker pid=17536)   File "/Users/bgreenbe/Github/isofit/isofit/core/fileio.py", line 684, in build_output [repeated 19x across cluster]
+(Worker pid=17536)     rfl_alg_opt, Ls, coeffs = invert_algebraic( [repeated 19x across cluster]
+(Worker pid=17536) ValueError: not enough values to unpack (expected 3, got 2) [repeated 19x across cluster]
+(Worker pid=17536) INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11 [repeated 3x across cluster]
+WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file
+2025-07-08 15:23:17,031 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores
+INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete.  1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core
+2025-07-08 15:23:18,445 INFO worker.py:1747 -- Calling ray.init() again after it has already been called.
+(Worker pid=17655) INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4
+(Worker pid=17655) INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50 [repeated 8x across cluster]
+(Worker pid=17655) INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58 [repeated 8x across cluster]
+INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete.  51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core
+INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.
+(Worker pid=17657) INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60 [repeated 5x across cluster]
+I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:"2025-07-08T15:24:10.613957-07:00", file_line:1171, file:"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc"}
+
+
+
+
[15]:
+
+
+
from spectral.io import envi
+import matplotlib.pyplot as plt
+for _key, key in enumerate(report.keys()):
+  if _key < 1:
+
+    rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))
+    rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()
+    wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])
+
+    miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5
+    maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5
+    minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5
+    maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5
+
+    plt.figure()
+    plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))
+    plt.title(f'NIS01_20210403_{key}')
+    for k,i in report[key].items():
+        plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)
+
+    for k,i in report[key].items():
+        plt.figure()
+        in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())
+        in_situ = np.genfromtxt(in_situ_path, skip_header=3)
+        plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')
+        mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))
+        plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')
+        plt.legend()
+
+
+
+
+
+
+
+../../_images/sensor_examples_neon_neon_13_0.png +
+
+
+
+
+
+../../_images/sensor_examples_neon_neon_13_1.png +
+
+
+
+
+
+../../_images/sensor_examples_neon_neon_13_2.png +
+
+
+
+
+
+../../_images/sensor_examples_neon_neon_13_3.png +
+
+
+
+
+
+../../_images/sensor_examples_neon_neon_13_4.png +
+
+
+
+
+
+../../_images/sensor_examples_neon_neon_13_5.png +
+
+
+
+

Per-Pixel Retrievals

+

This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).

+

To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:

+
    +

  1. The ForwardModel object

    2. +

  2. The IO object

    3. +

  3. The Inverse object

    4. +
+

There is also an Isofit object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe).

+
+
[16]:
+
+
+
from isofit.core.isofit import Isofit
+from isofit.core.fileio import IO
+from isofit.core.forward import ForwardModel
+from isofit.inversion.inverse import Inversion
+from isofit.inversion.inverse_simple import invert_algebraic
+from isofit.configs import configs
+from isofit.core.geometry import Geometry
+
+import os
+import logging
+import numpy as np
+from spectral.io import envi
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+# Enable the ISOFIT logger
+logging.getLogger().setLevel(logging.INFO)
+
+
+
+
+
[22]:
+
+
+
# Now run actual retrievals
+config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))
+config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())
+
+#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))
+config.input.measured_radiance_file =  os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')
+config.input.obs_file =  os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')
+config.input.loc_file =  os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')
+
+fm = ForwardModel(config)
+io = IO(config, fm)
+inv = Inversion(config, fm)
+
+
+
+
+
+
+
+
+INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json
+INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt
+INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided
+INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory
+WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is
+WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is
+INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file
+
+
+
+
[24]:
+
+
+
region = 'Veg'
+offsets = {}
+miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5
+maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5
+minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5
+maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5
+offsets[neon_id] = [minx,miny]
+adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]
+
+rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))
+obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))
+loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))
+
+geom = Geometry(obs=obs,loc=loc)
+states = inv.invert(rdn, geom)
+
+x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])
+
+x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument,
+                           x_surface, x_RT, x_instrument,
+                           rdn, geom,
+                           )
+
+
+
+
+
+
+
+
+WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line
+
+
+
+
[25]:
+
+
+
def closest_wl(mv):
+    return np.argmin(np.abs(io.meas_wl-mv))
+
+wl_nan = io.meas_wl.copy()
+wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan
+wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan
+
+fig = plt.figure(figsize=(14,5))
+print(states.shape)
+offset = 0
+for n in range(0,states.shape[0],4):
+    lab = f'Step {n}'
+    if n == 0:
+        lab = 'Algebraic inversion at initial guess'
+
+    plt.plot(wl_nan, states[n,:-2] + offset, label=lab)
+    offset += 0.04
+plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')
+plt.legend()
+
+print(states[-1,-2:])
+
+
+
+
+
+
+
+
+(13, 428)
+[0.10742364 0.60519719]
+
+
+
+
+
+
+../../_images/sensor_examples_neon_neon_18_1.png +
+
+
+
[ ]:
+
+
+

+
+
+
+
+
+ + +
+
+
+ +
+ +
+

© Copyright Copyright 2018 California Institute of Technology.

+
+ + Built with Sphinx using a + theme + provided by Read the Docs. + + +
+
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/sensor_examples/neon/neon.ipynb b/isofit-tutorials/build/html/sensor_examples/neon/neon.ipynb new file mode 100644 index 0000000..339460d --- /dev/null +++ b/isofit-tutorials/build/html/sensor_examples/neon/neon.ipynb @@ -0,0 +1,1608 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "35412b86-171d-473c-8575-470b8fbed89d", + "metadata": {}, + "source": [ + "# NEON\n", + "\n", + "Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f81e3c4a-0bef-4cbe-a494-75c8e0d908ca", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.\n", + "\n", + "Prerequisites:\n", + "- Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the 'data' folder which includes the 'subsets' directory.\n", + "- Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed8d9de0-a74a-4e6c-83b2-54f7bc32f593", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "from pathlib import Path\n", + "from types import SimpleNamespace\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "from spectral.io import envi\n", + "\n", + "import isofit\n", + "from isofit.utils.apply_oe import apply_oe \n", + "from isofit.utils.surface_model import surface_model\n", + "from isofit import ray\n", + "ray.shutdown()\n" + ] + }, + { + "cell_type": "markdown", + "id": "164060bf-3cad-4d58-811f-838158d7d967", + "metadata": {}, + "source": [ + "ISOFIT needs at minimum three pieces as input:\n", + "\n", + " 1. Radiance measurements (rdn)\n", + " 2. Observation values (obs)\n", + " 3. Location information (loc)\n", + "\n", + "This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can 'fake' the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:\n", + "\n", + "```\n", + "Radiance\n", + "├── 173647\n", + "│ ├── NIS01_20210403_173647_obs_ort\n", + "│ ├── NIS01_20210403_173647_obs_ort.hdr\n", + "│ ├── NIS01_20210403_173647_rdn_ort\n", + "│ └── NIS01_20210403_173647_rdn_ort.hdr\n", + "└── 174150\n", + " ├── NIS01_20210403_174150_obs_ort\n", + " ├── NIS01_20210403_174150_obs_ort.hdr\n", + " ├── NIS01_20210403_174150_rdn_ort\n", + " └── NIS01_20210403_174150_rdn_ort.hdr\n", + "```\n", + "\n", + "These files have corresponding in situ data as well, and below we've encoded the locations of each, which we can use to help subset data files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7b88339c-ac36-4aab-98b7-2a1dd07ab8a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data subset directory at: /Users/bgreenbe/.isofit/neon_subset\n", + "Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json\n", + "sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5\n", + "6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs\n" + ] + } + ], + "source": [ + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "\n", + "# Path to the input NEON data\n", + "subset_dir = str(Path('~/.isofit/neon_subset').expanduser())\n", + "print(f'Data subset directory at: {subset_dir}')\n", + "\n", + "# Path to write isofit output\n", + "output = str(Path('~/.isofit/neon_subset/output').expanduser())\n", + "if os.path.isdir(output) is False:\n", + " os.mkdir(output)\n", + "\n", + "if os.path.isdir(subset_dir) is False:\n", + " os.mkdir(subset_dir)\n", + "\n", + "surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())\n", + "print(f'Surface model at: {surface_model_path}')\n", + "neon_id = '173647'\n", + "\n", + "\n", + "# Optionally set some environment variables as needed\n", + "#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'\n", + "#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'\n", + "\n", + "print(f'sRTMnet emulator path (required): {os.environ[\"EMULATOR_PATH\"]}')\n", + "print(f'6s path (required): {os.environ[\"SIXS_DIR\"]}')\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "727dcd06-2a38-4020-8a15-b6707b8ed453", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a5656147-509e-41f4-9cac-c9b81117c5b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Which NEON date to process - change this to process a different date\n", + "neon_id = list(report.keys())[0]\n", + "\n", + "# Select the locations from the neon id -- roi == Regions of Interest\n", + "roi = report[neon_id]" + ] + }, + { + "cell_type": "markdown", + "id": "e9ec9046-3c9d-47bf-914c-68e67424065f", + "metadata": {}, + "source": [ + "#### Loc file generation\n", + "\n", + "NEON doesn't distribute (?) a loc file, so let's fake one for now. We'll do this for the full file and for the subset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5b51ea6-f2ba-4348-9ec9-4a3eadd6c1c0", + "metadata": {}, + "outputs": [], + "source": [ + "def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):\n", + " \"\"\"\n", + " Retrieves the metadata from an envi header\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']\n", + " Removes keys from the metadata dictionary\n", + " \"\"\"\n", + " rdn_ds = envi.open(file)\n", + " metadata = rdn_ds.metadata.copy()\n", + " for key in remove:\n", + " if key in metadata:\n", + " del metadata[key]\n", + " else:\n", + " print(f'Key {key!r} not found in the metadata, skipping')\n", + "\n", + " return metadata\n", + "\n", + "def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake LOC file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " lon: float\n", + " Longitude value for location\n", + " lat: float\n", + " Latitude value for location\n", + " elv: float\n", + " Elevation in kilometers\n", + " output: str, default=None\n", + " Path to write the LOC file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `loc`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " Logger.error('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 3\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " loc = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " loc[..., 0] = lon\n", + " loc[..., 1] = lat\n", + " loc[..., 2] = elv\n", + "\n", + " del ds, loc\n", + "\n", + "def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake OBS file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN file containing metadata\n", + " param0: int, float, default=0\n", + " Parameter 0\n", + " sea: int, float, default=0\n", + " Solar Azimuth\n", + " sez: int, float, default=0\n", + " Sensor Zenith\n", + " soa: int, float, default=0\n", + " Solar Azimuth\n", + " soz: int, float, default=0\n", + " Solar Zenith\n", + " phase: int, float, default=0\n", + " Phase\n", + " slope: int, float, default=0\n", + " Slope\n", + " aspect: int, float, default=0\n", + " Aspect\n", + " cosi: int, float, default=0\n", + " COS(i)\n", + " param9: int, float, default=0\n", + " Parameter 9\n", + " param10: int, float, default=0\n", + " Parameter 10\n", + " output: str, default=None\n", + " Path to write the OBS file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `obs`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " print('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " rdn_ds = envi.open(rdn)\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 11\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " obs = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " obs[..., 0] = param0\n", + " obs[..., 1] = sea\n", + " obs[..., 2] = sez\n", + " obs[..., 3] = soa\n", + " obs[..., 4] = soz\n", + " obs[..., 5] = phase\n", + " obs[..., 6] = slope\n", + " obs[..., 7] = aspect\n", + " obs[..., 8] = cosi\n", + " obs[..., 9] = param9\n", + " obs[..., 10] = param10\n", + "\n", + " del ds, obs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bac7ba6b-1c0e-41b7-97e0-d9e137a9e217", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key 'band names' not found in the metadata, skipping\n" + ] + } + ], + "source": [ + "fakeLOC(\n", + " rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),\n", + " lon = -105.237000,\n", + " lat = 40.125000,\n", + " elv = 1689.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "83bf8ace-3e19-4674-86df-d2f46e220a32", + "metadata": {}, + "source": [ + "## Apply OE\n", + "\n", + "The next part walks through running the ISOFIT utility script `isofit/utils/apply_oe.py`. This is the first step of executing ISOFIT and will generate a default configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d0ec94f8-b1e7-4e4d-9b8f-450134ca5a83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n" + ] + } + ], + "source": [ + "output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "surface_model(**{\n", + " 'config_path': surface_model_path,\n", + " 'output_path': output_surface_file,\n", + " 'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3cbe6f39-6d6f-4182-abfb-30e95ce49ede", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns\n", + "WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...\n", + "2025-07-08 15:20:10,698\tINFO worker.py:1917 -- Started a local Ray instance.\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn\n", + "2025-07-08 15:20:11,728\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: completing\n", + "2025-07-08 15:20:11,781\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc\n", + "2025-07-08 15:20:11,825\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2 0.84 1.49 2.13 2.77 3.42 4.06 4.7 5.35 5.99]\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.\n", + "INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess\n", + "INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "2025-07-08 15:20:11,882\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:20:19.280425-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete\u001b[32m [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11\u001b[32m [repeated 7x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17160)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete. 34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded. Aerosol State Vector:\n", + "{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}\n", + "Aerosol LUT Grid:\n", + "{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}\n", + "Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt\n", + "INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT\n", + "INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "2025-07-08 15:20:53,541\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:20:59 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)\n", + "INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:03 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)\n", + "INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:08 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)\n", + "INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:13 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)\n", + "INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:17 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)\n", + "INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:21 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)\n", + "INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:27 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)\n", + "INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:31 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)\n", + "INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:35 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)\n", + "INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:21:43 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\", file_line:1171, created_time:\"2025-07-08T15:21:46.660474-07:00\", http2_error:2, grpc_status:14}\n", + "I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:21:46.660733-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:21:47 ||| \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (32,0).\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:21:52 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (27,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:21:58 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (55,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:03 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (61,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:08 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (99,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:13 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (105,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:18 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (166,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:23 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (193,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:28 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (210,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:33 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (230,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:39 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (269,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:44 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (275,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:49 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (303,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:55 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (320,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:00 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (376,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:05 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (383,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:10 ||| \u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (412,0).\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete. 91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core\n", + "INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference\n", + "INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:16 ||| \u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (419,0).\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n", + "2025-07-08 15:23:17,031\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores\n", + "INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete. 1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core\n", + "2025-07-08 15:23:18,445\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete. 51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core\n", + "INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.\n", + "\u001b[36m(Worker pid=17657)\u001b[0m INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:24:10.613957-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n" + ] + } + ], + "source": [ + "kwargs = {\n", + " 'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance\n", + " 'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location\n", + " 'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations\n", + " 'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory\n", + " 'sensor': 'neon', \n", + " \"surface_path\": output_surface_file, # Surface priors - often changes\n", + " 'emulator_base': os.environ['EMULATOR_PATH'],\n", + " 'n_cores': 4,\n", + " \"wavelength_path\": None,\n", + " \"surface_category\": \"multicomponent_surface\",\n", + " \"rdn_factors_path\": None, # RCC update used 'on the fly'\n", + " \"channelized_uncertainty_path\": None, # Channelized uncertainty - if you have an instrument model\n", + " \"model_discrepancy_path\": None, # Model discrepancy term - handle things like unknown radiative transfer model effects\n", + " \"lut_config_file\": None,\n", + " \"logging_level\": \"INFO\",\n", + " \"log_file\": None,\n", + " \"presolve\": True, # Attempts to solve for the right wv range\n", + " \"analytical_line\": True, # mathematical representation of OE given that the atmsophere is known\n", + " \"ray_temp_dir\": \"/tmp/ray\",\n", + " \"segmentation_size\": 10,\n", + " \"num_neighbors\": [5],\n", + " \"atm_sigma\": [0.5],\n", + " \"pressure_elevation\": False,\n", + "}\n", + "\n", + "apply_oe(**kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9d31291a-c036-4288-9114-cd772dda6748", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "for _key, key in enumerate(report.keys()):\n", + " if _key < 1:\n", + "\n", + " rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))\n", + " rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()\n", + " wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])\n", + "\n", + " miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5\n", + " maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5\n", + " minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5\n", + " maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5\n", + "\n", + " plt.figure()\n", + " plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))\n", + " plt.title(f'NIS01_20210403_{key}')\n", + " for k,i in report[key].items():\n", + " plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)\n", + "\n", + " for k,i in report[key].items():\n", + " plt.figure()\n", + " in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())\n", + " in_situ = np.genfromtxt(in_situ_path, skip_header=3)\n", + " plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')\n", + " mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))\n", + " plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')\n", + " plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "85419744-2391-48f0-b6c2-239390d4b994", + "metadata": {}, + "source": [ + "## Per-Pixel Retrievals\n", + "\n", + "This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).\n", + "\n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f60f1ae9-754b-4c25-bc51-70b792debed7", + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5efac6d4-c9f5-4292-a8e1-739939056ac1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n" + ] + } + ], + "source": [ + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')\n", + "config.input.loc_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "467786f7-35a6-4472-92c5-1fa753da9e3d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line\n" + ] + } + ], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fdbd8001-530b-497f-a2c8-fdda0a2206d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(13, 428)\n", + "[0.10742364 0.60519719]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def closest_wl(mv):\n", + " return np.argmin(np.abs(io.meas_wl-mv))\n", + "\n", + "wl_nan = io.meas_wl.copy()\n", + "wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan\n", + "wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan\n", + "\n", + "fig = plt.figure(figsize=(14,5))\n", + "print(states.shape)\n", + "offset = 0\n", + "for n in range(0,states.shape[0],4):\n", + " lab = f'Step {n}'\n", + " if n == 0:\n", + " lab = 'Algebraic inversion at initial guess'\n", + " \n", + " plt.plot(wl_nan, states[n,:-2] + offset, label=lab)\n", + " offset += 0.04\n", + "plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')\n", + "plt.legend()\n", + "\n", + "print(states[-1,-2:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8fcb0f-cd8e-47b9-9146-2e1335afcfd2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/build/html/sensor_examples/neon/neon_single_pixel.html b/isofit-tutorials/build/html/sensor_examples/neon/neon_single_pixel.html new file mode 100644 index 0000000..12bf339 --- /dev/null +++ b/isofit-tutorials/build/html/sensor_examples/neon/neon_single_pixel.html @@ -0,0 +1,281 @@ + + + + + + + Setup — ISOFIT: Imaging Spectrometer Optimal FITting Tutorials documentation + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Setup

+

This notebook is an excercise in running ISOFIT in pixel mode (dynamically from python), in order to get into some configuation details.

+

Prerequisites:

+
    +

  • Run the neon.ipynb notebook succesfully - we’ll use some of the outputs created from that intiial sample run

    • +
+
+

Running Per-Pixel Retrievals

+

That gave us a baseline run, but its not clear what might be improved. Let’s load up some individual retrievals so we can understand the performance a bit better. To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:

+
    +

  1. The ForwardModel object

    2. +

  2. The IO object

    3. +

  3. The Inverse object

    4. +
+

There is also an Isofit object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe).

+
+
[6]:
+
+
+
from isofit.core.isofit import Isofit
+from isofit.core.fileio import IO
+from isofit.core.forward import ForwardModel
+from isofit.inversion.inverse import Inversion
+from isofit.inversion.inverse_simple import invert_algebraic
+from isofit.configs import configs
+from isofit.core.geometry import Geometry
+
+import os
+import logging
+import numpy as np
+from spectral.io import envi
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+# Enable the ISOFIT logger
+logging.getLogger().setLevel(logging.INFO)
+
+
+
+
+
[8]:
+
+
+
import numpy as np
+
+# Extract the image locations of each point of interest (POI)
+# These are defined in the NEON report as pixel locations, so we round here to convert to indices
+report = {}
+report['173647'] = {           # Upp L Y  | Low R Y  | Upp L X | Low R X
+    'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),
+    'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),
+    'Veg'      : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),
+    'RoadEW'   : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),
+    'RoadNS'   : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)
+}
+report['174150'] = {           # Upp L Y | Low R Y | Upp L X  | Low R X
+    'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),
+    'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),
+    'Veg'      : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),
+    'RoadEW'   : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),
+    'RoadNS'   : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)
+}
+# Converts numpy array to comma-separated string for ISOFIT
+toString = lambda array: ', '.join(str(v) for v in array)
+
+
+
+
+
[9]:
+
+
+

# Find where we're running the tutorial from
+home = os.path.abspath(os.getcwd())
+output = os.path.join(home,'outputs')
+output_surface_file = os.path.join(output, 'surface.mat')
+neon_id = '173647' #one of 173647, 174150
+roi = report[neon_id]
+indata = os.path.join(home, 'data')
+
+# Now run actual retrievals
+config = configs.create_new_config(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))
+config.forward_model.surface.surface_file = output_surface_file
+#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))
+config.input.measured_radiance_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_ort')
+config.input.obs_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_obs_ort')
+config.input.loc_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_loc_ort')
+
+fm = ForwardModel(config)
+io = IO(config, fm)
+inv = Inversion(config, fm)
+
+
+
+
+
+
+
+
+INFO:root:Loading config file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json
+INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Loading from wavelength_file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/data/wavelengths.txt
+INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Prebuilt LUT provided
+WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_upwelling
+WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_downwelling
+INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Resampling LUT to instrument spectral response.
+
+
+

Now that we have the basic setup, we can run some retrievals.

+
+
[14]:
+
+
+
region = 'Veg'
+offsets = {}
+miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5
+maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5
+minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5
+maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5
+offsets[neon_id] = [minx,miny]
+adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]
+
+rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))
+obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))
+loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))
+
+geom = Geometry(obs=obs,loc=loc)
+states = inv.invert(rdn, geom)
+
+x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])
+
+x_alg, Ls, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument,
+                           x_surface, x_RT, x_instrument,
+                           rdn, geom,
+                           )
+
+
+
+
+
[26]:
+
+
+
m
+
+
+
+
+
+
+
+
+(12, 428)
+[0.11728845 0.61252989]
+
+
+
+
+
+
+../../_images/sensor_examples_neon_neon_single_pixel_7_1.png +
+
+
+
+ + +
+
+
+ +
+ +
+

© Copyright Copyright 2018 California Institute of Technology.

+
+ + Built with Sphinx using a + theme + provided by Read the Docs. + + +
+
+
+
+
+ + + + \ No newline at end of file diff --git a/isofit-tutorials/build/html/sensor_examples/neon/neon_single_pixel.ipynb b/isofit-tutorials/build/html/sensor_examples/neon/neon_single_pixel.ipynb new file mode 100644 index 0000000..069c37b --- /dev/null +++ b/isofit-tutorials/build/html/sensor_examples/neon/neon_single_pixel.ipynb @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup\n", + "\n", + "This notebook is an excercise in running ISOFIT in pixel mode (dynamically from python), in order to get into some configuation details.\n", + "\n", + "Prerequisites:\n", + "- Run the neon.ipynb notebook succesfully - we'll use some of the outputs created from that intiial sample run" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running Per-Pixel Retrievals\n", + "\n", + "That gave us a baseline run, but its not clear what might be improved. Let's load up some individual retrievals so we can understand the performance a bit better. \n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Loading config file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Loading from wavelength_file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Prebuilt LUT provided\n", + "WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_upwelling\n", + "WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_downwelling\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Resampling LUT to instrument spectral response.\n" + ] + } + ], + "source": [ + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "output = os.path.join(home,'outputs')\n", + "output_surface_file = os.path.join(output, 'surface.mat')\n", + "neon_id = '173647' #one of 173647, 174150\n", + "roi = report[neon_id]\n", + "indata = os.path.join(home, 'data') \n", + "\n", + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = output_surface_file\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_obs_ort')\n", + "config.input.loc_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the basic setup, we can run some retrievals." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, Ls, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(12, 428)\n", + "[0.11728845 0.61252989]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/isofit-tutorials/make.bat b/isofit-tutorials/make.bat new file mode 100644 index 0000000..6247f7e --- /dev/null +++ b/isofit-tutorials/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=source +set BUILDDIR=build + +if "%1" == "" goto help + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.http://sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/isofit-tutorials/source/conf.py b/isofit-tutorials/source/conf.py new file mode 100644 index 0000000..3ba9e1b --- /dev/null +++ b/isofit-tutorials/source/conf.py @@ -0,0 +1,74 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +import os +import sys + + +# -- Project information ----------------------------------------------------- + +project = 'ISOFIT: Imaging Spectrometer Optimal FITting Tutorials' +copyright = 'Copyright 2018 California Institute of Technology' +author = ''' D. R. Thompson, P. G. Brodrick, W. Olson Duvall, others''' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.coverage', + 'sphinx.ext.napoleon', + 'sphinx.ext.viewcode', + 'sphinx.ext.todo', + 'sphinx.ext.intersphinx', + 'myst_parser', + 'nbsphinx', +] + +intersphinx_mapping = { + 'python': ('https://docs.python.org/3', None), + 'numpy': ('https://numpy.org/doc/stable', None), + 'sklearn': ('https://sklearn-features.readthedocs.io/en/stable', None), + 'scipy': ('https://docs.scipy.org/doc/scipy/', None) +} + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = [] + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'sphinx_rtd_theme' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = [] + +# make sure things will work with readthedocs +autodoc_mock_imports = ['ray'] +master_doc = 'index' + +autodoc_member_order = 'bysource' +todo_include_todos = True +add_module_names = False +modindex_common_prefix = ['isofit-tutorials'] diff --git a/isofit-tutorials/source/how_to_run/about.rst b/isofit-tutorials/source/how_to_run/about.rst new file mode 100644 index 0000000..e470d9c --- /dev/null +++ b/isofit-tutorials/source/how_to_run/about.rst @@ -0,0 +1,22 @@ +===== +About +===== + +ISOFIT contains a set of routines and utilities for fitting surface, atmosphere and instrument models to imaging +spectrometer data. It is written primarily in Python, with JSON format configuration files and some dependencies on +widely-available numerical and scientific libraries such as scipy, numpy, and scikit-learn. It is designed for maximum +flexibility, so that users can swap in and evaluate model components based on different radiative transfer models (RTMs) +and various statistical descriptions of surface, instrument, and atmosphere. It can run on individual radiance spectra +in text format, or imaging spectrometer data cubes. + +Feature overview +---------------- + +* utilities for fitting surface, atmosphere and instrument models to imaging spectrometer data +* a selection of radiative transfer models (RTMs) incl. MODTRAN, LibRadTran, and 6S +* sRTMnet emulator for MODTRAN 6 by coupling a neural network with a surrogate RTM (6S v2.1) +* various statistical descriptions of surface, instrument, and atmosphere +* application to both individual radiance spectra and imaging spectrometer data cubes +* custom instrument models to handle new sensors +* observation uncertanities to account for model discrepancy errors +* prior distribution based on background knowledge of the state vector diff --git a/isofit-tutorials/source/how_to_run/apply_oe.ipynb b/isofit-tutorials/source/how_to_run/apply_oe.ipynb new file mode 100644 index 0000000..fa54073 --- /dev/null +++ b/isofit-tutorials/source/how_to_run/apply_oe.ipynb @@ -0,0 +1,753 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1be88697", + "metadata": {}, + "source": [ + "# Apply OE" + ] + }, + { + "cell_type": "markdown", + "id": "94f3598f", + "metadata": {}, + "source": [ + "#### What is Apply OE?" + ] + }, + { + "cell_type": "markdown", + "id": "c0421619", + "metadata": {}, + "source": [ + "Apply OE is the built-in end-to-end atmospheric correction pipeline, and is the easiest way to run Isofit. Apply OE is run via a command line interface (CLI) tool accessed with a terminal call:\n", + "\n", + " `isofit apply_oe --help`\n", + "\n", + " The function docstring is printed when this command is run within a terminal window and acts as a guide for how to run the function.\n", + "\n", + " ```\n", + "isofit apply_oe --help\n", + "\n", + "Usage: isofit apply_oe [OPTIONS] INPUT_RADIANCE INPUT_LOC INPUT_OBS\n", + " WORKING_DIRECTORY SENSOR\n", + "\n", + " Applies OE over a flightline using a radiative transfer engine. This\n", + " executes ISOFIT in a generalized way, accounting for the types of variation\n", + " that might be considered typical.\n", + "\n", + " Observation (obs) and location (loc) files are used to determine appropriate\n", + " geometry lookup tables and provide a heuristic means of determining\n", + " atmospheric water ranges.\n", + " Parameters\n", + " ----------\n", + " input_radiance : str\n", + " Radiance data cube. Expected to be ENVI format\n", + " input_loc : str\n", + " Location data cube of shape (Lon, Lat, Elevation). Expected to be ENVI format\n", + " input_obs : str\n", + " Observation data cube of shape:\n", + " (path length, to-sensor azimuth, to-sensor zenith,\n", + " to-sun azimuth, to-sun zenith, phase,\n", + " slope, aspect, cosine i, UTC time)\n", + " Expected to be ENVI format\n", + " working_directory : str\n", + " Directory to stage multiple outputs, will contain subdirectories\n", + " sensor : str\n", + " The sensor used for acquisition, will be used to set noise and datetime\n", + " settings\n", + " surface_path : str\n", + " Path to surface model or json dict of surface model configuration\n", + " copy_input_files : bool, default=False\n", + " Flag to choose to copy input_radiance, input_loc, and input_obs locally into\n", + " the working_directory\n", + " modtran_path : str, default=None\n", + " Location of MODTRAN utility. Alternately set with `MODTRAN_DIR` environment\n", + " variable\n", + " wavelength_path : str, default=None\n", + " Location to get wavelength information from, if not specified the radiance\n", + " header will be used\n", + " surface_category : str, default=\"multicomponent_surface\"\n", + " The type of ISOFIT surface priors to use. Default is multicomponent_surface\n", + " aerosol_climatology_path : str, default=None\n", + " Specific aerosol climatology information to use in MODTRAN\n", + " rdn_factors_path : str, default=None\n", + " Specify a radiometric correction factor, if desired\n", + " atmosphere_type : str, default=\"ATM_MIDLAT_SUMMER\"\n", + " Atmospheric profile to be used for MODTRAN simulations. Unused for other\n", + " radiative transfer models.\n", + " channelized_uncertainty_path : str, default=None\n", + " Path to a channelized uncertainty file\n", + " model_discrepancy_path : str, default=None\n", + " Modifies S_eps in the OE formalism as the Gamma additive term, as:\n", + " S_eps = Sy + Kb.dot(self.Sb).dot(Kb.T) + Gamma\n", + " lut_config_file : str, default=None\n", + " Path to a look up table configuration file, which will override defaults\n", + " choices\n", + " multiple_restarts : bool, default=False\n", + " Use multiple initial starting poitns for each OE ptimization run, using\n", + " the corners of the atmospheric variables as starting points. This gives\n", + " a more robust, albeit more expensive, solution.\n", + " logging_level : str, default=\"INFO\"\n", + " Logging level with which to run ISOFIT\n", + " log_file : str, default=None\n", + " File path to write ISOFIT logs to\n", + " n_cores : int, default=1\n", + " Number of cores to run ISOFIT with. Substantial parallelism is available, and\n", + " full runs will be very slow in serial. Suggested to max this out on the\n", + " available system\n", + " presolve : int, default=False\n", + " Flag to use a presolve mode to estimate the available atmospheric water range.\n", + " Runs a preliminary inversion over the image with a 1-D LUT of water vapor, and\n", + " uses the resulting range (slightly expanded) to bound determine the full LUT.\n", + " Advisable to only use with small cubes or in concert with the empirical_line\n", + " setting, or a significant speed penalty will be incurred\n", + " empirical_line : bool, default=False\n", + " Use an empirical line interpolation to run full inversions over only a subset\n", + " of pixels, determined using a SLIC superpixel segmentation, and use a KDTREE of\n", + " local solutions to interpolate radiance->reflectance. Generally a good option\n", + " if not trying to analyze the atmospheric state at fine scale resolution.\n", + " Mutually exclusive with analytical_line\n", + " analytical_line : bool, default=False\n", + " Use an analytical solution to the fixed atmospheric state to solve for each\n", + " pixel. Starts by running a full OE retrieval on each SLIC superpixel, then\n", + " interpolates the atmospheric state to each pixel, and closes with the\n", + " analytical solution.\n", + " Mutually exclusive with empirical_line\n", + " ray_temp_dir : str, default=\"/tmp/ray\"\n", + " Location of temporary directory for ray parallelization engine\n", + " emulator_base : str, default=None\n", + " Location of emulator base path. Point this at the model folder (or h5 file) of\n", + " sRTMnet to use the emulator instead of MODTRAN. An additional file with the\n", + " same basename and the extention _aux.npz must accompany\n", + " e.g. /path/to/emulator.h5 /path/to/emulator_aux.npz\n", + " segmentation_size : int, default=40\n", + " If empirical_line is enabled, sets the size of segments to construct\n", + " num_neighbors : list[int], default=[]\n", + " Forced number of neighbors for empirical line extrapolation - overides default\n", + " set from segmentation_size parameter\n", + " atm_sigma : list[int], default=[2]\n", + " A list of smoothing factors to use during the atmospheric interpolation, one\n", + " for each atmospheric parameter (or broadcast to all if only one is provided).\n", + " Only used with the analytical line.\n", + " pressure_elevation : bool, default=False\n", + " Flag to retrieve elevation\n", + " prebuilt_lut : str, default=None\n", + " Use this pre-constructed look up table for all retrievals. Must be an\n", + " ISOFIT-compatible RTE NetCDF\n", + " no_min_lut_spacing : bool, default=False\n", + " Don't allow the LUTConfig to remove a LUT dimension because of minimal spacing.\n", + " inversion_windows : list[float], default=None\n", + " Override the default inversion windows. Will supercede any sensor specific\n", + " defaults that are in place.\n", + " Must be in 2-item tuples\n", + " config_only : bool, default=False\n", + " Generates the configuration then exits before execution. If presolve is\n", + " enabled, that run will still occur.\n", + " interpolate_bad_rdn : bool, default=False\n", + " Flag to perform a per-pixel interpolation across no-data and NaN data bands.\n", + " Does not interpolate vectors that are entire no-data or NaN, only partial.\n", + " Currently only designed for wavelength interpolation on spectra.\n", + " Does NOT do any spatial interpolation\n", + " interpolate_inplace : bool, default=False\n", + " Flag to tell interpolation to work on the file in place, or generate a\n", + " new interpolated rdn file. The location of the new file will be in the\n", + " \"input\" directory within the working directory.\n", + "\n", + " References\n", + " ----------\n", + " D.R. Thompson, A. Braverman,P.G. Brodrick, A. Candela, N. Carbon, R.N. Clark,D. Connelly, R.O. Green, R.F.\n", + " Kokaly, L. Li, N. Mahowald, R.L. Miller, G.S. Okin, T.H.Painter, G.A. Swayze, M. Turmon, J. Susilouto, and\n", + " D.S. Wettergreen. Quantifying Uncertainty for Remote Spectroscopy of Surface Composition. Remote Sensing of\n", + " Environment, 2020. doi: https://doi.org/10.1016/j.rse.2020.111898.\n", + "\n", + " sRTMnet emulator:\n", + " P.G. Brodrick, D.R. Thompson, J.E. Fahlen, M.L. Eastwood, C.M. Sarture, S.R. Lundeen, W. Olson-Duvall,\n", + " N. Carmon, and R.O. Green. Generalized radiative transfer emulation for imaging spectroscopy reflectance\n", + " retrievals. Remote Sensing of Environment, 261:112476, 2021.doi: 10.1016/j.rse.2021.112476.\n", + "\n", + "Options:\n", + " -sp, --surface_path TEXT [required]\n", + " --copy_input_files\n", + " --modtran_path TEXT\n", + " --wavelength_path TEXT\n", + " --surface_category TEXT\n", + " --aerosol_climatology_path TEXT\n", + " --rdn_factors_path TEXT\n", + " --atmosphere_type TEXT\n", + " --channelized_uncertainty_path TEXT\n", + " --model_discrepancy_path TEXT\n", + " --lut_config_file TEXT\n", + " --multiple_restarts\n", + " --logging_level TEXT\n", + " --log_file TEXT\n", + " --n_cores INTEGER\n", + " --presolve\n", + " --empirical_line\n", + " --analytical_line\n", + " --ray_temp_dir TEXT\n", + " --emulator_base TEXT\n", + " --segmentation_size INTEGER\n", + " -nn, --num_neighbors INTEGER\n", + " -as, --atm_sigma FLOAT\n", + " --pressure_elevation\n", + " --prebuilt_lut TEXT\n", + " --no_min_lut_spacing\n", + " --inversion_windows FLOAT...\n", + " --config_only\n", + " --interpolate_bad_rdn\n", + " --interpolate_inplace\n", + " --debug-args Prints the arguments list without executing\n", + " the command\n", + " --profile TEXT\n", + " --help Show this message and exit.\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "id": "f1b4490f", + "metadata": {}, + "source": [ + "The Apply OE function can leverage a large number of input parameters, but most are optional. The important inputs are the non-optional arguments: \n", + "\n", + "`INPUT_RADIANCE` `INPUT_LOC` `INPUT_OBS` `WORKING_DIRECTORY` `SENSOR` and `--surface_path`.\n", + "\n", + "which must be entered in the specified order. Descriptions of each are found in the docstring printed above. It is important to note that the `INPUT_RADIANCE`, `INPUT_LOC`, and `INPUT_OBS` are ENVI raster data formats that must be at the same row-column dimensions. The `--surface_path` points the program torwards the prior distribution file for surface reflectance (more on this later). Optional arguments are denoted by the '--' in their name, e.g. `--modtran_path`, `--pressure_elevation`. The default radiative transfer engine (RTE) is currently set to Modtran, however we suggest that new users use the sRTMnet emulator. You must specify an `--emulator_path` to use the sRTMnet emulator." + ] + }, + { + "cell_type": "markdown", + "id": "8b199b77", + "metadata": {}, + "source": [ + "#### How do you run Apply OE?" + ] + }, + { + "cell_type": "markdown", + "id": "f6028b6c", + "metadata": {}, + "source": [ + "The script is run via the CLI. For example:" + ] + }, + { + "cell_type": "markdown", + "id": "b9867343", + "metadata": {}, + "source": [ + "```\n", + "isofit apply_oe \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010 \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010 \\\n", + " ~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010 \\\n", + " ~/.isofit/examples/image_cube/small \\\n", + " ang \\\n", + " --surface_path ~/.isofit/imagecube/small/data/surface.mat \\\n", + " --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \\\n", + " --n_cores 10 \\\n", + " --presolve \\\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "id": "31d41c48", + "metadata": {}, + "source": [ + "Here, \n", + "\n", + "```\n", + "~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010\n", + "~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010\n", + "~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010\n", + "```\n", + "\n", + "are the radiance, location, and observational geometry files respectively. The `\\` tells the CLI call to expect a multi-line input. The remaining two requried parameters are `ang`, the sensor designation (AVIRIS-NG), and the `--surface_path` pointing to the surface prior file at `~/.isofit/imagecube/small/data/surface.mat`.\n", + "\n", + "The remaining arguments set Apply OE to run with:\n", + "1) `--emulator_base` points isofit to the location of the sRTMnet emulator to use as the radiative transfer engine (RTE)\n", + "2) `--n_cores = 10` CPU cores\n", + "3) The `--presolve` algorithm to narrow down the water vapor retrievals, which leads to faster total processing time" + ] + }, + { + "cell_type": "markdown", + "id": "ac5b2463", + "metadata": {}, + "source": [ + "We can examine both the inputs and outputs of Apply OE with this run call:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b18118d1", + "metadata": {}, + "outputs": [], + "source": [ + "# Common imports\n", + "import os\n", + "from pathlib import Path\n", + "\n", + "from spectral import envi\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "\n", + "from isofit.core.common import envi_header" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5b8a685f", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the input files\n", + "rdn_path = Path('~/.isofit/imagecube/small/ang20170323t202244_rdn_7000-7010')\n", + "loc_path = Path('~/.isofit/imagecube/small/ang20170323t202244_loc_7000-7010')\n", + "obs_path = Path('~/.isofit/imagecube/small/ang20170323t202244_obs_7000-7010')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0f7ec5b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Band names in the location file:\n", + "Longitude (WGS-84)\n", + "Latitude (WGS-84)\n", + "Elevation (m)\n", + "\n", + "Band names in the observational geometry file:\n", + "Path length (m)\n", + "To-sensor azimuth (0 to 360 degrees cw from N)\n", + "To-sensor zenith (0 to 90 degrees from zenith)\n", + "To-sun azimuth (0 to 360 degrees cw from N)\n", + "To-sun zenith (0 to 90 degrees from zenith)\n", + "Solar phase\n", + "Slope\n", + "Aspect\n", + "Cosine(i)\n", + "UTC Time\n", + "Earth-sun distance (AU)\n" + ] + } + ], + "source": [ + "# Print the bands of the input files\n", + "print('Band names in the location file:')\n", + "[print(f\"{i}\") for i in loc.metadata['band names']]\n", + "\n", + "print()\n", + "print('Band names in the observational geometry file:')\n", + "temp = [print(f\"{i}\") for i in obs.metadata['band names']]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4ce97d24", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the input data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(13, 4))\n", + "plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))\n", + "plot = axs[1].imshow(loc_im[..., 0])\n", + "plot = axs[2].imshow(obs_im[..., 4])\n", + "\n", + "title = axs[0].set_title('Radiance (RGB)')\n", + "title = axs[1].set_title('Longitude (WGS-84)')\n", + "title = axs[2].set_title('Solar zenith angle (Deg)')" + ] + }, + { + "cell_type": "markdown", + "id": "e12b5307", + "metadata": {}, + "source": [ + "The input image doesn't look like much because this is just a 10x10 pixel example. However we see per-pixel spectral variation in the radiance RGB, and systematic variation in the location and geometric variables.\n", + "\n", + "Looking at the output data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65ce0e9f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of the _rfl file: (10, 10, 425)\n", + "Shape of the _state file: (10, 10, 427)\n", + "Shape of the _uncert file: (10, 10, 427)\n" + ] + } + ], + "source": [ + "# Load the output files\n", + "rfl_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_rfl')\n", + "state_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_state')\n", + "uncert_path = Path('~/.isofit/imagecube/small/output/ang20170323t202244_uncert')\n", + "\n", + "rfl = envi.open(envi_header(str(rfl_path.expanduser())))\n", + "state = envi.open(envi_header(str(state_path.expanduser())))\n", + "uncert = envi.open(envi_header(str(uncert_path.expanduser())))\n", + "\n", + "rfl_im = rfl.open_memmap(interleave='bip')\n", + "state_im = state.open_memmap(interleave='bip')\n", + "uncert_im = uncert.open_memmap(interleave='bip')\n", + "\n", + "print(f'Shape of the _rfl file: {rfl_im.shape}')\n", + "print(f'Shape of the _state file: {state_im.shape}')\n", + "print(f'Shape of the _uncert file: {uncert_im.shape}')" + ] + }, + { + "cell_type": "markdown", + "id": "7054b0ee", + "metadata": {}, + "source": [ + "The difference between the `_rfl` file and the `_state` file is that the `_rfl` file only contains the solutions for surface reflectance variables. Here, the AVIRIS-NG image contains 425 wavelength bands. As a result, the `_rfl` contains 425 bands. The `_state` and `_uncert` files contain the surface reflectance solutions and uncertainty calculated as the standard deviation of the posterior distributions for the 425 wavelength bands and for non-reflectance statevector elements; here, aerosol optical depth (AOD) and water vapor (H2O). " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a518609c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the output data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(8, 8))\n", + "axs = np.ravel(axs)\n", + "plot = axs[0].imshow(normalize(rfl_im[..., bands], 0, 0.3))\n", + "uncert = axs[1].imshow(uncert_im[..., 55])\n", + "aod = axs[2].imshow(state_im[..., -2])\n", + "h2o = axs[3].imshow(state_im[..., -1])\n", + "\n", + "plt.colorbar(uncert)\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "title = axs[0].set_title('Reflectance')\n", + "title = axs[1].set_title('Uncertainty (at 650 nm)')\n", + "title = axs[2].set_title('AOD')\n", + "title = axs[3].set_title('H2O')" + ] + }, + { + "cell_type": "markdown", + "id": "697e2986", + "metadata": {}, + "source": [ + "#### The Analytical Line" + ] + }, + { + "cell_type": "markdown", + "id": "58752472", + "metadata": {}, + "source": [ + "In the example above, we ran Isofit using the full optimal estimation (OE) on each pixel independently. Computationally, this amounts to iterating through each row-column pair to solve for the full state-vector (427 variables in the above case). However for large images, this demands long run-times, and ignores the principle that some state-vector elements, namely the atmospheric variables like AOD and H2O, should not vary from one pixel to the next, but rather should be spatially smooth, and only vary over multi-pixel length scales [Link to the relevent paper](https://www.sciencedirect.com/science/article/pii/S0034425723004534/).\n", + "\n", + "The analytical line and empirical line algorithms leverage the assumption of a spatially smooth atmosphere to decrease run times by a factor of 10. Currently, we suggest using the analytical line algorithm and not the empirical line algorithm." + ] + }, + { + "cell_type": "markdown", + "id": "ad1b9d10", + "metadata": {}, + "source": [ + "See the following CLI call to run Apply OE with the analytical line algorithm:\n", + "\n", + "```\n", + "isofit apply_oe \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k \\\n", + " ~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k \\\n", + " ~/.isofit/imagecube/medium \\\n", + " ang \\\n", + " --surface_path ~/.isofit/imagecube/small/data/surface.mat \\\n", + " --emulator_base ~/.isofit/srtmnet/sRTMnet_v120.h5 \\\n", + " --n_cores 10 \\\n", + " --presolve \\\n", + " --log_file ~/.isofit/imagecube/medium/log.txt \\\n", + " --analytical_line \\\n", + " --segmentation_size 50\n", + "```\n", + "\n", + "Most of the input parameters are identical to the per-pixel application above. However, we've added a `--log_file`, the `--analytical_line` flag, and a `--segmentation_size`. The `--log_file` points the program to write a text file to print logging statements during run time. The `--analytical_line` flag tells Isofit to use the analytical line algorithm. \n", + "\n", + "A simple overview for the anylitical line algorithm:\n", + "\n", + "1) All three input files are \"segmented\" into superpixel blocks using the SLIC algorithm. The `--segmentation_size` value sets the number of pixels that each superpixel contains.\n", + "\n", + "2) At the superpixel resolution, Isofit solves for the OE solutions, which provides both surface and atmospheric state variables. \n", + "\n", + "3) Atmospheric state variables are spatially interpolated to full image resolution. The spatial interpolation uses the Apply OE parameters `--num_neighbors` and `--atm_sigma`.\n", + "\n", + "4) With a fixed atmosphere, we leverage a closed form solution for surface state elements that allows for a solution convergence in a single iteration.\n", + "\n", + "We can visualize what the segmentation is doing by leveraging the `isofit reconstruct_subs` CLI command. \n", + "\n", + "Visualizing the input data:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5ce57697", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting the input data\n", + "rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')\n", + "loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')\n", + "obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')\n", + "\n", + "subs_rdn_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_rdn')\n", + "subs_loc_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_loc')\n", + "subs_obs_path = Path('~/.isofit/imagecube/medium/input/ang20170323t202244_subs_recon_obs')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "subs_rdn = envi.open(envi_header(str(subs_rdn_path.expanduser())))\n", + "subs_loc = envi.open(envi_header(str(subs_loc_path.expanduser())))\n", + "subs_obs = envi.open(envi_header(str(subs_obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')\n", + "\n", + "subs_rdn_im = subs_rdn.open_memmap(interleave='bip')\n", + "subs_loc_im = subs_loc.open_memmap(interleave='bip')\n", + "subs_obs_im = subs_obs.open_memmap(interleave='bip')\n", + "\n", + "fig, axs = plt.subplots(2, 3, sharex=True, sharey=True, figsize=(5, 10))\n", + "axs = np.ravel(axs)\n", + "\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(loc[0:400, :, 0])\n", + "axs[2].imshow(obs[0:400, :, 4])\n", + "\n", + "axs[3].imshow(normalize(subs_rdn_im[0:400, :, bands], 0, 15))\n", + "axs[4].imshow(subs_loc[0:400, :, 0])\n", + "axs[5].imshow(subs_obs[0:400, :, 4])\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Longitude')\n", + "axs[2].set_title('Elevation')\n", + "\n", + "axs[0].set_ylabel('Full resolution')\n", + "axs[3].set_ylabel('Superpixel resolution')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7788d2ce", + "metadata": {}, + "source": [ + "We can examine the results from Apply OE after the OE solutions on the superpixels:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "abf4b8ee", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.12389879..1.5404001].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wl = np.array(rdn.metadata['wavelength']).astype(float)\n", + "\n", + "state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_recon_subs_state')\n", + "state = envi.open(envi_header(str(state_path.expanduser())))\n", + "state_im = state.open_memmap(interleave='bip')\n", + "\n", + "fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(normalize(state_im[0:400, :, bands], 0, 0.25))\n", + "aod = axs[2].imshow(state_im[0:400, :, -2])\n", + "h2o = axs[3].imshow(state_im[0:400, :, -1])\n", + "\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Reflectance')\n", + "axs[2].set_title('AOD')\n", + "axs[3].set_title('H2O')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "af4360b8", + "metadata": {}, + "source": [ + "Finally, we can examine the final results at the end of the anlaytical line algorithm:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50c92071", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.0983623].\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.11736042..1.7135264].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rfl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_rfl')\n", + "atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')\n", + "\n", + "rfl = envi.open(envi_header(str(rfl_path.expanduser())))\n", + "atm = envi.open(envi_header(str(atm_path.expanduser())))\n", + "\n", + "rfl_im = rfl.open_memmap(interleave='bip')\n", + "atm_im = atm.open_memmap(interleave='bip')\n", + "\n", + "\n", + "fig, axs = plt.subplots(1, 4, sharex=True, sharey=True, figsize=(8, 5), tight_layout=True)\n", + "axs[0].imshow(normalize(rdn_im[0:400, :, bands], 0, 15))\n", + "axs[1].imshow(normalize(rfl_im[0:400, :, bands], 0, 0.25))\n", + "aod = axs[2].imshow(atm_im[0:400, :, -2])\n", + "h2o = axs[3].imshow(atm_im[0:400, :, -1])\n", + "\n", + "plt.colorbar(aod)\n", + "plt.colorbar(h2o)\n", + "\n", + "axs[0].set_title('Radiance')\n", + "axs[1].set_title('Reflectance')\n", + "axs[2].set_title('AOD')\n", + "axs[3].set_title('H2O')\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/source/how_to_run/functions.ipynb b/isofit-tutorials/source/how_to_run/functions.ipynb new file mode 100644 index 0000000..167a6f0 --- /dev/null +++ b/isofit-tutorials/source/how_to_run/functions.ipynb @@ -0,0 +1,733 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fe75c48b", + "metadata": {}, + "source": [ + "# Internal Functions" + ] + }, + { + "cell_type": "markdown", + "id": "f0f4eaf6", + "metadata": {}, + "source": [ + "When debugging issues or testing configurations, it may be advantagous to run Isofit in a more controlled manner than the end-to-end Apply OE pipeline. This notebook gives a quick introduction to the structure of Isofit and how it can be used more like a Python package.\n", + "\n", + "NOTE: Isofit is actively developed, so while we try to make sure that Apply OE is stable from a CLI standpoint, individual functions are subject to change." + ] + }, + { + "cell_type": "markdown", + "id": "eee6abd3", + "metadata": {}, + "source": [ + "We'll start with the medium example found at `~/.isofit/imagecube/medium`. First, run Apply OE on this example, or for more adept users, run Apply OE with the `--config_only` flag. The objective here, is to generate an Isofit config file at `~/.isofit/imagecube/small/config/ang20170323t202244_isofit.json`. This saves us the trouble of building the configuration file manually. We can edit the Apply OE generated configuration as needed." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "75064908", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "from pathlib import Path\n", + "from pprint import pprint\n", + "\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "from spectral import envi\n", + "\n", + "from isofit.core.common import envi_header\n", + "from isofit.core.isofit import Isofit\n", + "from isofit.configs import configs\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.radiative_transfer.radiative_transfer import RadiativeTransfer\n", + "from isofit.surface.surface import Surface\n", + "from isofit.core.instrument import Instrument\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.core.geometry import Geometry\n", + "from isofit.core.fileio import IO\n", + "from isofit.inversion.inverse_simple import (\n", + " invert_algebraic,\n", + " invert_analytical,\n", + " invert_simple,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "04d04288", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the input data\n", + "rdn_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_rdn_7k-8k')\n", + "loc_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_loc_7k-8k')\n", + "obs_path = Path('~/.isofit/imagecube/medium/ang20170323t202244_obs_7k-8k')\n", + "\n", + "rdn = envi.open(envi_header(str(rdn_path.expanduser())))\n", + "loc = envi.open(envi_header(str(loc_path.expanduser())))\n", + "obs = envi.open(envi_header(str(obs_path.expanduser())))\n", + "\n", + "rdn_im = rdn.open_memmap(interleave='bip')\n", + "loc_im = loc.open_memmap(interleave='bip')\n", + "obs_im = obs.open_memmap(interleave='bip')\n", + "\n", + "wl = np.array(rdn.metadata['wavelength']).astype(float)" + ] + }, + { + "cell_type": "markdown", + "id": "fe59a430", + "metadata": {}, + "source": [ + "### ISOFIT Configs and Classes\n", + "\n", + "ISOFIT is built around object classes.\n", + "\n", + "For example, the `config` object contains the full Isofit config. This is constructed directly from the config `.json` file via the `configs.create_new_config` function. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2ac3ee92", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The config object:\n", + "\n", + "\n", + "Config attributes:\n", + "_input_type\n", + "input\n", + "_output_type\n", + "output\n", + "_forward_model_type\n", + "forward_model\n", + "_implementation_type\n", + "implementation\n", + "\n", + "Example:\n", + "Forward model type: \n", + "Forward model: \n", + "\n", + "Forward model:\n", + "{'_instrument_type': ,\n", + " '_model_discrepancy_file_type': ,\n", + " '_radiative_transfer_type': ,\n", + " '_surface_type': ,\n", + " 'instrument': ,\n", + " 'model_discrepancy_file': None,\n", + " 'radiative_transfer': ,\n", + " 'surface': }\n", + "\n", + "Surface model:\n", + "{'_emissivity_for_surface_T_init_type': ,\n", + " '_select_on_init_type': ,\n", + " '_selection_metric_type': ,\n", + " '_surface_T_prior_sigma_degK_type': ,\n", + " '_surface_category_type': ,\n", + " '_surface_file_type': ,\n", + " '_wavelength_file_type': ,\n", + " 'emissivity_for_surface_T_init': 0.98,\n", + " 'select_on_init': True,\n", + " 'selection_metric': 'Euclidean',\n", + " 'surface_T_prior_sigma_degK': 1.0,\n", + " 'surface_category': 'multicomponent_surface',\n", + " 'surface_file': '/Users/bgreenbe/.isofit/imagecube/medium/data/surface.mat',\n", + " 'wavelength_file': None}\n" + ] + } + ], + "source": [ + "# Initialize the config object\n", + "config_file = Path('~/.isofit/imagecube/medium/config/ang20170323t202244_isofit.json')\n", + "config = configs.create_new_config(str(config_file.expanduser()))\n", + "\n", + "print('The config object:')\n", + "print(config)\n", + "print()\n", + "\n", + "print('Config attributes:')\n", + "[print(key) for key in vars(config).keys()]\n", + "print()\n", + "\n", + "print('Example:')\n", + "print(f'Forward model type: {config._forward_model_type}')\n", + "print(f'Forward model: {config.forward_model}\\n')\n", + "\n", + "print('Forward model:')\n", + "pprint(vars(config.forward_model), width=100, compact=False)\n", + "print()\n", + "print('Surface model:')\n", + "pprint(vars(config.forward_model.surface), width=100, compact=False)" + ] + }, + { + "cell_type": "markdown", + "id": "b5957a17-e65a-41eb-93e8-0df0c9abf8b9", + "metadata": {}, + "source": [ + "The `ForwardModel` object contains the `Instrument`, `Radiative transfer` and `Surface` portions of the ISOFIT forward model. The three forward model components are object classes themselves, which contain the math and logic relevant to these features. For example, the `Instrument` portion holds functions for instrument uncertainty quantification and calibration, the `Radiative transfer` portion holds functions relevant for generating and sampling the radiative transfer lookup-tables (LUTs), and the `Surface` portion holds functions relevant to sampling surface priors and formulating surface-specific forward model elements.\n", + "\n", + "Note: if the LUT has not been generated at the expected location from the config, initializing the forward model class will immediately constructing the LUT at that location." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "daf7e8d6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The expected location of the LUT:\n", + "/Users/bgreenbe/.isofit/imagecube/medium/lut_full/lut.nc\n", + "\n", + "\n", + "\n", + "\n", + ">\n" + ] + } + ], + "source": [ + "print('The expected location of the LUT:')\n", + "print(config.forward_model.radiative_transfer.radiative_transfer_engines[0].lut_path)\n", + "print()\n", + "\n", + "# Initialized from the config:\n", + "fm = ForwardModel(config)\n", + "\n", + "# Print the three forward model components\n", + "print(fm.instrument)\n", + "print(fm.RT)\n", + "print(fm.surface)\n", + "\n", + "# Print an example method from RT\n", + "print(fm.RT.calc_rdn)" + ] + }, + { + "cell_type": "markdown", + "id": "ddb76898-3e1a-4f9f-8ef2-3e916f14255e", + "metadata": {}, + "source": [ + "and individual component classes can also be initialized from the `config` object:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "420af4de-8a64-4624-91e4-56320dd7808f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:isofit.radiative_transfer.luts:thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:isofit.radiative_transfer.luts:thermal_downwelling is fully NaN, leaving as-is\n" + ] + } + ], + "source": [ + "instrument = Instrument(config)\n", + "rt = RadiativeTransfer(config)\n", + "surface = Surface(config)" + ] + }, + { + "cell_type": "markdown", + "id": "4b46aef7-7150-4447-be06-df47456dac7c", + "metadata": {}, + "source": [ + "The optimal estimation inversion is handled by the Inversion class object." + ] + }, + { + "cell_type": "markdown", + "id": "3b7e324d-8ef6-4832-9b54-b09fc2458d04", + "metadata": {}, + "source": [ + "### OE Inversions" + ] + }, + { + "cell_type": "markdown", + "id": "2daca64c-2f56-4aea-97a5-bbafe760ecd5", + "metadata": {}, + "source": [ + "We will go into how to perform single pixel optimal estimation (OE) inversions from a set of input data and an ISOFIT config. To do this, we need to load in a radiance spectrum with paired observational geometry data. We'll pull this directly from the `rdn`, `obs`, and `loc` files we loaded above. \n", + "\n", + "OE inversions are run using the Inversion class:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "451f496a-a7dd-435a-b69a-660ff487ecc4", + "metadata": {}, + "outputs": [], + "source": [ + "iv = Inversion(config, fm)" + ] + }, + { + "cell_type": "markdown", + "id": "1ac96a7e-c0e1-4210-bc9a-7919158c8ca5", + "metadata": {}, + "source": [ + "Next, we'll select a pixel to run through the OE inversion." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "15ad55ab-481f-4cc9-8eac-d049bb46bbba", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.1097916..1.1813465].\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Pick a pixel\n", + "row = 175\n", + "col = 50\n", + "\n", + "# Plot the input data\n", + "normalize = lambda x, vmin, vmax: (x - vmin) / (vmax - vmin)\n", + "bands = [55, 35, 15]\n", + "\n", + "fig, axs = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(8, 8))\n", + "plot = axs[0].imshow(normalize(rdn_im[..., bands], 0, 15))\n", + "plot = axs[1].imshow(loc_im[..., 0])\n", + "plot = axs[2].imshow(obs_im[..., 4])\n", + "\n", + "axs[0].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "axs[1].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "axs[2].scatter(col, row, facecolor='white', edgecolor='black', s=100)\n", + "\n", + "title = axs[0].set_title('Radiance (RGB)')\n", + "title = axs[1].set_title('Longitude (WGS-84)')\n", + "title = axs[2].set_title('Solar zenith angle (Deg)')" + ] + }, + { + "cell_type": "markdown", + "id": "a238060c-b133-4c0e-a4e7-52c41b435716", + "metadata": {}, + "source": [ + "Then we'll load in the measurement and observational data for that pixel. The geometry object holds all of the observational information for a given pixel." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "be82abde-7b34-4e5f-b456-be34a50d5dc3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "197.31315008280822\n", + "71.53144734704047\n", + "-0.3017277626279998\n" + ] + } + ], + "source": [ + "meas = rdn_im[row, col, :]\n", + "geom = Geometry(\n", + " obs=obs_im[row, col, :],\n", + " loc=loc_im[row, col, :],\n", + " esd=IO.load_esd(),\n", + " svf=1\n", + ")\n", + "\n", + "# e.g.\n", + "print(geom.solar_azimuth)\n", + "print(geom.observer_azimuth)\n", + "print(geom.cos_i)" + ] + }, + { + "cell_type": "markdown", + "id": "6adf64c4-b09c-4f83-ba3b-34bee40e616c", + "metadata": {}, + "source": [ + "and finally run the OE inversion via the inversions.invert function:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "dca42de9-475e-4cf7-a3cb-3e11c40d121e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of iterations to convergence: 9\n", + "Data type of 'oe': \n", + "Array shape: (9, 427)\n" + ] + } + ], + "source": [ + "oe = iv.invert(meas, geom)\n", + "\n", + "print(f\"Number of iterations to convergence: {len(oe)}\")\n", + "print(f\"Data type of 'oe': {type(oe)}\")\n", + "print(f\"Array shape: {oe.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "89d8779d-b82b-4077-ac35-ebd705327d95", + "metadata": {}, + "source": [ + "The `oe` variable is a numpy array where each row is a subsequent iteration of the OE procedure. It is often useful to examine how the solution changes during optimization, which can help debug potential issues with final statevector solutions.\n", + "\n", + "The plots below show the trajectory of the reflectance solution throughout the optimization. The earlier solutions are lighter colors while the later solutions are darker colors.\n", + "\n", + "The plots also show the prior mean selected for this specific pixel via the `surface.xa` function, which can be called directly using the initial guess of the reflectance solution and the pixel observation variables." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "0a20094c-daf1-422b-a326-b7329781b092", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a color map for the iterations\n", + "n = len(oe)\n", + "cmap_name = 'viridis_r'\n", + "cmap = plt.get_cmap(cmap_name)\n", + "colors = [cmap(i) for i in np.linspace(0, 1, n)]\n", + "\n", + "# Fit the prior mean\n", + "xa = fm.surface.xa(oe[0], geom)\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 4))\n", + "axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')\n", + "axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')\n", + "for i, sp in enumerate(oe):\n", + " axs[0].plot(wl, sp[:len(wl)], color=colors[i])\n", + " axs[1].plot(wl, sp[:len(wl)], color=colors[i])\n", + "\n", + "axs[0].plot(wl, oe[-1][:len(wl)], color='black', label='Final')\n", + "axs[1].plot(wl, oe[-1][:len(wl)], color='black')\n", + "\n", + "axs[0].set_ylabel('Reflectance')\n", + "axs[0].set_xlabel('Wavelength (nm)')\n", + "axs[1].set_ylabel('Reflectance')\n", + "axs[1].set_xlabel('Wavelength (nm)')\n", + "\n", + "axs[1].set_xlim([725, 1200])\n", + "axs[1].set_ylim([.1, .5])\n", + "\n", + "axs[0].set_title('Full spectrum')\n", + "axs[1].set_title('Highlighting 725 - 1200 nm')\n", + "\n", + "axs[0].legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "36d20b3b-f06f-4aba-a731-99284b089cb2", + "metadata": {}, + "source": [ + "We can also look at the trajectory of atmospheric statevector variables:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3f0bfd77-470b-4e5d-bce8-1289e17d3041", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, sharex=True, figsize=(10, 5))\n", + "iters = [i for i in range(len(oe))]\n", + "axs[0].set_title('AOT550')\n", + "axs[0].scatter(iters, oe[:, -2], edgecolor='black', facecolor='green', s=200)\n", + "axs[0].set_ylabel('AOT550')\n", + "\n", + "axs[1].set_title('H2O')\n", + "axs[1].scatter(iters, oe[:, -1], edgecolor='black', facecolor='green', s=200)\n", + "axs[1].set_ylabel('H2O')\n", + "\n", + "axs[0].set_xlabel('Iteration')\n", + "axs[1].set_xlabel('Iteration')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1f1cc68c-59aa-44d1-ae46-94291e97fc2a", + "metadata": {}, + "source": [ + "### Inversions with a constrained atmosphere\n", + "\n", + "Scene-scale processing generally leverages superpixel algorithms that simultaneously speed up processing and enforce a spatially smooth atmosphere. Here, we'll demonstrate the analytical line algorithm. The analytical line algorithm assumes there exists a closed form state-vector solution under the assumptions of 1) a fixed atmosphere, and 2) that the measurement can be modeled as a linear combination of state-vector elements. We can call the anlaytical line solution for a given pixel directly, albeit with slightly more set-up.\n", + "\n", + "First, we'll set up a wrapper function to call the analytical line inversion. In practice, the analytical inversion is sensitive to the initial guess (x0 below). We generally use the \"priorless\" solution for the state-vector elemnents for a given atmosphere via the `invert_algebraic` and `iv.fm.surface.fit_params` functions." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "21b0f415-f11f-4aa8-9a27-0381f4e1c40c", + "metadata": {}, + "outputs": [], + "source": [ + "def invert_aoe(iv, meas, geom, sub_state, x_RT, n=1):\n", + "\n", + " # This script sets up the initial guess for the inversion\n", + " x_surface, _, x_instrument = iv.fm.unpack(iv.fm.init.copy())\n", + " rfl_est, coeffs = invert_algebraic(\n", + " iv.fm.surface,\n", + " iv.fm.RT,\n", + " iv.fm.instrument,\n", + " x_surface,\n", + " x_RT,\n", + " x_instrument,\n", + " meas,\n", + " geom,\n", + " )\n", + "\n", + " rfl_est = iv.fm.surface.fit_params(rfl_est, geom)\n", + "\n", + " x0 = np.concatenate(\n", + " [\n", + " rfl_est,\n", + " x_RT,\n", + " x_instrument,\n", + " ]\n", + " )\n", + "\n", + " # This script is responsible for performing the inversion\n", + " states, unc, EXIT_CODE = invert_analytical(\n", + " iv.fm,\n", + " iv.winidx,\n", + " meas,\n", + " geom,\n", + " np.copy(x0),\n", + " sub_state,\n", + " n,\n", + " None,\n", + " None,\n", + " )\n", + "\n", + " return states[-1], unc, x0" + ] + }, + { + "cell_type": "markdown", + "id": "01255d4b-036b-4b34-a958-1d7b7d19de1a", + "metadata": {}, + "source": [ + "Next, we will pull the superpixel state solution and spatially smooth atmosphere for the selected pixel. \n", + "\n", + "Note: This assumes that these files already exist at the expected location." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "2a668a70-b4c0-4b9a-a286-253374dd3eae", + "metadata": {}, + "outputs": [], + "source": [ + "sub_state_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_subs_state')\n", + "lbl_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_lbl')\n", + "atm_path = Path('~/.isofit/imagecube/medium/output/ang20170323t202244_atm_interp')\n", + "\n", + "sub_state = envi.open(envi_header(str(sub_state_path.expanduser())))\n", + "lbl = envi.open(envi_header(str(lbl_path.expanduser())))\n", + "atm = envi.open(envi_header(str(atm_path.expanduser())))\n", + "\n", + "sub_state_im = sub_state.open_memmap(interleave='bip')\n", + "lbl_im = lbl.open_memmap(interleave='bip')\n", + "atm_im = atm.open_memmap(interleave='bip')\n", + "\n", + "idx = int(lbl[row, col, 0])\n", + "sub_state = sub_state_im[idx, 0, :]\n", + "x_RT = atm_im[row, col, :]" + ] + }, + { + "cell_type": "markdown", + "id": "fbd02d3f-26ee-4953-a489-bc154f24a79d", + "metadata": {}, + "source": [ + "We can then call the wrapper function. Solutions are generally acceptible after one iteration, but `n` can be definted to explictely set the number of iterations to perform. " + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e0a8370a-44af-491e-b2ff-6b11308940c1", + "metadata": {}, + "outputs": [], + "source": [ + "aoe, aoe_unc, x0 = invert_aoe(\n", + " iv, meas, geom, sub_state, x_RT, n=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "ee7eefc7-183b-4321-9abb-e90389c455e3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a color map for the iterations\n", + "n = len(oe)\n", + "cmap_name = 'viridis_r'\n", + "cmap = plt.get_cmap(cmap_name)\n", + "colors = [cmap(i) for i in np.linspace(0, 1, n)]\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", + "\n", + "axs[0].plot(wl, xa[:len(wl)], color='black', ls='--', label='Prior mean')\n", + "axs[1].plot(wl, xa[:len(wl)], color='black', ls='--')\n", + "\n", + "axs[0].plot(wl, aoe[:len(wl)], color='purple', lw=2, label='AOE')\n", + "axs[1].plot(wl, aoe[:len(wl)], color='purple', lw=2)\n", + "\n", + "axs[0].plot(wl, oe[-1][:len(wl)], color='green', label='OE')\n", + "axs[1].plot(wl, oe[-1][:len(wl)], color='green')\n", + "\n", + "axs[0].set_ylabel('Reflectance')\n", + "axs[0].set_xlabel('Wavelength (nm)')\n", + "axs[1].set_ylabel('Reflectance')\n", + "axs[1].set_xlabel('Wavelength (nm)')\n", + "\n", + "axs[1].set_xlim([725, 1200])\n", + "axs[1].set_ylim([.1, .5])\n", + "axs[0].set_ylim([-.1, .5])\n", + "\n", + "axs[0].set_title('Full spectrum')\n", + "axs[1].set_title('Highlighting 725 - 1200 nm')\n", + "\n", + "axs[0].legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "adfffc32-8ef7-47c6-818f-d03acae7c50e", + "metadata": {}, + "outputs": [], + "source": [ + "### Algebraic inversions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0e5bf2f-cf60-409e-8c48-1573cf572c08", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/source/index.rst b/isofit-tutorials/source/index.rst new file mode 100644 index 0000000..947094a --- /dev/null +++ b/isofit-tutorials/source/index.rst @@ -0,0 +1,39 @@ +ISOFIT tutorials +================ + +This contains examples, tutorials and notebooks for the ISOFIt software. +Included here are: + +* A demonstration of how ISOFIT is run via the Apply Optimal Estimation (Apply OE) pipeline +* Examples for how ISOFIT can be run through function calls akin to a Python library +* Sensor-specific examples (NEON, EMIT, etc.) +* Information for how to contribute additional examples. + + +This is a companion to the `primary ISOFIT documentation `_ +and `source code `_. + + +Table of contents: +================== + +.. toctree:: + :Caption: Running Isofit + :maxdepth: 1 + + how_to_run/apply_oe.ipynb + how_to_run/functions.ipynb + +.. toctree:: + :caption: Sensor examples + :maxdepth: 1 + + sensor_examples/neon + +.. toctree:: + :Caption: Information + :maxdepth: 2 + + information/contribute.rst + information/code_of_conduct.rst + information/project_support.rst diff --git a/isofit-tutorials/source/information/code_of_conduct.rst b/isofit-tutorials/source/information/code_of_conduct.rst new file mode 100644 index 0000000..b9bb238 --- /dev/null +++ b/isofit-tutorials/source/information/code_of_conduct.rst @@ -0,0 +1,70 @@ +Code of Conduct +=============== + +**Our Pledge** + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a positive experience for everyone. + +**Our Standards** + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming language +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members +* Scientific integrity and honesty, respecting the scientific method +* Crediting other's work where appropriate +* Striving towards, and sharing, new scientific knowledge to benefit humanity + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others’ private information, such as a physical or electronic address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a professional setting +* Misrepresenting or manufacturing experimental data or test results +* Failing to duly recognize the contributions of others in one's work + +**Our Responsibilities** + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +**Scope** + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +**Enforcement** + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at david.r.thompson@jpl.nasa.gov. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project’s leadership. + +**Attribution** + +This Code of Conduct is adapted from the Contributor Covenant, version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html diff --git a/isofit-tutorials/source/information/contribute.rst b/isofit-tutorials/source/information/contribute.rst new file mode 100644 index 0000000..a9a6373 --- /dev/null +++ b/isofit-tutorials/source/information/contribute.rst @@ -0,0 +1,22 @@ +Contributing +============ + +We hope that these tutorials can be a community repository of software examples for +atmospheric and surface corrections using the ISOFIT software. If new functionality is added to the codebase, +it can be accompanied by notebook-style code examples. + +Examples of potential contributions include: + +* Tutorials for existing and new ISOFIT functionality +* Examples of ISOFIT running on various supported instruments + +Please feel free to draft notebooks, contact the maintainers, and open pull requests. +If you have have discovered an issue or desire a missing feature, please create a `new +issue `_. + +The primary ISOFIT documentation `describes in detail `_ how to begin contributing. + +We use `nbsphinx `_ to display jupyter notebook examples on the readthedocs page. Contributed examples can be written, and hosted simply as an .ipynb file. +Notebook codes are executed locally and jupyter cell outputs are saved as image hashes, which are then viewable on the static html page. + +The current notebook directory structure is subject to change as more examples are added. Place your example in the source folder under the most appropriate directory. We can always iterate through the PR process. diff --git a/isofit-tutorials/source/information/project_support.rst b/isofit-tutorials/source/information/project_support.rst new file mode 100644 index 0000000..bc8bb26 --- /dev/null +++ b/isofit-tutorials/source/information/project_support.rst @@ -0,0 +1,21 @@ +Project Support +============ + +The ISOFIT codebase was made possible with support from various sources. +The initial algorithm and code was developed by the NASA Earth Science +Division data analysis program “Utilization of Airborne Visible/Infrared +Imaging Spectrometer Next Generation Data from an Airborne Campaign in +India," program NNH16ZDA001N-AVRSNG, managed by Woody Turner. + +Later research and maturation was provided by the Jet Propulsion Laboratory and +California Institute of Technology President and Director’s Fund, and the +Jet Propulsion Laboratory Research and Technology Development Program. +The project is currently supported by the Open Source Tools, Frameworks, +and Libraries Program (NNH20ZDA001N), managed by Dr. Steven Crawford. + +Neural network radiative transfer is supported by the NASA Center +Innovation Fund managed in conjunction with the Jet Propulsion Laboratory +Office of the Chief Scientist and Technologist. + +The initial research took place at the Jet Propulsion Laboratory, California Institute of Technology, +4800 Oak Grove Dr., Pasadena, CA 91109 USA. diff --git a/isofit-tutorials/source/requirements.txt b/isofit-tutorials/source/requirements.txt new file mode 100644 index 0000000..fbf9c6d --- /dev/null +++ b/isofit-tutorials/source/requirements.txt @@ -0,0 +1,6 @@ +sphinx==7.2.6 +sphinx_rtd_theme==2.0.0 +sphinxcontrib-napoleon +sphinx_autodoc_typehints==1.25.2 +myst-parser +sphinx-autoapi diff --git a/isofit-tutorials/source/sensor_examples/neon.ipynb b/isofit-tutorials/source/sensor_examples/neon.ipynb new file mode 100644 index 0000000..516534f --- /dev/null +++ b/isofit-tutorials/source/sensor_examples/neon.ipynb @@ -0,0 +1,1610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "35412b86-171d-473c-8575-470b8fbed89d", + "metadata": {}, + "source": [ + "# NEON\n", + "\n", + "Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f81e3c4a-0bef-4cbe-a494-75c8e0d908ca", + "metadata": {}, + "source": [ + "## Full image example\n", + "\n", + "This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.\n", + "\n", + "Prerequisites:\n", + "- Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the 'data' folder which includes the 'subsets' directory.\n", + "- Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed8d9de0-a74a-4e6c-83b2-54f7bc32f593", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "from pathlib import Path\n", + "from types import SimpleNamespace\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "from spectral.io import envi\n", + "\n", + "import isofit\n", + "from isofit.utils.apply_oe import apply_oe \n", + "from isofit.utils.surface_model import surface_model\n", + "from isofit import ray\n", + "ray.shutdown()\n" + ] + }, + { + "cell_type": "markdown", + "id": "164060bf-3cad-4d58-811f-838158d7d967", + "metadata": {}, + "source": [ + "### Setup\n", + "\n", + "ISOFIT needs at minimum three pieces as input:\n", + "\n", + " 1. Radiance measurements (rdn)\n", + " 2. Observation values (obs)\n", + " 3. Location information (loc)\n", + "\n", + "This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can 'fake' the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:\n", + "\n", + "```\n", + "Radiance\n", + "├── 173647\n", + "│ ├── NIS01_20210403_173647_obs_ort\n", + "│ ├── NIS01_20210403_173647_obs_ort.hdr\n", + "│ ├── NIS01_20210403_173647_rdn_ort\n", + "│ └── NIS01_20210403_173647_rdn_ort.hdr\n", + "└── 174150\n", + " ├── NIS01_20210403_174150_obs_ort\n", + " ├── NIS01_20210403_174150_obs_ort.hdr\n", + " ├── NIS01_20210403_174150_rdn_ort\n", + " └── NIS01_20210403_174150_rdn_ort.hdr\n", + "```\n", + "\n", + "These files have corresponding in situ data as well, and below we've encoded the locations of each, which we can use to help subset data files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7b88339c-ac36-4aab-98b7-2a1dd07ab8a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data subset directory at: /Users/bgreenbe/.isofit/neon_subset\n", + "Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json\n", + "sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5\n", + "6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs\n" + ] + } + ], + "source": [ + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "\n", + "# Path to the input NEON data\n", + "subset_dir = str(Path('~/.isofit/neon_subset').expanduser())\n", + "print(f'Data subset directory at: {subset_dir}')\n", + "\n", + "# Path to write isofit output\n", + "output = str(Path('~/.isofit/neon_subset/output').expanduser())\n", + "if os.path.isdir(output) is False:\n", + " os.mkdir(output)\n", + "\n", + "if os.path.isdir(subset_dir) is False:\n", + " os.mkdir(subset_dir)\n", + "\n", + "surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())\n", + "print(f'Surface model at: {surface_model_path}')\n", + "neon_id = '173647'\n", + "\n", + "\n", + "# Optionally set some environment variables as needed\n", + "#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'\n", + "#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'\n", + "\n", + "print(f'sRTMnet emulator path (required): {os.environ[\"EMULATOR_PATH\"]}')\n", + "print(f'6s path (required): {os.environ[\"SIXS_DIR\"]}')\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "727dcd06-2a38-4020-8a15-b6707b8ed453", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a5656147-509e-41f4-9cac-c9b81117c5b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Which NEON date to process - change this to process a different date\n", + "neon_id = list(report.keys())[0]\n", + "\n", + "# Select the locations from the neon id -- roi == Regions of Interest\n", + "roi = report[neon_id]" + ] + }, + { + "cell_type": "markdown", + "id": "e9ec9046-3c9d-47bf-914c-68e67424065f", + "metadata": {}, + "source": [ + "#### Loc file generation\n", + "\n", + "NEON doesn't distribute (?) a loc file, so let's fake one for now. We'll do this for the full file and for the subset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5b51ea6-f2ba-4348-9ec9-4a3eadd6c1c0", + "metadata": {}, + "outputs": [], + "source": [ + "def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):\n", + " \"\"\"\n", + " Retrieves the metadata from an envi header\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']\n", + " Removes keys from the metadata dictionary\n", + " \"\"\"\n", + " rdn_ds = envi.open(file)\n", + " metadata = rdn_ds.metadata.copy()\n", + " for key in remove:\n", + " if key in metadata:\n", + " del metadata[key]\n", + " else:\n", + " print(f'Key {key!r} not found in the metadata, skipping')\n", + "\n", + " return metadata\n", + "\n", + "def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake LOC file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " lon: float\n", + " Longitude value for location\n", + " lat: float\n", + " Latitude value for location\n", + " elv: float\n", + " Elevation in kilometers\n", + " output: str, default=None\n", + " Path to write the LOC file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `loc`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " Logger.error('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 3\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " loc = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " loc[..., 0] = lon\n", + " loc[..., 1] = lat\n", + " loc[..., 2] = elv\n", + "\n", + " del ds, loc\n", + "\n", + "def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake OBS file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN file containing metadata\n", + " param0: int, float, default=0\n", + " Parameter 0\n", + " sea: int, float, default=0\n", + " Solar Azimuth\n", + " sez: int, float, default=0\n", + " Sensor Zenith\n", + " soa: int, float, default=0\n", + " Solar Azimuth\n", + " soz: int, float, default=0\n", + " Solar Zenith\n", + " phase: int, float, default=0\n", + " Phase\n", + " slope: int, float, default=0\n", + " Slope\n", + " aspect: int, float, default=0\n", + " Aspect\n", + " cosi: int, float, default=0\n", + " COS(i)\n", + " param9: int, float, default=0\n", + " Parameter 9\n", + " param10: int, float, default=0\n", + " Parameter 10\n", + " output: str, default=None\n", + " Path to write the OBS file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `obs`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " print('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " rdn_ds = envi.open(rdn)\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 11\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " obs = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " obs[..., 0] = param0\n", + " obs[..., 1] = sea\n", + " obs[..., 2] = sez\n", + " obs[..., 3] = soa\n", + " obs[..., 4] = soz\n", + " obs[..., 5] = phase\n", + " obs[..., 6] = slope\n", + " obs[..., 7] = aspect\n", + " obs[..., 8] = cosi\n", + " obs[..., 9] = param9\n", + " obs[..., 10] = param10\n", + "\n", + " del ds, obs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bac7ba6b-1c0e-41b7-97e0-d9e137a9e217", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key 'band names' not found in the metadata, skipping\n" + ] + } + ], + "source": [ + "fakeLOC(\n", + " rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),\n", + " lon = -105.237000,\n", + " lat = 40.125000,\n", + " elv = 1689.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "83bf8ace-3e19-4674-86df-d2f46e220a32", + "metadata": {}, + "source": [ + "#### Apply OE\n", + "\n", + "The next part walks through running the ISOFIT utility script `isofit/utils/apply_oe.py`. This is the first step of executing ISOFIT and will generate a default configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d0ec94f8-b1e7-4e4d-9b8f-450134ca5a83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n" + ] + } + ], + "source": [ + "output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "surface_model(**{\n", + " 'config_path': surface_model_path,\n", + " 'output_path': output_surface_file,\n", + " 'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3cbe6f39-6d6f-4182-abfb-30e95ce49ede", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns\n", + "WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...\n", + "2025-07-08 15:20:10,698\tINFO worker.py:1917 -- Started a local Ray instance.\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn\n", + "2025-07-08 15:20:11,728\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: completing\n", + "2025-07-08 15:20:11,781\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc\n", + "2025-07-08 15:20:11,825\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2 0.84 1.49 2.13 2.77 3.42 4.06 4.7 5.35 5.99]\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.\n", + "INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess\n", + "INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "2025-07-08 15:20:11,882\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:20:19.280425-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete\u001b[32m [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11\u001b[32m [repeated 7x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17160)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete. 34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded. Aerosol State Vector:\n", + "{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}\n", + "Aerosol LUT Grid:\n", + "{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}\n", + "Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt\n", + "INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT\n", + "INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "2025-07-08 15:20:53,541\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:20:59 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)\n", + "INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:03 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)\n", + "INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:08 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)\n", + "INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:13 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)\n", + "INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:17 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)\n", + "INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:21 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)\n", + "INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:27 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)\n", + "INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:31 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)\n", + "INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:35 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)\n", + "INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:21:43 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\", file_line:1171, created_time:\"2025-07-08T15:21:46.660474-07:00\", http2_error:2, grpc_status:14}\n", + "I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:21:46.660733-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:21:47 ||| \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (32,0).\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:21:52 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (27,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:21:58 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (55,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:03 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (61,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:08 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (99,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:13 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (105,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:18 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (166,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:23 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (193,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:28 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (210,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:33 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (230,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:39 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (269,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:44 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (275,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:49 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (303,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:55 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (320,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:00 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (376,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:05 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (383,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:10 ||| \u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (412,0).\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete. 91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core\n", + "INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference\n", + "INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:16 ||| \u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (419,0).\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n", + "2025-07-08 15:23:17,031\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores\n", + "INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete. 1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core\n", + "2025-07-08 15:23:18,445\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete. 51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core\n", + "INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.\n", + "\u001b[36m(Worker pid=17657)\u001b[0m INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:24:10.613957-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n" + ] + } + ], + "source": [ + "kwargs = {\n", + " 'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance\n", + " 'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location\n", + " 'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations\n", + " 'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory\n", + " 'sensor': 'neon', \n", + " \"surface_path\": output_surface_file, # Surface priors - often changes\n", + " 'emulator_base': os.environ['EMULATOR_PATH'],\n", + " 'n_cores': 4,\n", + " \"wavelength_path\": None,\n", + " \"surface_category\": \"multicomponent_surface\",\n", + " \"rdn_factors_path\": None, # RCC update used 'on the fly'\n", + " \"channelized_uncertainty_path\": None, # Channelized uncertainty - if you have an instrument model\n", + " \"model_discrepancy_path\": None, # Model discrepancy term - handle things like unknown radiative transfer model effects\n", + " \"lut_config_file\": None,\n", + " \"logging_level\": \"INFO\",\n", + " \"log_file\": None,\n", + " \"presolve\": True, # Attempts to solve for the right wv range\n", + " \"analytical_line\": True, # mathematical representation of OE given that the atmsophere is known\n", + " \"ray_temp_dir\": \"/tmp/ray\",\n", + " \"segmentation_size\": 10,\n", + " \"num_neighbors\": [5],\n", + " \"atm_sigma\": [0.5],\n", + " \"pressure_elevation\": False,\n", + "}\n", + "\n", + "apply_oe(**kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9d31291a-c036-4288-9114-cd772dda6748", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhx9JREFUeJzt3XlYVNUfx/H3gCxKirugoqK57+GG+5IolZppmgtqufzMJcnSXHOpXFNxSS03tMWw1DQ1FXMXXAOztHJNM0hxAVEBhfv74zIjwyYDw8wd+b6eZx5g5s6dM3MPnA/nnnuOTlEUBSGEEEIIDbOzdgGEEEIIIZ5GAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNC+ftQtgLklJSfz7778ULFgQnU5n7eIIIYQQIgsUReHevXuULl0aO7uM+1GemcDy77//4uHhYe1iCCGEECIbrl27RtmyZTN8/JkJLAULFgTUN1yoUCErl0YIIYQQWRETE4OHh4ehHc9ItgLL0qVLmTt3LhEREdSsWZOAgABatGjx1OcdOXKEVq1aUatWLcLDw40e27hxI5MnT+bixYtUqlSJTz75hK5du2a5TPrTQIUKFZLAIoQQQtiYpw3nMHnQbVBQEP7+/kycOJGwsDBatGiBr68vV69ezfR50dHR9OvXj3bt2qV5LDQ0lJ49e+Ln58fp06fx8/OjR48eHDt2zNTiCSGEEOIZpDN1tebGjRvzwgsvsGzZMsN91atX59VXX2XmzJkZPu+NN96gcuXK2Nvb88MPPxj1sPTs2ZOYmBh++uknw30dO3akSJEirF+/PkvliomJwdXVlejoaOlhEUIIIWxEVttvk3pYEhISOHXqFD4+Pkb3+/j4EBISkuHz1qxZw8WLF5kyZUq6j4eGhqbZZ4cOHTLdpxBCCCHyDpPGsERFRZGYmEipUqWM7i9VqhSRkZHpPuf8+fOMGzeOQ4cOkS9f+i8XGRlp0j4B4uPjiY+PN/wcExPz1PInJiby6NGjp24nRHbZ29uTL18+ubReCCHMLFuDblP/MVYUJd0/0ImJifTu3Ztp06ZRpUoVs+xTb+bMmUybNi3LZY6NjeWff/7BxDNgQpisQIECuLu74+joaO2iCCHEM8OkwFK8eHHs7e3T9HzcuHEjTQ8JwL179zh58iRhYWGMGDECUCd4UxSFfPnysXv3btq2bYubm1uW96k3fvx4Ro8ebfhZf1lUehITE/nnn38oUKAAJUqUkP9+Ra5QFIWEhARu3rzJ5cuXqVy5cqaTIAkhhMg6kwKLo6MjXl5eBAcHG11yHBwcTJcuXdJsX6hQIc6cOWN039KlS9m7dy/ff/89np6eAHh7exMcHMy7775r2G737t00bdo0w7I4OTnh5OSUpXI/evQIRVEoUaIE+fPnz9JzhMiO/Pnz4+DgwN9//01CQgLOzs7WLpIQQjwTTD4lNHr0aPz8/GjQoAHe3t588cUXXL16laFDhwJqz8f169dZt24ddnZ21KpVy+j5JUuWxNnZ2ej+UaNG0bJlS2bPnk2XLl3YsmULe/bs4fDhwzl8e8akZ0VYgvSqCCGE+ZkcWHr27MmtW7eYPn06ERER1KpVix07dlC+fHkAIiIinjonS2pNmzbl22+/ZdKkSUyePJlKlSoRFBRE48aNTS2eEEIIIZ5BJs/DolWZXccdFxfH5cuX8fT0lC56keukvgkhRNblyjws4tlUoUIFAgICrF0Ms7py5Qo6nS7NEhBCCCFskwQWDRswYACvvvpqjvZx//59PvjgAypWrIizszMlSpSgdevWbNu2zbDNiRMnGDJkiOFnnU7HDz/8kKPXBdi/fz86nc5wK1asGG3btuXIkSM53rep9AEmvdvRo0f5448/0Ol0aZaDaNy4MU5OTjx48MBwX0JCAgUKFOCLL76w9NsQQog865lZrVmkb+jQoRw/fpwlS5ZQo0YNbt26RUhICLdu3TJsU6JEiVwtw59//kmhQoW4efMmH3/8MS+//DJ//fUXJUuWzNXXTc+ePXuoWbOm0X3FihXDwcEBd3d39u3bZxg7FRsbS1hYGKVKlSIkJIQXX3wRgGPHjvHw4UPatGlj8fLbqq+//pqiRYvi6+tr7aIIIWxU3uxhURS4f986txwMGWrdujXvvPMOY8eOpWjRori5uTF16tRMn/Pjjz8yYcIEXnrpJSpUqICXlxcjR46kf//+hm1SnhKqUKECAF27dkWn0xl+Tq+3x9/fn9atWz+13CVLlsTNzY3atWszadIkoqOjjXoyDhw4QKNGjXBycsLd3Z1x48bx+PFjw+M7d+6kefPmFC5cmGLFivHKK69w8eJFo9c4fvw49evXx9nZmQYNGhAWFpZuWYoVK4abm5vRzcHBAVA/3/379xu2PXToEFWqVKFz585G9+/fv58yZcpQuXLlp753AZcvX6Zv37689NJL1i6KEMKG5c3A8uABPPecdW4pTi1kx9q1a3FxceHYsWPMmTOH6dOnExwcnOH2bm5u7Nixg3v37mVp/ydOnADU9Z8iIiIMP5vDgwcPWLNmDYAhJFy/fp2XXnqJhg0bcvr0aZYtW8aqVav4+OOPDc+7f/8+o0eP5sSJE/z888/Y2dnRtWtXkpKSDI+/8sorVK1alVOnTjF16lTef/99k8vXpk0bDh8+bAhL+/bto3Xr1rRq1Yp9+/YZttu3b5/0rpjg33//NWn7Xbt20bhxY3777bdcKpEQwhbJKSEbU6dOHcMikpUrV2bJkiX8/PPPtG/fPt3tv/jiC/r06UOxYsWoW7cuzZs3p3v37jRr1izd7fWnhwoXLoybm5tZyly2bFlADSyKouDl5UW7du0AdSJBDw8PlixZgk6no1q1avz777988MEHfPjhh9jZ2dGtWzej/a1atYqSJUty9uxZatWqxddff01iYiKrV6+mQIEC1KxZk3/++Ye33347TVmaNm2aZp6U6Oho7O3tad26Nffv3+fEiRN4e3uzf/9+xowZQ8uWLfHz8+PBgwfky5ePo0ePsmTJErN8NnmBqet3dezYEYAuXbqk6UkTQuRdeTOwFCgAsbHWe+0cqFOnjtHP7u7u3LhxI8PtW7ZsyaVLlzh69ChHjhxh7969LFy4kGnTpjF58uQclSWrDh06hIuLC2FhYXzwwQcEBgYaeljOnTuHt7e30aR+zZo1M6z9VK5cOS5evMjkyZM5evQoUVFRhp6Vq1evUqtWLc6dO0fdunUpkOKz9fb2TrcsQUFBVK9e3eg+e3t7QA2AZcuWZf/+/dSsWZOwsDBatWpFyZIl8fT05MiRIzg5OfHw4UPatm1r1s/oWZbdBUcjIiLMXBIhhC3Lm4FFpwMXF2uXIlv0Db2eTqczNOCZPadFixa0aNGCcePG8fHHHzN9+nQ++OCDLC/QZ2dnl2bhyKw2RJ6enhQuXJgqVaoQFxdH165d+e2333Byckp3kUv96+jv79SpEx4eHqxYsYLSpUuTlJRErVq1SEhIMNo+Kzw8PHj++eczfLx169bs27ePOnXqULlyZcPAYP1pIScnJ8qXL28Y2yOeLuV4JFPIyupCiJTy5hiWPK5GjRo8fvyYuLi4dB93cHAgMTHR6L4SJUqk+Y83O3Oc+Pn5kZSUxNKlSw1lCQkJMQodISEhFCxYkDJlynDr1i3OnTvHpEmTaNeuHdWrV+fOnTtp3s/p06d5+PCh4b6jR4+aXDZQx7GEhIQQHBxsNKC4VatW7N+/n/3790vviomyG1iy+zwhxLNJAsszrnXr1nz++eecOnWKK1eusGPHDiZMmECbNm0ynFGwQoUK/Pzzz0RGRhrCQdu2bTl58iTr1q3j/PnzTJkyJVuDIu3s7PD392fWrFk8ePCAYcOGce3aNUaOHMkff/zBli1bmDJlCqNHj8bOzo4iRYpQrFgxvvjiCy5cuMDevXuNVukG6N27N3Z2dgwcOJCzZ8+yY8cOPv3003Rf/9atW0RGRhrdUga3Nm3acP/+fVavXk2rVq0M97dq1YqTJ09y9OhRGXBrIgkeQghzkMDyjOvQoQNr167Fx8eH6tWrM3LkSDp06MCGDRsyfM68efMIDg7Gw8OD+vXrG/YzefJkxo4dS8OGDbl37x79+vXLVpneeustHj16xJIlSyhTpgw7duzg+PHj1K1bl6FDhzJw4EAmTZoEqAHn22+/5dSpU9SqVYt3332XuXPnGu3vueee48cff+Ts2bPUr1+fiRMnMnv27HRf+8UXX8Td3d3olnKSPE9PT8qXL8+9e/eMAkuZMmUoV64ccXFxElhMJKd2hBDmIGsJCWFmUt+MffPNN/Tp0wfI2nijlGOanpE/T0KITMhaQkIITUh5SkgCiBAiuySwCCFyVcpTQhJYhBDZJYFFCJGrpIdFCGEOEliEELnK1EG3qeflEUIIkMAihMhlpvawZHUyQyFE3iKBRQiRqySwCCHMQQKLECJXSWARQpiDBBYhRK6SwCKEMAcJLEKTBgwYwKuvvmrtYggzMHXQrZOTUy6VRAhhyySwaNiAAQPQ6XTodDry5ctHuXLlePvtt9Ms/peZK1euoNPpsrVQYevWrQ2v7+joSKVKlRg/fjzx8fEm7yunUn4WKW8dO3YE4I033sDX19foOT/99BM6nY7Jkycb3f/RRx9RunRpi5U9rzO1hyX1iuRCCAGQz9oFEJnr2LEja9as4fHjx5w9e5a33nqLu3fvsn79eou8/uDBg5k+fToJCQmcOHGCN998E4CZM2da5PVT0n8WKen/G2/Tpg3vv/8+jx8/Jl8+tVrv378fDw8P9u3bZ/Sc/fv3y3pAFmTqxHFySkgIkR7pYdE4Jycn3NzcKFu2LD4+PvTs2ZPdu3cbbbNmzRqqV6+Os7Mz1apVY+nSpYbHPD09Aahfvz46nY7WrVub9PoFChTAzc2NcuXK0a1bN9q3b2/0+vHx8bzzzjuULFkSZ2dnmjdvzokTJwyPJyYmMnDgQDw9PcmfPz9Vq1Zl4cKFRq+RmJjI6NGjKVy4MMWKFWPs2LHpNmz6zyLlrUiRIoAaWGJjYzl58qRh+/379zNu3DhOnDjBgwcPAEhISCA0NFQCiwXJGBYhhDnkyR4WRVEMDZilFShQINsTY126dImdO3cadZmvWLGCKVOmsGTJEurXr09YWBiDBw/GxcWF/v37c/z4cRo1asSePXuoWbNmjhqD06dPc+TIESpUqGC4b+zYsWzcuJG1a9dSvnx55syZQ4cOHbhw4QJFixYlKSmJsmXLsmHDBooXL05ISAhDhgzB3d2dHj16AOrq0KtXr2bVqlXUqFGDefPmsXnzZtq2bZvlslWpUoXSpUuzb98+mjRpwr179/jll1/Ytm0bS5Ys4ciRI7Rv356jR4/y8OFDCSwWJIFFCGEWyjMiOjpaAZTo6Og0jz18+FA5e/as8vDhQ0VRFCU2NlYBrHKLjY3N8nvq37+/Ym9vr7i4uCjOzs6GfcyfP9+wjYeHh/LNN98YPe+jjz5SvL29FUVRlMuXLyuAEhYWZvJn2qpVK8XBwUFxcXFRHB0dFUCxs7NTvv/+e8Pn6ODgoHz99deG5yQkJCilS5dW5syZk+F+hw0bpnTr1s3ws7u7uzJr1izDz48ePVLKli2rdOnSJd3PIuVt+vTphm169+6t+Pj4KIqiKNu3b1dq1KihKIqiDB06VJkwYYKiKIoybdo0xcPDw+TPwhSp61teN3ToUJPqf8uWLQ3bP3782AIlFEJYU2btd0p5sofFlrRp04Zly5bx4MEDVq5cyV9//cXIkSMBuHnzJteuXWPgwIEMHjzY8JzHjx/j6upqltfv06cPEydOJCYmhtmzZ1OoUCG6desGwMWLF3n06BHNmjUzbO/g4ECjRo04d+6c4b7ly5ezcuVK/v77bx4+fEhCQgL16tUDIDo6moiICLy9vQ3b58uXjwYNGqT5b1z/WaRUtGhRo8f9/f159OgR+/fvN5z+atWqFYsXLwbU00Sm9NyInMtJD0t8fDwFChTIlXIJIWxLngwsBQoUIDY21mqvbQoXFxeef/55ABYtWkSbNm2YNm0aH330EUlJSYB6Wqhx48ZGz7O3tzdLeV1dXQ2v/9VXX1GzZk1WrVrFwIEDDY1P6lNciqIY7tuwYQPvvvsu8+bNw9vbm4IFCzJ37lyOHTtmcllSfhbpadOmDffv3+fEiRPs27ePMWPGAGpg6devH7dv3yY0NJT+/fub/Noi+ySwCCHMIU8GFp1Oh4uLi7WLkS1TpkzB19eXt99+m9KlS1OmTBkuXbpEnz590t1e/8c/MTExx6/t4ODAhAkTGD9+PL169eL555/H0dGRw4cP07t3b0C9IuTkyZP4+/sDcOjQIZo2bcqwYcMM+7l48aLhe1dXV9zd3Tl69CgtW7YE1Abu1KlTvPDCCyaVr1KlSnh4eLB161bCw8Np1aoVAO7u7lSoUIF58+YRFxcn41cszNTAkjJsW+MSeiGENslVQjamdevW1KxZkxkzZgAwdepUZs6cycKFC/nrr784c+YMa9asYf78+QCULFmS/Pnzs3PnTv777z+io6MB2Lx5M9WqVTP59Xv37o1Op2Pp0qW4uLjw9ttvM2bMGHbu3MnZs2cZPHgwDx48YODAgQA8//zznDx5kl27dvHXX38xefJko6uIAEaNGsWsWbPYvHkzf/zxB8OGDePu3btpXjs+Pp7IyEijW1RUlNE2bdq0YenSpTz//POUKlXKcL/+tFDFihUpV66cye9bZJ+pgSUlCSwiyx48ADP8Yya0SwKLDRo9ejQrVqzg2rVrDBo0iJUrVxIYGEjt2rVp1aoVgYGBhsuZ8+XLx6JFi/j8888pXbo0Xbp0AdSxI3/++afJr+3o6MiIESOYM2cOsbGxzJo1i27duuHn58cLL7zAhQsX2LVrl+Fy46FDh/Laa6/Rs2dPGjduzK1bt4x6WwDee+89+vXrx4ABAwynjbp27ZrmtXfu3Im7u7vRrXnz5kbbtGnThnv37qW5fLtVq1bcu3dPeleswNSZblOGGgksIkO//w5Ll4KvL5QoAS4u4OEBAwbA/v3WLp3IBTrF1H95NComJgZXV1eio6MpVKiQ0WNxcXFcvnwZT09PnJ2drVRCkVdIfTPWpUsXtm7dCsCdO3coXLhwptu/8sorbN++HYBff/2V2rVr53YRha1ISoJt22D2bAgJyXzb114Db2+4dQtu34bISDh/Hnx8YMoUSP6nSlhfZu13StnqYVm6dKnhj7GXlxeHDh3KcNvDhw/TrFkzihUrRv78+alWrRoLFiww2iYwMDDdadfj4uKyUzwhhIaYekpIelhEGvHxsHo11KwJXbqoYcXODlq1gvHj4auvYNcuCAqCPn3UxzZtgjFjYNYs+OIL2LoVzp2DhQuhQgX46SdrvythIpMH3QYFBeHv78/SpUtp1qwZn3/+Ob6+vpw9ezbdsQEuLi6MGDGCOnXq4OLiwuHDh/nf//6Hi4sLQ4YMMWxXqFChNKco5L9TIWxfTgJLQkJCrpRJ2IizZ+Gtt+DECbV3BcDVFd5+G955B9zd0z6nRw/44AOYPx+uX1fve+45qFEDnJxg+XL491/o3h1CQ6FOHcu9H5EjJgeW+fPnM3DgQAYNGgRAQEAAu3btYtmyZemuL1O/fn3q169v+LlChQps2rSJQ4cOGQUWnU6Hm5tbdt6DEELDZNCtyJbjx+Hll0E/sL5MGXj3XRg8GDI5bQBA7dqQat0xg3Hj1P0GB6vf79hh3nKLXGPSKaGEhAROnTqFj4+P0f0+Pj6EPO18YrKwsDBCQkIMl5zqxcbGUr58ecqWLcsrr7xCWFhYpvuJj48nJibG6CaE0B4ZdCtMNn++Ov4kKgq8vODAAbh0Cd577+lh5WkcHGDZMrC3V08LhYaap8wi15kUWKKiokhMTDS6XBSgVKlSREZGZvrcsmXL4uTkRIMGDRg+fLihhwagWrVqBAYGsnXrVtavX4+zszPNmjXj/PnzGe5v5syZuLq6Gm4eHh6mvBUhhIXIGBZhkm3b1GCSlAQvvQQ//wwtW4I515iqVEm9mgjUAbjCJmRr0G1mM5tm5NChQ5w8eZLly5cTEBDA+vXrDY81adKEvn37UrduXVq0aMGGDRuoUqWKYTr19IwfP57o6GjD7dq1a08t9zNyQZTQOKlnxiSwWEBSEty8qQ4qvXEDbLUOLlkCnTur3w8fDtu3q2NWcsOkSWpvS3AwZGPmbWF5Jo1hKV68OPb29ml6U27cuJGm1yU1/bwgtWvX5r///mPq1Kn06tUr3W3t7Oxo2LBhpj0sTk5OODk5Zanc+pkzExISyJ8/f5aeI0R26VcCT7mqdl6W8pSQBJZsio+HX3+FP/5QB4xev65+1X8fEQEpT73VqAEzZz5p/G3BP/+oV/UoitqzMmdO7r5ehQrqFUWBgfDpp/Ddd7n7eiLHTAosjo6OeHl5ERwcbDSxV3BwsGFCsqxQFCXTP0SKohAeHm62+Rfy5ctHgQIFuHnzJg4ODtjZyXx5wvwUReHBgwfcuHGDwoULm209J1uX8kofGXSbjocP4b//1HlC/vvP+PvISLh6VQ0rWbliqlAhiIlRr67p0gXmzYPRo3P/PZjDhx9CXBw0b66eFnpKr71ZvP++Glg2bYKLF9VTRUKzTL5KaPTo0fj5+dGgQQO8vb354osvuHr1KkOHDgXUUzXXr19n3bp1AHz22WeUK1fOMA384cOH+fTTTw0rDgNMmzaNJk2aULlyZWJiYli0aBHh4eF89tln5niP6HQ63N3duXz5Mn///bdZ9ilERgoXLixXvKUgg25Rew3+/Rd++cX4dvOm2nuSFUWLQt266myupUurtzJlnnzv5qaO87hzRw0pgYHqWJB//lF7K/JpeOm4uXOfXNXz6aeWCSugzuvy0kvqlULz54OZ2hyRO0yuwT179uTWrVtMnz6diIgIatWqxY4dOyhfvjwAERERXL161bB9UlIS48eP5/Lly+TLl49KlSoxa9Ys/ve//xm2uXv3LkOGDCEyMhJXV1fq16/PwYMHadSokRneosrR0ZHKlSvLvA4iVzk4OEjPSip58pSQosCFC+qA0b174eBBtcckI05OUKqUGjpKlTL+3t0d6tcHT8+sNeRFiqiTrFWvrs5HsmABHDmiTlevxVPi9+7B5Mnq96+9BqlWns9177+vBpbAQDXY2ejCuHlBnpiaXwhhPWXLluV68gRe//77L+7pTfaVQrt27di7dy8Afn5+rF279qmD+jXhwQPYuVMdKBocDKkvBLCzU8eWvPCCeqtfH8qVg8KF1YGlufEev/wS+vVTv2/fXm2YtdbTsnatesVOsWLqgGFLn7JXFPVU0OXL8P330K2bZV9fZLn91ljNFUI8a3LSw/Lll1/SuHFjhg8fnitly7GkJDh0CNatUwdt3rv35DFHR3UukXbtoE0bNaQUKGDZ8vn5qaeSXnlFDVFdu8KWLZYPBRk5flydsRZg5EjrlEunU0PKp59KYNE4CSxCiFxlamBJ7ZdffgHUwbvz5s1DURR69+5NhQoVzFVE0/31l9p78eWXkHJcXIUK6mBXX19o0cLyASU9L7+sNsbjxqmDWZctUy8ZtravvlKn2I+NVedZef9965VFH1i2bVMH/sqyMJokgUUIkauyO+i2Xbt2/Pzzz9y4cQOA77//ngkTJgBw4MABdu3aZd6CPk1cnNqLsmyZ8eyohQqp69f06wfNmmmn9yKl995Te3zeeQfGjoU33lBPwVjLokUwapT6fdu2aq+PNceONGqkDmC+fl3tierUyXplERnS4G+WEOJZkt1TQiVLlgTg5s2bAJw5c8awzZUrV8xYwqe4ckXtnfDwUENJaKg6rbuvL6xfr156vGKF2qOixbCiN3w41KqljrUJDrZeOdaseRJW3n8fdu9WFye0Jjs7dcAvwMaN1i2LyJCGf7uEEM8CU+dh0W+jn4xSH1j++OMPwza3bt0yZxHTSkpSB9B26gQVK8Ls2eq6Nh4e8PHH6qXCO3aoPRUau/ImISGBHj16pJ0p3M4OmjZVv08R/izqzp0np34++EC9KkcrV9Xpx65s3Wo8CZ/QDAksQohck5iYaBRSstPDoj8llDKw3L59m8TERHMWVRUTo062VqWK2oOybZt6FUn79rB5s7oA38SJ6iXHGrVy5Uq+++473tEPZk1JPxlnRoHlzp3cK1h8vHrq7PZt9Wqpjz+23HwrWdG8OZQsqX4G+/ZZuzQiHRJYhBC5JvX4FVMG3eoDS2xsLPfu3ePChQtG+7l7965ZygiovSeTJ6uXGb//vjrrqasr+Pur0+Hv3g2vvqq9S4JTePz4MRMnTiQgICDjjZIn8CS9ZU9+/FG9omj2bPMXTlFg0CDYs0cdq7JmjVk+y127dtG7d2/z1AV7+ydLGezcmfP9CbPT7m+fEMLmmTrgFp6EGldXVxwcHHj06BHHjh3j8ePHuLi4YGdnx71794iKiqJYTgeORkaqpyU+/1wd2wHqhGvvvgu9e9vUJGLLly9nxowZmW+kn3r+8mX1tFfKMTd+furXcePU3oYmTcx3umbiRPWqIHt7dRp8M0wKmpSURMeOHQHw8PBgtjmCVps2sHKleqm60BzpYRFC5Jrs9LDot7Gzs6NEiRIAHDx4EIBq1aoZ7svROJboaHW13kqV1JlgHzxQ50nZuBF++w0GD7apsALw+++/P30jDw+1ZyM+Xr0iJqWU4aV5c+jQwTwFO3JEXYgRYPly8PExy24PHDhg+F5/6buiKJw+fTr7pwtbtFC/hoWpl1sLTZHAIoTINTkJLDqdzhBOjh07BsDzzz9P8eLFAYiKijK9QAkJakCpVAk++UQNKo0bw08/wcmT6pUiGrvSJzExMUunPPRjfTKVL586VwxAUJDxY8mfq8HPP6tXSP3zT1aKmbG5c9WvAwaop4VyYNiwYdSrV4979+4Z1qsD2LNnD3Xq1KFevXrUq1ePRYsWZe8FPDzU04KJiXD0aI7KKsxPW7+ZQohnirkCy6lTpwAoV66c4TSQyYFl50510Ono0XDrljqeY9Mm9TLljh21NQA0hffff5+SJUsaQltGstTDAupCiQBjxsD9++pq0Xfvpj9ZWo0aaiP+/femFVrvzz/Vq25AvSooh5YtW8bp06dZu3YtW/X7TXbmzBl+/fVXgOwHFnjSyyKnhTRHAosQItfkZNCtTqczDLzVn/7x8PAw9LBk+ZTQ3bvqeBRfX3WG2lKl1HEKZ86oU9VrNKjoBQQE8OjRI/r27ZvhNnFxcZxPNZBW/9mlMWzYk+9//VVdVLFIkfSvHHr4UP06b56pxX7yPEVRLw/XD/h9in379nH58uU09z/QjzECvvnmG27fvk3hwoV56aWX0mz777//8lBfdlM1b65+PXw4e88XuUYCixAi12RndfSUoUbfw6JXtmxZ03pYQkKgXj11gjd7e7V35a+/YOBATV/xk54LFy4YfTZ//PEHrVu3Zv/+/fzxxx8kJSUZbZ/hgpE9e6qfCaifS2arSOsdP276Jc8xMerSBaD25mTB+fPnadu2LRUrViQ6Otrosf9SlDM0eaZhHx8fPvvsM5YsWUJUVBTBwcG4ubmRkJDA0RSndOLi4ggODk4T6tKl72E5elQ9NWSqmBg4dUqdUfjll9XBzJs2mb4fkYYEFiFErkn5XzGYfkoo9crOJvWwzJ+vrlHz99/q5G+HD6v/8dvQau7x8fFGP6dscHv06MGBAwd48cUXDafMWrZsyYIFC4CnfNYVK6pfU08uB096GFJKSjJ9bhL9ujxVq6a/z3SkfH+jRo0iJiaG6dOnM2PGDCIjI9Ns7+vrS4UKFRg+fDjFihXjxRdfpF27dgDMmDGD3bt3s2TJEjw8PPDx8aFKlSq8+eab3L9/P+NCVKumTgb44AGkuJT+qR48UNeRcnWFBg3UsTs7dqhXR3XrBn37Gi+OKUwmgUUIkWtiU11pYWpgqV+/vtFjHh4eWethmTNHXT8nMVH9DzcsTL1M1wZERUUZlh5I3UgvWbKETz/9lHbt2hmWKkhMTGTHjh0AtGnThhdffPHpL5JZaPv5Z+OfBw9Wv4aEZKn8Bl99pX59/fUsn3a7ffu24fu1a9fi6urKlClTmDhxYpoxPPny5aNbOisrDxgwADs7O/bs2UOHDh0YOXIkUVFRODg4ABAYGEijRo2MJiI0Ym8Pdeqo34eHZ6ncrFihnmpMNa4Gb291jSKAr7/WxqKTNkwCixAi1+Q0sHh5eRk9VqJECUMPS4ZXxcyf/2SA50cfwbp1NtOrkpSURMuWLalRowb//PMP11Nderx48WLGjBnD3r17je7flHzKQT8vCTzls85s7R5HR/XS7s6d1VNB3t7q/cmXDmfJhAnqlVc6nbp8QbITJ07QunVrfvvtt3SflrLXzMPDw+ixzZs3pyiiI3v27KFgwYJp9vHiiy8SFBRE5cqVqVq1KmXKlMHf35/Y2FgOHjyIu7s7Z8+epVmzZpw7dy798utPmWUlsHz1FQwZol4GXaSIOrg7JkadjDAkRL3K6qef1KvPvvxSXUBTZI/yjIiOjlYAJTo62tpFEUIk++677xTAcPvjjz+e+pyGDRsqgLJt2zZFURSj5yuKopw+fdrwc2BgoJKUlKR88sknyoQJE5SI6dMVRR3mqShTp+bqe8sN+/fvN7y3VatWKRs2bFAApWnTpkrTpk0VQHFxcTH6TPS3IkWKKI8fP1Z+++03BVCKFy+e8QuNG/fkc0p9S+30afX+/PkVJTb26W/i6lVFsbNTnzN7ttFDdnZ2CqBUrVo13adOmjRJAZRhw4Ypf/31l+Lm5pbmffr5+Sn//vvv08uRgYiICKVBgwYKoFSsWFGJi4tLu9GyZWr5O3bMfGd//aUozs7qtl27KsqDBxlvO2mSul3x4opy82a2y/8symr7LT0sQohck7qHJSuUp/TC1KlTh/HjxwPwzjvvsGnTJiZOnMiMGTPw+PBDegH3xoyBDz/MTpGt6iv9aRQgJCTEcKlymTJl2LRpE0uXLuXvv/8mJCSEFi1a0Fk/lTzQuXNn7O3tDYNtM/0c0+mZyFCtWuppjYcPYcOGp2+/bJk65qVFC3XgaQr6gcF//vlnuk/V97AUL16cypUrc/HiRdauXWu0TYUKFdKMbTKFm5sbP/30E+7u7ly6dInAwMC0G2W1h+Wjj9RxOi++qF76ndlCmB9+qF5WHxUFyfVXmMgi8ckCpIdFCO1ZsmSJ0X/H586de+pzvLy8FEDZvn27oiiKMmbMGAVQXnzxRcM2iYmJStWqVdPtaQAULy8vm/tbsHHjRsXR0THd9+Pv75/uc+7fv69Mnz5d+fLLL5WHDx8qiqIoZ8+eVQClaNGiGb/YwoVPelSKFFGUs2cVpWRJRRkzJv3tP/xQ3bZp08zfxP37ilK0qLrtpk1GD0VERBjej4uLS7pPf/311xVAWbhwoeG+q1evGn0Wn332WeZlyKKAgAAFUMqVK6fEx8cbPxgbqyg6nfo+IiLS38HNm4ri6Khuc+xY1l708GF1e51OUS5dytkbeIZID4sQwupyOoYF4KOPPuLLL7/km2++MWxjZ2fHuwMGGH62B64AIUOHUqJECU6dOkXv3r3TXOqrVZcvX6ZXr14kJCTQPJ0rakrrJ3tLpUCBAkyePJm+ffvinDzxW5Z6WFKOYXntNXX9pIgIdbByerp3V78eOwaPH2e83y++UFdjrljxyUKC6J/6ZNDs/fv30529N2UPi56HhwfVUszhUqpUqYxf3wRDhgzBzc2Nq1evGs2aC6jLMlSpon5/+nT6O/jqK3Xm5Pr1oWHDrL1os2Zqb4yiQKqeI/F0EliEELkm9eWj2QksTk5O9O3b13hOlp9/pt8nn9ADaA+sLl6c8tu24b1sGdu3b8fZ2Znt27cbLvHVunHjxpGQkECbNm3Yv38/1atXN3q8cOHCWd5XlgJLynWSChRQv2a2JEHNmuDgoF519e+/6W+TkPBkGv5x49IsnJj6Kp/0rtLRX/mVelHLt99+2/C9uQJL/vz5GZt8yuqTTz5Ju/6Q/rRQWFj6O1i1Sv06eLBpkw++9Zb6NTBQPXUmskwCixAi12Snh+WpLl6E7t3JHxtLUOPG7N6+nX7//adO0gU0bNjQMDX7hAkTMrwixRoUReHEiROsWLGCoKAgvvvuO0aOHMmGDRvQ6XTMnz8fe3t7tm7dSnBwMFOmTKFKlSp06tQpy6+RpcCS8gor/dpCmbGzU6foB7h6Nf1tVqxQw4y7O/Tvn+bhn1NdLr1o0aI088zoe1hSB5Z+/fqlKG4WyptF//vf/yhatChXrlwxLLBpoL+kPr1xLH//rV5JZW8PvXqZ9qKvvqrO1fL336bPbWNhu3btYuPGjdYuxhO5e2bKcmQMixDaM2TIEKPxB7/99ttTn1OvXj0FUHbu3Jn2wYQERWnYUB0H0KSJoqR3hYeiKElJScorr7yiAEqFChWUNm3aKG3atFG2bt2qJCYm5vRtZcupU6eUunXrZjjuZs6cOWZ5nb/++ksBlEKFCmW80cWLT8awZPWKlTZt1O2/+irtY2fOPNnf/PlpHr5165ai0+kUQOnatavhPX/44YeGbZKSkhRnZ2cFUC5fvpxmHydOnFB++umnrJXVBAMHDlQAZejQocYP7Nqlvp9KldI+adUq9TFv7+y96Ntvq8/v0yd7z7eAxMREw3G6ceNGrr6WjGERQlidOcawGJk7F06cgMKF1fksnJzS3YdOp2PFihUUK1aMK1eusG/fPvbt20fnzp2pWLEi48ePJywsLPMZT83k8OHDNGvWjEaNGnH69GkKFChAhw4d8Pb2plmzZvTs2ZN169YxJovT1z9NlnpYKlaE69fVK39Sr9KckXLl1K9//218f1ycOsOrfr8jRqR56p49e1AUhZo1azJt2jTD/RdSzCT74MED4uLigLQ9LAANGjQwmmfGXHr06AGoc9k8Tjk+p1Ej9VTPxYtply/Ys0f9mjyrrsn060Jt2wap1tvSipiYGMP3+uNibba1mIYQwqaYNbCcOwf6xm7xYihbNtP9uLm5sXfvXvbs2YObmxunT582XBY8a9YsZs2aBUDNmjWJj4+nVq1alC5dmgYNGtCnTx/s7e2xTzUOQ+/x48fMnz+fX375hf79+/PCCy9w9OhRHB0dKVGihOE01IEDB1i3bp1h8G+XLl1YtWpVug2yuWQpsMCTVZuzSh9Yrl0zvv+77+DSJXXStN271bEuqegnuvPx8aF27dqsWLGCwYMHcy/FVPX600GOjo48l9nEdmbWpk0bihYtyo0bNzh48CBt27ZVHyhcWL2k+8wZOHJEHZwMaj+SfuK+7AaWxo2hRAm4eVNdMqJNmxy/D3NLOSjaIZ1jag0SWIQQ5peQAJGR3DdXYFEUGDpU3e9LL0GfPlkqRp06daiTPM167969mTp1Ktu3b+ebb75h165dPHjwwDDXScr/9ocOHUpiYiIlSpSgTJky3Lx5k5iYGEqVKoWnpydhYWGGxfiCgoKeWo7+/fszdepUs46/yEiWA4up9AEnIsL4fv3MrSNHQqVK6T71TvLCiZ6engCGGWpTBpaUA24zXLgxFzg4ONC1a1dWrVrFhg0bngQWUK/qOXNGDRX6wPLbb2qPS/78T2YBNpW9vVqP166FiRNNX/bAAlIuPmn2upRNEliEEDnz+LE6bXtwsDpA8fff4fx5ePyY2FT/mWX7D9++fXDwoHoKaPly067KSCF//vx0796d7t27oygKly9fZs+ePTx8+JAjR47w+PFjQkNDDWv4REZGGq3nc/fuXcOkZ4UKFeK1115j06ZNxMTEULVqVXQ6HRcuXKBRo0a4uLjg6enJgAED8M5uw5YNudbY6ydrS3mVUHQ07Nqlfp98aiU9qUOovgclZQ+cfh2h3Ox9ykiPHj1YtWoVmzZtYsmSJeTTr+TdvLla344cebLxjz+qX9u0yfCUZJZ07qwGltBQ9fScfs0hjUjZwyKBRQhhu/79V13obds2NUhksArt/Wycn0+3h0V/uezgwU+uVskhnU5HxYoVGTJkCKCuDgzqbKznz5/nxo0bTJw4kRIlSjB69GiKFi3KmTNnuHPnDnXq1KFu3boUKFCAJUuWcPPmTcqXL49Op0NRFIv2EGQk13pY9IHl4kV4/nn1++rV1Uufn1IW/eeSuodFURRDA2nKJdzmoj8tdPPmTQ4cOGBY8ZlmzdSvv/yi1vGCBZ8scKgft5Ndr76q9rQkJqoLI6aaFdjaJLAIIWzXf/+pk2UFBakDX1NydVXP5zdrBjVqqI1XsWLEFi0KKS5dzdYpoX/+efJfvL+/Od5Jpuzs7KhatSpVq1ZNc6lr6vlRAFxcXHBJMa+JtcNKrp8SioxUe9Bat37y2NChmT41dVn0gSU2Npbz58/TrFkzCiUvUGmNwOLg4MBrr73GypUr+e67754ElvLl1VB24QJs366+Z/18MiZcap4uOzt1LNawYWqvjcYCixZPCclVQkKIzP3xh9qzUb48vP++GlZ0OvX8/cyZ6n+ft27Bxo0wejRKhw58c+gQf167xn39pGTJshVY1q1Tx7C0bJnhGAnxRK4FllKl1OOemAgdO6o9LUWLwpYt6viVTGR0SujevXtMmTKFmzdvcvHiRQBcXV3NW+4sev311wHYuHHjk6uFdLonp7o2bAD9XDJeXk9OkeVEhw7q18OHYcAATV0xpMUeFgksQoj0RUbCoEFqj8nKlWpPSaNGsHSp2liFhKgzmtavbzSr6ebNm+nTpw/VqlUjNtXlkNkKLN9+q35NMRW/yFiuBZZ8+dTQAupVQXZ26pilzp2fOqYoo1NCsbGxT8aLJLNGDwuop4WKFStGVFQUR1KOWUkOMuzcCT/9pN/YPC9asaJ6agjU8Sx162pm9ttnpodl6dKleHp64uzsjJeXF4cOHcpwW/0cBMWKFSN//vxUq1Yt3emyN27cSI0aNXBycqJGjRps3rw5O0UTQuTUw4dqz0nlyur044qiNkqHD6vd4W+/DW5uGT495d+Dhw8fAqAfmqiknv78aa5dU6/SsLNLszaNSF+uBRYw7lVo2zbL44ky6mFJSkrCLtWSANYKLA4ODnRI7vHYvXv3kwfq1n2yWvXXX6v36XtGzOH775/0UJ07B19+ab5958Az0cMSFBSEv78/EydOJCwsjBYtWuDr68vVDKZrdnFxYcSIERw8eJBz584xadIkJk2axBdffGHYJjQ0lJ49e+Ln58fp06fx8/OjR48eadaeEELkoqQk9fRL1aowYQLExqo9KkeOqN3++gGIT3EvnQG4hlk1Ulw6nBGjxk3/H22TJmCFq0dsUa4GlpRzt6S8/PcpUgcWFxcXw/epF6i01ikhUOeJgVSBRaeD//3vyc/Nm5v03p/K3h4WLQI/P/XnWbM00cvyTPSwzJ8/n4EDBzJo0CCqV69OQEAAHh4eLFu2LN3t69evT69evahZsyYVKlSgb9++dOjQwei/sICAANq3b8/48eOpVq0a48ePp127dgQEBGT7jQkhTPDrr+qYlP791V4NDw81vISGQtOmJu1Kf9mvnk6nI3/ySsLKiRPw+efqpG+lS8OYMWoPTgpGjZt+zEAuzHD6rLJYYElnAHJGUgcWnU5n1MuSkrV6WOBJYDl16pRhXhhADfArV6qDZHfsyHyhyOxasgQKFVLHjOkHmVuRzfewJCQkcOrUKcNB1fPx8SEkixPfhIWFERISQqtWrQz3hYaGptlnhw4dMt1nfHw8MTExRjchhIkePlT/GHt5wfHj6h/M2bPhzz/V//iy8Yc59Sq8Li4u2OkDy4IF6hUl16+rE5B9+ilMnmy0vVHjFhqq3tm8eTbeXN5ksVNCtWpl+WnpXaquDyyp/3ZbM7C4u7tTu3ZtFEVhX8qFCe3tYeBAddmB5PE3ZleokDpmDGDGjDRB3tJsvoclKiqKxMTENMt7lypVymhypfSULVsWJycnGjRowPDhwxmkPzCokzOZus+ZM2fi6upquHmYaW4GIfKMvXuhTh11vMrjx9Ctm3oOfexYdRbPbLh165bxf6aoAyx1yfsz/NlLOUnWJ5+ol4wmMzRuUVFqb4+dHTRsmK3y5EW5Glj0/1hWqWLSFVvpBRb9wNvU9cWap4QAwz/TmY3NzDX+/lCggDpeTD/Y3EpsvodFL/U8A1mZKOnQoUOcPHmS5cuXExAQwPr163O0z/HjxxMdHW24XUu9voUQIn23bsGbb6rzply4oIaHH35QB/+Zur5MKvreFXd3d0aMGEHDhg0ZM2YMutQzgv78szoRl37+kkmT0v5HmbweD3XqgAXXlrF1uRpYmjVTG9MjR0yabdiUwGLNHhaAli1bAqSZg8ciPDzggw/U7+fPt2ovixYDi0kTxxUvXhx7e/s0PR83btxI00OSmn4Nidq1a/Pff/8xdepUevXqBaiLlJm6TycnJ5xyMi2yEHmNoqhXILz/vrromk4Hw4erPRzJk3bl1I/J05Y3aNCAxYsXG+5ftGiRWgQ3N3VOl6pV1Qf+/hsqVFAvj922DTp1etK4Ja/xQ5MmZilbXpGrgQWyPPg6pcxOCWmth6VFixYA/Prrr9y5c4ciRYpYtgBvv62eEjp5Eg4cMJ6gz4Js/pSQo6MjXl5eBAcHG90fHBxMUxMG5imKQnyK2S+9vb3T7HP37t0m7VMIkYnff1f/8PXvr4aVWrXUeVQWLzZLWHnw4AFTpkxh9uzZALz55ptGjxsa0c2bYfr0Jw8UK6aGJoCPPgJFSRtYLLgOz7PA2jPtpiezHhb9woh61u5hcXNzo0qVKiiKYjwfSzpiYmL45JNPWLNmTbpXx2VLiRLQu7f6farxXZaScqkE/c+aoJjo22+/VRwcHJRVq1YpZ8+eVfz9/RUXFxflypUriqIoyrhx4xQ/Pz/D9kuWLFG2bt2q/PXXX8pff/2lrF69WilUqJAyceJEwzZHjhxR7O3tlVmzZinnzp1TZs2apeTLl085evRolssVHR2tAEp0dLSpb0mIZ9e9e4oydqyi5MunKKAoBQooyuzZihIfb9aXGTNmjII6REXx8PBQHj16ZPR4xYoVFUAJCQlJ++T//lMUZ2e1fAcOPNlWX+a//jJrWZ91//33n+FYaIWvr68CKGvWrDHc16tXL0M5U94ePnxovYImGzRokAIoY8eOzXCb69evK9WrVzeUu2bNmsrt27fNU4ArVxTFzk6t/3/++eT+FSsUxc1NUUqVUpRt2xTlk08UZfNm87xmCg8ePDA6Jn/88YfZXyOlrLbf2arRn332mVK+fHnF0dFReeGFF5QDBw4YHuvfv7/SqlUrw8+LFi1SatasqRQoUEApVKiQUr9+fWXp0qVKYmKi0T6/++47pWrVqoqDg4NSrVo1ZePGjSaVSQKLECkkJSnKpk2K4uGh/tEDRXn1VfUPodleIkk5d+6ccuPGDcXFxUUBlOeee07Ztm1bmm0rVaqkAMqRI0fS39ngwWoZe/VSPD09FUAJBUUpUUJ9LyLLbty4YWhokjTy2XXs2FEBlMDAQMN9gwcPTjewaMG6desUQGnSpEm6jz969Ehp3ry5AigODg6Kk5OTAigtW7Y0X+Dq2FH9nfjkE/V34ODBJ7/LqW/796vPMdPx/ueff4yOyblz58yy34zkamDRIgksQiS7eFFRXn75yR+zChUU5ccfzf4yY8eONfqjVq9evQwbyKcGllOn1LI6OCie5co9CSyvvmr2cj/rbt68aTgmqf8xtJYOHToogLJ27VrDfaNHj9ZsYLly5YoCKPny5VNiY2PTPP75558rgFKwYEHl/Pnzyq+//qoUKlRIAZQWLVooH3/8sTJ//nxlxIgRSokSJZTKlSsrd+7cMa0QK1aovxMeHsa/z+ndevdWlHnzFOW55xRl4cIcv/9ff/3V6JicPXs2x/vMjAQWIfKax4/V0z360ysODooycaKi3L9v9pcKDw83+oP23HPPpX+6J9nzzz+vAMrhw4cz3mmjRooCSoUiRRRAOQqKMmeO2cv+rIuKijIcl8ePH1u7OIqiKIqPj48CKOvWrTPc9+GHH2o2sCiKopRLDs47d+5M81jbtm0VQJk1a5bhvn379hl6WtK7+fv7m1aA+/fVfzZSh5PwcEW5dk1RBgxQg0p6Aeaff3L03vfv36/JwCKLHwrxLLh4EVq1Ui+JjItTpw7/9Vf4+GN1XgczmzdvHgDVqlUzLL3hncng2CxduTJ0qLpN8mA/HcBLL5mjuHlKyoGtmX7eFqQvR3qDbrXK19cXgK+++sro/qioKA4cOAA8WeEZoHXr1oSHh9OnTx9ee+01OnXqRL9+/Zg1axYAixcvTnNxSaYKFIBvvnnys729Oi9R3brqTNFr1qizUae3rlfNmpCDy7Jv375t9LNW6pF24mwOSQ+LyLP27lUUV1f1P6uCBRVl9epcHfeRmJiolChRQgGU/fpz509RpUoVBVAOHjyY8Ub37ytKkSJKueT/6o5XrWqmEuctt2/fNvxnnJCQYO3iKIqiKC+++KICKF999ZXhvuXLlxv9F+/j46OEh4dbsZTGjh8/rgCKs7Oz0emcVatWGU6BZpWfn59hvEv//v2VuLi4rBdk2jRFKV5cUdavT//xLVsU5fnnFWX6dEXZs0dR7O3VvwX29ory++9Zf50UVq5caXRsfvvtt2ztJ6ukh0WIvODrr9WVY6Oj1TV/zpxRJ4XLxUtbw8PDuXnzJgULFsy0VyWlLPWwFCgAixYZZsPVvf12DkuaN9lKD8tzqSYDHDt2LHXr1rVouTLToEEDateuTVxcHN+k6OnYtGkTAN26dcvyvlasWEGnTp149OgRa9euZdWqVVkvyIcfqlMRvPFG+o937gznz6uXQLdrB5s3q/cnJkKq3qGsSn2puVbqkQQWIWzRw4fqH6i+feHRI+jRQ509tnz5XH/p7777DoC2bdvi6Oho3p337avOQwHZmqBM2E5gSX1KyDl5vSmt0Ol0hiVkVq5cCajzruhP67z22mtZ3peTkxNbt25lypQpgLqIcGJioplLnKxTpyfT+uuX3TCRVk8JSWARwpYkJan/NVWtqo5PAXXm2vXrIZf/4N+/f58PPvjAcE7elD/Ypsy+qiTPYK3FCdBsga0GFi3OXN6nTx8cHR0JCwvjl19+Ydu2bSQkJFC1alWqm7Batd6YMWMoWrQoFy9eZPz48blQ4mQvvwz6z7NcOZOfLoFFCJEzUVHg66uuonztmrruyPr1MHdu7ix3j7pC+7Zt2/jggw+oXr06c+bMAeC9996jb9++Wd6PSYElncZNZJ2tBJbUp4S01sMCUKxYMUMwX7VqFStWrADUwbbZqZ8uLi4sXLgQgLlz5/L111+br7ApPfccdO2qfh8RoZ5WMoEEFiFE9igKBAerKxbv3q2upDxjBvz5Z8bntc3g7t27NG3alE6dOjFnzhyuXbtG+fLl2bx5M59++il2JoQkCSyWYyuBxRZ6WADDaaGlS5eyf/9+7O3tGTJkSLb317dvXz5MDhDDhw/n8uXLZilnGl99BV5e6vcffaSu15VFWg0sJi1+KITIZUlJcOiQ2nOya5c6cC42FvSD4CpVUldWrlUrV17+2rVrhISE8Pvvv/Ptt99y/vx5ihQpQvfu3alXrx4DBgygQDYuk5bAYjla/NxsObC0adMGT09PQ7Do1q0bHh4eOdrn5MmTCQ4OJjQ0lJdffpmQkBDzr6Fkb68uoPjqq7Bli/p3o169LD1VAosQImPx8bB6NcyZA1eupH3cwUFdxXXaNDDTH7bExEQOHz7M4cOHOXnyJCdOnOD69etG2xQvXpw9e/Zo6uoNkXVaaWhs9ZQQgJ2dHVOmTOHdd9+ladOmLFiwIMf7zJcvH9999x1NmjTh3LlzzJkzhxkzZpihtOlo314NLNOmqXM1tWkDqKd7Mxo0L4FFCJHWw4ewciXMng36sODqCq+9pl75U6SIerlvpUpGE8A9evSIfv36cf78eVauXEm9p/znpCgKv/76K5cvX+bEiRPcvHmT7du38++//xptZ29vT7169ahfvz716tXDz8+PQmZYzVl6WCzHVk4JpQ4sWu1hAejfvz/9+/c36z7LlCnD4sWL6dq1K8uWLWP8+PG5M5leq1ZPvn/pJYiK4vjvv9OyZUumTJmS7uBfCSxCiCcSE+HLL9VLk//5R72vbFkYNw7eeksdp5KOu3fvoigKY8eO5dvkSxebNWtGaGgoderUSbP9v//+S1BQEF9++SVhYWFpHi9SpAg+Pj40atSIhg0b8sILL+Di4mK+95lMAovl2Epgsbe3J3/+/Dx8+BDQbg9LburcuTNVqlThr7/+YuXKlbz77rvmf5FataBfP3VW3Lg4OHmSoe++S3x8PBMmTEgTWB49esS9e/cAKFCgAA8ePNBMPZLAIoQlKQr89JM6hf5vv6n3lS0LEyeqE75l8F+moih8//33DBw40PDHRO/Bgwf06tWLTZs2kT9/fn799Vf+/vtvtm3bxu7du0lKSgLUBqFGjRrUr1+fUqVK0bBhQ3x9fS3yn60EFsuxlcAC6jgWfWAx+5w+NsDOzo4xY8YwePBg5s+fz4gRI3BwcDD/CwUGqpNLbtkCoaGGvwnpuXXrFqAeqyJFikhgESJPOnECxo6F/fvVnwsXhgkTYOTITOdQefz4Ma+//jo//PCD4T47OzsCAwPp0KEDderU4ezZs1SrVi3d5zdt2pQePXrQt29fihUrZr73YwIJLJZja4Hlxo0bODk55dnj3bdvXyZNmsQ///zDV199xZtvvmn+F9HpwMdHDSwff0xSJnOzXL16FYDSpUuTL58aEbRSj+SyZiFy24UL0LMnNGqkhhUnJxgzBi5dUr8+pSt89+7d/PDDDzg4ODBhwgRCQ0M5deoUfn5+lCxZkv3799O2bVtA7WavW7cuvr6+fPzxx/z1118cOXKEUaNGWS2sCMuypcCiH8ei5fEruc3Z2Zn33nsPgEmTJhEbG5s7L9S/vzqJ3P37JJ079+T+3r1h507Dj/qroTzLl0eXkABopx5JD4sQueXmTZg+HZYvV6fH1unUc8nTp5s0+6R+KvwhQ4bwySefpHm8WrVq/Pzzz8THxwPa/OMvPSyWY0uBRT/IVIt11pJGjhzJsmXLuHz5MkuXLmXs2LHmfxEXF3XSyU8+weiE0Pr16sruHTsCcCX5KsUKkZFcj4gAtFOPpIdFCHNLTFRDStWqsGSJGlZ8fdWJmwIDTQorCQkJhlNBKZeyT4+Tk5Nm//BLYLEcWwwseXHAbUrOzs588MEHAGzcuDH3XqhBAwCjwBIP8PvvEBMDpAgsly6hP1paqUcSWIQwp/Pn1csI335bneytXj3Yuxd27IB0ruJ5mpCQEO7evUvJkiVp3ry5+ctrIRJYLMeWAoucEnqic+fOABw/fpzIyMgsPefSpUucP38+6y/yyiswaRKP8z05uRKt/+bDD0FRDIHFEySwCPFMSkhQFyOsVQuOHIGCBWHRInWgbfJETdmxP3mAbrt27bC3tzdTYS1PAovl2FJgkR6WJ9zd3WmQ3AOyffv2p27/+++/U6dOHV544QUiIyMZMGAADRo0ICoqKuMn5csHH33E3RTzvdxN/vv0cOFClBEjuHz6NAAV8ueXwCLEM+f4cXXNjsmT1eDSoQOcPq1e/ZMvZ8PE9u3bB6jTgwuRFbYYWKSHRfXqq68C8Omnn/Lo0SOjx+Lj43n33XdZu3Yt8fHxvP7669y/f5/Y2FhKly7N2rVrOXXqFB/rV3HPQFJSEneiDf0q3K1WjUjAHXh96VL+Th63UuHhQwksQjxTZs8Gb291TpXixeGbb9R5Vjw9c7zrhw8fcvToUQBat26d4/1Zk/SwWI4WP7ennRKSHhbV8OHDKVGiBH/88QdLly41emz69OkEBAQwYMAAxowZw7kUV/qk/L1aunQpq1at4vHjx+m+xr1794zmYYn29WVV2bJEAxuBONRg4EGKU0KZzNtiSRJYhMiu8HB1ZtqkJPXSwHPnoFcv9WogM1i/fj0JCQmUKVOG559/3iz7tBYJLNahlf+MpYclawoXLsxHH30EwPz58w2h48KFC8yZM8ew3eLFiwFYvnw5xYsXR6fTsWDBAl577TUePXrEoEGDqFixIidOnEjzGnf0C6kmuxsXx71UA/rLAg6kCCxxceZ5gzkkgUUIU0VHw7x5UL+++nO9evD112oPi5ns3bvXcNWAv7+/zTfeElisQ+uBRQbdptW/f3+KFy/O1atX2bp1KwCLFi1K02PSuXNnhgwZwrFjxwgLC8Pf35+goCDmzJlDiRIluHbtGm3btuWdd94hOsUpoNTrBN29e5eI5Nlt9SokfzUEllSnp6xFAosQprh/X73a5/33n9yXPE+KuXz++ee0a9eOqKgoateuzahRo8y6f2uQwGJZpnzelpDRMW3VqhUlS5bkpZdeskaxNMnZ2ZkhQ4YA8NFHH3Hnzh3WrFkDwK5du1i0aBGrV69m8+bN6HQ6KlasaFhNPV++fIwZM4ZLly7Rpk0bYmNjWbx4MUuWLDHsP3VgiY6O5s8//zS6r0LyVwksQtiq+/fV6a2Tp66mfn24exfMeLpm1apVDB8+HIA333yTPXv25M7aIuKZZiuBpVatWkRGRjJixAhrFEuz/P39KVy4MOHh4RQtWpTY2Fhq1KhB+/btGTlyJG+++SZ2dhk338899xzBwcEMHToUMJ7bJfUpoTt37qQJLPoReIbAksF4GEuTwCJEVvzwAzz3HISEgIMDbN0Kv/wCrq5m2X18fDz/+9//GDRoEImJiQwYMIBVq1ZRsmRJs+zf2qSHxbJsJbBkdF9eV6JECaZNm2Z034IFC0z6rOzt7Zk+fTp2dnaEhYUZptxP3cNy4cIF7t69a3RfheSv0sMihK05cQK6dn3y8zffQKdOZtv9hQsXaNmyJV988QU6nY5PPvmEVatWPVN/yCWwWJYtBRaRvpEjRzJ37lwKFy6Mv78/Pj4+Ju+jRIkStGrVCoBt27YB8Msvvxhto78SMaUK06bBxInSwyKETdm7V120UG/tWuje3Sy7vn//PhMmTKBmzZocP36cokWL8tNPPzFhwoRMu3ttkQQWy5LAYvt0Oh3vv/8+t2/fZsGCBdneT9OmTQE4e/YsSUlJ/Pjjj8CTpT70qzOn5Nm/P3z8Mbrkv0NKYmK2X9+cnq2/ikKY0+HD0K6d+n2RInDlirp4oRkcP36c+vXrM3PmTBISEujYsSMnT56kQ4cOZtm/1khgsSwJLM+OnH5mlStXBtSelG7duhEREcFzzz3HgAEDjLbT98TY29tTpkwZo9eWU0JCaNmFC9CixZOfT56E8uVzvNvw8HAGDBhA06ZNOX/+PGXKlOGHH35gx44deJphsrlngVYaWVsmgUXo6QNLeHi4YSHVjh070qZNG6PLyQcMGICLiwtNmjQhX/IM3YZ6JKeEhNCoHTugRo0nP58/DxUr5miXN27cYNiwYbzwwgusXbuWxMREevbsya+//kqXLl2e+T/k2WlAn/XPJDdJYBF6VapUMfrZzc2NWbNmkT9/fsPl0AAdOnTg77//5ueffzbc90wElqVLl+Lp6YmzszNeXl4cOnQow203bdpE+/btKVGiBIUKFcLb25tdu3YZbRMYGIhOp0tzi9PI7HoiD5k7F15+GfRdoPv2ZfuyZUVRCAoKon379pQuXZply5ahKAo9evTg8OHDfPvttxQtWtSMhdcuOSVkWRJYhF6xYsWMFk49efIklSpVAjB8BXXxxWLFihn1uth8YAkKCsLf35+JEycSFhZGixYt8PX1TXfgDsDBgwdp3749O3bs4NSpU7Rp04ZOnToRFhZmtF2hQoWIiIgwusn6EsKivvoKxo5Vvy9WDCIjIRtr+CQkJLBw4UJq1arFG2+8wZ49e0hMTKRRo0bs3buXoKAgmjVrZt6ya5wEFsvS2mcnx9R6dDodiSkGzerHpwB88sknlC5dmokTJ2b4XNBOYDF5Kdn58+czcOBABg0aBEBAQAC7du1i2bJlzJw5M832AQEBRj/PmDGDLVu28OOPP1JfP7U56gfj5uZmanGEyD5FgZ074cgRdZ6V339X7+/cGTZvhmxcqRMcHMzIkSMNEzG5uLjw3nvv0a9fP6P/ZvIaCSzWIT0sAtSJ5GJjYw1rN+l5enpy/fr1DJ+ntcBi0l/khIQETp06leZ6cB8fH0JCQrK0j6SkJO7du5emKzw2Npby5ctTtmxZXnnllTQ9MKnFx8cTExNjdBMiyx4/hhEj4KWX4JNPnoSVDz6ATZtMDitJSUlMmjQJHx8f/vzzT0qWLMlnn33GtWvXmDZtWp4OK6bSSiNry+SUkEhp27Zt1K9fn3379pn0PMNlzfHxuVEsk5nUwxIVFUViYiKlSpUyur9UqVJERkZmaR/z5s3j/v379OjRw3BftWrVCAwMpHbt2sTExLBw4UKaNWvG6dOnDSOcU5s5c2aamQCFyJJr16BvXzh4UP25dWu4dQsGD4aRI03e3cOHD/Hz8zNMfz1s2DBmzJiBq5lmwX0WyKBby5LAIlJq1apVmgnjskKXPPZFK6s1m3xKCNJWOkVRslQR169fz9SpU9myZYvRlONNmjShSZMmhp+bNWvGCy+8wOLFi1m0aFG6+xo/fjyjR482/BwTE4OHh4epb0XkJY8fw7RpMGcOJCRAgQIQGAipllZP6dq1ayxfvhw3NzeqVKlCtWrVKJ/i8ua///6bHj16cPz4cRwdHVm5ciV+fn4WeDO2RU4JWZYEFmEOhh4WWwwsxYsXx97ePk1vyo0bN9L0uqQWFBTEwIED+e6773jxxRcz3dbOzo6GDRty/vz5DLdxcnKSJclF1igK/PQTTJ8Ox46p973wAnz5pfHly6nEx8fTuXNnwsPDje6fPHkyI0eOZMaMGaxcuZLY2FiKFi3K5s2badmyZS6+EdslgcWyJLAIczD0sDx8aOWSqEw6Ue/o6IiXlxfBwcFG9wcHBxum/03P+vXrGTBgAN988w0vv/zyU19HURTCw8Nxd3c3pXhCpLVvHzRtql6qfOwYFCyorgV08mSmYQVg2rRphIeHU6xYMbp27UqN5O0/+ugjSpYsSUBAALGxsXh7e3PixAkJK1kggcUyJLAIczAElkwG5lqSyZdBjB49mpUrV7J69WrOnTvHu+++y9WrVw3LWI8fP55+KaYvX79+Pf369WPevHk0adKEyMhIIiMjiY6ONmwzbdo0du3axaVLlwgPD2fgwIGEh4cb9imEyY4fh/btoW1bOHoU8ueHt9+GsDDo1Qsy+cP56aefotPpDFe9rVixgk2bNvH777/z5ptvGrarX78+O3fu5PDhw1TM4cRyzzpTGiqtNLK2TAKLMAed/uKYf/5Re6qtzOQxLD179uTWrVtMnz6diIgIatWqxY4dOwzn9SMiIozmZPn88895/Pgxw4cPZ/jw4Yb7+/fvT2BgIAB3795lyJAhREZG4urqSv369Tl48CCNUi46J0RW/PYbTJ6sXqYM4OAA//sfTJgAWeixi42NZax+LhagUaNGvPrqq4afFy1axPPPP0+tWrV4+eWXjSZkEhmTQbeWJYFFmEVyYFGmTMn0nzxLydag22HDhjFs2LB0H9OHEL39+/c/dX8LFizI0WqUQnDxIkydCl9/rf4nYGenLlQ4ZQpUqJClXWzfvp3u3bsb/rhWqlSJRYsWGf2Rfe6555gwYUIuvIFnmwQWy5LAIszBUI+sXA49WUtI2LbISLUHpVo1daZaRVGv+vntN1izJsth5cyZM3Tv3t2wHMSCBQu4cOECjRs3zsXC5x1ZbUBTPi6NW/ZJYBHmoLV6lK0eFiGsLjZWXfdn3jy4f1+9r2NHdRK4F14weXfDhg0jLi6OwoUL88EHH2TYgyhyRgKLZWitoZHAYpu0Vo8ksAjb8+OP6gBa/cj1Ro3U8JLNq3Ru3LjB4cOHAbWnpWzZsuYqqUiW1YZKK38YbZ3WgoEEFtuktcAip4SE7bhxA/r0Udf6uX4dPD3hu+/Uq4BycEmxfvXw+vXrS1jJJTKGxTq00tBIYLFNWgss0sMibMPGjerU+XfuqANqR49WJ4LLnz9Hu1UUhS1btgDw0ksvmaOkIh0yhsWytNbQaKUcwjRaq0fSwyK07bffoFMn6N5dDSv16qkTwM2dm6OwoigKX331FW3atDGsAdSpUyczFVqkJoHFsrTW0EgPi23SWj2SHhahTYoCn34KEyfCo0dPelVmzoR8Oau2ly9fZsiQIezZswcAe3t7ZsyYIVcEWYAEFsvQWkMjgcU2aa0eSWAR2nP/Prz5pjo+BdQelnnzIIOVu01x+fJlGjRowO3bt3F2dmb8+PH06dOHSpUq5XjfImMy6NaytNbQSGCxTVqrRxJYhLZcuQJdusCvv6qz1C5eDEOGmGWWxdDQUIYMGcLt27epV68eGzZsoLIZQpB4Ohl0a1laa2gksNgmrdUjCSxCO0JD1SuAoqKgVCn4/nto3twsu/7jjz9o1aoVjx49olixYmzZsoVy5cqZZd/i6WQMi2VpraGRwGKbtFaPZNCt0IY9e+DFF9WwUr8+nDhhtrACMH/+fB49ekTz5s355ZdfJKxYmAQWy9JaQyOBxTZprR5JYBHW9+OP8PLL8OAB+PjAoUPg4WGWXSclJbFq1SrWrVsHwKxZsySsWJEEFsvQWkMjgcU2aa0eSWAR1rVrF3TrBgkJ8OqrsHUruLiYZdenTp2iadOmDBo0iPj4eHx9fWnatKlZ9i1MI4NuLUtrDY0EFtuktXokgUVYz+HD0LWretly9+6wYQM4OeV4t3/++SdDhw6lYcOGHDt2jIIFCzJ//ny2bNkifzCtRAbdWpbWGhoJLLZJa/VIBt0K6wgPV08DPXwIvr7w9dfqVUE5cPfuXT788EMWL15suK93797MnTuX0qVL57DAIidkDItlae2zk8BimySwCPHvv+ppoJgYaNFCvRrI0THbu4uKiuLjjz9m1apVxMbGAuo0+2PGjKF169ZmKrTICQks1qGVhkYCi22SwCLytpgYaN8eLl1SB9Zu3QoFCmRrV/Hx8Xz//feMGzeOf/75B4CaNWsyd+5cfH19zVlqYSYSWCxDaw2NBBbbpLV6JIFFWE5iIvTqBWfPgru7eilz4cIm7yY+Pp6FCxcyd+5coqKiAKhatSoLFy7Ex8dH/ihqkAy6tSytNTQSWGyT1uqRBBZhOePGwY4d4OwMW7ZAlSom7+Kvv/6id+/enDp1CoCyZcsyZMgQ/P39KViwoLlLLMxEBt1altYaGgkstklr9UgCi7CMwEB1MUP99w0bmvT0kJAQpk2bxu7duwEoVqwY8+bNo0+fPuTL4WKIIvfJGBbL0lpDI4HFNmmtHslfepH7jhxR1wMCmDwZevY06ekHDx6kQ4cOxMXFodPp8PX1ZenSpZQvXz4XCitygwQWy9JaQyOBxTZprR7JPCwid/3995O5Vrp1g6lTTXp6REQEr732GnFxcfj6+nLhwgW2b98uYeUZJYHFPLTW0EhgsU1aq0fSwyJyz6NH8MYbcPMm1KsHa9eCXdYz8r179+jbty+3bt2iXr16bNy4kfz58+deeUWuyU4Pi8g+rTU0Elhsk9bqkfSwiNwzbRocPQqFCsGmTSZNuX/hwgW8vb3Zu3cvzs7OfPnllxJWbJgMurUsrTU0Elhsk9bqkQQWkTv27oUZM9TvV6wAT88sP3X37t00bNiQ33//HXd3d/bt20etWrVyqaDCEmQMi2VpraGRwGKbtFaPJLAI84uKgr59QVFg0CDo0SPLT12wYAG+vr7cvXuXJk2acPLkSZo0aZKLhRWWIIHFsrTW0EhgsU1aq0cSWIR5xceDnx9EREC1ahAQkOWnTp06ldGjR5OUlMRbb73F/v37ZQ2gPEYCi3lo7bOTwGKbJLCIZ5eiQP/+sHOnuuryt99medzK1KlTmTZtGgCzZs1i5cqVOJlh5WahDTLo1jq08nlKYLFNWgsscpWQMJ8lSyAoSF11+YcfoG7dpz5FURSmT59uCCtz587l/fffz+WCCkvT2h++Z53WPm8JLLZJa/VIAoswj5Mn4b331O/nzoWOHZ/6lISEBIYMGcLatWsBmDNnjoSVZ5SpPSzSsOWM1hoaPTmutkVr9UgCi8i5O3fUgbWPHsGrr8I77zz1KYqiMGLECNauXYudnR3z589n1KhRuV9WYVUSWCxDaw2NnhxX26K1epStMSxLly7F09MTZ2dnvLy8OHToUIbbbtq0ifbt21OiRAkKFSqEt7c3u3btSrPdxo0bqVGjBk5OTtSoUYPNmzdnp2jC0pKS1HErly9DhQqwejVk4Y/Snj17WLFiBTqdjs2bN0tYecaZulqzNGw5o6WGRgZS2y4t1SPIRmAJCgrC39+fiRMnEhYWRosWLfD19eXq1avpbn/w4EHat2/Pjh07OHXqFG3atKFTp06EhYUZtgkNDaVnz574+flx+vRp/Pz86NGjB8eOHcv+OxOWMXcu/PijOsh240YoUiRLT/vpp58AGDBgAJ07d87NEgoNkEG3lqWlhkYCi+3SUj2CbASW+fPnM3DgQAYNGkT16tUJCAjAw8ODZcuWpbt9QEAAY8eOpWHDhlSuXJkZM2ZQuXJlfvzxR6Nt2rdvz/jx46lWrRrjx4+nXbt2BJhwSaywgv37YcIE9ftFi+CFF7L0tPj4ePbv3w+Aj49P7pRNaIqpf/ikYcsZLTU0Elhsl5bqEZgYWBISEjh16lSaRsbHx4eQkJAs7SMpKYl79+5RtGhRw32hoaFp9tmhQ4dM9xkfH09MTIzRTVhQRIS6TlBSEvTrB4MHZ+lpS5cuxdnZ2dDD1qpVq9wspdAIGXRrWVpqaCSw2C4t1SMwMbBERUWRmJhIqVKljO4vVaoUkZGRWdrHvHnzuH//Pj1SzH4aGRlp8j5nzpyJq6ur4ebh4WHCOxE58vixGlb++w9q1YJly7I0bmXt2rUMHz7c8HOxYsVwd3fPzZIKjZHAYhlaamgksNguLdUjyOag29SVTlGULFXE9evXM3XqVIKCgihZsmSO9jl+/Hiio6MNt2vXrpnwDkSOTJwIBw9CwYLquJUCBZ76lIMHDzI4uRemSpUqlClThg8//DC3Syo0QgbdWpaWGhoJLLZLa8fLpMuaixcvjr29fZqejxs3bqTpIUktKCiIgQMH8t133/Hiiy8aPebm5mbyPp2cnGQmVGvYsgXmzFG/X70aqlR56lPOnTtH165defToET169GD9+vXY2ckky3mJDLq1LAkswpy0UI/AxB4WR0dHvLy8CA4ONro/ODiYpk2bZvi89evXM2DAAL755htefvnlNI97e3un2efu3bsz3aewgkuX1EuYAfz9oXv3pz4lKCiIhg0bcvv2bRo2bEhgYKCElTxIBt1alpY+PwkstktLwReyMXHc6NGj8fPzo0GDBnh7e/PFF19w9epVhg4dCqinaq5fv866desANaz069ePhQsX0qRJE0NPSv78+XF1dQVg1KhRtGzZktmzZ9OlSxe2bNnCnj17OHz4sLnep8ipuDg1oERHg7c3zJ6d6eZJSUl8+OGHfPLJJ4A6uDYoKIj8+fNborRCY2TQrXVooaGRwGK7tBZYTP5Xt2fPngQEBDB9+nTq1avHwYMH2bFjB+XLlwcgIiLCaE6Wzz//nMePHzN8+HDc3d0Nt5QThTVt2pRvv/2WNWvWUKdOHQIDAwkKCqJx48ZmeIsixxQF3n4bwsKgeHHYsAEcHTPZXOF///ufIayMGTOGn3/++amnDcWzTwKLZWipoZHAYru0VI8gm1PzDxs2jGHDhqX7WGBgoNHP+vk2nqZ79+50z8IpBmEFixdDYCDY2cH69VC2bKabf/bZZ6xcuRI7OztWr15Nf/1pJJFnyaBby9JSQyOBxXZpqR5BNq8SEnnIvn0werT6/dy5kGrAdGq7d+/m3XffBWD27NkSVgQgg24tTUsNjQQW26WlegQSWERmrlyB11+HxETo2xeSg0h64uLiGDRoEB06dODx48f06tWL9/SrN4s8TwbdWpaWGhoJLLZLS/UIZLVmkZEHD9SVl2/dAi8v+OKLDCeHu379Ol27duXEiRPodDoGDBjAkiVL5I+TMJBBt5alpYZGAovt0lI9AgksIj2KAm+9BadPQ4kSsHkzZHB1T0xMDK1ateLixYsULVqUoKCgNPPsCKEngcUytNTQSGCxXVqqRyCBRaRn7lwICoJ8+dSZbDNZ9mDUqFFcvHiRcuXKsW/fPipWrGjBggpbIYNuLUtLDY0EFtulpXoEMoZFpLZ7N4wfr36/aBG0aJHhphs3biQwMBCdTsdXX30lYUVkSAbdWpaWGhoJLLZLS/UIJLCIlC5fhl691BWYBw6E5MkA03PlyhXD2kDjxo2jRSbBRggZdGtZWmpoJLDYLi3VI5DAIvQePIDXXoPbt6FhQ1iyJN1BtoqisHHjRjp06MCdO3do2LAhU6dOtXx5hU2RQbeWpaWGRgKL7dJSPQIZwyJAHWQ7dCiEh6uDbDduBGfnNJvduXOHfv36sW3bNgBKlizJ999/j2Mms94KkZIEFsvQ0ucngcV2aS2wSA+LUHtTvvwS7O3VafdTDbK9fv06J06coGnTpmzbtg1HR0cmTpzImTNnKFeunJUKLWyJDLq1Di00NBJYbJfWAov0sOR1hw4Zz2TburXhocTERFavXs3QoUNJSkoCoGzZsvz444/Uq1fP8mUVNksG3VqWlhoaCSy2S0v1CKSHJW+LiFBnsn38GN54A/z9AXj48CGTJ0+mcOHCDBkyxBBWmjVrxrFjxySsCJPJoFvL0lJDo4UyiOzRUj0C6WHJu5KSYMAA+O8/qF0bVq4EnY5Lly7RrVs3wsPDAciXLx8jRoxg5syZOKczrkWIrJBBt5alpYZGjqnt0lI9AgksedfixeqcK87O6iRxLi789NNP9OnThzt37lC8eHGWLVtG165dsbe3t3ZpxTNCAotlaKmhkWNqu7RUj0BOCeVNZ87ABx+o38+bR1LVqkybNo2XX36ZO3fu0KhRI3755Re6d+8uYUWYhQy6tSwtNTRyTG2XluoRSA9L3pOYCP37Q3w8vPwyd954g76dOrFjxw4A3n77bRYsWICTk5OVCyqeJTLo1rK01NBIYLFdWqpHIIEl7/n8cwgLg8KFebB4MR19fTl+/DjOzs4sX76c/v37W7uE4hkkg24tS0sNjQQW26WlegRySihHFi9ezFtvvUVoaKi1i5I1N2/CxIkAJE6bRi9/f44fP07RokUJCQmRsCJyjQy6tSwtNTRyTG2XluoRSGDJkZ07d7JmzRr++OMPaxclayZPhrt3oW5dxly6xNatW3FycmLr1q3Ur1/f2qUTeYAEFsvQUkMjx9R2aakegQSWHHFxcQHg/v37Vi5JFly4oF66DPzQowcLFi4E4Msvv6RZs2bWLJnIA2TQrWVpqaGRY2q7tFSPQAJLjthUYJkyBRITudu+Pf9LDitjxozh9ddft3LBRF4gg24tS0vhQAKL7ZLA8gyxmcDy+++wfj0K8F6BAty4cYNq1arx8ccfW7tkIo+QQbfWoYWGRgKL7ZLA8gyxmcAyfz4oCjNq1mT1li0AfPbZZ7LKsrAYGXRrWVpqaLRQBpE9WqpHIIElR2wisNy4AV9/zZ/A1OTBwYsXL6Zt27bWLZfIkySwWIaWGho5prZLS/UIJLDkiE0Els8/h/h4PihcmMeJibzyyiuMGDHC2qUSeYwMurUsLTU0ckxtl5bqEUhgyZHnnnsO0HBgiY+HpUv5Fdhy9y52dnbMnTvX2qUSeZAMurUsLTU0Elhsl5bqEUhgyRF9D0tsbKyVS5KBH36AyEhm588PwOuvv061atWsWyaRJ8mgW8vSUkMjgcV2aakegQSWHNH8KaFVq7gEfBsXB8AH+gUPhbASGcNiGVpqaOSY2i4t1SOQwJIjmg4sV65AcDDzgCRFoUOHDjKbrbAauUrIsrTU0MgxtV1aqkcggSVHNB1Y1qzhP2C1nXqIx40bZ93yiDxNBt1alpYaGjmmtktL9QgksOSIZgNLYiKsXs0iIC4picaNG9OqVStrl0rkYTLo1rK01NBIYLFdWqpHkM3AsnTpUjw9PXF2dsbLy4tDhw5luG1ERAS9e/ematWq2NnZ4e/vn2abwMBAdDpdmltc8tgLrdJsYAkO5v4///BZcmUbN26c/LEQViWDbi1LSw2NBBbbpaV6BNkILEFBQfj7+zNx4kTCwsJo0aIFvr6+XL16Nd3t4+PjKVGiBBMnTqRu3boZ7rdQoUJEREQY3ZydnU0tnkWlDCxaOaAArFzJ90C0olCxYkU6d+5s7RIJAcgYFkvR0ucnx9R22XxgmT9/PgMHDmTQoEFUr16dgIAAPDw8WLZsWbrbV6hQgYULF9KvXz9cXV0z3K9Op8PNzc3opnX6wJKYmEhCQoKVS5Psxg3YupVVyT8OHDgQOzs58yesSwbdWocWGho5prbLpgNLQkICp06dwsfHx+h+Hx8fQkJCclSQ2NhYypcvT9myZXnllVcICwvLdPv4+HhiYmKMbpamDyygodNCX37Jn48ecQiws7NjwIAB1i6REDLo1sK01NDIMRXmYlJgiYqKIjExkVKlShndX6pUKSIjI7NdiGrVqhEYGMjWrVtZv349zs7ONGvWjPPnz2f4nJkzZ+Lq6mq4eXh4ZPv1sytfvnw4OTkBGpk8TlFgxQpD78rLL79M6dKlrVokIUAG3VqaBBZhDlqqR5DNQbepK56iKDmqjE2aNKFv377UrVuXFi1asGHDBqpUqcLixYszfM748eOJjo423K5du5bt188JTQ28PXSI+D//ZG3yjwMHDrRqcYTQk0G3lqWlhkYCi+3SUj0CyGfKxsWLF8fe3j5Nb8qNGzfS9LrkhJ2dHQ0bNsy0h8XJycnQu2FNLi4u3L59WxuBZcUKFgI3gDJlyvDSSy9Zu0RCGJExLJahpYZGjqnt0lI9AhN7WBwdHfHy8iI4ONjo/uDgYJo2bWq2QimKQnh4OO7u7mbbZ27RTA/L7dvc3rCBj5N/nDFjBg4ODlYtkhB6MujWsrTU0MgxtV1aqkdgYg8LwOjRo/Hz86NBgwZ4e3vzxRdfcPXqVYYOHQqop2quX7/OunXrDM8JDw8H1HEeN2/eJDw8HEdHR2rUqAHAtGnTaNKkCZUrVyYmJoZFixYRHh7OZ599Zoa3mLs0E1i+/JKvExK4B9SqVYu+fftatzxCpGDqoFuRM1pqaCSw2C4t1SPIRmDp2bMnt27dYvr06URERFCrVi127NhB+fLlAXWiuNRzsqRcw+bUqVN88803lC9fnitXrgBw9+5dhgwZQmRkJK6urtSvX5+DBw/SqFGjHLw1y9BEYEkebLsm+cfBgwfLpcxCU6SHxbK01NDIMbVdWqpHkI3AAjBs2DCGDRuW7mOBgYFp7nvam12wYAELFizITlGsThOBJTSUsN9/JwxwcHCgd+/e1iuLEOmQQbeWpaWGRgKL7dJSPQJZSyjHnnvuOcDKlzUvXszC5G+7d+9O8eLFrVcWITIhPSyWoaWGRo6p7dJSPQIJLDlWuHBhQD2tZRVXrxK5YQPrk38cNWqUdcohRCbklJBlaamhkWNqu7RUj0ACS45ZPbAsXsyUpCQSgKZNm9K4cWPrlEOITMigW8vSUjiQwGK7JLA8Y/SB5c6dO5Z/8ZgYflu2jJXJP86ePdvyZRAiC6SHxTq00NDIMbVdElieMUWKFAGs1MOyciVj7t8nCXita1eaN29u+TIIkQUy6NaytNTQSGCxXVqqRyCBJcesdkro3j32TZ/OTsDB3p7Zc+ZY9vWFyAbpYbEMLTU0ckxtl5bqEUhgyTGrnRIKCCAgOhqAQYMG8fzzz1v29YUwgazWbFlaamjkmNouLdUjkMCSY1Y5JXTrFpfmzOHH5B9Hvfuu5V5biGyQ1ZotS0sNjQQW26WlegQSWHLMKj0ss2ezNDYWBfBp356qVata7rWFyAYZdGtZWmpo5JjaLi3VI5DAkmP6Hpbo6GiSkpJy/wWvX+f+okWsSv5x5Dvv5P5rCpFDMujWsrTU0EhgsV1aqkcggSXHXF1dAfWAxsTE5P4LfvQRX8fHcxeoWLEivr6+uf+aQpiJ9LBYhpYaGjmmtktL9QgksOSYs7Mzzs7OgAXGsVy4gLJyJYuTfxw+fDj29va5+5pCmIEMurUsLTU0ckxtl5bqEUhgMQuLDbydMoXNiYn8BhQoUIC33nord19PCDORQbeWpaWGRgKL7dJSPQIJLGZhkYG3p0+z+Ztv6JH848CBAw2vK4TWyaBby9JSQyPH1HZpqR6BBBazyPXJ4xSFv4cO5U0gEejduzdzZKI4YUNk0K1laenzk8Biu7QWWPJZuwDPAv0podzqYXm8YQN9jh4lGmhSvz6BgYE4ODjkymsJkZukh8WytNDQyDG1XVoLLNLDYgb6HpZbt26Zf+cPHvDhkCEcAQo6OvLNxo0SVoTNkUG3lqWlhkaOqe3SUj0CCSxmUblyZQB+/fVXs+97bZ8+zEy+XPrzzz/H09PT7K8hRG6TQbeWpaWGRgKL7dJSPQIJLGbRuHFjAI4dO2bW/R7euJHBP/wAwIRXX6XXgAFm3b8QliKDbi1LSw2NHFPbpaV6BBJYzKJRo0YAnD9/ntu3b5tln/Hx8Qzo149HQPfixfno++/Nsl8hrEEG3VqWlhoaCSy2S0v1CCSwmEWxYsUMqyWfOHEix/u7cuUK3Zs35+KDB7gBq7dvx04miBPPAOlhsQytNTQgx9QWaa0eSWAxE/1poZwGluvXr9OsaVO2nTwJwNxOnSiY3IMjhK2SQbeWpaWGRo6p7dJSPQIJLGZTo0YNQD0tlF3Lly+ndu3a/BsRQTVgt5sbfb/91kwlFMJ6ZNCtZWmpoZHAYru0VI9A5mExm0qVKgFw8eLFbD3/6NGjDB8+nKSkJKoA24GKa9ZAgQLmK6QQViKDbi1LSw2NHFPbpaV6BBJYzCargSUiIoLff/+dGzduMHv2bG7duoW3tzcHDhwgKSmJ3s7OrIuLw/7tt6FjR0sUXQiLkUG3lqGlhkYCi+3SUj0CCSxmow8skZGR3L9/HxcXlzTbHDlyhBdffJG4uDij+79PvgKomosLi+7fx75GDZg3L/cLLYSFSA+LZWmpoZFjaru0VI9AAovZFClShCJFinDnzh0uXbpE7dq1jR6PjIzkjTfeIC4ujnLlyuHm5kaDBg1o3bo1v/32G0UPHWLIvn3kd3aG9eshf34rvRMhzE8G3VqWlj4/Oaa2SwLLM6xSpUqcPHmSOnXqsGbNGvr3749Op+PgwYOMGjWKf/75h6pVq3LixAkKFixoeN7rN2/Cvn3qD2vXQp06VnoHQuQOGXRrHVr4PCWw2C4JLM8wNzc3w/dvvvkmp0+fpnbt2gwcOBCA4sWLs23bNqOwwg8/wIgR6vcffQQ9eliwxEJYhpwSsiwtNTRyTG2XluoRyGXNZtWiRQujnwMCAgxhpVevXoSEhBgmmAPg6FHo1QsUBQYPhokTLVlcISxOBt1ahpYaGgkstktL9QgksJjVO++8w08//cSDBw8ICAjAzk79eHv06MFXX31lWCQRgAsXoFMniIuDl16CpUtBfqHFM0p6WCxLSw2NHFPbpaV6BNkMLEuXLsXT0xNnZ2e8vLw4dOhQhttGRETQu3dvqlatip2dHf7+/ulut3HjRmrUqIGTkxM1atRg8+bN2SmaVTk7O9OxY0fy58/PqFGjuHbtGufPn+fbb781hBcAHj6Erl0hKgq8vCAoCPLJ2Tnx7JJBt5alpYZGjqnt0toxMzmwBAUF4e/vz8SJEwkLC6NFixb4+vpy9erVdLePj4+nRIkSTJw4kbp166a7TWhoKD179sTPz4/Tp0/j5+dHjx49zL76saWVLl2a559/Pu1Bf+89+O03KFkSfvwRnnvOOgUUwkJk0K1lSWAR5qSFegTZCCzz589n4MCBDBo0iOrVqxMQEICHhwfLli1Ld/sKFSqwcOFC+vXrh6ura7rbBAQE0L59e8aPH0+1atUYP3487dq1IyAgwNTiad+mTaD/rL78EtzdrVseISxATglZlgQWYQ5aqkdgYmBJSEjg1KlT+Pj4GN3v4+NDSEhItgsRGhqaZp8dOnTI0T416eZNdXAtwNixkOo9C/Gsk0G3lqGlhkYCi+3SUj0CEy9rjoqKIjExkVKlShndX6pUKSIjI7NdiMjISJP3GR8fT3x8vOHnmJiYbL++xYwdC7dvq/OsfPyxtUsjhMVID4tlaamhkWNqu7RUjyCbg25TVzxFUXJcGU3d58yZM3F1dTXcPDw8cvT6ue7gQQgMVK8E+vxzcHCwdomEsBgZdGtZWmpo5JjaLi3VIzAxsBQvXhx7e/s0PR83btxI00NiCjc3N5P3OX78eKKjow23a9euZfv1c11CArz9tvr94MHQpIl1yyOEhcmgW8vSUkMjgcV2aakegYmBxdHRES8vL4KDg43uDw4OpmnTptkuhLe3d5p97t69O9N9Ojk5UahQIaObZs2bB2fPQokSMHOmtUsjhMXJKSHL0tLnJ8fUdmktsJg8+cfo0aPx8/OjQYMGeHt788UXX3D16lWGDh0KqD0f169fZ926dYbnhIeHAxAbG8vNmzcJDw/H0dGRGjVqADBq1ChatmzJ7Nmz6dKlC1u2bGHPnj0cPnzYDG/Ryi5ehOnT1e/nz4eiRa1bHiGsSAbdWpYWGhoJLLbL5gNLz549uXXrFtOnTyciIoJatWqxY8cOypcvD6gTxaWek6V+/fqG70+dOsU333xD+fLluXLlCgBNmzbl22+/ZdKkSUyePJlKlSoRFBRE48aNc/DWNEBRYPhwdTbbdu2gTx9rl0gIq5AeFsvSUkOjhTKI7NFSPYJsLn44bNgwhg0blu5jgYGBae7Lypvt3r073bt3z05xtGvDBti1CxwdZep9kafJoFvL0lJDI8fUdmmpHoGsJZR77t6FUaPU7ydOhCpVrFocIaxJBt1alpYaGgkstktL9QgksOQORVHDyn//QdWq8MEH1i6REFYlp4QsS0sNjRxT26WlegQSWHLHihWwbh3Y2anfOzlZu0RCaIIMurUMLTU0Elhsl5bqEUhgMb9Tp2DkSPX7Tz6BFi2sWx4hNEB6WCxLSw2NHFPbpaV6BBJYzOv2bejeXZ0ornNndSp+IYQMurUwLTU0ckxtl5bqEUhgMZ+kJPDzgytXoGJFWLtWPSUkhJBBtxampYZGAovt0lI9Agks5vPJJ7BjBzg7w/ffQ+HC1i6REJohp4QsS0sNjRxT26WlegQSWMxj3z6YMkX9ftkySDFRnhDiCRl0axlaamgksNguLdUjkMCSc/fvw6BB6qXMgwbBgAHWLpEQmiM9LJalpc9PjqntksDyrJk8GS5dAg8Pda0gIUQaMujWOrTQ0MgxtV0SWJ4loaEQEKB+//nnULCgVYsjhFbJoFvL0lJDI4HFdmmpHoEEluyLi4O33lJPBfXvD76+1i6REJolp4QsS0sNjRxT26WlegQSWLLvww/hjz/AzU1OBQmRRTLo1jK01NBIYLFdWqpHIIEle3btgk8/Vb9fvhyKFrVueYTQOOlhsSwtNTRyTG2XluoRSGAx3f790LWreipo8GDo0sXaJRJC82TQrWVpqaGRY2q7tFSPQAKLaXbvhpdfhocP1TErixZZu0RC2AQZdGtZWmpoJLDYLi3VI5DAknWrV0OHDvDgAXTsCJs2qbPaCiGyTE4JWYaWGho5prZLS/UIJLA8XXw8DB0KAweqP/fuDZs3S1gRwgSm/uGTxi1ntNTQSGCxXVqqRwD5rF0ATUtIgG7dYPt29ed33oEFC2RRQyFMJINuLUtLDY0cU9ulpXoEEliezslJ7U35/HN1NWb5pRPCZDLo1rK01NDIMbVdWqpHIIElc46O8O23cOYMvPCCtUsjhM2SQbeWpaVwIIHFdmktsMi5jadxcJCwIoSZyCkhy9JCQyPH1HZJYBFC5Dky6NaytNTQSGCxXVqqRyCBRQhhATLo1rK01NDIMbVdWqpHIIFFCGEBMujWsrTU0MgxtV1aqkcggUUIYQEy6NaytNTQSGCxXVqqRyCBRQhhQXJKyDK01NDIMbVdWqpHIIFFCGEBMujWsrTU0EhgsV1aqkcggUUIYQEy6NaytNTQyDG1XVo7ZhJYhBC5TgbdWpYEFmFOWqhHIIFFCGEBMujWsiSwCHPQUj0CCSxCCAuSU0KWoaWGRo6p7dJSPYJsBpalS5fi6emJs7MzXl5eHDp0KNPtDxw4gJeXF87OzlSsWJHly5cbPR4YGIhOp0tzi4uLy07xhBAaI4NuLUtLn58EFttl84ElKCgIf39/Jk6cSFhYGC1atMDX15erV6+mu/3ly5d56aWXaNGiBWFhYUyYMIF33nmHjRs3Gm1XqFAhIiIijG7Ozs7Ze1dCCE2RMSzWoYWGRo6p7dJaYDF5teb58+czcOBABg0aBEBAQAC7du1i2bJlzJw5M832y5cvp1y5cgQEBABQvXp1Tp48yaeffkq3bt0M2+l0Otzc3LL5NoQQWiZXCVmWlhoaOaa2S0v1CEzsYUlISODUqVP4+PgY3e/j40NISEi6zwkNDU2zfYcOHTh58iSPHj0y3BcbG0v58uUpW7Ysr7zyCmFhYZmWJT4+npiYGKObEEKbZNCtZWmpoZHAYru0VI/AxMASFRVFYmIipUqVMrq/VKlSREZGpvucyMjIdLd//PgxUVFRAFSrVo3AwEC2bt3K+vXrcXZ2plmzZpw/fz7DssycORNXV1fDzcPDw5S3IoSwAulhsQwtNTRyTG2XluoRZHPQbeqKpyhKppUxve1T3t+kSRP69u1L3bp1adGiBRs2bKBKlSosXrw4w32OHz+e6Ohow+3atWvZeStCCAuQQbeWpaWGRgKL7dJSPQITx7AUL14ce3v7NL0pN27cSNOLoufm5pbu9vny5aNYsWLpPsfOzo6GDRtm2sPi5OSEk5OTKcUXQliJDLq1LC01NHJMbZeW6hGY2MPi6OiIl5cXwcHBRvcHBwfTtGnTdJ/j7e2dZvvdu3fToEEDHBwc0n2OoiiEh4fj7u5uSvGEEBolg24tS0sNjRxT26WlegTZOCU0evRoVq5cyerVqzl37hzvvvsuV69eZejQoYB6qqZfv36G7YcOHcrff//N6NGjOXfuHKtXr2bVqlW8//77hm2mTZvGrl27uHTpEuHh4QwcOJDw8HDDPoUQtk0G3VqWlhoaCSy2S0v1CLJxWXPPnj25desW06dPJyIiglq1arFjxw7Kly8PQEREhNGcLJ6enuzYsYN3332Xzz77jNKlS7No0SKjS5rv3r3LkCFDiIyMxNXVlfr163Pw4EEaNWpkhrcohNAK6WGxDC01NHJMbZeW6hFkI7AADBs2jGHDhqX7WGBgYJr7WrVqxS+//JLh/hYsWMCCBQuyUxQhhA2QU0KWpaWGRo6p7dJSPQJZS0gIYQGmNlbSuOWMlhoaCSy2S0v1CCSwCCEsQHpYLEtLn58cU9slgUUIkefIoFvr0MLnKYHFdklgEULkWdLDYhlaamjkmNouLdUjkMAihLAAOSVkWVpqaOSY2i4t1SOQwCKEsAAZdGtZWmpoJLDYLi3VI5DAIoSwAOlhsSwtNTRyTG2XluoRSGARQliADLq1LC01NBJYbJeW6hFIYBFCWJD0sFiGlhoaOaa2S0v1CCSwCCEsQE4JWZbWGhqQY2qLtHbMJLAIIXKdDLq1LC0FFgmhtivlMdNCXZLAIoTIddLDYlkSWIQ5SGARQuRZMujWMiSwCHOQwCKEyHOkh8WytPT5yTG1XRJYhBB5jgQW69BCIyPH1HZJYBFC5Dky6NaytHhKSNgeCSxCiDxHelgsS4uBRY6p7ZHAIoTIs2TQrWVIYBHmIIFFCJHnSA+LZUlgEeYggUUIkedIYLEsCSzCHCSwCCHyHBl0a1kSWIQ5SGARQuQ50sNiWRJYhDlIYBFC5Fky6NYyJLAIc5DAIoTIc6SHxbIksAhzkMAihMhzJLBYlgQWYQ4SWIQQeY4MurUsLX1+EliEuUhgEULkOulhsQ4t/Fcsx9R2SQ+LECLPkkG3liGnhIQ5SGARQuQ50sNiWRJYhDlIYBFC5DkSWCxLAoswBwksQog8RwbdWpYEFmEOz0RgWbp0KZ6enjg7O+Pl5cWhQ4cy3f7AgQN4eXnh7OxMxYoVWb58eZptNm7cSI0aNXBycqJGjRps3rw5O0UTQmiQ9LBYlgQWYQ42H1iCgoLw9/dn4sSJhIWF0aJFC3x9fbl69Wq621++fJmXXnqJFi1aEBYWxoQJE3jnnXfYuHGjYZvQ0FB69uyJn58fp0+fxs/Pjx49enDs2LHsvzMhhObIoFvLkMAizMHmA8v8+fMZOHAggwYNonr16gQEBODh4cGyZcvS3X758uWUK1eOgIAAqlevzqBBg3jrrbf49NNPDdsEBATQvn17xo8fT7Vq1Rg/fjzt2rUjICAg229MCKEd0sNiWRJYhLlpoS6ZFFgSEhI4deoUPj4+Rvf7+PgQEhKS7nNCQ0PTbN+hQwdOnjzJo0ePMt0mo30CxMfHExMTY3QTQmiTBBbLksAizEVLdcmkwBIVFUViYiKlSpUyur9UqVJERkam+5zIyMh0t3/8+DFRUVGZbpPRPgFmzpyJq6ur4ebh4WHKWxFCWJAMurUsLTUyElhsm5bqUrYG3aaueIqiZFoZ09s+9f2m7nP8+PFER0cbbteuXcty+YUQlpXVxkoaN/PQUiMjx9S2aaku5TNl4+LFi2Nvb5+m5+PGjRtpekj03Nzc0t0+X758FCtWLNNtMtongJOTE05OTqYUXwihAZn9M6KFP4rPAi2FAwkstk1LgcWkHhZHR0e8vLwIDg42uj84OJimTZum+xxvb+802+/evZsGDRrg4OCQ6TYZ7VMIYVuyerWBNG7mpYVGRo6pbdNSYDGphwVg9OjR+Pn50aBBA7y9vfniiy+4evUqQ4cOBdRTNdevX2fdunUADB06lCVLljB69GgGDx5MaGgoq1atYv369YZ9jho1ipYtWzJ79my6dOnCli1b2LNnD4cPHzbT2xRCWJMEFsvSUiMjx9S2aakumRxYevbsya1bt5g+fToRERHUqlWLHTt2UL58eQAiIiKM5mTx9PRkx44dvPvuu3z22WeULl2aRYsW0a1bN8M2TZs25dtvv2XSpElMnjyZSpUqERQUROPGjc3wFoUQ1iaDbi1LS42MBBbbpqW6ZHJgARg2bBjDhg1L97HAwMA097Vq1Ypffvkl0312796d7t27Z6c4QgiNkx4Wy9JSIyPH1LZpqS5lK7AIIUR2jR49Gju79IfPhYWFWbg0zyZ9I3Pv3j38/f2tWpbffvsNkMBiq/THbdq0aRQqVAh/f38qVKhglbJIYBFC5DpnZ2ccHR1JSEhg8eLFT93e1dXVAqV6duk/v7i4OBYuXGjl0qjkmNqmwoUL8/DhQ9asWQPAG2+8IYFFCPHsKlCgAJs2bcp09mq94sWLy+nhHCpbtizr16/nzJkz1i4KACVLlqRTp07WLobIhqCgIHbu3Gn4uXTp0lYri07RwokpM4iJicHV1ZXo6GgKFSpk7eIIIYQQIguy2n5na6ZbIYQQQghLksAihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNy2ftApiLftHpmJgYK5dECCGEEFmlb7f17XhGnpnAcu/ePQA8PDysXBIhhBBCmOrevXu4urpm+LhOeVqksRFJSUn8+++/FCxYEJ1OZ+3imE1MTAweHh5cu3aNQoUKWbs4IhU5Ptomx0fb5PhonyWOkaIo3Lt3j9KlS2Nnl/FIlWemh8XOzo6yZctauxi5plChQvILrWFyfLRNjo+2yfHRvtw+Rpn1rOjJoFshhBBCaJ4EFiGEEEJongQWjXNycmLKlCk4OTlZuygiHXJ8tE2Oj7bJ8dE+LR2jZ2bQrRBCCCGeXdLDIoQQQgjNk8AihBBCCM2TwCKEEEIIzZPAIoQQQgjNk8BiYVOnTkWn0xnd3NzcDI8risLUqVMpXbo0+fPnp3Xr1vz+++9G+4iPj2fkyJEUL14cFxcXOnfuzD///GPpt/LMOHjwIJ06daJ06dLodDp++OEHo8fNdUzu3LmDn58frq6uuLq64ufnx927d3P53dm+px2fAQMGpPmdatKkidE2cnxyz8yZM2nYsCEFCxakZMmSvPrqq/z5559G28jvkPVk5fjYyu+QBBYrqFmzJhEREYbbmTNnDI/NmTOH+fPns2TJEk6cOIGbmxvt27c3rJUE4O/vz+bNm/n22285fPgwsbGxvPLKKyQmJlrj7di8+/fvU7duXZYsWZLu4+Y6Jr179yY8PJydO3eyc+dOwsPD8fPzy/X3Z+uednwAOnbsaPQ7tWPHDqPH5fjkngMHDjB8+HCOHj1KcHAwjx8/xsfHh/v37xu2kd8h68nK8QEb+R1ShEVNmTJFqVu3brqPJSUlKW5ubsqsWbMM98XFxSmurq7K8uXLFUVRlLt37yoODg7Kt99+a9jm+vXrip2dnbJz585cLXteACibN282/GyuY3L27FkFUI4ePWrYJjQ0VAGUP/74I5ff1bMj9fFRFEXp37+/0qVLlwyfI8fHsm7cuKEAyoEDBxRFkd8hrUl9fBTFdn6HpIfFCs6fP0/p0qXx9PTkjTfe4NKlSwBcvnyZyMhIfHx8DNs6OTnRqlUrQkJCADh16hSPHj0y2qZ06dLUqlXLsI0wH3Mdk9DQUFxdXWncuLFhmyZNmuDq6irHzQz2799PyZIlqVKlCoMHD+bGjRuGx+T4WFZ0dDQARYsWBeR3SGtSHx89W/gdksBiYY0bN2bdunXs2rWLFStWEBkZSdOmTbl16xaRkZEAlCpVyug5pUqVMjwWGRmJo6MjRYoUyXAbYT7mOiaRkZGULFkyzf5Lliwpxy2HfH19+frrr9m7dy/z5s3jxIkTtG3blvj4eECOjyUpisLo0aNp3rw5tWrVAuR3SEvSOz5gO79Dz8xqzbbC19fX8H3t2rXx9vamUqVKrF271jDISafTGT1HUZQ096WWlW1E9pnjmKS3vRy3nOvZs6fh+1q1atGgQQPKly/P9u3bee211zJ8nhwf8xsxYgS//vorhw8fTvOY/A5ZX0bHx1Z+h6SHxcpcXFyoXbs258+fN1wtlDqN3rhxw/DfiZubGwkJCdy5cyfDbYT5mOuYuLm58d9//6XZ/82bN+W4mZm7uzvly5fn/PnzgBwfSxk5ciRbt25l3759lC1b1nC//A5pQ0bHJz1a/R2SwGJl8fHxnDt3Dnd3dzw9PXFzcyM4ONjweEJCAgcOHKBp06YAeHl54eDgYLRNREQEv/32m2EbYT7mOibe3t5ER0dz/PhxwzbHjh0jOjpajpuZ3bp1i2vXruHu7g7I8cltiqIwYsQINm3axN69e/H09DR6XH6HrOtpxyc9mv0dMsvQXZFl7733nrJ//37l0qVLytGjR5VXXnlFKViwoHLlyhVFURRl1qxZiqurq7Jp0yblzJkzSq9evRR3d3clJibGsI+hQ4cqZcuWVfbs2aP88ssvStu2bZW6desqjx8/ttbbsmn37t1TwsLClLCwMAVQ5s+fr4SFhSl///23oijmOyYdO3ZU6tSpo4SGhiqhoaFK7dq1lVdeecXi79fWZHZ87t27p7z33ntKSEiIcvnyZWXfvn2Kt7e3UqZMGTk+FvL2228rrq6uyv79+5WIiAjD7cGDB4Zt5HfIep52fGzpd0gCi4X17NlTcXd3VxwcHJTSpUsrr732mvL7778bHk9KSlKmTJmiuLm5KU5OTkrLli2VM2fOGO3j4cOHyogRI5SiRYsq+fPnV1555RXl6tWrln4rz4x9+/YpQJpb//79FUUx3zG5deuW0qdPH6VgwYJKwYIFlT59+ih37tyx0Lu0XZkdnwcPHig+Pj5KiRIlFAcHB6VcuXJK//7903z2cnxyT3rHBlDWrFlj2EZ+h6znacfHln6HdMlvSAghhBBCs2QMixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNE8CixBCCCE0TwKLEEIIITRPAosQQgghNO//mpsDdofvaw4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "for _key, key in enumerate(report.keys()):\n", + " if _key < 1:\n", + "\n", + " rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))\n", + " rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()\n", + " wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])\n", + "\n", + " miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5\n", + " maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5\n", + " minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5\n", + " maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5\n", + "\n", + " plt.figure()\n", + " plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))\n", + " plt.title(f'NIS01_20210403_{key}')\n", + " for k,i in report[key].items():\n", + " plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)\n", + "\n", + " for k,i in report[key].items():\n", + " plt.figure()\n", + " in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())\n", + " in_situ = np.genfromtxt(in_situ_path, skip_header=3)\n", + " plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')\n", + " mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))\n", + " plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')\n", + " plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "85419744-2391-48f0-b6c2-239390d4b994", + "metadata": {}, + "source": [ + "## Per-Pixel Retrievals\n", + "\n", + "This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).\n", + "\n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f60f1ae9-754b-4c25-bc51-70b792debed7", + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5efac6d4-c9f5-4292-a8e1-739939056ac1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n" + ] + } + ], + "source": [ + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')\n", + "config.input.loc_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "467786f7-35a6-4472-92c5-1fa753da9e3d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line\n" + ] + } + ], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fdbd8001-530b-497f-a2c8-fdda0a2206d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(13, 428)\n", + "[0.10742364 0.60519719]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def closest_wl(mv):\n", + " return np.argmin(np.abs(io.meas_wl-mv))\n", + "\n", + "wl_nan = io.meas_wl.copy()\n", + "wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan\n", + "wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan\n", + "\n", + "fig = plt.figure(figsize=(14,5))\n", + "print(states.shape)\n", + "offset = 0\n", + "for n in range(0,states.shape[0],4):\n", + " lab = f'Step {n}'\n", + " if n == 0:\n", + " lab = 'Algebraic inversion at initial guess'\n", + " \n", + " plt.plot(wl_nan, states[n,:-2] + offset, label=lab)\n", + " offset += 0.04\n", + "plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')\n", + "plt.legend()\n", + "\n", + "print(states[-1,-2:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8fcb0f-cd8e-47b9-9146-2e1335afcfd2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/source/sensor_examples/neon/neon.ipynb b/isofit-tutorials/source/sensor_examples/neon/neon.ipynb new file mode 100644 index 0000000..339460d --- /dev/null +++ b/isofit-tutorials/source/sensor_examples/neon/neon.ipynb @@ -0,0 +1,1608 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "35412b86-171d-473c-8575-470b8fbed89d", + "metadata": {}, + "source": [ + "# NEON\n", + "\n", + "Here, we show how one would apply ISOFIT to data collected by the NEON imaging spectrometer.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f81e3c4a-0bef-4cbe-a494-75c8e0d908ca", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "This is an excercise in executing ISOFIT on entire images collected on two dates from the NEON dataset.\n", + "\n", + "Prerequisites:\n", + "- Download sample data from https://avng.jpl.nasa.gov/pub/PBrodrick/isofit/tutorials/subset_data.zip. This dataset was prepped already from the data_prep notebook. Place the dataset into the NEON folder in this repo and unzip it, which will create the 'data' folder which includes the 'subsets' directory.\n", + "- Have a working installation of ISOFIT, with sRTMnet installed and configured (see environment variable specification on the next line)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed8d9de0-a74a-4e6c-83b2-54f7bc32f593", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "from pathlib import Path\n", + "from types import SimpleNamespace\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "from spectral.io import envi\n", + "\n", + "import isofit\n", + "from isofit.utils.apply_oe import apply_oe \n", + "from isofit.utils.surface_model import surface_model\n", + "from isofit import ray\n", + "ray.shutdown()\n" + ] + }, + { + "cell_type": "markdown", + "id": "164060bf-3cad-4d58-811f-838158d7d967", + "metadata": {}, + "source": [ + "ISOFIT needs at minimum three pieces as input:\n", + "\n", + " 1. Radiance measurements (rdn)\n", + " 2. Observation values (obs)\n", + " 3. Location information (loc)\n", + "\n", + "This sample dataset from NEON has radiance and observation data, but no location values (more recent NEON datasets include the location file). However, we can 'fake' the location file with sufficient accuracy for ISOFIT to run successfully. Note that there are data available for two dates:\n", + "\n", + "```\n", + "Radiance\n", + "├── 173647\n", + "│ ├── NIS01_20210403_173647_obs_ort\n", + "│ ├── NIS01_20210403_173647_obs_ort.hdr\n", + "│ ├── NIS01_20210403_173647_rdn_ort\n", + "│ └── NIS01_20210403_173647_rdn_ort.hdr\n", + "└── 174150\n", + " ├── NIS01_20210403_174150_obs_ort\n", + " ├── NIS01_20210403_174150_obs_ort.hdr\n", + " ├── NIS01_20210403_174150_rdn_ort\n", + " └── NIS01_20210403_174150_rdn_ort.hdr\n", + "```\n", + "\n", + "These files have corresponding in situ data as well, and below we've encoded the locations of each, which we can use to help subset data files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7b88339c-ac36-4aab-98b7-2a1dd07ab8a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data subset directory at: /Users/bgreenbe/.isofit/neon_subset\n", + "Surface model at: /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json\n", + "sRTMnet emulator path (required): /Users/bgreenbe/.isofit/srtmnet/sRTMnet_v120.h5\n", + "6s path (required): /Users/bgreenbe/Github/6sMultiComponentFN/Sixs\n" + ] + } + ], + "source": [ + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "\n", + "# Path to the input NEON data\n", + "subset_dir = str(Path('~/.isofit/neon_subset').expanduser())\n", + "print(f'Data subset directory at: {subset_dir}')\n", + "\n", + "# Path to write isofit output\n", + "output = str(Path('~/.isofit/neon_subset/output').expanduser())\n", + "if os.path.isdir(output) is False:\n", + " os.mkdir(output)\n", + "\n", + "if os.path.isdir(subset_dir) is False:\n", + " os.mkdir(subset_dir)\n", + "\n", + "surface_model_path = str(Path('~/.isofit/examples/20171108_Pasadena/configs/ang20171108t184227_surface.json').expanduser())\n", + "print(f'Surface model at: {surface_model_path}')\n", + "neon_id = '173647'\n", + "\n", + "\n", + "# Optionally set some environment variables as needed\n", + "#os.environ['EMULATOR_PATH'] = '/Users/brodrick/isofit_support/sRTMnet_v120.h5'\n", + "#os.environ['SIXS_DIR'] = '/Users/brodrick/6s/'\n", + "\n", + "print(f'sRTMnet emulator path (required): {os.environ[\"EMULATOR_PATH\"]}')\n", + "print(f'6s path (required): {os.environ[\"SIXS_DIR\"]}')\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "727dcd06-2a38-4020-8a15-b6707b8ed453", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a5656147-509e-41f4-9cac-c9b81117c5b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Which NEON date to process - change this to process a different date\n", + "neon_id = list(report.keys())[0]\n", + "\n", + "# Select the locations from the neon id -- roi == Regions of Interest\n", + "roi = report[neon_id]" + ] + }, + { + "cell_type": "markdown", + "id": "e9ec9046-3c9d-47bf-914c-68e67424065f", + "metadata": {}, + "source": [ + "#### Loc file generation\n", + "\n", + "NEON doesn't distribute (?) a loc file, so let's fake one for now. We'll do this for the full file and for the subset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5b51ea6-f2ba-4348-9ec9-4a3eadd6c1c0", + "metadata": {}, + "outputs": [], + "source": [ + "def getMetadata(file, remove=['fwhm', 'band names', 'wavelength', 'wavelength units']):\n", + " \"\"\"\n", + " Retrieves the metadata from an envi header\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " remove: list, default=['fwhm', 'band names', 'wavelength', 'wavelength units']\n", + " Removes keys from the metadata dictionary\n", + " \"\"\"\n", + " rdn_ds = envi.open(file)\n", + " metadata = rdn_ds.metadata.copy()\n", + " for key in remove:\n", + " if key in metadata:\n", + " del metadata[key]\n", + " else:\n", + " print(f'Key {key!r} not found in the metadata, skipping')\n", + "\n", + " return metadata\n", + "\n", + "def fakeLOC(rdn, lon, lat, elv, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake LOC file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN header file containing metadata\n", + " lon: float\n", + " Longitude value for location\n", + " lat: float\n", + " Latitude value for location\n", + " elv: float\n", + " Elevation in kilometers\n", + " output: str, default=None\n", + " Path to write the LOC file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `loc`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " Logger.error('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 3\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " loc = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " loc[..., 0] = lon\n", + " loc[..., 1] = lat\n", + " loc[..., 2] = elv\n", + "\n", + " del ds, loc\n", + "\n", + "def fakeOBS(rdn, param0=0, sea=0, sez=0, soa=0, soz=0, phase=0, slope=0, aspect=0, cosi=0, param9=0, param10=0, output=None, **kwargs):\n", + " \"\"\"\n", + " Creates a fake OBS file\n", + "\n", + " Parameters\n", + " ----------\n", + " rdn: str\n", + " Path to the RDN file containing metadata\n", + " param0: int, float, default=0\n", + " Parameter 0\n", + " sea: int, float, default=0\n", + " Solar Azimuth\n", + " sez: int, float, default=0\n", + " Sensor Zenith\n", + " soa: int, float, default=0\n", + " Solar Azimuth\n", + " soz: int, float, default=0\n", + " Solar Zenith\n", + " phase: int, float, default=0\n", + " Phase\n", + " slope: int, float, default=0\n", + " Slope\n", + " aspect: int, float, default=0\n", + " Aspect\n", + " cosi: int, float, default=0\n", + " COS(i)\n", + " param9: int, float, default=0\n", + " Parameter 9\n", + " param10: int, float, default=0\n", + " Parameter 10\n", + " output: str, default=None\n", + " Path to write the OBS file to. If None, will attempt to replace the\n", + " substring 'rdn' in the `rdn` path with `obs`\n", + " **kwargs\n", + " Additional arguments passed to getMetadata()\n", + " \"\"\"\n", + " if not output:\n", + " if 'rdn' in rdn:\n", + " output = rdn.replace('rdn', 'loc')\n", + " else:\n", + " print('No ouput file specified and cannot generate a unique name')\n", + " return False\n", + "\n", + " rdn_ds = envi.open(rdn)\n", + " metadata = getMetadata(rdn, **kwargs)\n", + " metadata['bands'] = 11\n", + "\n", + " ds = envi.create_image(output, metadata, ext='', force=True)\n", + " obs = ds.open_memmap(interleave='bip', writable=True)\n", + "\n", + " obs[..., 0] = param0\n", + " obs[..., 1] = sea\n", + " obs[..., 2] = sez\n", + " obs[..., 3] = soa\n", + " obs[..., 4] = soz\n", + " obs[..., 5] = phase\n", + " obs[..., 6] = slope\n", + " obs[..., 7] = aspect\n", + " obs[..., 8] = cosi\n", + " obs[..., 9] = param9\n", + " obs[..., 10] = param10\n", + "\n", + " del ds, obs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bac7ba6b-1c0e-41b7-97e0-d9e137a9e217", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key 'band names' not found in the metadata, skipping\n" + ] + } + ], + "source": [ + "fakeLOC(\n", + " rdn = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort.hdr'),\n", + " lon = -105.237000,\n", + " lat = 40.125000,\n", + " elv = 1689.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "83bf8ace-3e19-4674-86df-d2f46e220a32", + "metadata": {}, + "source": [ + "## Apply OE\n", + "\n", + "The next part walks through running the ISOFIT utility script `isofit/utils/apply_oe.py`. This is the first step of executing ISOFIT and will generate a default configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d0ec94f8-b1e7-4e4d-9b8f-450134ca5a83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "1 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "2 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "3 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "4 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "5 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "6 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n", + "7 ['/Users/bgreenbe/.isofit/data/reflectance/surface_model_ucsb']\n" + ] + } + ], + "source": [ + "output_surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "surface_model(**{\n", + " 'config_path': surface_model_path,\n", + " 'output_path': output_surface_file,\n", + " 'wavelength_path': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort.hdr')\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3cbe6f39-6d6f-4182-abfb-30e95ce49ede", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Checking input data files...\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...Data file checks complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Setting up files and directories....\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | Flightline ID: NIS01_20210403_173647\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:__init__() | no noise path found, proceeding without\n", + "INFO:2025-07-08,15:20:08 || template_construction.py:stage_files() | Staging /Users/bgreenbe/.isofit/examples/20171108_Pasadena/configs/surface.mat to /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/surface.mat\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | ...file/directory setup complete\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Using inversion windows: [[350.0, 1360.0], [1410, 1800.0], [1970.0, 2500.0]]\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | No wavelength file provided. Obtaining wavelength grid from ENVI header of radiance cube.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Wavelength units of nm inferred...converting to microns\n", + "WARNING:2025-07-08,15:20:08 || template_construction.py:check_surface_model() | Center wavelengths provided in surface model file do not match wavelengths in radiance cube. Please consider rebuilding your surface model for optimal performance.\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Observation means:\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Path (km): 1.0036078691482544\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor azimuth (deg): 153.4481201171875\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sensor zenith (deg): 1.619314193725586\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun azimuth (deg): 145.23248291015625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | To-sun zenith (deg): 39.8218994140625\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Relative to-sun azimuth (deg): 31.813383102416992\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Altitude (km): 2.692207098007202\n", + "INFO:2025-07-08,15:20:08 || apply_oe.py:apply_oe() | Segmenting...\n", + "2025-07-08 15:20:10,698\tINFO worker.py:1917 -- Started a local Ray instance.\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_rdn\n", + "2025-07-08 15:20:11,728\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_obs\n", + "\u001b[36m(segment_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: completing\n", + "2025-07-08 15:20:11,781\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Extracting /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/input/NIS01_20210403_173647_subs_loc\n", + "2025-07-08 15:20:11,825\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Pre-solve H2O grid: [0.2 0.84 1.49 2.13 2.77 3.42 4.06 4.7 5.35 5.99]\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Writing H2O pre-solve configuration file.\n", + "INFO:2025-07-08,15:20:11 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json.tmpl\n", + "INFO:2025-07-08,15:20:11 || apply_oe.py:apply_oe() | Run ISOFIT initial guess\n", + "INFO:2025-07-08,15:20:11 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_h2o.json\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:11 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "2025-07-08 15:20:11,882\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:11 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "\u001b[36m(extract_chunk pid=17119)\u001b[0m INFO:2025-07-08,15:20:11 ||| 0: starting\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:11 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:11 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:12 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:12 ||| Loaded ini from: /Users/bgreenbe/.isofit/isofit.ini\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:02.100901, rate: 0:00:00.210090, eta: 0:00:18.908109)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:02.151416, rate: 0:00:00.215142, eta: 0:00:08.605664)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:02.198190, rate: 0:00:00.219819, eta: 0:00:05.129110)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:14 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:02.768149, rate: 0:00:00.276815, eta: 0:00:04.152223)\n", + "INFO:2025-07-08,15:20:14 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:03.296599, rate: 0:00:00.329660, eta: 0:00:03.296599)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:03.347710, rate: 0:00:00.334771, eta: 0:00:02.231807)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:03.396394, rate: 0:00:00.339639, eta: 0:00:01.455597)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:15 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:03.946926, rate: 0:00:00.394693, eta: 0:00:00.986732)\n", + "INFO:2025-07-08,15:20:15 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:04.459773, rate: 0:00:00.445977, eta: 0:00:00.495530)\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:16 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:16 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:20:16 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:20:17 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_h2o/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:20:17 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 20.00% simulations complete (elapsed: 0:00:00.133107, rate: 0:00:00.013311, eta: 0:00:01.197963)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 30.00% simulations complete (elapsed: 0:00:00.190843, rate: 0:00:00.019084, eta: 0:00:00.763372)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "\u001b[36m(streamSimulation pid=17119)\u001b[0m INFO:2025-07-08,15:20:18 ||| Loading LUT into memory\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 40.00% simulations complete (elapsed: 0:00:00.242991, rate: 0:00:00.024299, eta: 0:00:00.566979)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.291772, rate: 0:00:00.029177, eta: 0:00:00.437658)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 60.00% simulations complete (elapsed: 0:00:00.343262, rate: 0:00:00.034326, eta: 0:00:00.343262)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 70.00% simulations complete (elapsed: 0:00:00.392020, rate: 0:00:00.039202, eta: 0:00:00.261347)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 80.00% simulations complete (elapsed: 0:00:00.437945, rate: 0:00:00.043794, eta: 0:00:00.187691)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 90.00% simulations complete (elapsed: 0:00:00.481330, rate: 0:00:00.048133, eta: 0:00:00.120332)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:00.522997, rate: 0:00:00.052300, eta: 0:00:00.058111)\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:20:18 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:20:18 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:20:18 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:20:18 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1752013219.280426 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64327: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:20:19.280425-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:20 ||| Worker 0 completed 1/~105.0:: 0.95% complete\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:23 ||| Worker at start location (42,0) completed 10/11\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:24 ||| Worker 3 completed 11/~105.0:: 10.48% complete\u001b[32m [repeated 7x across cluster] (Ray deduplicates logs by default. Set RAY_DEDUP_LOGS=0 to disable log deduplication, or see https://docs.ray.io/en/master/ray-observability/user-guides/configure-logging.html#log-deduplication for more options.)\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:29 ||| Worker at start location (95,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:31 ||| Worker 3 completed 33/~105.0:: 31.43% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17157)\u001b[0m INFO:2025-07-08,15:20:36 ||| Worker at start location (192,0) completed 9/10\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:37 ||| Worker 3 completed 55/~105.0:: 52.38% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:43 ||| Worker at start location (268,0) completed 10/11\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:44 ||| Worker 3 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:47 ||| Worker at start location (343,0) completed 10/11\u001b[32m [repeated 7x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17158)\u001b[0m INFO:2025-07-08,15:20:48 ||| Worker 3 completed 88/~105.0:: 83.81% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17160)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (397,0) completed 10/11\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Inversions complete. 34.78s total, 12.0769 spectra/s, 3.0192 spectra/s/core\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Full (non-aerosol) LUTs:\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Elevation: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sensor zenith: [0.9608 2.9675]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | To-sun zenith: None\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Relative to-sun azimuth: [3.80000e-03 4.12002e+01 8.23965e+01]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | H2O Vapor: [0.6025 0.6627]\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/output/NIS01_20210403_173647_subs_state\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Writing main configuration file.\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Loading Climatology\n", + "INFO:2025-07-08,15:20:53 || template_construction.py:load_climatology() | Climatology Loaded. Aerosol State Vector:\n", + "{'AOT550': {'bounds': [0.001, 1.0], 'scale': 1, 'init': 0.1009, 'prior_sigma': 10.0, 'prior_mean': 0.1009}}\n", + "Aerosol LUT Grid:\n", + "{'AOT550': [0.001, 0.1009, 0.2008, 0.3007, 0.4006, 0.5005, 0.6004, 0.7003, 0.8002, 0.9001, 1.0]}\n", + "Aerosol model path:/Users/bgreenbe/.isofit/data/aerosol_model.txt\n", + "INFO:2025-07-08,15:20:53 || ini.py:toTemplate() | Saved converted json to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json.tmpl\n", + "INFO:2025-07-08,15:20:53 || apply_oe.py:apply_oe() | Running ISOFIT with full LUT\n", + "INFO:2025-07-08,15:20:53 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Checking config sections for configuration issues\n", + "INFO:2025-07-08,15:20:53 || configs.py:get_config_errors() | Configuration file checks complete, no errors found.\n", + "2025-07-08 15:20:53,541\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:20:53 || isofit.py:run() | Building first forward model, will generate any necessary LUTs\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Creating a simulator configuration\n", + "INFO:2025-07-08,15:20:53 || sRTMnet.py:preSim() | Building simulator and executing (6S)\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | No LUT store found, beginning initialization and simulations\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:__init__() | Initializing LUT file\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Running any pre-sim functions\n", + "INFO:2025-07-08,15:20:53 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:20:59 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:06.067500, rate: 0:00:00.045966, eta: 0:00:54.607500)\n", + "INFO:2025-07-08,15:20:59 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:03 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:10.271446, rate: 0:00:00.077814, eta: 0:00:41.085784)\n", + "INFO:2025-07-08,15:21:03 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:08 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:14.459419, rate: 0:00:00.109541, eta: 0:00:33.738644)\n", + "INFO:2025-07-08,15:21:08 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:13 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:19.976911, rate: 0:00:00.151340, eta: 0:00:29.965367)\n", + "INFO:2025-07-08,15:21:13 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:17 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:24.268372, rate: 0:00:00.183851, eta: 0:00:24.268372)\n", + "INFO:2025-07-08,15:21:17 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:21 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:28.106960, rate: 0:00:00.212932, eta: 0:00:18.737973)\n", + "INFO:2025-07-08,15:21:21 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:27 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:33.346920, rate: 0:00:00.252628, eta: 0:00:14.291537)\n", + "INFO:2025-07-08,15:21:27 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:31 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:37.560121, rate: 0:00:00.284546, eta: 0:00:09.390030)\n", + "INFO:2025-07-08,15:21:31 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:35 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:42.008716, rate: 0:00:00.318248, eta: 0:00:04.667635)\n", + "INFO:2025-07-08,15:21:35 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:46.415069, rate: 0:00:00.351629, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:40 || radiative_transfer_engine.py:runSimulations() | Saving post-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:40 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:40 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Interpolating simulator quantities to emulator size\n", + "INFO:2025-07-08,15:21:40 || sRTMnet.py:preSim() | Loading and predicting with emulator\n", + "INFO:2025-07-08,15:21:43 || sRTMnet.py:preSim() | Saving intermediary prediction results to: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/lut_full/sRTMnet.predicts.nc\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Saving pre-sim data to index zero of all dimensions except wl\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Executing parallel simulations\n", + "INFO:2025-07-08,15:21:43 || common.py:__call__() | 10.61% simulations complete (elapsed: 0:00:00.286329, rate: 0:00:00.002169, eta: 0:00:02.576961)\n", + "INFO:2025-07-08,15:21:43 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 20.45% simulations complete (elapsed: 0:00:00.443106, rate: 0:00:00.003357, eta: 0:00:01.772424)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 30.30% simulations complete (elapsed: 0:00:00.603308, rate: 0:00:00.004571, eta: 0:00:01.407719)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 40.15% simulations complete (elapsed: 0:00:00.810682, rate: 0:00:00.006142, eta: 0:00:01.216023)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 50.00% simulations complete (elapsed: 0:00:00.967955, rate: 0:00:00.007333, eta: 0:00:00.967955)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:44 || common.py:__call__() | 60.61% simulations complete (elapsed: 0:00:01.137875, rate: 0:00:00.008620, eta: 0:00:00.758583)\n", + "INFO:2025-07-08,15:21:44 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 70.45% simulations complete (elapsed: 0:00:01.338172, rate: 0:00:00.010138, eta: 0:00:00.573502)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 80.30% simulations complete (elapsed: 0:00:01.500123, rate: 0:00:00.011365, eta: 0:00:00.375031)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 90.15% simulations complete (elapsed: 0:00:01.657305, rate: 0:00:00.012555, eta: 0:00:00.184145)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || common.py:__call__() | 100.00% simulations complete (elapsed: 0:00:01.823216, rate: 0:00:00.013812, eta: 0:00:00)\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Flushing netCDF to disk\n", + "INFO:2025-07-08,15:21:45 || radiative_transfer_engine.py:runSimulations() | Running any post-sim functions\n", + "INFO:2025-07-08,15:21:45 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:21:45 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:21:45 || isofit.py:run() | Beginning 420 inversions in 40 chunks using 4 cores\n", + "I0000 00:00:1752013306.660474 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64423: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\", file_line:1171, created_time:\"2025-07-08T15:21:46.660474-07:00\", http2_error:2, grpc_status:14}\n", + "I0000 00:00:1752013306.660734 2663633 chttp2_transport.cc:1182] ipv4:127.0.0.1:64428: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:21:46.660733-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:21:47 ||| \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (32,0).\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 0 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17159)\u001b[0m INFO:2025-07-08,15:20:53 ||| Worker at start location (408,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:21:52 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (27,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:47 ||| Worker 1 completed 1/~105.0:: 0.95% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:21:55 ||| Worker at start location (9,0) completed 9/10\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:21:58 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (55,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:57 ||| Worker 1 completed 12/~105.0:: 11.43% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:21:56 ||| Worker at start location (31,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:03 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (61,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:03 ||| Worker 3 completed 21/~105.0:: 20.0% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:05 ||| Worker at start location (85,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:08 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (99,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:06 ||| Worker 0 completed 23/~105.0:: 21.9% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:11 ||| Worker at start location (95,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:13 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (105,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:12 ||| Worker 3 completed 31/~105.0:: 29.52% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 2 completed 34/~105.0:: 32.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:14 ||| Worker at start location (117,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:18 ||| \u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (166,0).\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 27x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:15 ||| Worker 0 completed 34/~105.0:: 32.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:20 ||| Worker at start location (139,0) completed 10/11\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:22 ||| Worker at start location (149,0) completed 9/10\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:22:23 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (193,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:24 ||| Worker 2 completed 45/~105.0:: 42.86% complete\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:23 ||| Worker at start location (160,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:22:28 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (210,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 3 completed 53/~105.0:: 50.48% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:30 ||| Worker 1 completed 54/~105.0:: 51.43% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker at start location (214,0) completed 10/11\u001b[32m [repeated 4x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:33 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (230,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:32 ||| Worker 2 completed 56/~105.0:: 53.33% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:37 ||| Worker at start location (235,0) completed 9/10\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:38 ||| Worker at start location (225,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:39 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (269,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:39 ||| Worker 3 completed 64/~105.0:: 60.95% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker at start location (257,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:44 ||| \u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (275,0).\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 24x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:41 ||| Worker 2 completed 67/~105.0:: 63.81% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:22:47 ||| Worker at start location (279,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m ERROR:2025-07-08,15:22:49 ||| \u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Encountered the following ValueError in (row,col) (303,0).\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 26x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:49 ||| Worker 0 completed 77/~105.0:: 73.33% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker at start location (300,0) completed 10/11\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m ERROR:2025-07-08,15:22:55 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Encountered the following ValueError in (row,col) (320,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:50 ||| Worker 2 completed 78/~105.0:: 74.29% complete\n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:22:57 ||| Worker 1 completed 86/~105.0:: 81.9% complete\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:22:58 ||| Worker at start location (332,0) completed 9/10\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:00 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (376,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:00 ||| Worker 2 completed 89/~105.0:: 84.76% complete\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:22:59 ||| Worker at start location (343,0) completed 10/11\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m ERROR:2025-07-08,15:23:05 ||| \u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Encountered the following ValueError in (row,col) (383,0).\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 25x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m INFO:2025-07-08,15:23:05 ||| Worker at start location (354,0) completed 10/11\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m INFO:2025-07-08,15:23:06 ||| Worker 3 completed 97/~105.0:: 92.38% complete\u001b[32m [repeated 2x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17537)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:10 ||| \u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (412,0).\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 21x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17537)\u001b[0m INFO:2025-07-08,15:23:08 ||| Worker at start location (386,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:07 ||| Worker 0 completed 97/~105.0:: 92.38% complete\n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17535)\u001b[0m \n", + "\u001b[36m(Worker pid=17538)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "INFO:2025-07-08,15:23:16 || isofit.py:run() | Inversions complete. 91.06s total, 4.6123 spectra/s, 1.1531 spectra/s/core\n", + "INFO:2025-07-08,15:23:16 || apply_oe.py:apply_oe() | Analytical line inference\n", + "INFO:2025-07-08,15:23:16 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:23:16 || luts.py:load() | Loading LUT into memory\n", + "\u001b[36m(Worker pid=17536)\u001b[0m \n", + "\u001b[36m(Worker pid=17536)\u001b[0m ERROR:2025-07-08,15:23:16 ||| \u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Encountered the following ValueError in (row,col) (419,0).\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Results for this pixel will be all zeros.\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m Traceback (most recent call last):\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/isofit.py\", line 263, in run_set_of_spectra\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m self.io.write_spectrum(row, col, states, self.fm, self.iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 747, in write_spectrum\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m to_write = self.build_output(states, self.current_input_data, fm, iv)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m File \"/Users/bgreenbe/Github/isofit/isofit/core/fileio.py\", line 684, in build_output\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m rfl_alg_opt, Ls, coeffs = invert_algebraic(\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m ValueError: not enough values to unpack (expected 3, got 2)\u001b[32m [repeated 19x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17536)\u001b[0m INFO:2025-07-08,15:23:16 ||| Worker at start location (419,0) completed 10/11\u001b[32m [repeated 3x across cluster]\u001b[0m\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:23:16 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:23:16 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n", + "2025-07-08 15:23:17,031\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "INFO:2025-07-08,15:23:17 || atm_interpolation.py:atm_interpolation() | Beginning atmospheric interpolation 4 cores\n", + "INFO:2025-07-08,15:23:18 || atm_interpolation.py:atm_interpolation() | Parallel atmospheric interpolations complete. 1.3430540561676025 s total, 3142.8370143526467 spectra/s, 785.7092535881617 spectra/s/core\n", + "2025-07-08 15:23:18,445\tINFO worker.py:1747 -- Calling ray.init() again after it has already been called.\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:22 ||| Analytical line writing line 4\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:28 ||| Analytical line writing line 9\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:34 ||| Analytical line writing line 17\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:40 ||| Analytical line writing line 25\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:46 ||| Analytical line writing line 33\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:52 ||| Analytical line writing line 42\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:23:58 ||| Analytical line writing line 50\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "\u001b[36m(Worker pid=17655)\u001b[0m INFO:2025-07-08,15:24:04 ||| Analytical line writing line 58\u001b[32m [repeated 8x across cluster]\u001b[0m\n", + "INFO:2025-07-08,15:24:10 || analytical_line.py:analytical_line() | Analytical line inversions complete. 51.63s total, 81.7487 spectra/s, 20.4372 spectra/s/core\n", + "INFO:2025-07-08,15:24:10 || apply_oe.py:apply_oe() | Done.\n", + "\u001b[36m(Worker pid=17657)\u001b[0m INFO:2025-07-08,15:24:07 ||| Analytical line writing line 60\u001b[32m [repeated 5x across cluster]\u001b[0m\n", + "I0000 00:00:1752013450.613965 2663318 chttp2_transport.cc:1182] ipv4:127.0.0.1:65123: Got goaway [2] err=UNAVAILABLE:GOAWAY received; Error code: 2; Debug Text: Cancelling all calls {grpc_status:14, http2_error:2, created_time:\"2025-07-08T15:24:10.613957-07:00\", file_line:1171, file:\"external/com_github_grpc_grpc/src/core/ext/transport/chttp2/transport/chttp2_transport.cc\"}\n" + ] + } + ], + "source": [ + "kwargs = {\n", + " 'input_radiance': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_rdn_ort'), # Radiance\n", + " 'input_loc': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_loc_ort'), # Location\n", + " 'input_obs': os.path.join(subset_dir,f'NIS01_20210403_{neon_id}_obs_ort'), # Observations\n", + " 'working_directory': os.path.join(output, f'NIS01_20210403_{neon_id}'), # Output directory\n", + " 'sensor': 'neon', \n", + " \"surface_path\": output_surface_file, # Surface priors - often changes\n", + " 'emulator_base': os.environ['EMULATOR_PATH'],\n", + " 'n_cores': 4,\n", + " \"wavelength_path\": None,\n", + " \"surface_category\": \"multicomponent_surface\",\n", + " \"rdn_factors_path\": None, # RCC update used 'on the fly'\n", + " \"channelized_uncertainty_path\": None, # Channelized uncertainty - if you have an instrument model\n", + " \"model_discrepancy_path\": None, # Model discrepancy term - handle things like unknown radiative transfer model effects\n", + " \"lut_config_file\": None,\n", + " \"logging_level\": \"INFO\",\n", + " \"log_file\": None,\n", + " \"presolve\": True, # Attempts to solve for the right wv range\n", + " \"analytical_line\": True, # mathematical representation of OE given that the atmsophere is known\n", + " \"ray_temp_dir\": \"/tmp/ray\",\n", + " \"segmentation_size\": 10,\n", + " \"num_neighbors\": [5],\n", + " \"atm_sigma\": [0.5],\n", + " \"pressure_elevation\": False,\n", + "}\n", + "\n", + "apply_oe(**kwargs)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9d31291a-c036-4288-9114-cd772dda6748", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "for _key, key in enumerate(report.keys()):\n", + " if _key < 1:\n", + "\n", + " rfl_ds = envi.open(os.path.join(output, f'NIS01_20210403_{key}','output',f'NIS01_20210403_{key}_rfl.hdr'))\n", + " rfl_rgb = rfl_ds.open_memmap(interleave='bip')[:,:,np.array([60,40,30])].copy()\n", + " wl = np.array([float(x) for x in rfl_ds.metadata['wavelength']])\n", + "\n", + " miny = np.min([np.min([i[0],i[1]]) for k,i in report[key].items()])-5\n", + " maxy = np.max([np.max([i[0],i[1]]) for k,i in report[key].items()])+5\n", + " minx = np.min([np.min([i[2],i[3]]) for k,i in report[key].items()])-5\n", + " maxx = np.max([np.max([i[2],i[3]]) for k,i in report[key].items()])+5\n", + "\n", + " plt.figure()\n", + " plt.imshow(rfl_rgb / np.max(rfl_rgb,axis=(0,1)))\n", + " plt.title(f'NIS01_20210403_{key}')\n", + " for k,i in report[key].items():\n", + " plt.plot([i[2]-minx,i[3]-minx,i[3]-minx,i[2]-minx,i[2]-minx],[i[0]-miny,i[0]-miny,i[1]-miny,i[1]-miny,i[0]-miny],label=k)\n", + "\n", + " for k,i in report[key].items():\n", + " plt.figure()\n", + " in_situ_path = str(Path(f'~/.isofit/neon_subset/FieldSpectrometer/{k}01/Data/{k}01_Refl.dat').expanduser())\n", + " in_situ = np.genfromtxt(in_situ_path, skip_header=3)\n", + " plt.plot(in_situ[:,0], in_situ[:,1], label=f'In Situ {k}',c='red',ls='-')\n", + " mean_rfl = np.mean(rfl_ds.open_memmap(interleave='bip')[i[0]-miny:i[1]-miny,i[2]-minx:i[3]-minx,:],axis=(0,1))\n", + " plt.plot(wl, mean_rfl, label=f'Ret. {k}', c='black')\n", + " plt.legend()\n" + ] + }, + { + "cell_type": "markdown", + "id": "85419744-2391-48f0-b6c2-239390d4b994", + "metadata": {}, + "source": [ + "## Per-Pixel Retrievals\n", + "\n", + "This next section is an excercise in running ISOFIT in pixel mode (dynamically from python).\n", + "\n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f60f1ae9-754b-4c25-bc51-70b792debed7", + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5efac6d4-c9f5-4292-a8e1-739939056ac1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-07-08,15:50:17 || configs.py:create_new_config() | Loading config file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Loading from wavelength_file: /Users/bgreenbe/.isofit/neon_subset/output/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | Prebuilt LUT provided\n", + "INFO:2025-07-08,15:50:17 || luts.py:load() | Loading LUT into memory\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_upwelling is fully NaN, leaving as-is\n", + "WARNING:2025-07-08,15:50:17 || luts.py:load() | thermal_downwelling is fully NaN, leaving as-is\n", + "INFO:2025-07-08,15:50:17 || radiative_transfer_engine.py:__init__() | LUT grid loaded from file\n" + ] + } + ], + "source": [ + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output, f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = str(Path('~/.isofit/examples/20171108_Pasadena/configs/surface.mat').expanduser())\n", + "\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_obs_ort')\n", + "config.input.loc_file = os.path.join(subset_dir, f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "467786f7-35a6-4472-92c5-1fa753da9e3d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:2025-07-08,15:50:30 || geometry.py:__init__() | Earth sun distance not provided. Proceeding without might cause some inaccuracies down the line\n" + ] + } + ], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fdbd8001-530b-497f-a2c8-fdda0a2206d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(13, 428)\n", + "[0.10742364 0.60519719]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def closest_wl(mv):\n", + " return np.argmin(np.abs(io.meas_wl-mv))\n", + "\n", + "wl_nan = io.meas_wl.copy()\n", + "wl_nan[closest_wl(1360):closest_wl(1410)] = np.nan\n", + "wl_nan[closest_wl(1800):closest_wl(1970)] = np.nan\n", + "\n", + "fig = plt.figure(figsize=(14,5))\n", + "print(states.shape)\n", + "offset = 0\n", + "for n in range(0,states.shape[0],4):\n", + " lab = f'Step {n}'\n", + " if n == 0:\n", + " lab = 'Algebraic inversion at initial guess'\n", + " \n", + " plt.plot(wl_nan, states[n,:-2] + offset, label=lab)\n", + " offset += 0.04\n", + "plt.plot(wl_nan, states[-1,:-2] + offset, label=f'Step {states.shape[0]}')\n", + "plt.legend()\n", + "\n", + "print(states[-1,-2:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e8fcb0f-cd8e-47b9-9146-2e1335afcfd2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/isofit-tutorials/source/sensor_examples/neon/neon_single_pixel.ipynb b/isofit-tutorials/source/sensor_examples/neon/neon_single_pixel.ipynb new file mode 100644 index 0000000..069c37b --- /dev/null +++ b/isofit-tutorials/source/sensor_examples/neon/neon_single_pixel.ipynb @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setup\n", + "\n", + "This notebook is an excercise in running ISOFIT in pixel mode (dynamically from python), in order to get into some configuation details.\n", + "\n", + "Prerequisites:\n", + "- Run the neon.ipynb notebook succesfully - we'll use some of the outputs created from that intiial sample run" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running Per-Pixel Retrievals\n", + "\n", + "That gave us a baseline run, but its not clear what might be improved. Let's load up some individual retrievals so we can understand the performance a bit better. \n", + "To get started with executing ISOFIT for iterable improvements, ISOFIT is comprised of three primary pieces:\n", + "\n", + "1. The `ForwardModel` object\n", + "2. The `IO` object\n", + "2. The `Inverse` object\n", + "\n", + "There is also an `Isofit` object that holds each of the other three, and is commonly used for more generic runs (it is what is called by apply_oe)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from isofit.core.isofit import Isofit\n", + "from isofit.core.fileio import IO\n", + "from isofit.core.forward import ForwardModel\n", + "from isofit.inversion.inverse import Inversion\n", + "from isofit.inversion.inverse_simple import invert_algebraic\n", + "from isofit.configs import configs\n", + "from isofit.core.geometry import Geometry\n", + "\n", + "import os\n", + "import logging\n", + "import numpy as np\n", + "from spectral.io import envi\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# Enable the ISOFIT logger\n", + "logging.getLogger().setLevel(logging.INFO)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Extract the image locations of each point of interest (POI)\n", + "# These are defined in the NEON report as pixel locations, so we round here to convert to indices\n", + "report = {}\n", + "report['173647'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([2224.9626, 2230.9771, 316.0078, 324.9385,]).astype(int),\n", + " 'BlackTarp': np.round([2224.9626, 2231.0032, 328.0086, 333.9731,]).astype(int),\n", + " 'Veg' : np.round([2245.0381, 2258.8103, 343.9006, 346.9423,]).astype(int),\n", + " 'RoadEW' : np.round([2214.9905, 2216.9978, 348.9902, 373.0080,]).astype(int),\n", + " 'RoadNS' : np.round([2205.9580, 2225.9612, 357.9536, 359.9608,]).astype(int)\n", + "}\n", + "report['174150'] = { # Upp L Y | Low R Y | Upp L X | Low R X\n", + " 'WhiteTarp': np.round([653.9626, 659.9771, 3143.0078, 3151.9385]).astype(int),\n", + " 'BlackTarp': np.round([653.9626, 660.0032, 3155.0086, 3160.9731]).astype(int),\n", + " 'Veg' : np.round([674.0381, 687.8103, 3170.9006, 3173.9423]).astype(int),\n", + " 'RoadEW' : np.round([643.9905, 645.9978, 3175.9902, 3200.0080]).astype(int),\n", + " 'RoadNS' : np.round([634.9580, 654.9612, 3184.9536, 3186.9608]).astype(int)\n", + "}\n", + "# Converts numpy array to comma-separated string for ISOFIT\n", + "toString = lambda array: ', '.join(str(v) for v in array)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Loading config file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/config/NIS01_20210403_173647_isofit.json\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Loading from wavelength_file: /Users/brodrick/repos/isofit-tutorials/isotuts/NEON/outputs/NIS01_20210403_173647/data/wavelengths.txt\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Prebuilt LUT provided\n", + "WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_upwelling\n", + "WARNING:/Users/brodrick/repos/isofit/isofit/radiative_transfer/luts.py:Detected NaNs in the following LUT variable and may cause issues: thermal_downwelling\n", + "INFO:/Users/brodrick/repos/isofit/isofit/radiative_transfer/radiative_transfer_engine.py:Resampling LUT to instrument spectral response.\n" + ] + } + ], + "source": [ + "\n", + "# Find where we're running the tutorial from\n", + "home = os.path.abspath(os.getcwd())\n", + "output = os.path.join(home,'outputs')\n", + "output_surface_file = os.path.join(output, 'surface.mat')\n", + "neon_id = '173647' #one of 173647, 174150\n", + "roi = report[neon_id]\n", + "indata = os.path.join(home, 'data') \n", + "\n", + "# Now run actual retrievals\n", + "config = configs.create_new_config(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json')) \n", + "config.forward_model.surface.surface_file = output_surface_file\n", + "#model = Isofit(os.path.join(output,f'NIS01_20210403_{neon_id}','config',f'NIS01_20210403_{neon_id}_isofit.json'))\n", + "config.input.measured_radiance_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_ort')\n", + "config.input.obs_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_rdn_obs_ort')\n", + "config.input.loc_file = os.path.join(indata,f'NIS01_20210403_{neon_id}_loc_ort')\n", + "\n", + "fm = ForwardModel(config)\n", + "io = IO(config, fm)\n", + "inv = Inversion(config, fm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have the basic setup, we can run some retrievals." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "region = 'Veg'\n", + "offsets = {}\n", + "miny = np.min([np.min([i[0],i[1]]) for k,i in report[neon_id].items()])-5\n", + "maxy = np.max([np.max([i[0],i[1]]) for k,i in report[neon_id].items()])+5\n", + "minx = np.min([np.min([i[2],i[3]]) for k,i in report[neon_id].items()])-5\n", + "maxx = np.max([np.max([i[2],i[3]]) for k,i in report[neon_id].items()])+5\n", + "offsets[neon_id] = [minx,miny]\n", + "adj_roi = [roi[region][0] - offsets[neon_id][1], roi[region][1] - offsets[neon_id][1], roi[region][2] - offsets[neon_id][0], roi[region][3] - offsets[neon_id][0]]\n", + "\n", + "rdn = np.mean(envi.open(config.input.measured_radiance_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "obs = np.mean(envi.open(config.input.obs_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "loc = np.mean(envi.open(config.input.loc_file + '.hdr').open_memmap(interleave='bip')[adj_roi[0]:adj_roi[1],adj_roi[2]:adj_roi[3],:].copy(),axis=(0,1))\n", + "\n", + "geom = Geometry(obs=obs,loc=loc)\n", + "states = inv.invert(rdn, geom)\n", + "\n", + "x_surface, x_RT, x_instrument = fm.unpack(states[-1,:])\n", + "\n", + "x_alg, Ls, coeffs = invert_algebraic(fm.surface, fm.RT, fm.instrument, \n", + " x_surface, x_RT, x_instrument,\n", + " rdn, geom,\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(12, 428)\n", + "[0.11728845 0.61252989]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}