diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..e69de29 diff --git a/.github/workflows/build_docs.yaml b/.github/workflows/build_docs.yaml new file mode 100644 index 0000000..383b484 --- /dev/null +++ b/.github/workflows/build_docs.yaml @@ -0,0 +1,71 @@ +name: Build the documentation + +on: + push: + branches: + - main + +permissions: + contents: write + +jobs: + build-docs: + concurrency: ci-${{ github.ref }} + name: Build docs (${{ matrix.python-version }}, ${{ matrix.os }}) + runs-on: ${{ matrix.os }} + defaults: + run: + shell: bash -l {0} + strategy: + matrix: + os: ["ubuntu-latest"] + python-version: ["3.10"] + + steps: + # Grap the latest commit from the branch + - name: Checkout the branch + uses: actions/checkout@v3.5.2 + with: + persist-credentials: false + + # Create a virtual environment + - name: create Conda environment + uses: conda-incubator/setup-miniconda@v2 + with: + auto-update-conda: true + python-version: ${{ matrix.python-version }} + + # Install katex for math support + - name: Install NPM + uses: actions/setup-node@v3 + with: + node-version: 16 + - name: Install KaTeX + run: | + npm install katex + # Install Poetry and build the documentation + - name: Install and configure Poetry + uses: snok/install-poetry@v1 + with: + version: 1.2.2 + virtualenvs-create: false + virtualenvs-in-project: false + installer-parallel: true + + - name: Install LaTex + run: | + sudo apt-get update + sudo apt-get install texlive-fonts-recommended texlive-fonts-extra texlive-latex-extra dvipng cm-super + + - name: Build the documentation with MKDocs + run: | + cp docs/examples/gpjax.mplstyle . + poetry install --all-extras --with docs + conda install pandoc + poetry run mkdocs build + + - name: Deploy Page 🚀 + uses: JamesIves/github-pages-deploy-action@v4.4.1 + with: + branch: gh-pages + folder: site \ No newline at end of file diff --git a/README.md b/README.md index f37470b..6674355 100644 --- a/README.md +++ b/README.md @@ -1,30 +1,177 @@ -# A minimal library for preprocessing remote sensing data for machine learning applications (In Progress) -[![CodeFactor](https://www.codefactor.io/repository/github/jejjohnson/rs_tools/badge)](https://www.codefactor.io/repository/github/jejjohnson/rs_tools) -[![codecov](https://codecov.io/gh/jejjohnson/rs_tools/branch/main/graph/badge.svg?token=YGPQQEAK91)](https://codecov.io/gh/jejjohnson/rs_tools) +# `rs-tools` -> This package has some simple, minimal preprocessing of helio-data to make it machine learning ready. +## What are RS-Tools? +`rs_tools` is a toolbox of functions designed to +There is a high barrier to entry when working with remote sensing data for machine learning (ML) research. +This is especially true for level 1 data which is typically raw radiance observations. +There are often many domain-specific transformations that can completely make or break the success of the ML task. +`rs_tools` seeks to lower the barrier to entry cost for ML researchers to make meaningful progress when dealing with remote sensing data. +It features a standardized, transparent and flexible procedure for defining data and evaluation pipelines for data-intensive level 1 data products. ---- +*** +### Agnostic Toolbox of Functions + +We provide a suite of useful functions which can be used to clean level-1 remote sensing data to be used for downstream tasks. +It is an agnostic suite of functions that can be piped together to create preprocessing and evaluation chains. +We take care of all of the nitty-gritty details which are often common for these types of datasets. +However, we take care not to hard-code anything and try to be as transparent as possible so that users can understand and modify the scripts for their own use cases. + +*** +### Pipelines + +We provide some hydra-integrated pipelines which allow users to do some high-level processing to produce ML-ready datasets. +We follow best principles to be as agnostic as possible so that users are not bound by any ML-framework. +In addition, we provide many small bite-sized functions which users can piece together in their own way for their own applications. + + +*** +#### Data Downloader + +With a few simple commands, we can download some raw level 1 data products with minimum preprocessing. +We currently have data downloaders for [MODIS Level 1](https://spaceml-org.github.io/rs_tools/datasets/modis) data, [MSG Level 1](https://spaceml-org.github.io/rs_tools/datasets/msg) data, and [GOES16 Level 1](https://spaceml-org.github.io/rs_tools/datasets/goes/) data. + + +A user can get started right away by simply running the following snippet in the command line. + +```bash +# GOES 16 +python rs_tools satellite=goes stage=download +# MODIS - AQUA (or TERRA) +python rs_tools satellite=aqua stage=download +# MSG +python rs_tools satellite=msg stage=download +``` + + +*** +#### Analysis-Ready Data + +We have scripts to generate some *analysis-ready data*. +These are datasets that have been harmonized under a common data structure. +We try to keep as much meta-data as possible which could be useful for downstream tasks, e.g., coordinates, time stamps, units and cloud masks. +A user can do some further analysis on these + +
+ drawing +
+ +A user can get started right away by simply running the following snippet in the command line. + +```bash +# GOES16 +python rs_tools satellite=goes stage=geoprocess +# MODIS - AQUA (or TERRA) +python rs_tools satellite=aqua stage=geoprocess +# MSG +python rs_tools satellite=msg stage=geoprocess +``` + +For more examples, see our pipelines sections for MODIS, MSG and GOES16. + +*** +#### Machine-Learning Ready Data + +We also feature some *ML-Ready* data which is immediately ready for ML-specific tasks. +These are data that have already been divided into patches which sufficiently span the space for the ML task. +A user can user whichever ML dataset/dataloader framework that they choose. + + + +
+ drawing +
+ +A user can get started right away by simply running the following snippet in the command line. + +```bash +# GOES16 +python rs_tools satellite=goes stage=patch +# MODIS - AQUA (or TERRA) +python rs_tools satellite=aqua stage=patch +# MSG +python rs_tools satellite=msg stage=patch +``` + +*** +#### Use Case: Instrument-to-Instrument Translation (Work In Progress) + +We also feature an Instrument-2-Instrument translation use-case. +See [github/InstrumentToInstrument](https://github.com/RobertJaro/InstrumentToInstrument/tree/master) repo for more details. +In the rs-tools library, we have a simple example training script. + + +```bash +python rs_tools ... +``` + +*** ## Installation -We can install it directly through pip +### Conda (Recommended) + +We recommend the user to use `conda` with the associated environment for the environment. ```bash -pip install git+https://github.com/jejjohnson/rs_tools +conda env create -f environments/environment.yaml +conda activate rs_tools ``` -We also use poetry for the development environment. +*** +### Pip (Alpha-Version) + +We can install via the github repo through pip. ```bash -git clone https://github.com/jejjohnson/rs_tools.git +pip install git+https://github.com/space-ml/rs_tools.git +``` + +**Warning**: This is an alpha version. + +*** +### Development Version + + + +```bash +git clone https://github.com/space-ml/rs_tools.git cd rs_tools -conda create -n rs_tools python=3.11 poetry poetry install ``` +!!! tip + We advise you to create a virtual environment before installing: + + ```bash + conda env create -f environment.yaml + conda activate rs_tools + ``` + + and recommend you check your installation passes the supplied unit tests: + + ```bash + poetry run pytest tests/ + ``` + +*** +### Instrument To Instrument (Work-in-Progress) + +We have an example where we could do inference using a pre-trainined model from the ITI repo. +This would require us to install the `itipy` repo directly. + +We can use + + +```bash +conda env create -f environments/environment_iti.yaml +conda activate rs_tools +``` + + +Please see the [InstrumentToInstrument](https://github.com/spaceml-org/InstrumentToInstrument/tree/development-eo) repo with the [example](https://github.com/spaceml-org/InstrumentToInstrument/blob/development-eo/iti/train/msg_to_goes.py) for more details. + --- diff --git a/config/example/satellite/aqua.yaml b/config/example/satellite/aqua.yaml index faa7597..20c048d 100644 --- a/config/example/satellite/aqua.yaml +++ b/config/example/satellite/aqua.yaml @@ -1,6 +1,6 @@ download: _target_: rs_tools._src.data.modis.downloader_aqua.download - save_dir: ${save_dir}/aqua/ + save_dir: ${save_dir}/aqua/raw start_date: ${period.start_date} start_time: ${period.start_time} end_date: ${period.end_date} diff --git a/config/example/satellite/goes.yaml b/config/example/satellite/goes.yaml index bf62790..56a48a4 100644 --- a/config/example/satellite/goes.yaml +++ b/config/example/satellite/goes.yaml @@ -1,6 +1,6 @@ download: _target_: rs_tools._src.data.goes.downloader_goes16.download - save_dir: ${save_dir}/goes16/ + save_dir: ${save_dir}/goes16/raw start_date: ${period.start_date} start_time: ${period.start_time} end_date: ${period.end_date} @@ -26,4 +26,4 @@ patch: patch_size: ${patch_size} stride_size: ${stride_size} nan_cutoff: ${nan_cutoff} - save_filetype: ${save_filetype} \ No newline at end of file + save_filetype: ${save_filetype} diff --git a/config/example/satellite/msg.yaml b/config/example/satellite/msg.yaml index 4b55e3c..8b8c86d 100644 --- a/config/example/satellite/msg.yaml +++ b/config/example/satellite/msg.yaml @@ -1,6 +1,6 @@ download: _target_: rs_tools._src.data.msg.downloader_msg.download - save_dir: ${save_dir}/msg/ + save_dir: ${save_dir}/msg/raw start_date: ${period.start_date} start_time: ${period.start_time} end_date: ${period.end_date} diff --git a/config/example/satellite/terra.yaml b/config/example/satellite/terra.yaml index 7fac0d4..ca158fd 100644 --- a/config/example/satellite/terra.yaml +++ b/config/example/satellite/terra.yaml @@ -1,6 +1,6 @@ download: _target_: rs_tools._src.data.modis.downloader_terra.download - save_dir: ${save_dir}/terra/ + save_dir: ${save_dir}/terra/raw start_date: ${period.start_date} start_time: ${period.start_time} end_date: ${period.end_date} diff --git a/config/main.yaml b/config/main.yaml new file mode 100644 index 0000000..e69de29 diff --git a/docs/assets/analysis_ready_data.png b/docs/assets/analysis_ready_data.png new file mode 100644 index 0000000..c505f0c Binary files /dev/null and b/docs/assets/analysis_ready_data.png differ diff --git a/docs/assets/ml_ready_data.png b/docs/assets/ml_ready_data.png new file mode 100644 index 0000000..995d2f9 Binary files /dev/null and b/docs/assets/ml_ready_data.png differ diff --git a/docs/datasets/goes.md b/docs/datasets/goes.md new file mode 100644 index 0000000..eb9551b --- /dev/null +++ b/docs/datasets/goes.md @@ -0,0 +1,94 @@ +# GOES 16 + +Below are some notes on NOAA's GOES satellites, specifically focussing on the [Advanced Baseline Imager](https://www.goes-r.gov/spacesegment/abi.html) (ABI). + + +## GOES Satellites + +### GOES-16 +- Launched on 19 November 2016, operational since 18 December 2017 +- Longitude central point: -75.2 + +### GOES-17 [no longer operational] +- Launched on 1 March 2018, operational from 12 February 2019 to 4 January 2023 at longitude -136.9 +- Replaced by GOES-18 due to issues with its Advanced Baseline Imager (ABI) instrument +- Moved to longitude -104.7 (between GOES-16 and GOES-18) and serves as backup for the operational satellites + +### GOES-18 +- Launched on 1 March 2022, operational since 4 January 2023 (replaced GOES-17) +- Longitude central point: -136.9 + +## [GOES Instruments](https://www.goes-r.gov/spacesegment/instruments.html) + +Earth-facing: +- Advanced Baseline Imager (ABI) +- Geostationary Lightning Mapper (GLM)] + +Sun-facing: +- Extreme Ultraviolet and X-ray Irradiance Sensors (EXIS) +- Solar Ultraviolet Imager (SUVI) + +Space environment: +- Magnetometer (MAG) +- Space Environment In-Situ Suite (SEISS) + +## ABI Data + +### Processing Levels + +* Level-0: Raw instrument measurements +* Level-1B: Calibrated and geolocated radiances +* Level-2: Derived geophysical variables +* Level-3: Geophysical variables mapped on uniform space-time grid + +### Level-1B: Spectral Bands & Resolution + +GOES-ABI-bands + +### Level 2: Clear Sky Mask (ACM) +The [clear sky mask algorithm](https://www.star.nesdis.noaa.gov/goesr/documents/ATBDs/Enterprise/ATBD_Enterprise_Cloud_Mask_v1.2_2020_10_01.pdf) uses the GOES ABI visible, near-infrared and infrared bands to automatically assign one of the following 4 classes to each pixel: +- cloudy +- probably cloudy +- probably clear +- clear + +ACM data is provided at the native 2km resolution on the ABI fixed grid for full disk, CONUS, and mesoscale coverage regions, at the same temporal resolution as ABI L1b data. + +### Naming Conventions +GOES ABI Level 1b and 2 data are named according to the following [naming conventions](https://cimss.ssec.wisc.edu/goes/ABI_File_Naming_Conventions.pdf): + +`\\_\\_\\_\\_\\_\.\` + +where: +- SE = System Environment +- DSN = Data Short Name +- PID = Platform Identifier +- Obs Start Date & Time = Observation Period Start Date & Time +- Obs End Date & Time = Observation Period End Date & Time +- Creation Date & Time = File Creation Date & Time +- FE = File Extension + +## Working with Level-1B Data + +GOES/ABI radiances are provided in $mW/m^2/sr/cm^{-1}$, i.e. the data is normalised to wavenumbers. In order to convert the data to $W/m^2/sr/um$, the data needs to be multiplied by $10^{-7}$; $mW = 10^{-3} W$, $cm^{-1} = 10^4 {um}$. + +## Data Format & Access +GOES Data can be explored in the following buckets: + +AWS: +- [GOES-16 AWS S3 Explorer](https://noaa-goes16.s3.amazonaws.com/index.html) +- [GOES-17 AWS S3 Explorer](https://noaa-goes17.s3.amazonaws.com/index.html) +- [GOES-18 AWS S3 Explorer](https://noaa-goes18.s3.amazonaws.com/index.html) + +Google Cloud: +- [GOES-16 Google Cloud Bucket Explorer](https://console.cloud.google.com/storage/browser/gcp-public-data-goes-16) +- [GOES-17 Google Cloud Bucket Explorer](https://console.cloud.google.com/storage/browser/gcp-public-data-goes-17) +- [GOES-18 Google Cloud Bucket Explorer](https://console.cloud.google.com/storage/browser/gcp-public-data-goes-18) + +## Software Tools +> [GOES2GO](https://blaylockbk.github.io/goes2go/_build/html/index.html) - Software download +* allows downloading of GOES data from AWS + + + +## Q/A \ No newline at end of file diff --git a/docs/datasets/modis.md b/docs/datasets/modis.md new file mode 100644 index 0000000..1b86549 --- /dev/null +++ b/docs/datasets/modis.md @@ -0,0 +1,124 @@ +# MODIS + + +Below are some notes on NASA's Terra and Aqua satellites, specifically focussing on the [Moderate Resolution Imaging Spectrometer](https://modis.gsfc.nasa.gov/about/) (MODIS). + +## Terra & Aqua Satellites + +> The [Terra](https://terra.nasa.gov/) and [Aqua](https://aqua.nasa.gov/) satellites, launched in 1999 and 2002 respectively, are cornerstones in NASA's Earth Observation Program, and have collected invaluable measurements of Earth's land, oceans, cryosphere and atmosphere over the last two decades. +> Both satellites follow a near-polar, Sun-synchronous orbit, i.e. they pass over the same point on Earth at the same time each day. Terra orbits the Earth as part of the Morning Train, while Aqua is part of the [Afternoon Train](https://en.wikipedia.org/wiki/A-train_(satellite_constellation)) of satellites. Both satellites image the same part of Earth approximately 3 hours apart, and together provide global coverage every 1 - 2 days. The orbit repeat cycle for each satellite is 16 days. + +### Terra Instruments +* [Advanced Spaceborne Thermal Emission and Reflection Radiometer](https://terra.nasa.gov/about/terra-instruments/aster) (ASTER) +* [Clouds and the Earth’s Radiant Energy System](https://terra.nasa.gov/about/terra-instruments/ceres) (CERES) +* [Multi-angle Imaging SpectroRadiometer](https://terra.nasa.gov/about/terra-instruments/misr) (MISR) +* [Moderate Resolution Imaging Spectrometer](https://terra.nasa.gov/about/terra-instruments/modis) (MODIS) +* [Measurement of Pollution in the Troposphere](https://terra.nasa.gov/about/terra-instruments/mopitt) (MOPITT) + +### Aqua Instruments +* [Atmospheric Infrared Sounder](https://aqua.nasa.gov/content/airs) (AIRS) +* [Advanced Microwave Sounding Unit ](https://aqua.nasa.gov/content/amsu) (AMS-U) +* [Humidity Sounder for Brazil](https://aqua.nasa.gov/content/hsb) (HSB) +* [Advanced Microwave Scanning Radiometer for EOS](https://aqua.nasa.gov/content/amsr-e) (AMSR-E) +* [Moderate Resolution Imaging Spectrometer](https://aqua.nasa.gov/modis) (MODIS) +* [Cloud's and the Earth's Radiant Energy System](https://aqua.nasa.gov/ceres) (CERES) + +## MODIS Data +### Spectral Bands & Resolution + +Both satellites share the MODIS instrument, which collects data in 36 spectral channels: + +Screenshot 2023-11-30 at 15 03 17 + +> Image Credit: Wikipedia + +### Processing Levels + +* Level-0: Raw instrument measurements (swath product) +* Level-1A: Scans of raw radiances in counts (swath product) +* Level-1B: Calibrated radiances at 250, 500, 1000 m resolution (swath product) +* Level-2: Derived geophysical variables at the same resolution and location as Level-1 source data (swath products) +* Level-2G: Level-2 data mapped on a uniform space-time grid scale (Sinusoidal) +* Level-3: Gridded variables in derived spatial and/or temporal resolutions +* Level-4: Model output or results from analyses of lower-level data + +In this project, we mainly work with Level 1-B data. + +### Naming Conventions + +> The MODIS Level-1 data files are named according to the following [naming conventions](https://lpdaac.usgs.gov/data/get-started-data/collection-overview/missions/modis-overview/#modis-naming-conventions): **SATXX.AYYYYDD.HHDD.CCC.YYYYDDDHHMMSS.hdf** + +* SAT: Satellite (Terra -> MOD, Aqua -> MYD, Combined Product -> MCD) +* XX: Other product details (e.g. QKM -> 250 m, HKM -> 500 m, 1KM -> 1000 m resolution) +* AYYYYDD: Julian Day of Acquisition +* HHDD: Time of Acquisition +* CCC: Collection +* YYYYDDDHHMMSS: Julian Day of Production + +### Day & Night Mode + +> MODIS continuously collects measurements in either **day mode**, **night mode**, or **mixed mode**, depending on the time of day of the are under observation. During each orbit, 9 **day mode**, 9 **night mode**, and 2 **mixed mode** granules are measured respectively. +> To reduce storage space and transmission of files containing no useful data, Level-1B allows writing of 250 m and 500 m data files to be turned off for granules that contain no day mode scans. When data are transmitted in night mode, the Reflective Solar Bands (bands 1-19) are empty and appear to contain fill values of "65535". +> While **day** and **mixed mode** files are usually 200-300 MB large, **night mode** files are often <100 MB. + +## Working with Level-1B Data + +A jupyter notebook on how to download, open, and plot Level-1B data is provided in the main repository. Below, we summarise some of the key takeaways from working with Level-1B data. + +Each Level-1B granule contains multiple data variables, including (1) the science data on a pixel-to-pixel basis, (2) uncertainty information on a pixel-to-pixel basis, (3) geolocation data for the pixels, and (4) metadata. Exactly how many variables are contained in each file depends on the spatial resolution. The 1KM aggregated data, for instance, contains 27 data variables, for which the science data is stored in the following variable names: + +**EV_250_Aggr1km_RefSB:** Earth View 250M Aggregated 1km Reflective Solar Bands Scaled Integers +* Bands: 1, 2 + +**EV_500_Aggr1km_RefSB:** Earth View 500M Aggregated 1km Reflective Solar Bands Scaled Integers +* Bands: 3, 4, 5, 6, 7 + +**EV_1KM_RefS:** Earth View 1KM Reflective Solar Bands Scaled Integers +* Bands: 8, 9, 10, 11, 12, 13lo, 13hi, 14lo, 14hi, 15, 16, 17, 18, 19, 26 + +**EV_1KM_Emissive:** Earth View 1KM Emissive Bands Scaled Integers +* Bands: 20, 21, 22, 23, 24, 25, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 + +Note that the data is provided in "scaled integers" and does not yet include units. To convert the scaled integers into radiances (or reflectances), the data needs to be corrected by subtracting the radiance_offsets (reflectance_offsets) and multiplying with the radiance_scales (reflectance_scales). After this correction step, radiances are provided in $W/m^2/\micro m/sr$, while reflectance is still unit-less. More information on this correction step is provided in the [MODIS Level-1B User Guide](https://ccplot.org/pub/resources/Aqua/MODIS%20Level%201B%20Product%20User%20Guide.pdf). + +In addition to the science data, geolocation information is provided for each granule. Note that the size of the latitude/longitude coordinates (406, 271) does not match the size of the data (2030, 1354). This is because geolocation data is only provided for a subset of the pixels. To match the geolocation data to the size of the data, the provided latitude/longitude coordinates can be interpolated. + +## Level 2: Cloud Mask (35_L2) + +The [MODIS Cloud Mask product](https://atmosphere-imager.gsfc.nasa.gov/products/cloud-mask) is a Level 2 product generated at 1-km and 250-m (at nadir) spatial resolutions from MODIS visible, near-infrared and infrared bands to automatically assign one of 4 classes to each pixel: + +- cloudy +- probably cloudy +- probably clear +- clear + +There are two MODIS Cloud Mask data product files: MOD35_L2 (for Terra satellite) and MYD35_L2 (for Aqua satellite). + + +## Data Format & Access + +MODIS data is provided in the [.hdf file format](https://asdc.larc.nasa.gov/documents/tools/hdf.pdf). + +MODIS data can be downloaded via NASA's EarthData graphical user interface ([https://ladsweb.modaps.eosdis.nasa.gov/search/](https://ladsweb.modaps.eosdis.nasa.gov/search/)) and data archive ([https://ladsweb.modaps.eosdis.nasa.gov/archive/allData/61](https://ladsweb.modaps.eosdis.nasa.gov/archive/allData/61)), or via the USGS ([https://e4ftl01.cr.usgs.gov/](https://e4ftl01.cr.usgs.gov/)). Note that the latter brings you directly to a US government computer that hosts the MODIS data (MOLA --> AQUA data, MOLT --> TERRA data, MOTA --> AQUA & TERRA data); the terms and conditions of usage should be respected when accessing this resource. As part of rs_tools, we developed easy-to-use download scripts to download data directly from NASA EarthData. + +## Software Tools + +**Google Earth Engine**. + +* [gee-tool](https://github.com/gee-community/gee_tools) +* [wxee](https://wxee.readthedocs.io/en/latest/) - xarray-based + +**Other Tools** + +* [modis-tool](https://github.com/fraymio/modis-tools) +* [pansat](https://github.com/SEE-GEO/pansat) +* [py-modis](http://www.pymodis.org/) + +--- +## Q/A + +**Noah** + +* How long it takes to download an image or set of images this way? +* Is there a "cutoff" date for when the images aren't available? --> Still collecting data today. +* Can you pre-filter based on cloud coverage? --> I don't think so? \ No newline at end of file diff --git a/docs/datasets/msg.md b/docs/datasets/msg.md new file mode 100644 index 0000000..f00cc27 --- /dev/null +++ b/docs/datasets/msg.md @@ -0,0 +1,130 @@ +# MSG + +Below are some notes on the Meteosat Second Generation (MSG) Spinning Enhanced Visible and Infrared Imager (SEVIRI) instrument. + +## MSG Satellites + +The MSG satellite family consists of four operational meteorological satellites in geostationary orbit: Meteosat-8, Meteosat-9, Meteosat-10, and Meteosat-11. Information about launch dates and operational periods is given below. All satellites have a primary field of view over Europe. After their main operational period, Meteosat-8 and Meteosat-10 were relocated to perform measurements over the Indian Ocean. During this time, they are referred to as Meteosat-8 (IODC) and Meteosat-10 (IODC). +MSG superseded the Meteosat First Generation (MFG) and is followed by the Metesat Third Generation (MTG). All satellites contain the same instruments, some of which were also flown on other Meteosat satellites. + +Meteosat-8: +* Launch Date: 28 Aug 2002 +* End of Life: 04 Jul 2016 +* Position: 3.7° E + +Meteosat-8 (IODC): +* Launch Date: 15 Sep 2016 +* End of Life: Nov 2022 +* Position: 41.5° E + +Meteosat-9: +* Launch Date: 21 Dec 2005 +* End of Life: 01 Apr 2022 +* Position: 3.5° E + +Meteosat-9 (IODC): +* Launch Date: 01 Jul 2022 +* End of Life: Operational (as of 01/2024) +* Position: 45.5° E + +Meteosat-10: +* Launch Date: 05 Jul 2012 +* End of Life: Operational (as of 01/2024) +* Position: 0.0° E + +Meteosat-11: +* Launch Date: 15 Jul 2015 +* End of Life: Operational (as of 01/2024) +* Position: 9.5° E + +### Instruments: +* [Data Collection Service](https://space.oscar.wmo.int/instruments/view/dcs_meteosat) (DCS) +* [Geostationary Search and Rescue](https://space.oscar.wmo.int/instruments/view/geos_r) (GOES&R) +* [Geostationary Earth Radiation Budget](https://space.oscar.wmo.int/instruments/view/gerb) (GERB) +* [Spinning Enhanced Visible and Infrared Imager](https://space.oscar.wmo.int/instruments/view/seviri) (SEVIRI) + +## SEVIRI Data +### Spectral Bands & Resolution + +The SEVIRI instruments measure 12 spectral channels. + +![MSG-SEVIRI-spectral-channels-VIS-visible-IR-infrared-WV-water-vapour](https://github.com/spaceml-org/rs_tools/assets/32869829/9c61f782-e955-4827-bb64-c76f8221af55) + +> Image Credit: Vázquez-Navarro et al. A fast method for the retrieval of integrated longwave and shortwave top-of-atmosphere irradiances from MSG/SEVIRI (RRUMS), Atmospheric Measurement Techniques 5(4):4969-5008 (2012), DOI: [10.5194/amtd-5-4969-2012](http://dx.doi.org/10.5194/amtd-5-4969-2012) + +The resolution of the instrument is 1 km at the sub-satellite point (SSP) for the high resolution visible (HRV) channel, and 3 km for all other channels. The resolution decreases closer to the image limb. + +![Spatial-resolution-and-coverage-of-the-SEVIRI-instrument-33](https://github.com/spaceml-org/rs_tools/assets/32869829/342dbb99-72e0-4acb-83b3-b3caff63e87c) + +> Image Credit: Eissa et al. Validation of the Surface Downwelling Solar Irradiance Estimates of the HelioClim-3 Database in Egypt, Remote Sens. 2015, 7(7), 9269-9291, DOI: [10.3390/rs70709269](http://dx.doi.org/10.3390/rs70709269) + +### Instrument Field-of-view + +An example field-of-view (FOV) the satellites positioned at 0.0° E and over the Indian Ocean are shown below. + +Screenshot 2024-02-01 at 17 43 03 + +Screenshot 2024-02-01 at 17 42 49 + +> Credit: [EUMETSAT](https://navigator.eumetsat.int/) + +In addition to the full disk measurements, the rapid scan mode is performed over the following FOV. + +Screenshot 2024-02-01 at 17 44 56 + +> Credit: [EUMETSAT](https://navigator.eumetsat.int/) + +### Processing Levels + +* Level-0: Raw instrument measurements. +* Level-1.5: Geolocated and radiometrically pre-processed image data, ready for further processing. Spacecraft specific effects have been removed. More information about Level-1.5 data can be found in the [technical user guide](https://www-cdn.eumetsat.int/files/2020-05/pdf_ten_05105_msg_img_data.pdf). + +### Naming Conventions + +> The MSG Level-1 data files are named according to the following naming conventions: MSG#-IIII-MSGXX-0100-NA-YYYYMMDDHHMMSS.ssssZ-NA.nat, for example _MSG4-SEVI-MSG15-0100-NA-20211110081242.766000000Z-NA.nat_. + +* #: Satellite number (e.g. 1 -> Meteosat-8, 2 -> Meteosat-9, etc.) +* IIII: Instrument details (e.g. SEVI for SEVIRI) +* XX-0100: likely referring to specific product or data types +* NA: not locationally constrained +* YYYYMMDD: Acquisition date +* HHMMSS: Acquisition time +* ssss: likely referring to sub-second acquisition time +* Z: Zulu / UTC time zone +* NA: not locationally constrained + +### Measurement Frequencies + +Full disk images are measured every 15 mins. + +### Day & Night Mode + +### Cloud Mask + +Cloud masks are provided (e.g. as data product EO:EUM:DAT:MSG:CLM), and contain 4 types of pixel classifications: +* 0 = clear sky over land +* 1 = clear sky over water +* 2 = clouds +* 3 = not processed + +![40c4488a-b6ea-4904-9d32-ea77992538e5](https://github.com/spaceml-org/rs_tools/assets/32869829/74f606bd-53cb-48cf-ad3a-88ceb37e8158) + +## Working with Level-1 Data + +MSG/SEVIRI radiances are provided in $mW/m^2/sr/cm^{-1}$, i.e. the data is normalised to wavenumbers. In order to convert the data to $W/m^2/sr/um$, the data needs to be multiplied by $10^{-7}$; $mW = 10^{-3} W$, $cm^{-1} = 10^4 {um}$. + +## Data Format & Access + +SEVIRI data can be downloaded via EUMETSAT's Data Access portal. The following data products are available: + +* EO:EUM:DAT:MSG:CLM - Cloud Mask (0 degree position) +* EO:EUM:DAT:MSG:CLM-IODC - Cloud Mask (Indian Ocean) +* EO:EUM:DAT:MSG:RSS-CLM - Rapid Scan Cloud Mask + +* EO:EUM:DAT:MSG:HRSEVIRI - High Rate SEVIRI Level 1.5 Image Data (0 degree position) +* EO:EUM:DAT:MSG:HRSEVIRI-IODC - High Rate SEVIRI Level 1.5 Image Data (Indian Ocean) +* EO:EUM:DAT:MSG:MSG15-RSS - Rapid Scan High Rate SEVIRI Level 1.5 Image Data + +The data is provided in .nat format. Each file contains data of shape (3712, 3712). + +## Software Tools \ No newline at end of file diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..7441aa7 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,108 @@ +# Welcome to `RSTools` + + + +## What are RS-Tools? + +`rs_tools` is a toolbox of functions designed to +There is a high barrier to entry when working with remote sensing data for machine learning (ML) research. +This is especially true for level 1 data which is typically raw radiance observations. +There are often many domain-specific transformations that can completely make or break the success of the ML task. +`rs_tools` seeks to lower the barrier to entry cost for ML researchers to make meaningful progress when dealing with remote sensing data. +It features a standardized, transparent and flexible procedure for defining data and evaluation pipelines for data-intensive level 1 data products. + +*** +### Agnostic Toolbox of Functions + +We provide a suite of useful functions which can be used to clean level-1 remote sensing data to be used for downstream tasks. +It is an agnostic suite of functions that can be piped together to create preprocessing and evaluation chains. +We take care of all of the nitty-gritty details which are often common for these types of datasets. +However, we take care not to hard-code anything and try to be as transparent as possible so that users can understand and modify the scripts for their own use cases. + +*** +### Pipelines + +We provide some hydra-integrated pipelines which allow users to do some high-level processing to produce ML-ready datasets. +We follow best principles to be as agnostic as possible so that users are not bound by any ML-framework. +In addition, we provide many small bite-sized functions which users can piece together in their own way for their own applications. + + +*** +#### Data Downloader + +With a few simple commands, we can download some raw level 1 data products with minimum preprocessing. +We currently have data downloaders for [MODIS Level 1]() data, [MSG Level 1]() data, and [GOES16 Level 1]() data. + + +A user can get started right away by simply running the following snippet in the command line. + +```bash +# GOES 16 +python rs_tools satellite=goes stage=download +# MODIS - AQUA (or TERRA) +python rs_tools satellite=aqua stage=download +# MSG +python rs_tools satellite=msg stage=download +``` + + +*** +#### Analysis-Ready Data + +We have scripts to generate some *analysis-ready data*. +These are datasets that have been harmonized under a common data structure. +We try to keep as much meta-data as possible which could be useful for downstream tasks, e.g., coordinates, time stamps, units and cloud masks. +A user can do some further analysis on these + +
+ drawing +
+ +A user can get started right away by simply running the following snippet in the command line. + +```bash +# GOES16 +python rs_tools satellite=goes stage=geoprocess +# MODIS - AQUA (or TERRA) +python rs_tools satellite=aqua stage=geoprocess +# MSG +python rs_tools satellite=msg stage=geoprocess +``` + +For more examples, see our pipelines sections for MODIS, MSG and GOES16. + +*** +#### Machine-Learning Ready Data + +We also feature some *ML-Ready* data which is immediately ready for ML-specific tasks. +These are data that have already been divided into patches which sufficiently span the space for the ML task. +A user can user whichever ML dataset/dataloader framework that they choose. + + + +
+ drawing +
+ +A user can get started right away by simply running the following snippet in the command line. + +```bash +# GOES16 +python rs_tools satellite=goes stage=patch +# MODIS - AQUA (or TERRA) +python rs_tools satellite=aqua stage=patch +# MSG +python rs_tools satellite=msg stage=patch +``` + +*** +#### Use Case: Instrument-to-Instrument Translation (Work In Progress) + +We also feature an Instrument-2-Instrument translation use-case. +See [github/InstrumentToInstrument](https://github.com/RobertJaro/InstrumentToInstrument/tree/master) repo for more details. +In the rs-tools library, we have a simple example training script. + + +```bash +python rs_tools ... +``` diff --git a/docs/installation.md b/docs/installation.md new file mode 100644 index 0000000..507fa69 --- /dev/null +++ b/docs/installation.md @@ -0,0 +1,66 @@ +# Installation + + +## Conda (Recommended) + +We recommend the user to use `conda` with the associated environment for the environment. + +```bash +conda env create -f environments/environment.yaml +conda activate rs_tools +``` + +*** +## Pip (Alpha-Version) + +We can install via the github repo through pip. + +```bash +pip install git+https://github.com/space-ml/rs_tools.git +``` + +**Warning**: This is an alpha version. + +*** +## Development Version + + + +```bash +git clone https://github.com/space-ml/rs_tools.git +cd rs_tools +poetry install +``` + +!!! tip + We advise you to create a virtual environment before installing: + + ```bash + conda env create -f environment.yaml + conda activate rs_tools + ``` + + and recommend you check your installation passes the supplied unit tests: + + ```bash + poetry run pytest tests/ + ``` + +*** +## Instrument To Instrument (Work-in-Progress) + +We have an example where we could do inference using a pre-trainined model from the ITI repo. +This would require us to install the `itipy` repo directly. + +We can use + + +```bash +conda env create -f environments/environment_iti.yaml +conda activate rs_tools +``` + + +Please see the [iti](https://github.com/spaceml-org/InstrumentToInstrument/tree/development-eo) repo with the [example](https://github.com/spaceml-org/InstrumentToInstrument/blob/development-eo/iti/train/msg_to_goes.py) for more details. + + diff --git a/docs/javascripts/katex.js b/docs/javascripts/katex.js new file mode 100644 index 0000000..841e35a --- /dev/null +++ b/docs/javascripts/katex.js @@ -0,0 +1,10 @@ +document$.subscribe(({ body }) => { + renderMathInElement(body, { + delimiters: [ + { left: "$$", right: "$$", display: true }, + { left: "$", right: "$", display: false }, + { left: "\\(", right: "\\)", display: false }, + { left: "\\[", right: "\\]", display: true } + ], + }) +}) \ No newline at end of file diff --git a/docs/javascripts/mathjax.js b/docs/javascripts/mathjax.js new file mode 100644 index 0000000..fea65f9 --- /dev/null +++ b/docs/javascripts/mathjax.js @@ -0,0 +1,16 @@ +window.MathJax = { + tex: { + inlineMath: [["\\(", "\\)"]], + displayMath: [["\\[", "\\]"]], + processEscapes: true, + processEnvironments: true, + }, + options: { + ignoreHtmlClass: ".*|", + processHtmlClass: "arithmatex", + }, +}; + +document$.subscribe(() => { + MathJax.typesetPromise(); +}); \ No newline at end of file diff --git a/docs/pipelines/analysis_datasets.ipynb b/docs/pipelines/analysis_datasets.ipynb new file mode 100644 index 0000000..79dbd29 --- /dev/null +++ b/docs/pipelines/analysis_datasets.ipynb @@ -0,0 +1,1439 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4ce89cc8-460a-42d1-88c3-5bc3def75210", + "metadata": {}, + "source": [ + "# Analysis Ready Data" + ] + }, + { + "cell_type": "markdown", + "id": "d14b5f2d-fe77-4d52-8e89-42ff749ff173", + "metadata": {}, + "source": [ + "In this tutorial, we will go over some of the basics to create dataloaders." + ] + }, + { + "cell_type": "markdown", + "id": "a04cb172-945d-49fa-bc64-cd2cd22d7979", + "metadata": {}, + "source": [ + "![](../assets/analysis_ready_data.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "86a8d52f-849b-4f0b-a4ea-1e828d51488d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/data.py:519: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n", + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/NEW.py:188: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n" + ] + } + ], + "source": [ + "import autoroot\n", + "import os\n", + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "from xrpatcher import XRDAPatcher\n", + "from torch.utils.data import Dataset, DataLoader, ConcatDataset\n", + "import numpy as np\n", + "import itertools\n", + "from dotenv import load_dotenv\n", + "from rs_tools._src.utils.io import get_list_filenames\n", + "\n", + "\n", + "xr.set_options(\n", + " keep_attrs=True, \n", + " display_expand_data=False, \n", + " display_expand_coords=False, \n", + " display_expand_data_vars=False, \n", + " display_expand_indexes=False\n", + ")\n", + "np.set_printoptions(threshold=10, edgeitems=2)\n", + "\n", + "\n", + "save_dir = os.getenv(\"ITI_DATA_SAVEDIR\")" + ] + }, + { + "cell_type": "markdown", + "id": "6a42b8ab-756a-4461-aee9-e3a4071412c4", + "metadata": {}, + "source": [ + "## Scenes" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9b2da1fb-1c11-49e8-a830-7e235ffea087", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_files = get_list_filenames(f\"{save_dir}/goes16/geoprocessed\", \".nc\")\n", + "len(list_of_files)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "36a42f7e-0d09-478e-ba13-98f6a3d967ca", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 10MB\n",
+       "Dimensions:          (x: 302, y: 207, time: 1, band_wavelength: 16, band: 16)\n",
+       "Coordinates: (8)\n",
+       "Data variables: (2)\n",
+       "Attributes: (12/30)\n",
+       "    naming_authority:          gov.nesdis.noaa\n",
+       "    Conventions:               CF-1.7\n",
+       "    standard_name_vocabulary:  CF Standard Name Table (v35, 20 July 2016)\n",
+       "    institution:               DOC/NOAA/NESDIS > U.S. Department of Commerce,...\n",
+       "    project:                   GOES\n",
+       "    production_site:           RBU\n",
+       "    ...                        ...\n",
+       "    timeline_id:               ABI Mode 6\n",
+       "    date_created:              2020-10-01T15:09:56.5Z\n",
+       "    time_coverage_start:       2020-10-01T15:00:19.6Z\n",
+       "    time_coverage_end:         2020-10-01T15:09:50.4Z\n",
+       "    LUT_Filenames:             SpaceLookParams(FM1A_CDRL79RevP_PR_09_00_02)-6...\n",
+       "    id:                        ae981973-758f-4213-b71e-e619d91ddddb
" + ], + "text/plain": [ + " Size: 10MB\n", + "Dimensions: (x: 302, y: 207, time: 1, band_wavelength: 16, band: 16)\n", + "Coordinates: (8)\n", + "Data variables: (2)\n", + "Attributes: (12/30)\n", + " naming_authority: gov.nesdis.noaa\n", + " Conventions: CF-1.7\n", + " standard_name_vocabulary: CF Standard Name Table (v35, 20 July 2016)\n", + " institution: DOC/NOAA/NESDIS > U.S. Department of Commerce,...\n", + " project: GOES\n", + " production_site: RBU\n", + " ... ...\n", + " timeline_id: ABI Mode 6\n", + " date_created: 2020-10-01T15:09:56.5Z\n", + " time_coverage_start: 2020-10-01T15:00:19.6Z\n", + " time_coverage_end: 2020-10-01T15:09:50.4Z\n", + " LUT_Filenames: SpaceLookParams(FM1A_CDRL79RevP_PR_09_00_02)-6...\n", + " id: ae981973-758f-4213-b71e-e619d91ddddb" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = xr.open_dataset(list_of_files[0], engine=\"netcdf4\")\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7235f58a-98be-45cd-9fe5-e58b754062b0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "XArray Patcher\n", + "==============\n", + "DataArray Size: OrderedDict([('variable', 2), ('band', 16), ('y', 207), ('x', 302)])\n", + "Patches: OrderedDict([('variable', 2), ('band', 16), ('y', 64), ('x', 64)])\n", + "Strides: OrderedDict([('variable', 1), ('band', 1), ('y', 16), ('x', 16)])\n", + "Num Items: OrderedDict([('variable', 1), ('band', 1), ('y', 9), ('x', 15)])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create a variable to get a tensor\n", + "da = ds.to_array(\"variable\")\n", + "\n", + "# create patchsizes and stride sizes\n", + "patches = dict(x=64, y=64)\n", + "strides = dict(x=16, y=16)\n", + "\n", + "# create a patcher object\n", + "patcher = XRDAPatcher(da, patches, strides)\n", + "\n", + "patcher" + ] + }, + { + "cell_type": "markdown", + "id": "7e6a1618-a1d9-4720-8268-7aac5041b84d", + "metadata": {}, + "source": [ + "We see that we have multiple patches available from the patcher.\n", + "In particular, we have a patchsize of `2x16x64x64` and we have `9x15` patches available for training." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8662ab9d-fe6a-4242-ab61-54eb70f13a48", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (variable: 2, band: 16, y: 64, x: 64)> Size: 524kB\n",
+       "60.15 62.58 94.26 103.2 103.2 113.7 112.9 112.9 ... nan nan nan nan nan nan nan\n",
+       "Coordinates: (9)\n",
+       "Attributes: (12/30)\n",
+       "    naming_authority:          gov.nesdis.noaa\n",
+       "    Conventions:               CF-1.7\n",
+       "    standard_name_vocabulary:  CF Standard Name Table (v35, 20 July 2016)\n",
+       "    institution:               DOC/NOAA/NESDIS > U.S. Department of Commerce,...\n",
+       "    project:                   GOES\n",
+       "    production_site:           RBU\n",
+       "    ...                        ...\n",
+       "    timeline_id:               ABI Mode 6\n",
+       "    date_created:              2020-10-01T15:09:56.5Z\n",
+       "    time_coverage_start:       2020-10-01T15:00:19.6Z\n",
+       "    time_coverage_end:         2020-10-01T15:09:50.4Z\n",
+       "    LUT_Filenames:             SpaceLookParams(FM1A_CDRL79RevP_PR_09_00_02)-6...\n",
+       "    id:                        ae981973-758f-4213-b71e-e619d91ddddb
" + ], + "text/plain": [ + " Size: 524kB\n", + "60.15 62.58 94.26 103.2 103.2 113.7 112.9 112.9 ... nan nan nan nan nan nan nan\n", + "Coordinates: (9)\n", + "Attributes: (12/30)\n", + " naming_authority: gov.nesdis.noaa\n", + " Conventions: CF-1.7\n", + " standard_name_vocabulary: CF Standard Name Table (v35, 20 July 2016)\n", + " institution: DOC/NOAA/NESDIS > U.S. Department of Commerce,...\n", + " project: GOES\n", + " production_site: RBU\n", + " ... ...\n", + " timeline_id: ABI Mode 6\n", + " date_created: 2020-10-01T15:09:56.5Z\n", + " time_coverage_start: 2020-10-01T15:00:19.6Z\n", + " time_coverage_end: 2020-10-01T15:09:50.4Z\n", + " LUT_Filenames: SpaceLookParams(FM1A_CDRL79RevP_PR_09_00_02)-6...\n", + " id: ae981973-758f-4213-b71e-e619d91ddddb" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "patcher[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "03b8b01b-2a98-4d57-8d92-cdeaf003cb40", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "da.sel(variable=\"Rad\").isel(band=0).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "132ed722-44d8-47a5-857d-fbdbfcfaf305", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Patches of Band 1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Patches of Band 2\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_patches(items_to_plot, nbaxes=(4, 4)):\n", + " fig, axs = plt.subplots(*nbaxes, figsize=(7.0, 5.5))\n", + "\n", + " for item, ax in zip(items_to_plot, [*itertools.chain(*reversed(axs))]):\n", + " ax.imshow(item, cmap=\"viridis\", vmax=70, vmin=-70, origin=\"lower\")\n", + " ax.set_xticks([], labels=None)\n", + " ax.set_axis_off()\n", + " ax.set_yticks([], labels=None)\n", + "\n", + "\n", + "print(\"Patches of Band 1\")\n", + "plot_patches([i.sel(variable=\"Rad\").isel(band=1) for i in patcher])\n", + "plt.show()\n", + "\n", + "print(\"Patches of Band 2\")\n", + "plot_patches([i.sel(variable=\"Rad\").isel(band=2) for i in patcher])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6b816de1-920e-4df9-a604-dd9dd8a00e8e", + "metadata": {}, + "source": [ + "***\n", + "\n", + "### PyTorch Integration" + ] + }, + { + "cell_type": "markdown", + "id": "f8529820-0e8d-4d3c-b512-63ed4bf139fd", + "metadata": {}, + "source": [ + "We can also use directly plug this into a PyTorch dataset and dataloader." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0e0dc8d2-6af5-4af3-b24e-5d57a9957041", + "metadata": {}, + "outputs": [], + "source": [ + "class XrTorchDataset(Dataset):\n", + " def __init__(self, batcher: XRDAPatcher, item_postpro=None):\n", + " self.batcher = batcher\n", + " self.postpro = item_postpro\n", + "\n", + " def __getitem__(self, idx):\n", + " item = self.batcher[idx].load().values\n", + " if self.postpro:\n", + " item = self.postpro(item)\n", + " return item\n", + "\n", + " def reconstruct_from_batches(self, batches, **rec_kws):\n", + " return self.batcher.reconstruct([*itertools.chain(*batches)], **rec_kws)\n", + "\n", + " def __len__(self):\n", + " return len(self.batcher)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2a4cc103-b33e-4457-8454-065baa80f762", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(135, (2, 16, 64, 64), numpy.ndarray)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create PyTorch dataset\n", + "torch_ds = XrTorchDataset(patcher)\n", + "\n", + "len(torch_ds), torch_ds[0].shape, type(torch_ds[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8712c2e2-8190-4122-9c1b-84eacb4bfb87", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([4, 2, 16, 64, 64]), torch.Tensor)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create pytorch dataloader\n", + "dataloader = DataLoader(torch_ds, batch_size=4, shuffle=False)\n", + "\n", + "# do a single iteration\n", + "batch = next(iter(dataloader))\n", + "\n", + "batch.shape, type(batch)" + ] + }, + { + "cell_type": "markdown", + "id": "dd047a72-9e58-4ad1-a00e-6edc9dd230ae", + "metadata": {}, + "source": [ + "#### Multiple Datasets" + ] + }, + { + "cell_type": "markdown", + "id": "d93e62bc-bfaa-40c8-87e6-109c1967a195", + "metadata": {}, + "source": [ + "Many times we have multple datasets or scenes that we wish to use for training or some other preprocessing.\n", + "We can directly plug this into the `xrpatcher` framework and then use the PyTorch concat dataset to combine the different datasets.\n", + "\n", + "First, let's create a simple concat dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "53d8e7ef-5aa3-4abc-bbb7-f37eab5a40c3", + "metadata": {}, + "outputs": [], + "source": [ + "class XrConcatDataset(ConcatDataset):\n", + " def __init__(self, *dses: XrTorchDataset):\n", + " super().__init__(dses)\n", + "\n", + " def reconstruct_from_batches(self, batches, weight=None):\n", + " items_iter = itertools.chain(*batches)\n", + " rec_das = []\n", + " for ds in self.datasets:\n", + " ds_items = list(itertools.islice(items_iter, len(ds)))\n", + " rec_das.append(ds.patcher.reconstruct(ds_items, weight=weight))\n", + "\n", + " return rec_das\n" + ] + }, + { + "cell_type": "markdown", + "id": "b676bf50-5113-4369-9b8a-fdb3b5a52193", + "metadata": {}, + "source": [ + "Now, we will initialize some patchers and create individual PyTorch datasets." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b71c303d-8ea6-4cfa-b7a2-0a52a29bbeb3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "270" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create individual patchers\n", + "patcher1 = XRDAPatcher(\n", + " xr.open_dataset(list_of_files[0]).to_array(\"variable\"),\n", + " patches, strides\n", + ")\n", + "patcher2 = XRDAPatcher(\n", + " xr.open_dataset(list_of_files[1]).to_array(\"variable\"),\n", + " patches, strides\n", + ")\n", + "\n", + "\n", + "# create individual pytorch datasets\n", + "torch_ds1 = XrTorchDataset(patcher1)\n", + "torch_ds2 = XrTorchDataset(patcher2)\n", + "\n", + "# create a concatenated dataset\n", + "torch_ds = XrConcatDataset(torch_ds1, torch_ds2)\n", + "\n", + "len(torch_ds)" + ] + }, + { + "cell_type": "markdown", + "id": "5b7bdfb1-38bb-478e-b34e-737406d7bd59", + "metadata": {}, + "source": [ + "There is twice as much data available for training." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "rs_tools", + "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.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/pipelines/goes16.ipynb b/docs/pipelines/goes16.ipynb new file mode 100644 index 0000000..ab0fd80 --- /dev/null +++ b/docs/pipelines/goes16.ipynb @@ -0,0 +1,1188 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c103011a-4a1d-412f-9200-b823c9dd37bc", + "metadata": {}, + "source": [ + "# GOES16 Pipeline\n" + ] + }, + { + "cell_type": "markdown", + "id": "cb92d3f7-b31e-41ba-8ade-ae3961a0b5b7", + "metadata": {}, + "source": [ + "> In this tutorial, we will walk through how one can download data and prep for any further machine learning work with the GOES16 dataset.\n", + "> We will:\n", + "> 1) download the data\n", + "> 2) harmonize the data\n", + "> 3) create patches that are ready for ML consumption." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e5d9b01f-9b02-4888-b8c2-42fdf3dfb27e", + "metadata": {}, + "outputs": [], + "source": [ + "import autoroot\n", + "import os\n", + "from dotenv import load_dotenv\n", + "import xarray as xr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "import rasterio\n", + "import cartopy\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER\n", + "xr.set_options(\n", + " keep_attrs=True, \n", + " display_expand_data=False, \n", + " display_expand_coords=False, \n", + " display_expand_data_vars=False, \n", + " display_expand_indexes=False\n", + ")\n", + "np.set_printoptions(threshold=10, edgeitems=2)\n", + "\n", + "import seaborn as sns\n", + "sns.reset_defaults()\n", + "sns.set_context(context=\"talk\", font_scale=1.0)\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "070298b8-c943-4e73-a6fe-8e471b81c530", + "metadata": {}, + "source": [ + "***\n", + "\n", + "## Download\n", + "\n", + "Firstly, we need to download the data." + ] + }, + { + "cell_type": "markdown", + "id": "62bfd570-ca59-4820-ad0f-ca74b652c7fb", + "metadata": {}, + "source": [ + "#### Save Directory" + ] + }, + { + "cell_type": "markdown", + "id": "a231a650-b349-40f3-a0ad-3a3e7a9c16db", + "metadata": {}, + "source": [ + "This is arguably the most important part.\n", + "We need to define where we want to save the data.\n", + "\n", + "We use the `autoroot` package to manually handle all of the \n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4eb1b8c6-8646-4861-943b-d651dfb1bdee", + "metadata": {}, + "outputs": [], + "source": [ + "root_dir = autoroot.root" + ] + }, + { + "cell_type": "markdown", + "id": "981748d3-0966-431f-803a-40fdc71501b3", + "metadata": {}, + "source": [ + "**Note**: The data is very heavy! So make sure you have adequate space." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c84f34f6-1e67-4c63-aa14-386c225181f8", + "metadata": {}, + "outputs": [], + "source": [ + "save_dir = os.getenv(\"ITI_DATA_SAVEDIR\")" + ] + }, + { + "cell_type": "markdown", + "id": "fbb0d83e-54cb-4c4d-a65f-0cd620067fff", + "metadata": {}, + "source": [ + "#### Config" + ] + }, + { + "cell_type": "markdown", + "id": "1fd46b9e-579c-417c-a6e5-6b261d95c2a1", + "metadata": {}, + "source": [ + "We have a configuration file which features some of the options available for downloading data.\n", + "One can take a peek using the command below." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "db2d8893-4f32-4fa8-b546-73cc576f6c8b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# PERIOD\n", + "period:\n", + " start_date: '2020-10-01'\n", + " start_time: '00:00:00'\n", + " end_date: '2020-10-31'\n", + " end_time: '23:59:00'\n", + "\n", + "# CLOUD MASK\n", + "cloud_mask: True\n", + " \n", + "# PATH FOR SAVING DATA\n", + "save_dir: data\n", + "\n", + "defaults:\n", + " - _self_\n", + " \n" + ] + } + ], + "source": [ + "!cat $autoroot.root/config/example/download.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "8684ff91-8f65-4ccc-9b6c-90f0691b65d9", + "metadata": {}, + "source": [ + "We also have some more things we can change that are satellite specific.\n", + "\n", + "We can see them using the command below." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7b92c827-8a66-4173-8ef8-6f588d7531e3", + "metadata": {}, + "outputs": [], + "source": [ + "# !cat $autoroot.root/config/example/satellite/goes.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "ec17acb5-f695-4b6f-b83c-56255341e7e5", + "metadata": {}, + "source": [ + "\n", + "```yaml\n", + "download:\n", + " _target_: rs_tools._src.data.goes.downloader_goes16.download\n", + " save_dir: ${save_dir}/goes16/raw\n", + " start_date: ${period.start_date}\n", + " start_time: ${period.start_time}\n", + " end_date: ${period.end_date}\n", + " end_time: ${period.end_time}\n", + " daily_window_t0: \"14:00:00\"\n", + " daily_window_t1: \"20:00:00\"\n", + " time_step: \"1:00:00\"\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "d7f54487-358b-42e9-bd4c-ebe3b415bbf1", + "metadata": {}, + "source": [ + "For this tutorial, we will change the save directory, start/end time, and the time step.\n", + "\n", + "Notice how we will change some configurations within the `download.yaml` file and some others that are within the `satellite.yaml` file, in particular the `goes.yaml`.\n", + "\n", + "```bash\n", + "python rs_tools \\\n", + " satellite=goes \\\n", + " stage=download \\\n", + " save_dir=\"/path/to/savedir\" \\\n", + " period.start_date=\"2020-10-01\" \\\n", + " period.end_date=\"2020-10-02\" \\\n", + " period.start_time=\"09:00:00\" \\\n", + " period.end_time=\"21:00:00\" \\\n", + " satellite.download.time_step=\"6:00:00\"\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "e399b813-0540-4cce-b4c1-32a14424fbfa", + "metadata": {}, + "source": [ + "***\n", + "\n", + "## GeoProcessing" + ] + }, + { + "cell_type": "markdown", + "id": "edf13380-752d-4f48-9d4b-185f29b64bb2", + "metadata": {}, + "source": [ + "\n", + "We have an extensive geoprocessing steps to be able to \n", + "\n", + "We can peek into the `rs_tools/config/example/download.yaml` configuration file to see some of the options we have to modify this.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "77ec517f-3fad-480d-9e41-65fbbf2d363f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "download:\n", + " _target_: rs_tools._src.data.goes.downloader_goes16.download\n", + " save_dir: ${save_dir}/goes16/raw\n", + " start_date: ${period.start_date}\n", + " start_time: ${period.start_time}\n", + " end_date: ${period.end_date}\n", + " end_time: ${period.end_time}\n", + " daily_window_t0: \"14:00:00\"\n", + " daily_window_t1: \"20:00:00\"\n", + " time_step: \"1:00:00\"\n", + "\n", + "geoprocess:\n", + " _target_: rs_tools._src.geoprocessing.goes.geoprocessor_goes16.geoprocess\n", + " read_path: ${read_path}/goes16/raw\n", + " save_path: ${save_path}/goes16/geoprocessed\n", + " resolution: null\n", + " region: \"-130 -15 -90 5\"\n", + " resample_method: bilinear\n", + "\n", + "# preprocess:\n", + "\n", + "patch:\n", + " _target_: rs_tools._src.preprocessing.prepatcher.prepatch\n", + " read_path: ${read_path}/goes16/geoprocessed\n", + " save_path: ${save_path}/goes16/analysis\n", + " patch_size: ${patch_size}\n", + " stride_size: ${stride_size}\n", + " nan_cutoff: ${nan_cutoff}\n", + " save_filetype: ${save_filetype}\n" + ] + } + ], + "source": [ + "!cat $autoroot.root/config/example/satellite/goes.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "9a77a4d9-5cae-4590-879d-8948336525ca", + "metadata": {}, + "source": [ + "In particular, we will focus on the `geoprocess` step within the configuration.\n", + "The most important options are the `resolution` and the `region`.\n", + "The resolution is a float or integer that is measured in km.\n", + "\n", + "Below, we have an example of the command we " + ] + }, + { + "cell_type": "markdown", + "id": "40b90173-93b5-4a91-85ba-2611ffcd7dde", + "metadata": {}, + "source": [ + "```bash\n", + "python rs_tools \\\n", + " satellite=goes \\\n", + " stage=geoprocess \\\n", + " read_path=\"/path/to/savedir/\" \\\n", + " save_path=\"/path/to/savedir/\" \\\n", + " satellite.geoprocess.resolution=5000\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "12ff6d62-2c29-4d16-abd0-d8153ffae126", + "metadata": {}, + "source": [ + "We can see the saved data are clean\n", + "\n", + "```bash\n", + "/path/to/savedir/goes16/geoprocessed/20201001150019_goes16.nc\n", + "/path/to/savedir/goes16/geoprocessed/20201002150019_goes16.nc\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8a4790d6-53d6-4a41-96ff-e893c6200284", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 10MB\n",
+       "Dimensions:          (x: 302, y: 207, time: 1, band_wavelength: 16, band: 16)\n",
+       "Coordinates: (8)\n",
+       "Data variables: (2)\n",
+       "Attributes: (12/30)\n",
+       "    naming_authority:          gov.nesdis.noaa\n",
+       "    Conventions:               CF-1.7\n",
+       "    standard_name_vocabulary:  CF Standard Name Table (v35, 20 July 2016)\n",
+       "    institution:               DOC/NOAA/NESDIS > U.S. Department of Commerce,...\n",
+       "    project:                   GOES\n",
+       "    production_site:           RBU\n",
+       "    ...                        ...\n",
+       "    timeline_id:               ABI Mode 6\n",
+       "    date_created:              2020-10-01T15:09:56.5Z\n",
+       "    time_coverage_start:       2020-10-01T15:00:19.6Z\n",
+       "    time_coverage_end:         2020-10-01T15:09:50.4Z\n",
+       "    LUT_Filenames:             SpaceLookParams(FM1A_CDRL79RevP_PR_09_00_02)-6...\n",
+       "    id:                        ae981973-758f-4213-b71e-e619d91ddddb
" + ], + "text/plain": [ + " Size: 10MB\n", + "Dimensions: (x: 302, y: 207, time: 1, band_wavelength: 16, band: 16)\n", + "Coordinates: (8)\n", + "Data variables: (2)\n", + "Attributes: (12/30)\n", + " naming_authority: gov.nesdis.noaa\n", + " Conventions: CF-1.7\n", + " standard_name_vocabulary: CF Standard Name Table (v35, 20 July 2016)\n", + " institution: DOC/NOAA/NESDIS > U.S. Department of Commerce,...\n", + " project: GOES\n", + " production_site: RBU\n", + " ... ...\n", + " timeline_id: ABI Mode 6\n", + " date_created: 2020-10-01T15:09:56.5Z\n", + " time_coverage_start: 2020-10-01T15:00:19.6Z\n", + " time_coverage_end: 2020-10-01T15:09:50.4Z\n", + " LUT_Filenames: SpaceLookParams(FM1A_CDRL79RevP_PR_09_00_02)-6...\n", + " id: ae981973-758f-4213-b71e-e619d91ddddb" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = xr.open_dataset(f\"{save_dir}/goes16/geoprocessed/20201001150019_goes16.nc\", engine=\"netcdf4\")\n", + "\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "id": "01416b1f-7576-46e6-b4a6-674fc74949b6", + "metadata": {}, + "source": [ + "### Demo Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "afa72e76-1292-4af0-8a30-df2c7b76d149", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# in an even better way \n", + "fig = plt.figure(figsize=(8,8))\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "cbar_kwargs = {\n", + " \"fraction\": 0.06, \n", + " \"pad\": 0.1, \n", + " \"orientation\": \"horizontal\",\n", + "}\n", + "# ax.set_extent([-20, -10, 30, 60])\n", + "# out[\"1\"].plot(ax=ax, transform=ccrs.PlateCarree())\n", + "# ax.pcolormesh(out[\"1\"].longitude, out[\"1\"].latitude, out[\"1\"].values)\n", + "ds.isel(band=0).Rad.plot.pcolormesh(\n", + " x=\"longitude\", y=\"latitude\", transform=ccrs.PlateCarree(),\n", + " cbar_kwargs=cbar_kwargs\n", + ")\n", + "\n", + "\n", + "ax.set(xlim=[-140, -70,],\n", + " ylim=[ -40, 10])\n", + "\n", + "# # Add map features with Cartopy \n", + "# ax.add_feature(cfeature.NaturalEarthFeature('physical', 'land', '10m', \n", + "# edgecolor='face', \n", + "# facecolor='lightgray'))\n", + "ax.coastlines()\n", + "# Plot lat/lon grid \n", + "gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,\n", + " linewidth=0.1, color='k', alpha=1, \n", + " linestyle='--')\n", + "gl.top_labels = False\n", + "gl.right_labels = False\n", + "gl.xformatter = LONGITUDE_FORMATTER\n", + "gl.yformatter = LATITUDE_FORMATTER\n", + "gl.xlabel_style = {'size': 12}\n", + "gl.ylabel_style = {'size': 12} \n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "009c2067-77a3-4a36-82eb-421874cb1358", + "metadata": {}, + "source": [ + "## Patching" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "841a304f-9ad8-4deb-bf84-4c0503145095", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cat: /config/example/patch.yaml: No existe el fichero o el directorio\n" + ] + } + ], + "source": [ + "!cat $cwd/config/example/patch.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "6f79744b-ccc2-4148-8a0a-4ae849c2b91d", + "metadata": {}, + "source": [ + "The most important arguments are the `patch_size` and `stride_size` argument.\n", + "The *patch_size* dictates how big the patches should be and the *stride_size* dictates how much space should be between patches. \n", + "For complete overlap, the stride size should be the `patch_size-1`.\n", + "For no overlap, the stride size should be `patch_size`" + ] + }, + { + "cell_type": "markdown", + "id": "c54c4ee5-24b4-406f-85ea-de61814a3172", + "metadata": {}, + "source": [ + "```bash\n", + "python rs_tools satellite=goes stage=patch read_path=$save_dir save_path=$save_dir nan_cutoff=0.5 \n", + "patch_size=16 stride_size=16\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "a793dd2a-8ea5-40e7-af92-b7748735574d", + "metadata": {}, + "source": [ + "#### Demo Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "90ed3569-466e-4f98-92ef-f5981dc61ccf", + "metadata": {}, + "outputs": [], + "source": [ + "ds = xr.open_dataset(f\"{save_dir}/goes16/analysis/20201001150019_patch_0.nc\", engine=\"netcdf4\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c6d07bbb-6850-42a2-b309-a9d8970cbaed", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# in an even better way \n", + "fig = plt.figure()\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "# ax.set_extent([-20, -10, 30, 60])\n", + "# out[\"1\"].plot(ax=ax, transform=ccrs.PlateCarree())\n", + "# ax.pcolormesh(out[\"1\"].longitude, out[\"1\"].latitude, out[\"1\"].values)\n", + "ds.isel(band=0).Rad.plot.pcolormesh(x=\"longitude\", y=\"latitude\", transform=ccrs.PlateCarree())\n", + "\n", + "\n", + "# ax.set(xlim=[-140, -70,],\n", + "# ylim=[ -40, 10])\n", + "\n", + "# # Add map features with Cartopy \n", + "# ax.add_feature(cfeature.NaturalEarthFeature('physical', 'land', '10m', \n", + "# edgecolor='face', \n", + "# facecolor='lightgray'))\n", + "ax.coastlines()\n", + "# Plot lat/lon grid \n", + "gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,\n", + " linewidth=0.1, color='k', alpha=1, \n", + " linestyle='--')\n", + "gl.top_labels = False\n", + "gl.right_labels = False\n", + "gl.xformatter = LONGITUDE_FORMATTER\n", + "gl.yformatter = LATITUDE_FORMATTER\n", + "gl.xlabel_style = {'size': 8}\n", + "gl.ylabel_style = {'size': 8} \n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6a0567ff-378c-4b12-a2cd-06a51c347f9e", + "metadata": {}, + "source": [ + "## DataLoading" + ] + }, + { + "cell_type": "markdown", + "id": "34fd7977-be41-42c7-8d61-70558c5b466c", + "metadata": {}, + "source": [ + "We can start using any dataloader framework right away.\n", + "In this example, we will use PyTorch." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1d9b5d86-625c-4f6f-9dc5-46ca6d305a4a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/data.py:519: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n", + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/NEW.py:188: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n" + ] + } + ], + "source": [ + "from rs_tools._src.utils.io import get_list_filenames\n", + "from rs_tools._src.datamodule.utils import load_nc_file\n", + "from rs_tools._src.datamodule.editor import StackDictEditor, CoordNormEditor\n", + "from toolz import compose_left" + ] + }, + { + "cell_type": "markdown", + "id": "bd0a9dbf-d6bc-4170-b532-b6f10adc9f45", + "metadata": {}, + "source": [ + "We will create a very simple demo dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9ba21c4b-89a9-45d8-87e6-1ee34f436e8f", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import Dataset, DataLoader\n", + "from typing import Optional, Callable\n", + "\n", + "class NCDataReader(Dataset):\n", + " def __init__(self, data_dir: str, ext: str=\".nc\", transforms: Optional[Callable]=None):\n", + " self.data_dir = data_dir\n", + " self.data_filenames = get_list_filenames(data_dir, ext)\n", + " self.transforms = transforms\n", + "\n", + " def __getitem__(self, ind) -> np.ndarray:\n", + " nc_path = self.data_filenames[ind]\n", + " x = load_nc_file(nc_path)\n", + " if self.transforms is not None:\n", + " x = self.transforms(x)\n", + " return x\n", + "\n", + " def __len__(self):\n", + " return len(self.data_filenames)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "4f9af252-b6e1-4577-82df-0846f466a391", + "metadata": {}, + "outputs": [], + "source": [ + "ds = NCDataReader(f\"{save_dir}/goes16/analysis\")\n", + "dl = DataLoader(ds, batch_size=8)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "91200aa6-6e72-40bc-855f-eeadb0e3f3bd", + "metadata": {}, + "outputs": [], + "source": [ + "out = next(iter(dl))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "3b5904f6-e7f1-4cef-a9ca-42470b226330", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['data', 'wavelengths', 'coords', 'cloud_mask']" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(out.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "19a8ee9e-7b14-42fa-92e7-b77cf87dcb26", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([8, 16, 8, 8]), torch.Size([8, 2, 8, 8]))" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out[\"data\"].shape, out[\"coords\"].shape" + ] + }, + { + "cell_type": "markdown", + "id": "9917774a-c9fd-400a-9d12-f0d403d7919f", + "metadata": {}, + "source": [ + "### Transforms/Editors" + ] + }, + { + "cell_type": "markdown", + "id": "9b198911-6ad3-41fc-99b6-b4b598daea4c", + "metadata": {}, + "source": [ + "We can also use custom transformations within the dataset (just like standard PyTorch) to transform our dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "12a71034-aa32-47bb-9aae-0f04c2082f8f", + "metadata": {}, + "outputs": [], + "source": [ + "transforms = compose_left(\n", + " CoordNormEditor(), \n", + " StackDictEditor(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e9521f77-6876-4b14-8a1c-632e61a69257", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([8, 19, 8, 8])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# initialize dataset with transforms\n", + "ds = NCDataReader(f\"{save_dir}/goes16/analysis\", transforms=transforms)\n", + "\n", + "# initialize dataloader\n", + "dl = DataLoader(ds, batch_size=8)\n", + "\n", + "# do one iteration\n", + "out = next(iter(dl))\n", + "\n", + "# inspect a batch\n", + "out.shape" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:rs_tools]", + "language": "python", + "name": "conda-env-rs_tools-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/pipelines/goes16_.md b/docs/pipelines/goes16_.md new file mode 100644 index 0000000..fe784c4 --- /dev/null +++ b/docs/pipelines/goes16_.md @@ -0,0 +1,142 @@ +# GOES16 Pipeline + + + + +## Downloading Data + +Firstly, we will download some data. The default configuration will consist of downloading over a years worth of data. + +```bash +python rs_tools satellite=goes stage=download +``` + + +--- +### Configuration + +We can peek into the `rs_tools/config/example/download.yaml` configuration file to see some of the options we have to modify this. + + +```yaml +# PERIOD +period: + start_date: '2020-10-01' + start_time: '00:00:00' + end_date: '2020-10-31' + end_time: '23:59:00' + +# CLOUD MASK +cloud_mask: True + +# PATH FOR SAVING DATA +save_dir: data + +defaults: + - _self_ +``` + +We see that we can change some of the configurations available. +For this example, we will change this to download only a subset of data. + +We also have some more general options for the user to change which are satellite specific. +These can be found in `rs_tools/config/example/satellite/goes.yaml` + +```yaml +download: + _target_: rs_tools._src.data.goes.downloader_goes16.download + save_dir: ${save_dir}/goes16/raw + start_date: ${period.start_date} + start_time: ${period.start_time} + end_date: ${period.end_date} + end_time: ${period.end_time} + daily_window_t0: "14:00:00" + daily_window_t1: "20:00:00" + time_step: "1:00:00" + +``` + +We will change the save directory, start/end time, and the time step. + +```bash +python rs_tools satellite=goes stage=download save_dir="/path/to/savedir" period.start_date="2020-10-01" period.end_date="2020-10-02" period.start_time="09:00:00" period.end_time="21:00:00" satellite.download.time_step="6:00:00" +``` + +We notice that there are some files that should be available for processing. +In particular, we have two sets of files: the Level 1 Radiances and the Cloud Mask. + + +```bash +/path/to/savedir/goes16/raw/goes16/L1b +/path/to/savedir/goes16/raw/goes16/CM +``` + +We use both in this project. + + +--- +## Geoprocessing + + +We have an extensive geoprocessing steps to be able to + +We can peek into the `rs_tools/config/example/download.yaml` configuration file to see some of the options we have to modify this. + + +```yaml +# PERIOD +geoprocess: + _target_: rs_tools._src.geoprocessing.goes.geoprocessor_goes16.geoprocess + read_path: ${read_path}/goes16/raw + save_path: ${save_path}/goes16/geoprocessed + resolution: null + region: "-130 -15 -90 5" + resample_method: bilinear +``` + +The most important options are the `resolution` and the `region`. +The resolution is a float or integer that is measured in km. + +Below, we have an example of the command we + + +```bash +python rs_tools satellite=goes stage=download save_dir="/path/to/new/save/dir" period.start_date="2020-10-01" period.end_date="2020-10-02" period.start_time="09:00:00" period.end_time="23:00:00" satellite.time_step="6:00:00" +``` + + +We can see the saved data are clean + +```bash +/path/to/savedir/goes16/geoprocessed/20201001150019_goes16.nc +/path/to/savedir/goes16/geoprocessed/20201002150019_goes16.nc +``` + +```bash +PYTHONPATH="." python rs_tools satellite=goes stage=download save_dir="/pool/usuarios/juanjohn/data/iti/raw" period.start_date="2020-10-01" period.end_date="2020-10-02" period.start_time="09:00:00" period.end_time="21:00:00" satellite.download.time_step="6:00:00" + +PYTHONPATH="." python rs_tools satellite=goes stage=geoprocess read_path="/pool/usuarios/juanjohn/data/iti/" save_path="/pool/usuarios/juanjohn/data/iti/" satellite.geoprocess.resolution=10000 + +PYTHONPATH="." python rs_tools satellite=goes stage=patch read_path="/pool/usuarios/juanjohn/data/iti/" save_path="/pool/usuarios/juanjohn/data/iti/" nan_cutoff=1.0 patch_size=8 +``` + +**Warning**: +The data is quite heavy. +Make sure you have enough space! + +### GeoProcessing Data + +In this stage, we will do some light geoprocessing to "harmonize" the data. + +```bash +python rs_tools satellite=goes stage=geoprocess read_path="/path/to/new/save/dir" +``` + + +*** + +**TODO**: Explain the Concepts: +- Start/End Date +- Start/End Time +- Daily Window +- Time Step \ No newline at end of file diff --git a/docs/pipelines/ml_ready_datasets.ipynb b/docs/pipelines/ml_ready_datasets.ipynb new file mode 100644 index 0000000..c548265 --- /dev/null +++ b/docs/pipelines/ml_ready_datasets.ipynb @@ -0,0 +1,822 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4ce89cc8-460a-42d1-88c3-5bc3def75210", + "metadata": {}, + "source": [ + "# ML-Ready Data" + ] + }, + { + "cell_type": "markdown", + "id": "d14b5f2d-fe77-4d52-8e89-42ff749ff173", + "metadata": {}, + "source": [ + "In this tutorial, we will go over some of the basics to create dataloaders." + ] + }, + { + "cell_type": "markdown", + "id": "a04cb172-945d-49fa-bc64-cd2cd22d7979", + "metadata": {}, + "source": [ + "![](../assets/ml_ready_data.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "86a8d52f-849b-4f0b-a4ea-1e828d51488d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/data.py:519: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n", + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/NEW.py:188: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n" + ] + } + ], + "source": [ + "import autoroot\n", + "import os\n", + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "from xrpatcher import XRDAPatcher\n", + "from torch.utils.data import Dataset, DataLoader, ConcatDataset\n", + "import numpy as np\n", + "import itertools\n", + "from dotenv import load_dotenv\n", + "from rs_tools._src.utils.io import get_list_filenames\n", + "\n", + "\n", + "xr.set_options(\n", + " keep_attrs=True, \n", + " display_expand_data=False, \n", + " display_expand_coords=False, \n", + " display_expand_data_vars=False, \n", + " display_expand_indexes=False\n", + ")\n", + "np.set_printoptions(threshold=10, edgeitems=2)\n", + "\n", + "\n", + "save_dir = os.getenv(\"ITI_DATA_SAVEDIR\")" + ] + }, + { + "cell_type": "markdown", + "id": "6a42b8ab-756a-4461-aee9-e3a4071412c4", + "metadata": {}, + "source": [ + "## ML-Ready Datasets\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9b2da1fb-1c11-49e8-a830-7e235ffea087", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "96" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_files = get_list_filenames(f\"{save_dir}/aqua/analysis\", \".nc\")\n", + "len(list_of_files)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "36a42f7e-0d09-478e-ba13-98f6a3d967ca", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 169kB\n",
+       "Dimensions:          (y: 32, x: 32, band: 38, time: 1, band_wavelength: 38)\n",
+       "Coordinates: (6)\n",
+       "Dimensions without coordinates: y, x\n",
+       "Data variables: (1)
" + ], + "text/plain": [ + " Size: 169kB\n", + "Dimensions: (y: 32, x: 32, band: 38, time: 1, band_wavelength: 38)\n", + "Coordinates: (6)\n", + "Dimensions without coordinates: y, x\n", + "Data variables: (1)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = xr.open_dataset(list_of_files[0], engine=\"netcdf4\")\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "id": "6b816de1-920e-4df9-a604-dd9dd8a00e8e", + "metadata": {}, + "source": [ + "***\n", + "\n", + "### PyTorch Integration" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e95b4f0e", + "metadata": {}, + "outputs": [], + "source": [ + "from rs_tools._src.utils.io import get_list_filenames\n", + "from rs_tools._src.datamodule.utils import load_nc_file\n", + "from rs_tools._src.datamodule.editor import StackDictEditor, CoordNormEditor\n", + "from toolz import compose_left" + ] + }, + { + "cell_type": "markdown", + "id": "e9dca84a", + "metadata": {}, + "source": [ + "We will create a very simple demo dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c58e5ed8", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import Dataset, DataLoader\n", + "from typing import Optional, Callable\n", + "\n", + "class NCDataReader(Dataset):\n", + " def __init__(self, data_dir: str, ext: str=\".nc\", transforms: Optional[Callable]=None):\n", + " self.data_dir = data_dir\n", + " self.data_filenames = get_list_filenames(data_dir, ext)\n", + " self.transforms = transforms\n", + "\n", + " def __getitem__(self, ind) -> np.ndarray:\n", + " nc_path = self.data_filenames[ind]\n", + " x = load_nc_file(nc_path)\n", + " if self.transforms is not None:\n", + " x = self.transforms(x)\n", + " return x\n", + "\n", + " def __len__(self):\n", + " return len(self.data_filenames)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6a4f3275", + "metadata": {}, + "outputs": [], + "source": [ + "ds = NCDataReader(f\"{save_dir}/aqua/analysis\")\n", + "dl = DataLoader(ds, batch_size=8)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d24b7722", + "metadata": {}, + "outputs": [], + "source": [ + "out = next(iter(dl))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2207d237", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['data', 'wavelengths', 'coords', 'cloud_mask']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(out.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8c96f315", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([8, 38, 32, 32]), torch.Size([8, 2, 32, 32]))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out[\"data\"].shape, out[\"coords\"].shape" + ] + }, + { + "cell_type": "markdown", + "id": "65babebf", + "metadata": {}, + "source": [ + "### Transforms/Editors" + ] + }, + { + "cell_type": "markdown", + "id": "0efb6678", + "metadata": {}, + "source": [ + "We can also use custom transformations within the dataset (just like standard PyTorch) to transform our dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "42ca6022", + "metadata": {}, + "outputs": [], + "source": [ + "transforms = compose_left(\n", + " CoordNormEditor(), \n", + " StackDictEditor(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c95dd680", + "metadata": {}, + "outputs": [ + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", + "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", + "\u001b[1;31mClick here for more info. \n", + "\u001b[1;31mView Jupyter log for further details." + ] + } + ], + "source": [ + "# initialize dataset with transforms\n", + "ds = NCDataReader(f\"{save_dir}/aqua/analysis\", transforms=transforms)\n", + "\n", + "# initialize dataloader\n", + "dl = DataLoader(ds, batch_size=8)\n", + "\n", + "# do one iteration\n", + "out = next(iter(dl))\n", + "\n", + "# inspect a batch\n", + "out.shape" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "rs_tools", + "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.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/pipelines/modis_aqua.ipynb b/docs/pipelines/modis_aqua.ipynb new file mode 100644 index 0000000..f0c7f76 --- /dev/null +++ b/docs/pipelines/modis_aqua.ipynb @@ -0,0 +1,1776 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c103011a-4a1d-412f-9200-b823c9dd37bc", + "metadata": {}, + "source": [ + "# MODIS Pipeline\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "cb92d3f7-b31e-41ba-8ade-ae3961a0b5b7", + "metadata": {}, + "source": [ + "> In this tutorial, we will walk through how one can download data and prep for any further machine learning work with the GOES16 dataset.\n", + "> We will:\n", + "> 1) download the data\n", + "> 2) harmonize the data\n", + "> 3) create patches that are ready for ML consumption." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e5d9b01f-9b02-4888-b8c2-42fdf3dfb27e", + "metadata": {}, + "outputs": [], + "source": [ + "import autoroot\n", + "import os\n", + "from dotenv import load_dotenv\n", + "import xarray as xr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "import rasterio\n", + "import cartopy\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER\n", + "xr.set_options(\n", + " keep_attrs=True, \n", + " display_expand_data=False, \n", + " display_expand_coords=False, \n", + " display_expand_data_vars=False, \n", + " display_expand_indexes=False\n", + ")\n", + "np.set_printoptions(threshold=10, edgeitems=2)\n", + "\n", + "import seaborn as sns\n", + "sns.reset_defaults()\n", + "sns.set_context(context=\"talk\", font_scale=1.0)\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "070298b8-c943-4e73-a6fe-8e471b81c530", + "metadata": {}, + "source": [ + "***\n", + "\n", + "## Download\n", + "\n", + "Firstly, we need to download the data." + ] + }, + { + "cell_type": "markdown", + "id": "62bfd570-ca59-4820-ad0f-ca74b652c7fb", + "metadata": {}, + "source": [ + "#### Save Directory" + ] + }, + { + "cell_type": "markdown", + "id": "a231a650-b349-40f3-a0ad-3a3e7a9c16db", + "metadata": {}, + "source": [ + "This is arguably the most important part.\n", + "We need to define where we want to save the data.\n", + "\n", + "We use the `autoroot` package to manually handle all of the \n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4eb1b8c6-8646-4861-943b-d651dfb1bdee", + "metadata": {}, + "outputs": [], + "source": [ + "root_dir = autoroot.root" + ] + }, + { + "cell_type": "markdown", + "id": "981748d3-0966-431f-803a-40fdc71501b3", + "metadata": {}, + "source": [ + "**Note**: The data is very heavy! So make sure you have adequate space." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c84f34f6-1e67-4c63-aa14-386c225181f8", + "metadata": {}, + "outputs": [], + "source": [ + "save_dir = os.getenv(\"ITI_DATA_SAVEDIR\")" + ] + }, + { + "cell_type": "markdown", + "id": "857c8271-47b8-45e5-b469-513c35b68941", + "metadata": {}, + "source": [ + "### Account" + ] + }, + { + "cell_type": "markdown", + "id": "eff7d344-d09f-4d7a-ad45-032d644a205d", + "metadata": {}, + "source": [ + "We use the NASA data registry which hosts all of the datasets.\n", + "We use the [EarthAccess](https://earthaccess.readthedocs.io/en/stable/tutorials/getting-started/) API which enables us to easily download data using python.\n", + "\n", + "**Warning**: the user **must** have an account for the [NASA EarthData](https://urs.earthdata.nasa.gov) API.\n", + "Please follow the link to register for an account.\n", + "There are different ways to authenticate your account. \n", + "We recommend you log in once and store it to your local `~/.netrc` file or alternatively, setting the `.env` variable to your `EARTHDATA_USERNAME` and `EARTH_PASSWORD`.\n", + "See these [instructions](https://earthaccess.readthedocs.io/en/stable/tutorials/getting-started/#auth) for more information." + ] + }, + { + "cell_type": "markdown", + "id": "fbb0d83e-54cb-4c4d-a65f-0cd620067fff", + "metadata": {}, + "source": [ + "#### Config" + ] + }, + { + "cell_type": "markdown", + "id": "1fd46b9e-579c-417c-a6e5-6b261d95c2a1", + "metadata": {}, + "source": [ + "We have a configuration file which features some of the options available for downloading data.\n", + "One can take a peek using the command below." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "db2d8893-4f32-4fa8-b546-73cc576f6c8b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# PERIOD\n", + "period:\n", + " start_date: '2020-10-01'\n", + " start_time: '00:00:00'\n", + " end_date: '2020-10-31'\n", + " end_time: '23:59:00'\n", + "\n", + "# CLOUD MASK\n", + "cloud_mask: True\n", + " \n", + "# PATH FOR SAVING DATA\n", + "save_dir: data\n", + "\n", + "defaults:\n", + " - _self_\n", + " \n" + ] + } + ], + "source": [ + "!cat $autoroot.root/config/example/download.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "8684ff91-8f65-4ccc-9b6c-90f0691b65d9", + "metadata": {}, + "source": [ + "We also have some more things we can change that are satellite specific.\n", + "\n", + "We can see them using the command below." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7b92c827-8a66-4173-8ef8-6f588d7531e3", + "metadata": {}, + "outputs": [], + "source": [ + "# !cat $autoroot.root/config/example/satellite/aqua.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "ec17acb5-f695-4b6f-b83c-56255341e7e5", + "metadata": {}, + "source": [ + "\n", + "```yaml\n", + "download:\n", + " _target_: rs_tools._src.data.modis.downloader_aqua.download\n", + " save_dir: ${save_dir}/aqua/\n", + " start_date: ${period.start_date}\n", + " start_time: ${period.start_time}\n", + " end_date: ${period.end_date}\n", + " end_time: ${period.end_time}\n", + " region: \"-130 -15 -90 5\" # \"lon_min lat_min lon_max lat_max\"\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "d7f54487-358b-42e9-bd4c-ebe3b415bbf1", + "metadata": {}, + "source": [ + "For this tutorial, we will change the save directory, start/end time, and the time step.\n", + "\n", + "Notice how we will change some configurations within the `download.yaml` file and some others that are within the `satellite.yaml` file, in particular the `aqua.yaml`.\n", + "\n", + "```bash\n", + "python rs_tools \\\n", + " satellite=aqua \\\n", + " stage=download \\\n", + " save_dir=\"/path/to/savedir\" \\\n", + " period.start_date=\"2020-10-01\" \\\n", + " period.end_date=\"2020-10-02\" \\\n", + " period.start_time=\"09:00:00\" \\\n", + " period.end_time=\"21:00:00\"\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "e399b813-0540-4cce-b4c1-32a14424fbfa", + "metadata": {}, + "source": [ + "***\n", + "\n", + "## GeoProcessing" + ] + }, + { + "cell_type": "markdown", + "id": "edf13380-752d-4f48-9d4b-185f29b64bb2", + "metadata": {}, + "source": [ + "\n", + "We have an extensive geoprocessing steps to be able to \n", + "\n", + "We can peek into the `rs_tools/config/example/download.yaml` configuration file to see some of the options we have to modify this.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "77ec517f-3fad-480d-9e41-65fbbf2d363f", + "metadata": {}, + "outputs": [], + "source": [ + "# !cat $autoroot.root/config/example/satellite/aqua.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "fac7e9c6-ea1a-4af1-a513-6ef91ec5389e", + "metadata": {}, + "source": [ + "```yaml\n", + "geoprocess:\n", + " _target_: rs_tools._src.geoprocessing.modis.geoprocessor_modis.geoprocess\n", + " read_path: ${read_path}/aqua/raw\n", + " save_path: ${save_path}/aqua/geoprocessed\n", + " satellite: aqua\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "9a77a4d9-5cae-4590-879d-8948336525ca", + "metadata": {}, + "source": [ + "In particular, we will focus on the `geoprocess` step within the configuration.\n", + "The most important options are the `resolution` and the `region`.\n", + "The resolution is a float or integer that is measured in km.\n", + "\n", + "Below, we have an example of the command we " + ] + }, + { + "cell_type": "markdown", + "id": "40b90173-93b5-4a91-85ba-2611ffcd7dde", + "metadata": {}, + "source": [ + "```bash\n", + "python rs_tools \\\n", + " satellite=aqua \\\n", + " stage=geoprocess \\\n", + " read_path=$save_dir/data/iti \\\n", + " save_path=$save_dir/data/iti\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "12ff6d62-2c29-4d16-abd0-d8153ffae126", + "metadata": {}, + "source": [ + "We can see the saved data are clean\n", + "\n", + "```bash\n", + "/path/to/savedir/goes16/geoprocessed/20201001150019_goes16.nc\n", + "/path/to/savedir/goes16/geoprocessed/20201002150019_goes16.nc\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "43c18303", + "metadata": {}, + "outputs": [], + "source": [ + "# !ls $save_dir/aqua/geoprocessed\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ab2f84fb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 453MB\n",
+       "Dimensions:          (y: 2040, x: 1354, band: 38, time: 1, band_wavelength: 38)\n",
+       "Coordinates: (6)\n",
+       "Dimensions without coordinates: y, x\n",
+       "Data variables: (1)\n",
+       "Attributes:\n",
+       "    calibration:    radiance\n",
+       "    standard_name:  toa_outgoing_radiance_per_unit_wavelength\n",
+       "    platform_name:  EOS-Aqua\n",
+       "    sensor:         modis\n",
+       "    units:          Watts/m^2/micrometer/steradian
" + ], + "text/plain": [ + " Size: 453MB\n", + "Dimensions: (y: 2040, x: 1354, band: 38, time: 1, band_wavelength: 38)\n", + "Coordinates: (6)\n", + "Dimensions without coordinates: y, x\n", + "Data variables: (1)\n", + "Attributes:\n", + " calibration: radiance\n", + " standard_name: toa_outgoing_radiance_per_unit_wavelength\n", + " platform_name: EOS-Aqua\n", + " sensor: modis\n", + " units: Watts/m^2/micrometer/steradian" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = xr.open_dataset(f\"{save_dir}/aqua/geoprocessed/20201001195500_aqua.nc\", engine=\"netcdf4\")\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "bdfe5952", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# in an even better way \n", + "fig = plt.figure(figsize=(8,8))\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "cbar_kwargs = {\n", + " \"fraction\": 0.06, \n", + " \"pad\": 0.1, \n", + " \"orientation\": \"horizontal\",\n", + "}\n", + "# ax.set_extent([-20, -10, 30, 60])\n", + "# out[\"1\"].plot(ax=ax, transform=ccrs.PlateCarree())\n", + "# ax.pcolormesh(out[\"1\"].longitude, out[\"1\"].latitude, out[\"1\"].values)\n", + "ds.isel(band=0).Rad.plot.pcolormesh(\n", + " x=\"longitude\", y=\"latitude\", transform=ccrs.PlateCarree(),\n", + " cbar_kwargs=cbar_kwargs\n", + ")\n", + "\n", + "\n", + "ax.set(xlim=[-140, -70,],\n", + " ylim=[ -40, 10])\n", + "\n", + "# # Add map features with Cartopy \n", + "# ax.add_feature(cfeature.NaturalEarthFeature('physical', 'land', '10m', \n", + "# edgecolor='face', \n", + "# facecolor='lightgray'))\n", + "ax.coastlines()\n", + "# Plot lat/lon grid \n", + "gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,\n", + " linewidth=0.1, color='k', alpha=1, \n", + " linestyle='--')\n", + "gl.top_labels = False\n", + "gl.right_labels = False\n", + "gl.xformatter = LONGITUDE_FORMATTER\n", + "gl.yformatter = LATITUDE_FORMATTER\n", + "gl.xlabel_style = {'size': 12}\n", + "gl.ylabel_style = {'size': 12} \n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4ef9f0ce", + "metadata": {}, + "source": [ + "## Patching" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ad4cc18f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cat: /config/example/patch.yaml: No existe el fichero o el directorio\n" + ] + } + ], + "source": [ + "!cat $cwd/config/example/patch.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "af53e9d4", + "metadata": {}, + "source": [ + "The most important arguments are the `patch_size` and `stride_size` argument.\n", + "The *patch_size* dictates how big the patches should be and the *stride_size* dictates how much space should be between patches. \n", + "For complete overlap, the stride size should be the `patch_size-1`.\n", + "For no overlap, the stride size should be `patch_size`" + ] + }, + { + "cell_type": "markdown", + "id": "102f3987", + "metadata": {}, + "source": [ + "```bash\n", + "python rs_tools satellite=aqua stage=patch read_path=$save_dir save_path=$save_dir nan_cutoff=0.5 \n", + "patch_size=16 stride_size=16\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "13664c66", + "metadata": {}, + "source": [ + "#### Demo Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b9f40444", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 169kB\n",
+       "Dimensions:          (y: 32, x: 32, band: 38, time: 1, band_wavelength: 38)\n",
+       "Coordinates: (6)\n",
+       "Dimensions without coordinates: y, x\n",
+       "Data variables: (1)
" + ], + "text/plain": [ + " Size: 169kB\n", + "Dimensions: (y: 32, x: 32, band: 38, time: 1, band_wavelength: 38)\n", + "Coordinates: (6)\n", + "Dimensions without coordinates: y, x\n", + "Data variables: (1)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = xr.open_dataset(f\"{save_dir}/aqua/analysis/20201001195500_patch_0.nc\", engine=\"netcdf4\")\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a8a574b3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# in an even better way \n", + "fig = plt.figure()\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "# ax.set_extent([-20, -10, 30, 60])\n", + "# out[\"1\"].plot(ax=ax, transform=ccrs.PlateCarree())\n", + "# ax.pcolormesh(out[\"1\"].longitude, out[\"1\"].latitude, out[\"1\"].values)\n", + "ds.isel(band=0).Rad.plot.pcolormesh(x=\"longitude\", y=\"latitude\", transform=ccrs.PlateCarree())\n", + "\n", + "\n", + "# ax.set(xlim=[-140, -70,],\n", + "# ylim=[ -40, 10])\n", + "\n", + "# # Add map features with Cartopy \n", + "# ax.add_feature(cfeature.NaturalEarthFeature('physical', 'land', '10m', \n", + "# edgecolor='face', \n", + "# facecolor='lightgray'))\n", + "ax.coastlines()\n", + "# Plot lat/lon grid \n", + "gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,\n", + " linewidth=0.1, color='k', alpha=1, \n", + " linestyle='--')\n", + "gl.top_labels = False\n", + "gl.right_labels = False\n", + "gl.xformatter = LONGITUDE_FORMATTER\n", + "gl.yformatter = LATITUDE_FORMATTER\n", + "gl.xlabel_style = {'size': 8}\n", + "gl.ylabel_style = {'size': 8} \n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1f842115", + "metadata": {}, + "source": [ + "## DataLoading" + ] + }, + { + "cell_type": "markdown", + "id": "1c65364c", + "metadata": {}, + "source": [ + "We can start using any dataloader framework right away.\n", + "In this example, we will use PyTorch." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "99a48417", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/data.py:519: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n", + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/NEW.py:188: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n" + ] + } + ], + "source": [ + "from rs_tools._src.utils.io import get_list_filenames\n", + "from rs_tools._src.datamodule.utils import load_nc_file\n", + "from rs_tools._src.datamodule.editor import StackDictEditor, CoordNormEditor\n", + "from toolz import compose_left" + ] + }, + { + "cell_type": "markdown", + "id": "13371f30", + "metadata": {}, + "source": [ + "We will create a very simple demo dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "95c0e276", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import Dataset, DataLoader\n", + "from typing import Optional, Callable\n", + "\n", + "class NCDataReader(Dataset):\n", + " def __init__(self, data_dir: str, ext: str=\".nc\", transforms: Optional[Callable]=None):\n", + " self.data_dir = data_dir\n", + " self.data_filenames = get_list_filenames(data_dir, ext)\n", + " self.transforms = transforms\n", + "\n", + " def __getitem__(self, ind) -> np.ndarray:\n", + " nc_path = self.data_filenames[ind]\n", + " x = load_nc_file(nc_path)\n", + " if self.transforms is not None:\n", + " x = self.transforms(x)\n", + " return x\n", + "\n", + " def __len__(self):\n", + " return len(self.data_filenames)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3fcf9441", + "metadata": {}, + "outputs": [], + "source": [ + "ds = NCDataReader(f\"{save_dir}/aqua/analysis\")\n", + "dl = DataLoader(ds, batch_size=8)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9018229d", + "metadata": {}, + "outputs": [], + "source": [ + "out = next(iter(dl))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "9b263066", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['data', 'wavelengths', 'coords', 'cloud_mask']" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(out.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "11674c57", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([8, 38, 32, 32]), torch.Size([8, 2, 32, 32]))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out[\"data\"].shape, out[\"coords\"].shape" + ] + }, + { + "cell_type": "markdown", + "id": "87141e43", + "metadata": {}, + "source": [ + "### Transforms/Editors" + ] + }, + { + "cell_type": "markdown", + "id": "6ed7abb4", + "metadata": {}, + "source": [ + "We can also use custom transformations within the dataset (just like standard PyTorch) to transform our dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "0d85d10f", + "metadata": {}, + "outputs": [], + "source": [ + "transforms = compose_left(\n", + " CoordNormEditor(), \n", + " StackDictEditor(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "46f4b3d2", + "metadata": {}, + "outputs": [ + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", + "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", + "\u001b[1;31mClick here for more info. \n", + "\u001b[1;31mView Jupyter log for further details." + ] + } + ], + "source": [ + "# initialize dataset with transforms\n", + "ds = NCDataReader(f\"{save_dir}/aqua/analysis\", transforms=transforms)\n", + "\n", + "# initialize dataloader\n", + "dl = DataLoader(ds, batch_size=8)\n", + "\n", + "# do one iteration\n", + "out = next(iter(dl))\n", + "\n", + "# inspect a batch\n", + "out.shape" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "rs_tools", + "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.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/pipelines/msg.ipynb b/docs/pipelines/msg.ipynb new file mode 100644 index 0000000..c476548 --- /dev/null +++ b/docs/pipelines/msg.ipynb @@ -0,0 +1,1601 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c103011a-4a1d-412f-9200-b823c9dd37bc", + "metadata": {}, + "source": [ + "MSG Pipeline\n" + ] + }, + { + "cell_type": "markdown", + "id": "cb92d3f7-b31e-41ba-8ade-ae3961a0b5b7", + "metadata": {}, + "source": [ + "> In this tutorial, we will walk through how one can download data and prep for any further machine learning work with the MSG dataset.\n", + "> We will:\n", + "> 1) download the data\n", + "> 2) harmonize the data\n", + "> 3) create patches that are ready for ML consumption." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e5d9b01f-9b02-4888-b8c2-42fdf3dfb27e", + "metadata": {}, + "outputs": [], + "source": [ + "import autoroot\n", + "import os\n", + "from dotenv import load_dotenv\n", + "import xarray as xr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "import rasterio\n", + "import cartopy\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER\n", + "xr.set_options(\n", + " keep_attrs=True, \n", + " display_expand_data=False, \n", + " display_expand_coords=False, \n", + " display_expand_data_vars=False, \n", + " display_expand_indexes=False\n", + ")\n", + "np.set_printoptions(threshold=10, edgeitems=2)\n", + "\n", + "import seaborn as sns\n", + "sns.reset_defaults()\n", + "sns.set_context(context=\"talk\", font_scale=1.0)\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "070298b8-c943-4e73-a6fe-8e471b81c530", + "metadata": {}, + "source": [ + "***\n", + "\n", + "## Download\n", + "\n", + "Firstly, we need to download the data." + ] + }, + { + "cell_type": "markdown", + "id": "62bfd570-ca59-4820-ad0f-ca74b652c7fb", + "metadata": {}, + "source": [ + "#### Save Directory" + ] + }, + { + "cell_type": "markdown", + "id": "a231a650-b349-40f3-a0ad-3a3e7a9c16db", + "metadata": {}, + "source": [ + "This is arguably the most important part.\n", + "We need to define where we want to save the data.\n", + "\n", + "We use the `autoroot` package to manually handle all of the \n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4eb1b8c6-8646-4861-943b-d651dfb1bdee", + "metadata": {}, + "outputs": [], + "source": [ + "root_dir = autoroot.root" + ] + }, + { + "cell_type": "markdown", + "id": "981748d3-0966-431f-803a-40fdc71501b3", + "metadata": {}, + "source": [ + "**Note**: The data is very heavy! So make sure you have adequate space." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c84f34f6-1e67-4c63-aa14-386c225181f8", + "metadata": {}, + "outputs": [], + "source": [ + "save_dir = os.getenv(\"ITI_DATA_SAVEDIR\")" + ] + }, + { + "cell_type": "markdown", + "id": "857c8271-47b8-45e5-b469-513c35b68941", + "metadata": {}, + "source": [ + "### Account" + ] + }, + { + "cell_type": "markdown", + "id": "eff7d344-d09f-4d7a-ad45-032d644a205d", + "metadata": {}, + "source": [ + "We use the NASA data registry which hosts all of the datasets.\n", + "We use the [EUMETSAT Data Access](https://user.eumetsat.int/resources/user-guides/eumetsat-data-access-client-eumdac-guide) API which enables us to easily download data using python.\n", + "\n", + "**Warning**: the user **must** have an account for the [EUMETSAT](https://user.eumetsat.int/resources/user-guides/eumetsat-data-access-client-eumdac-guide) API.\n", + "Please follow the [link to register for an account](https://eoportal.eumetsat.int/cas/login).\n", + "There are different ways to authenticate your account. \n", + "We recommend you log in once and store it to your local `~/.netrc` file or alternatively, setting the `.env` variable to your `EARTHDATA_USERNAME` and `EARTH_PASSWORD`.\n", + "See these [instructions](https://user.eumetsat.int/resources/user-guides/eumetsat-data-access-client-eumdac-guide) for more information." + ] + }, + { + "cell_type": "markdown", + "id": "fbb0d83e-54cb-4c4d-a65f-0cd620067fff", + "metadata": {}, + "source": [ + "#### Config" + ] + }, + { + "cell_type": "markdown", + "id": "1fd46b9e-579c-417c-a6e5-6b261d95c2a1", + "metadata": {}, + "source": [ + "We have a configuration file which features some of the options available for downloading data.\n", + "One can take a peek using the command below." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "db2d8893-4f32-4fa8-b546-73cc576f6c8b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# PERIOD\n", + "period:\n", + " start_date: '2020-10-01'\n", + " start_time: '00:00:00'\n", + " end_date: '2020-10-31'\n", + " end_time: '23:59:00'\n", + "\n", + "# CLOUD MASK\n", + "cloud_mask: True\n", + " \n", + "# PATH FOR SAVING DATA\n", + "save_dir: data\n", + "\n", + "defaults:\n", + " - _self_\n", + " \n" + ] + } + ], + "source": [ + "!cat $autoroot.root/config/example/download.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "8684ff91-8f65-4ccc-9b6c-90f0691b65d9", + "metadata": {}, + "source": [ + "We also have some more things we can change that are satellite specific.\n", + "\n", + "We can see them using the command below." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7b92c827-8a66-4173-8ef8-6f588d7531e3", + "metadata": {}, + "outputs": [], + "source": [ + "# !cat $autoroot.root/config/example/satellite/msg.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "ec17acb5-f695-4b6f-b83c-56255341e7e5", + "metadata": {}, + "source": [ + "\n", + "```yaml\n", + "download:\n", + " _target_: rs_tools._src.data.msg.downloader_msg.download\n", + " save_dir: ${save_dir}/msg/raw\n", + " start_date: ${period.start_date}\n", + " start_time: ${period.start_time}\n", + " end_date: ${period.end_date}\n", + " end_time: ${period.end_time}\n", + " daily_window_t0: \"9:00:00\"\n", + " daily_window_t1: \"17:00:00\"\n", + " time_step: \"1:00:00\"\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "d7f54487-358b-42e9-bd4c-ebe3b415bbf1", + "metadata": {}, + "source": [ + "For this tutorial, we will change the save directory, start/end time, and the time step.\n", + "\n", + "Notice how we will change some configurations within the `download.yaml` file and some others that are within the `satellite.yaml` file, in particular the `msg.yaml`.\n", + "\n", + "```bash\n", + "python rs_tools \\\n", + " satellite=aqua \\\n", + " stage=download \\\n", + " save_dir=\"/path/to/savedir\" \\\n", + " period.start_date=\"2020-10-01\" \\\n", + " period.end_date=\"2020-10-02\" \\\n", + " period.start_time=\"09:00:00\" \\\n", + " period.end_time=\"21:00:00\"\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "e399b813-0540-4cce-b4c1-32a14424fbfa", + "metadata": {}, + "source": [ + "***\n", + "\n", + "## GeoProcessing" + ] + }, + { + "cell_type": "markdown", + "id": "edf13380-752d-4f48-9d4b-185f29b64bb2", + "metadata": {}, + "source": [ + "\n", + "We have an extensive geoprocessing steps to be able to \n", + "\n", + "We can peek into the `rs_tools/config/example/download.yaml` configuration file to see some of the options we have to modify this.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "77ec517f-3fad-480d-9e41-65fbbf2d363f", + "metadata": {}, + "outputs": [], + "source": [ + "# !cat $autoroot.root/config/example/satellite/aqua.yaml" + ] + }, + { + "cell_type": "markdown", + "id": "fac7e9c6-ea1a-4af1-a513-6ef91ec5389e", + "metadata": {}, + "source": [ + "```yaml\n", + "geoprocess:\n", + " _target_: rs_tools._src.geoprocessing.modis.geoprocessor_modis.geoprocess\n", + " read_path: ${read_path}/aqua/raw\n", + " save_path: ${save_path}/aqua/geoprocessed\n", + " satellite: aqua\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "9a77a4d9-5cae-4590-879d-8948336525ca", + "metadata": {}, + "source": [ + "In particular, we will focus on the `geoprocess` step within the configuration.\n", + "The most important options are the `resolution` and the `region`.\n", + "The resolution is a float or integer that is measured in km.\n", + "\n", + "Below, we have an example of the command we " + ] + }, + { + "cell_type": "markdown", + "id": "40b90173-93b5-4a91-85ba-2611ffcd7dde", + "metadata": {}, + "source": [ + "```bash\n", + "python rs_tools \\\n", + " satellite=msg \\\n", + " stage=geoprocess \\\n", + " read_path=\"/path/to/savedir/\" \\\n", + " save_path=\"/path/to/savedir/\" \\\n", + " satellite.geoprocess.resolution=5000\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f05084c2-5f5b-4c96-9f62-47f05331fe2c", + "metadata": {}, + "outputs": [], + "source": [ + "# !ls $save_dir/msg/geoprocessed" + ] + }, + { + "cell_type": "markdown", + "id": "12ff6d62-2c29-4d16-abd0-d8153ffae126", + "metadata": {}, + "source": [ + "We can see the saved data are clean\n", + "\n", + "```bash\n", + "/path/to/savedir/msg/geoprocessed/20201001091243_msg.nc\n", + "/path/to/savedir/msg/geoprocessed/20201001151243_msg.nc\n", + "/path/to/savedir/msg/geoprocessed/20201002091243_msg.nc\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8a4790d6-53d6-4a41-96ff-e893c6200284", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 40MB\n",
+       "Dimensions:          (x: 1457, y: 400, band: 11, time: 1, band_wavelength: 11)\n",
+       "Coordinates: (8)\n",
+       "Data variables: (1)\n",
+       "Attributes:\n",
+       "    calibration:         radiance\n",
+       "    standard_name:       toa_outgoing_radiance_per_unit_wavenumber\n",
+       "    platform_name:       Meteosat-11\n",
+       "    sensor:              seviri\n",
+       "    units:               mW m-2 sr-1 (cm-1)-1\n",
+       "    orbital_parameters:  {"projection_longitude": 0.0, "projection_latitude":...
" + ], + "text/plain": [ + " Size: 40MB\n", + "Dimensions: (x: 1457, y: 400, band: 11, time: 1, band_wavelength: 11)\n", + "Coordinates: (8)\n", + "Data variables: (1)\n", + "Attributes:\n", + " calibration: radiance\n", + " standard_name: toa_outgoing_radiance_per_unit_wavenumber\n", + " platform_name: Meteosat-11\n", + " sensor: seviri\n", + " units: mW m-2 sr-1 (cm-1)-1\n", + " orbital_parameters: {\"projection_longitude\": 0.0, \"projection_latitude\":..." + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds = xr.open_dataset(f\"{save_dir}/msg/geoprocessed/20201001091243_msg.nc\", engine=\"netcdf4\")\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "66c78453-1a48-46e5-a8eb-6cad5feb4bb5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# in an even better way \n", + "fig = plt.figure(figsize=(8,8))\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "cbar_kwargs = {\n", + " \"fraction\": 0.06, \n", + " \"pad\": 0.1, \n", + " \"orientation\": \"horizontal\",\n", + "}\n", + "# ax.set_extent([-20, -10, 30, 60])\n", + "# out[\"1\"].plot(ax=ax, transform=ccrs.PlateCarree())\n", + "# ax.pcolormesh(out[\"1\"].longitude, out[\"1\"].latitude, out[\"1\"].values)\n", + "ds.isel(band=0).Rad.plot.pcolormesh(\n", + " x=\"longitude\", y=\"latitude\", transform=ccrs.PlateCarree(),\n", + " cbar_kwargs=cbar_kwargs\n", + ")\n", + "\n", + "\n", + "# ax.set(xlim=[-140, -70,],\n", + "# ylim=[ -40, 10])\n", + "\n", + "# # Add map features with Cartopy \n", + "# ax.add_feature(cfeature.NaturalEarthFeature('physical', 'land', '10m', \n", + "# edgecolor='face', \n", + "# facecolor='lightgray'))\n", + "ax.coastlines()\n", + "# Plot lat/lon grid \n", + "gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,\n", + " linewidth=0.1, color='k', alpha=1, \n", + " linestyle='--')\n", + "gl.top_labels = False\n", + "gl.right_labels = False\n", + "gl.xformatter = LONGITUDE_FORMATTER\n", + "gl.yformatter = LATITUDE_FORMATTER\n", + "gl.xlabel_style = {'size': 12}\n", + "gl.ylabel_style = {'size': 12} \n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0872f66a-103e-43d5-9fe3-0345fb3745cd", + "metadata": {}, + "source": [ + "## Patching" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "841a304f-9ad8-4deb-bf84-4c0503145095", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# PATH WITH GEOPROCESSED DATA\n", + "read_path: data\n", + "\n", + "# PATH FOR SAVING PATCHES\n", + "save_path: data\n", + "\n", + "# PATCH PARAMETERS\n", + "patch_size: 256\n", + "stride_size: 256\n", + "\n", + "# NAN CUTOFF\n", + "nan_cutoff: 0.5\n", + "\n", + "# FILETYPE TO SAVE [nc = netcdf, np = numpy]\n", + "save_filetype: nc\n", + "\n", + "defaults:\n", + " - _self_" + ] + } + ], + "source": [ + "!cat $root_dir/config/example/patch.yaml" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "19da6612-6c90-4942-9538-8b32f6a10dc5", + "metadata": {}, + "outputs": [], + "source": [ + "# !ls $save_dir/msg/analysis/" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "2602e401-0de1-4f17-b00a-25874fa78fbe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 71kB\n",
+       "Dimensions:          (x: 32, y: 32, band: 11, time: 1, band_wavelength: 11)\n",
+       "Coordinates: (8)\n",
+       "Data variables: (1)
" + ], + "text/plain": [ + " Size: 71kB\n", + "Dimensions: (x: 32, y: 32, band: 11, time: 1, band_wavelength: 11)\n", + "Coordinates: (8)\n", + "Data variables: (1)" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "ds = xr.open_dataset(f\"{save_dir}/msg/analysis/20201001091243_patch_0.nc\", engine=\"netcdf4\")\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "b4707555-625c-430c-93ef-10f46d46ab88", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmgAAAG+CAYAAAAnYPjmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACh7klEQVR4nOzdd1xTVxsH8N8NWxkKDkALghMVB4gVUKbWtm5FrbWO14GrVRwV996KdbaO2qq1bqFWbbWKIE5UcOHWAoKAE1GQmdz3D0wKEpKbcENy4fn2k08xOfeck0NIntx7znMYlmVZEEIIIYQQnSHSdgcIIYQQQkhxFKARQgghhOgYCtAIIYQQQnQMBWiEEEIIITqGAjRCCCGEEB1DARohhBBCiI6hAI0QQgghRMdQgEYIIYQQomP0td0BQgghhKuBAwfi3r17Gqm7SZMm+P333zVSNyGqogCNEEKIYNy7dw+xsbHa7gYhGkcBGiGEEMExMWbg1NCQl7ruPsxDdg7tekh0CwVohBBCBKdJQwNE/1OXl7rafpaEa7fyeKmLEL5QgEYIIUSQxKxE210gRGNoFSchhBBCiI6hM2iEEEIEhwUgAT/zxmj2GdFFFKARQggRIBYS8HWJk0I0onvoEichhBBCiI6hM2iEEEIEhwUgZukSp7ZFRUXB0NAQ7dq141T+8uXLyMnJgZeXl4Z7JnwUoBFCCCFELT4+PrCxscHTp085le/fvz+SkpJQUFCg4Z4JHwVohBBCBImvRQKkbFgVz2SqWr6yogCNEEKI4LAAxLSKU3CysrJgYGCg7W4IAi0SIIQQQojG3b9/Hy9fvkStWrW03RVBoDNohBBCBIkucZa/w4cP4/Dhw8Xuy8jIwLBhw0o9hmVZvHnzBmfPngXDMOjQoYOmu1khUIBGCCFEcFiwPK7ipECPq+vXr2P79u1gGEY2lyw7Oxvbt2/ndHzNmjUxd+5cDfaw4qAAjRBCCCGctGrVCkOGDJH9e8eOHTAxMUG/fv1KPUYkEsHc3BzNmzdHnz59UK1atXLoqfBRgEYIIUSQaKv08tejRw/06NFD9u8dO3bAwsICv/76qxZ7VTFRgEYIIYQQtURERMDQ0FDb3aiQKEAjhBAiOJRmQzd4e3truwsVFgVohBBCBElMkRWpwChAI4QQQohSfn5+AAB7e3vZnDPpfapgGAbh4eG89q0iogCNEEKI4LDgb5EAnYjjJjIyEgDQpEmTEvepgmEYnnpUsVGARgghhBClpPnLatSoUeI+wj8K0AghhAiSGHQmpjzJC8YoQNMcCtAIIYQIDssCEp6uTfK0IQEhvKLN0gkhhBBCdAydQSOEECJADI+XOOlSKdE9dAaNEEKI4BQmqmV4udEVzrJhWRbbt29H586dYWNjAyMjI+jp6ZV609enc0Nc0CgRQgghRC25ubno0qULIiIiwNJkPl5RgEYIIUSQJCxdmtS25cuX4/Tp0wCA3r17o0ePHrC1taWzZDygESSEEEKIWvbu3QuGYTBnzhxKucEzCtAIIYQIjnQOGl91EfXEx8eDYRhMnjxZ210pgWVZJCUlAQDs7Oy03BvVUYBGCCFEgBiIeVvnRpdK1WVmZgaxWAxTU1Ntd6WE169fo169ehCJRCgoKNB2d1RGqzgJIYQQohY3NzdkZGTg9evX2u5KqYS6eIECNEIIIYLDonCRAB83YX5864ZJkyaBZVn88MMP2u5KhUOXOAkhhAgS7cWpff7+/li+fDmmT58OQ0NDTJ48GVWqVNF2tyoECtAIIYQQohY/Pz8AhXPR5s2bh6VLl6JZs2YwMzMr9RiGYRAeHs6pfj09PV76KUQUoBFCCBEcFoCY5WeWDl3iVF9kZGSxf+fk5CAmJkbhMQzD/cynUOeP8YECNEIIIYSoRdO5z0xMTJCTk4NJkyahefPmKh2bmZmJ7777TkM90zwK0AghhAgQAwml2dA6TQdoLVu2RHR0NOrWrYshQ4aodOyrV68EHaDRKk5CCCGCQ5ulVw4uLi5gWRaxsbHa7kq5owCNEEIIITrJ1dUVACplgEaXOAkhhAgOLRKoHDw8PODl5QVDQ0OwLKvSAgMzMzP8+uuvGuydZlGARgghRIAYSHibO0Zz0NSlThoMhmE4b73UuHHjEitFuTI0NFR53pouoQCNEEIIIWqpzGkwNI0CNEIIIYJTuEiALnFqW0REhMLHMzIyEB0dja1bt4JlWWzcuBG1a9cup94JGwVohBBCCFGLt7e30jLdu3fHhAkT4Ovri7lz5+Lq1au89+PSpUvIy8uDl5cX73VrC63iJIQQIjxs4SIBPm6aPIUWERGBrl27ombNmjAxMUGTJk0we/ZsZGVlqV3noUOH4Ovri+rVq6Nq1apo1aoVVq1ahfz8fM51vH//Ho6OjmAYBgzDqD3Pi6tatWph48aNuH//PpYuXcp7/b169ZJtO1VRUIBGCCFEcNgPiWr5uLEaWiSwfv16+Pv749ixYzA2NoaTkxMSEhKwaNEiuLm54fXr1yrXOWXKFAQEBCAyMhJWVlZo0KAB4uLi8P3336Njx47Izc3lVM+sWbMQHx+vcvtl4e3tDWNjYxw8eFAj9Ve0+XAUoBFCCCE8i4mJQVBQEABg8+bNePLkCWJjY/Hvv//C1dUVd+/exciRI1WqMywsDCEhITAyMsLhw4fx6NEj3LhxA3FxcXBwcEBUVBRmzJihtJ4rV65g3bp16NGjhzpPTW0Mw0AkEuHJkyfl2q5QUYBGCCFEkMQsw8tNExYuXAiJRIJBgwYhMDBQlr/L1tYWe/bsgUgkQmhoKG7evMm5zvnz5wMAgoOD0b17d9n9TZo0wc8//wwA2LhxI168eFFqHQUFBRgxYgRMTEywYcMGdZ6a2mJiYvD+/XtUqVKlXNsVKgrQCCGEEB5lZmbi+PHjAIDAwMASjzds2FA2X+rAgQOc6nz48CFu3LhRap1+fn5o0KABcnNz8eeff5Zaz4oVK3Dz5k0sXLgQdevW5dQ2H65cuYJBgwaBYRh4enqWW7tCRqs4CSGECI4up9m4du0acnNzYWRkhLZt28ot06FDB5w6dQqXLl3iVKe0nKOjI+rUqVNqnY8ePcKlS5cwfPjwEo8/ePAACxcuhIuLC2+biCubmJ+Tk4OkpCSkpKSAZVkYGhpi1qxZvLRdVEWbfwZQgEYIIUSQGEh42uqJ750EHjx4AACws7ODgYGB3DL169cHANy/f1+lOqXHqVony7IIDAxEXl4eNm/erNYOAPKosvrT3t4emzdvhpubm9rtOTg4QCQS4cSJE2jQoIHs/nXr1iE7O1vtenURBWiEEEIIgLt378o25+YiMDAQo0aNKnG/dHWmpaVlqcdKH0tPT+fUVlnr3Lp1K86cOYPx48ejTZs2nNrkYu7cuQof19fXR/Xq1dGyZUt4eHiotJemPKmpqTA0NCwWnAFAv379ylSvLqIAjRBCiOBo4hJndnY2YmNjOR+Xmpoq9/6cnBwAhXtBlsbIyEjWJhdlqTM1NRVTp05FnTp1sGjRIk7tcaUsQOObra2twkUQFQkFaIQQQgSJ7xWYJiYmcHJy4lzexsZG7v3GxsYAgLy8vFKPleYrMzEx4dRWWeocN24cMjIy8Msvv8DMzIxTe+Vt4sSJePv2LbZt26awXMeOHbFt2zZcu3YNrVu3LqfeaQcFaIQQQggAJycnxMTElLme6tWrA4DCRLTSx6RlNVXnn3/+ibCwMHTr1g29e/fm1JY27N27F8+fP1caoE2bNg179+7Ft99+i5MnT1bolB0UoBFCCBEc6U4CfNXFp0aNGgEAnjx5gvz8fLkLBR4/flysLNc6Hz16VGoZeXVKL9lGRUXB2tq61GN79+4NQ0ND9O/fH2vXruXUJ23Q19fH5s2bMWrUKDRv3hzfffcdPDw8UKtWLYULH+zs7Mqxl/ygAI0QQgjhUevWrWFoaIjc3FxcvnxZbt6vs2fPAgDc3d051dmuXTsAQHx8PJ4+fSo31YaiOjMyMpCRkVFq/dKFBYrK6AIHBwfZz1lZWZgyZYrSYxiGQUFBgSa7pRGUqJYQQogg8bZZOs/MzMzQuXNnAMCWLVtKPP7w4UOcPn0aABAQEMCpzkaNGsHZ2bnUOk+fPo1Hjx7B0NCw2C4D8+bNA8uypd6kIiIiwLIstm/fzvl5aoOi51LaTSKRaLvbaqEzaIQQQgSHBSDh6dKkJlKczp49G0ePHsVvv/0GT09PjBw5EgzDIDU1FQMGDIBEIkHPnj3RsmXLYsfVq1cPALBq1aoSwdvcuXMREBCA5cuXo02bNujWrRuAwrxnI0aMAACMHTsWNWvW1MAz0g3lvcG7NlGARgghhPDMzc0Nq1evxqRJkzBq1CgsWrQINWrUwJ07d5Cbm4vGjRtj69atJY5LTEwEULhd1Mf69OmDoKAgrFmzBt27d0f9+vVhamqKuLg4iMVitG/fHkuXLtX4c9Mme3t7bXeh3NAlTkIIIcLDMvxd4tTQhulBQUE4efIkvvjiC2RlZeHOnTuwt7fHjBkzcPXqVdSoUUPlOn/44Qfs378f3t7eePnyJR48eICmTZti+fLlOH36tCwdBxE+OoNGCCFEcHR5L86i/P394e/vz70vHPaU7Nu3L/r27VuWbqnUnpC8ePEC586dg0gkgre3N6pVq6btLqmNzqARQgghRBCuXr2KYcOGISQkpMRje/fuRb169RAQEIDevXvDzs4OYWFhWuglPyhAI4QQIkgSluHlRoRj9+7d2LFjB0Si4uFLSkoKhg8fjuzsbNnqzczMTHz99dey/HBCQwEaIYQQQgQhKioKAIqlEgEKU49kZ2ejRYsWePjwIZKSkuDt7Y28vDysW7dOG10tM5qDRgghRHBYMDzOQaOzaNrGdS5camoqGIYpsZrz2LFjYBgGixYtQv369QEAa9euRatWrWQ554SGAjRCCCGCJNFAklmiGj8/PzAMgy1btsgCI3WsW7cO2dnZSsu9evUK1apVg77+f+FLdnY2rl+/DiMjI3z22Wey+1u0aAFDQ0MkJCSo3S9togCNEEIIIWo5d+4cDAwMyhScAUC/fv04ldPX18fbt2+L3XflyhWIxWK4u7vD0NCw2GOmpqbIysoqU9+0hb5+EEIIEZzCNBsML7eKlWiifNWuXbtEUKRJ9erVg1gsxpUrV2T3/fnnn2AYpsSep2KxGBkZGahVq1a59Y9PFKARQggRIAYSVsTLDTQHTW1eXl54+/YtHj58WC7tderUCSzLYty4cYiOjsYff/wh25tUuvWV1K1btyAWi1G3bt1y6RvfKEAjhBBCiFqmTJkCfX19TJ48uVyS3k6ZMgXVqlVDTEwMPDw80KdPH2RmZsLX1xceHh7FykoXDri7u2u8X5pAARohhBDBoUucuqF169bYs2cPIiMj4enpibCwMDx79kxjwVqdOnUQEREBX19fGBsbw9raGiNHjsShQ4eKlWNZFr/++itYloWvr69G+qJptEiAEEIIIWrR09OT/RwdHY2AgAClxzAMg4KCArXbbNmyJU6dOqWwjEQiQXh4OIDCoE6IKEAjhBAiSJRmQ/t0dS9PPT29ErnShIYCNEIIIYLDsgzEPAVoLG33pLaIiAhtd6HCogCNEEIIIWrx9vbWdhcqLArQCCGECJKE0mOQCowCNEIIIYLDAvxd4uSlFgIUzkl79eoV3r9/Dzs7O213R9BohiUhhBBCyiQ2Nha9e/eGhYUFateuDUdHx2KPp6enY9SoURg9ejSnPTcJnUEjhBAiSAwkvE3up0ulZfHbb79hxIgRyM/PL7VM9erV8fjxY0RERMDHxwdfffVVOfZQmOgMGiGEEELUcufOHYwcORL5+fkYP348rl69iho1asgtO2TIELAsi7///ruceylMdAaNEEKI4BTuJEBz0LRt9erVyMvLw7hx47BmzRoAxZPXFuXv7w8AiImJKa/uCRoFaIQQQgSJv0ucRF0RERFgGAbBwcFKy9ra2sLExARJSUnl0DPho0uchBBCCFFLSkoKqlatirp163IqX6VKFVokwBEFaIQQQgSHBQMJRLzcWFokoDYjIyPk5eVx2vIpNzcXb968QbVq1VRu5/79+wgMDETr1q3RokULDBw4EJGRkUqPs7Gxgb6+MC8WUoBGCCGEELU4OjoiPz8fDx48UFr2xIkTEIvFaNasmUptHDlyBK1atcK2bdtw48YNxMXFYe/evfD398egQYOQlZWl8Hhd3S9UGQrQCCGECJKYZXi5EfV9+eWXYFlWtkCgNO/evcO0adPAMAy6d+/Ouf6UlBQMGjQIubm5MDY2xpdffonevXujVq1aYFkWu3fvhoeHB54/f17GZ6J7KEAjhBAiOCxbuEiAj5tAT7DohKCgIFhYWGDLli2YPXs23rx5U+zx7OxshIaGom3btrh37x6sra0RGBjIuf4NGzbg7du3sLe3x+3bt3H06FEcPHgQSUlJWLp0KQwMDBAXFwdfX188e/aM52enXRSgEUIIIUQtNWrUwIEDB2BsbIwlS5agdu3aePnyJYDCVZsWFhbo27cv7t+/D1NTUxw8eBBVq1blXP8///wDhmHwww8/oF69erL79fX1ERwcjFOnTqFGjRq4d+9ehQvSKEAjhBAiSBJWxMuNlE3Hjh1x6dIl+Pj4ID8/H2KxGCzLIi0tDQUFBWBZFj4+Prh48SLc3d1VqvvRo0dgGAZffPGF3Mfbt2+PM2fOoHbt2rh//z58fHyQlpbGx9PSOmEubSCEEFKpsWAg5mn1Ja3iLDtnZ2eEh4cjMTER58+fR0pKCsRiMaytreHp6YkGDRqoVe/79+9hYWEBIyOjUss0adIEkZGR8PX1xf379+Hn54eIiAjUrl1b3aejEyhAI4QQQggv7O3tYW9vz1t9lpaWePnyJXJzcxUGaY0aNUJERAR8fX1llzsjIiJ464c20LldQgghgsTXIgGiu5ycnMCyLC5duqS0rDRIs7a2xv379+Hr6yvopLh0Bo0QQgghZZaWloZDhw7h6tWrsrQXtWrVQps2bdCnTx9YW1urXKd0jtmBAwfg7e2ttHyjRo0QGRkJHx8f3L9/HyzLgmGEGYTTGTRCCCGCRIsEdEN+fj6mTJkCe3t7jB8/Hjt37sTff/+Nv//+Gzt37sT48eNhb2+PyZMnIy8vT6W6u3TpAgD4/fffkZGRwekYaZBmY2Oj8nPRJXQGjRBCiOCwACS8LRIg6pJIJOjRowdOnDgBlmVhYmICV1dX1KlTBwDw9OlTxMTEIDs7G2vWrMHt27fx999/cz6r1a5dOyxatAj5+flITExEixYtOB3XqFEjnDlzBosXLxbsTgIUoBFCCCFELT/99BOOHz8OhmEwa9YsfP/99zAzMytWJjMzE6tWrcLChQtx8uRJ/Pjjjxg3bhznNmbMmKFW3+rXr49ffvlFrWN1AZ3bJYQQIkD8bPNUuNWTMOco6YJff/0VDMNg4cKFWLBgQYngDABMTU0xb948LFy4ECzLCjpoKk8UoBFCCBGcwq2e+JmDJtArYDrh3r17EIlEGD9+vNKy48ePh56eHu7fv897Py5duoSoqCje69UmusRJCCGEELUYGRnB2NgYpqamSsuamprC3NxcI/3o1asXXrx4gYKCAo3Urw10Bo0QQoggUR407WvevDnevHmDV69eKS376tUrvHnzBs7Ozhrpi1AXA5SGAjRCCCGEqGXcuHGQSCRYuHCh0rLSOWiqLBCozOgSJyGEEMGhNBu6oV+/foiNjcXKlSuRkZGB2bNnw9HRsViZ+Ph4LFy4EDt27EBwcDD69u2rpd4KCwVohBBCBIjPy5N0mVNdfn5+AABzc3Ps3LkTO3fuxCeffFIsD1pSUhIAwMLCAtHR0bJjimIYBuHh4eXXcQGgAI0QQgghaomMjCxx35MnT/DkyZMS979580ZueQBl3o6pos0/AyhAI4QQIlC0TZP2zZ07V9tdAACsW7dO0Bujy0MBGiGEEMFhAd4ucVa8cy/lR1cCtH79+mm7C7yjrx+EEEII0arVq1djwYIF2u6GTqEzaIQQQgSJr1WcRPtWrlyJ58+fY86cOZyPEYvFePjwIdLT05Gfn6+wrJeXV1m7WO4oQCOEEEKIYCQnJ2PGjBkIDQ3lNO+MYRhB7jBAARohhBDBYXncBYCl3QQE499//4WnpyeeP3/OeeWmUFd40hw0QgghgkRbPVU+M2bMwLNnz1CjRg1s27YNycnJyM/Ph0QiUXgTIjqDRgghhBBBOHXqFBiGwd69e+Hr66vt7mgUBWiEEEIEic5+VT45OTkwMTGp8MEZQJc4CSGECJA0DxofN2HOUKqcHBwcBDunTFUUoBG1+Pj4gGEYzJs3T9td0YihQ4eCYRgMHTpU210hhBDyQf/+/ZGTk1Mp9u2kAI2QCkAaMPv4+JR4LDIyEgzDlLjp6+vDysoKHh4eWLBgAV6+fKmRvuXl5WH16tVwc3ODhYUFTE1N4ezsjLlz5+Ldu3elHvf+/Xv8/fffWLRoEXr37g17e3tZ31X9YpCWlobZs2fD1dUVlpaWMDExgb29PT7//HMsW7ZMaQ4lopskYHi5EeGYPHkyWrZsicDAQMTHx2u7OxpFc9AIqUSqV68OQ0NDAEBubi5ev36Nixcv4uLFi9iwYQOOHz8OFxcX3tpLT0+Hv78/rl27BgAwMjKCnp4e4uLiEBcXhx07duDMmTOwt7cvcezly5fx5ZdflrkP+/btQ2BgIN6+fQsAMDY2hqGhoWxD5xMnTmD06NGoVq1amdsihGiWiYkJTp06hZEjR8LZ2RkBAQFwc3ODmZmZwuMGDx5cTj3kDwVohFQioaGhxc6yZWRk4JdffsG0adPw4sUL9O3bF/fu3YOBgQEv7Q0cOBDXrl2Dubk5tm7dioCAAIhEIpw8eRJDhgxBYmIiunXrhmvXrkFPT6/E8dWrV4eLi4vsNnHiRKSlpXFu/8CBA/j6668hkUgQGBiICRMmoGnTpgCAd+/e4fr16wgLC+Pt+ZLyw4LHPGh0Fk1QEhIS8OzZM7x//x6//fYbfvvtN4XlGYahAI0QIiwWFhaYOHEiMjMzMWfOHPz777+IiIjAZ599Vua6w8PD8ffffwMANm/eXGwz406dOuHQoUPw8PDArVu3sH37dgwfPrzY8R06dMDr16+L3Tdt2jTO7aempmLUqFGQSCQICQnBpEmTij1uZmaGDh06oEOHDqo+NaILWB5XcVaOOec6jevE/5s3b8LHxwdZWVkAAENDQ9SoUQP6+hUvnKE5aKTM8vLysGzZMrRo0QJVq1ZF9erV0alTJ9mHszxpaWlYv349evToAScnJ1hYWMDExAQNGjTAiBEjcPv27VKP/XgC/8GDB+Hj4wNLS0tUqVIFrVq1wtq1a5UmJ/z999/h6ekJMzMzWFhY4NNPP8WWLVsqzQqhoj7//HPZz4rGXhU7duwAADg6OqJ///4lHnd3d5edzdu5c2eJx+WdUVPFunXrkJ6ejtatW2PixIllqosQolnff/89p304586di8zMTDg4OCA8PBxZWVlISkpCfHy8wpsQVbyQk5SrvLw8dOzYEWfPnoW+vj5MTU3x5s0bnDp1CqdOncLcuXPlTuieNm2a7ANcX18f5ubmeP/+PR4/fozHjx9j165d+P3339GnTx+F7X/77bfYuHEjRCIRzM3NkZ2djRs3biAoKAixsbGyNopiWRbDhw/Hr7/+CqDw9He1atVw9epVXL58GRERETAyMir74AhI0aBULBbzUufJkycBFAZ/DCP/TMcXX3yByMhInDt3DtnZ2TAxMeGlbeC/oO+bb74ptX0ibJQHTbdIJBLExMQgMTER79+/V+my4uTJkzmVu3DhAhiGwb59++Dq6qpuVwWBzqCRMvnxxx9x+fJlbNq0Ce/evUN6ejqePHmCgIAAAMD8+fPx559/ljiuQYMGWLlyJW7duoXs7Gy8evUKubm5iIuLw8CBA5Gbm4shQ4YgJSWl1Lb//PNPbN26FatXr0Z6ejrS09Px8uVLjBgxAkDhB/Tp06dLHLd+/XpZcPbtt9/i+fPneP36NV6/fo158+Zh3759OHz4MB/DIxjHjx+X/ezo6Fjm+l69eiWbK9a8efNSy0kfk0gkuHv3bpnblYqPj5e9dlxdXXHr1i18/fXXsLGxgZGREerWrYv+/fvj/PnzvLVJSGW2fv162NjYoF27dujfvz/+97//FXs8PT0dzZs3R5MmTfDs2TO123n//j2qVq1a4YMzgAI0UkYZGRn48ccfMWrUKBgbGwMAPvnkE+zbtw9eXl4ACvdO+9isWbMwZcoUNG/eXDZ3QCQSoVmzZti1axe6dOmCrKws/PLLL6W2nZ6ejs2bN2PixIkwNzcHAFhZWWHr1q2yP949e/YUOyYnJwfz588HAAwaNAjr169HjRo1ABTOx5o7dy6Cg4Px5s0btcdk3rx5ctNacL0lJCSo3baqMjIysGbNGixevBgAULt2bV5WThYNrOvUqVNquaKPKQrGVfXgwQPZz+fPn0ebNm2wZ88eZGRkwNjYGE+fPsX+/fvRoUMHLFy4kLd2SfmhRLW6Y9y4cQgKCsKLFy9gZmYm94y1dMHPw4cPceDAAbXbatCgAfLz83k706/LKEAjZfLJJ5+U+KYEFAZbs2bNAlA4p+nWrVsq1dulSxcAwLlz5xS2PWTIELmPde/eHUDhhNKi/vnnH9nE89LmO0ybNk0WbKrD1NQUtWvXVvtW1rlXivTu3RvW1tawtrZG9erVUa1aNUycOBF5eXkwMzPDvn37yvTcpYrmN6tSpUqp5Yo+pignmqrS09NlP8+ePRu2trY4efIkMjMzkZGRgdu3b8PHxwcsy2LOnDkIDQ3lrW1SfliW4eVG1Hf8+HH89NNPMDU1RVhYGN68eYOaNWvKLfv111+DZVmcOnVK7fYGDx6M3NxcuVdmKhqag0bKRJogVZ4OHTpAX18fBQUFuHr1KpydnYs9fuPGDWzevBnnzp1DQkICMjMzS0zQT05OLrVtNze3Utu2tbUFgBKrAK9evQqgMLhr0KCB3GMtLCzg6uqq9uWvKVOmYMqUKWodq2lFA5eiWrVqhb/++gs2Njbl3CPNKLpAhGVZHDp0qFh+t6ZNm+LIkSNo2LAh0tLSMH/+fPTu3VsbXSVE0DZt2gSGYbBgwQL06NFDYVl3d3cAUPkLe1Hjx4/HsWPHMGrUKFhbW8vqrIgoQCNloujylbGxMaysrPDs2TM8f/682GMbNmzAhAkTZB+kDMPAwsJCNjk/Ozsbb9++lS2llkdRYkLpZdOPM8RL+6Go3wBQt25dhY8LVUREhGzlpDRJ7dSpU3H9+nWMGTMGhw4d4uUMXtHfzfv370stV/QxZYkm1W3f399fbvJdU1NTjBs3DrNnz8bNmzfx7Nkz1K5dm7c+EE3jcxcAOoumrujoaADAsGHDlJa1sLCAubm5SrkMP7Z48WK4u7sjNjYW7du3R/v27dG2bVul7x9cVojqGgrQSLm7e/cugoKCIJFI0LdvX3z//fdo2bKlLMM9AGzbtg0jRoyolCkvyoulpSW6dOkCNzc3tGjRAocPH8bChQt52V9VegYTAJ4+fVpquaKPFT2mrIoG4E5OTqWWkyatBYDExEQK0AREOgeNr7qIel6/fg0LCwvOX7BEIpHSFEiKSOf4AoVnx8+ePatwKowUBWik0lH04Zubm4tXr14BAGrVqiW7/+DBgxCLxXBycsLevXshEpWcClmWb1iKSPuhqN9cHldk1apVWLVqldrHX7lyBZ988onax6uqVq1aWLp0KYYNG4Zly5Zh6NChqFevXpnqtLKygrW1NdLS0hAXF1dqOeljIpFIYSClqqZNm0JPT0/pROKiXwAoFQchqjM3N0d6ejry8/OV7sjx+vVrZGRklOnLmJeXV6X5W6UAjZTJmTNnwLKs3D+Ys2fPoqCgAADQpk0b2f1JSUkAgJYtW8oNzgCUaRKpItJ+JCUl4fHjx6hfv36JMm/fvkVMTIzabWRmZpZpGbk2VicNHjwYixcvxuPHjzFnzhy5iWNV1alTJ/z22284ceJEqa8RaXqP9u3b85oDzdjYGF5eXoiIiFCYvuPOnTsACoOzsgalpJyx4G+CP51CU5uzszPOnDmD6OhotG/fXmHZPXv2gGXZYp8HqoqMjFT7WKGhVZykTJ48eSI3GaxEIsGSJUsAFJ7NKLpAwMLCAkDhRFF5lzD//vtvjf0RdurUCdWrVweAUtMrrFixAtnZ2Wq3MW/ePLAsq/ZNG4GCnp4egoODAQC7d+/GvXv3ylyndIXt48eP5S6rj46ORkREBADNbGQsXV0cHh6O2NjYEo9nZmbixx9/BAB8+umnpa48I4SULiAgACzLYt68eQovXd64cQOzZs0CwzAYMGBAOfZQuChAI2ViYWGBMWPGYOvWrcjJyQFQeHZqwIABsg/fRYsWFTtGuq3Q7du3MW7cONlKy6ysLGzevBkBAQGwsrLSSH9NTEwwe/ZsAIVbEQUFBckuw759+xYLFy7EkiVLUK1aNY20r8uGDBmCOnXqQCwW8zIPzd/fH1988QUAIDAwEAcOHJC9gYeHh8tWTTo7O8u27fqYNPmw9CY9/v3798Xuz8zMLHHswIED0bZtW7Asiz59+iA8PFx2/N27d9G9e3ekpaVBJBLJ8sARYeErDxpR38iRI9G0aVNERESgU6dOOHr0qOwqwMOHD3Hy5EmMHz8eHh4eyMjIQLt27dC3b18t91oYKEAjZTJ27Fi0adMGgYGBMDc3h6WlJezs7LB//34AhQlpe/XqVewYf39/fPXVVwCAn376CVZWVqhevTosLCwwevRoODk58RIglGbChAkYNGgQAGDt2rWoVasWLC0tYWlpiTlz5qB///5Kl4tXRIaGhrL0IPv37y/TUnip33//Ha1bt0ZGRgb69euHqlWromrVqujYsSNSUlJgb2+PI0eOlLpytHXr1qhZs6bsJr08vnLlymL3f/vttyWOFYlEOHz4MJo2bYqEhAR07NgRZmZmqFatmuwDxcDAAJs2bYKfn1+ZnyspXyz4y4NGVzjVZ2BggGPHjqFRo0aIiIhAjx49ZF96mzRpgs8//xwbN25EdnY2nJ2dcejQoUozh6ysKEAjZWJoaIjw8HAsWbIEjRs3Rm5uLiwsLODv749jx46Vehnx999/x5o1a9CiRQsYGRlBLBbD2dkZS5cuxfnz52FqaqqxPotEIuzcuRM7d+5Eu3btYGJigoKCAri4uGDTpk3YvXu3xtrWdYGBgahRowZYlsXcuXPLXF/16tVx6dIlrFq1Cq6urjAwMADDMGjevDnmzJmDmzdvwt7enoeey2dtbY3Y2FisWrUKbm5uMDAwQHZ2NurVq4dhw4YhNjYWI0eO1Fj7hFQG9vb2iImJwfz582FnZ1di2oatrS3mzZuHCxcuwNraWtvdFQyGpTwGhBBCBMLV1RWxsbGo0sAazdaX3MVEHbe/+xXvH6XBxcWlTAuE5ImIiEBISAiio6ORmZkJe3t79O3bF9OmTUPVqlXVqvPQoUPYsGEDrl+/jry8PDRs2BDffPMNJkyYIHcl5d27d7Fr1y5cvnwZjx8/xosXL5CXlwcbGxt4enri22+/5TXha0pKClJSUiAWi2Ftba3RL2EVGQVohBBCBKNogNZ0HT8B2p3xmgnQ1q9fjwkTJoBlWdStWxc1a9bEnTt3kJubCycnJ5w7dw6WlpYq1TllyhSEhIQAAOrXr4+qVavi9u3bEIvF8PLywj///CNL+C21Zs0aTJw4EQzDoFatWrC1tUV2djYSEhKQk5MDhmGwePFiTJ8+nbfnTsqOLnESQgghPIuJiUFQUBAAYPPmzXjy5AliY2Px77//wtXVFXfv3lX58npYWBhCQkJgZGSEw4cP49GjR7hx4wbi4uLg4OCAqKgozJgxo8Rxbm5u2LNnD54/f460tDTExsbi7t27SEtLw3fffQeWZTFz5kxcvnyZj6dOeEIBGiGEEMFhAUg+bPdU1psmLiMtXLgQEokEgwYNQmBgoGxivK2tLfbs2QORSITQ0FDcvHmTc53z588HAAQHB6N79+6y+5s0aYKff/4ZALBx40a8ePGi2HGenp746quvUKNGjWL3W1hYYO3atWjWrJlsz1pVXbp0CS4uLhg3bpzSsiNGjICLi4tsT2SiGAVohJBSTZgwAdbW1ird9u3bp+1uE6JVmZmZsiTMgYGBJR5v2LChbOWwvByB8jx8+BA3btwotU4/Pz80aNAAubm5+PPPPzn3lWEYNG7cGIDifXNLs3v3bty4cQMdOnRQWrZdu3a4fv16pV6IpQoK0AghpcrIyMCzZ89UupUlyS8hnLH8pdng+xTatWvXkJubCyMjI7Rt21ZuGWlAc+nSJU51Sss5OjoW22u2LHUCQE5OjmzenToZ/s+cOQMA+Oyzz5SWlaZckubI5EKdoLGioK2eCCGl2r59O7Zv367tbhAil64mmX3w4AEAwM7OrtT9KaXbzN2/f1+lOuVtT6dOnRkZGYiLi8P8+fORmJgIDw8PDBw4kFNfikpOToaFhQWnxQ5WVlawsLBQaa9jS0tLtG3bFj4+PvD19YWHh0eJRRAVFQVohBBCCArTUbi6unIuHxgYiFGjRpW4X7o7iqKgRfpYeno6p7b4qPPNmzeyre6kqlevjsWLF2PSpEnQ11c9JMjOzoahoSHn8izL4t27d5zL5+Xl4fz58zh//jwWL14MQ0NDtGvXDr6+vvD19UW7du2UbtIuVBU6QBs4cCAvewoSQghRT5MmTfD7779rpG6+k0RlZ2fL3be1NKmpqXLvl257pyhwkZ4F4jolgI869fX14enpCQB48eIFEhMTkZ6ejn379sHT0xPe3t6c+lJUrVq1kJSUhJSUFNja2ios+/TpU7x9+7bUS7TyLFmyBJGRkTh//jyysrKQm5uLM2fOICoqCvPnz4exsTE8PDzg5+cHX19fuLm5lbozidBU6ADt3r17Kv2xEUIIEQbpVk981QUU7tXr5OTE+TgbGxu59xsbGwMoPPtTmtzcXFmbXPBRp6mpKc6dOyf799u3b7FixQosWbIEnTp1wpkzZ1ROWNuuXTskJSVh48aNSve03bhxIwDg008/5Vz/tGnTMG3aNBQUFODKlSuIjIyUBWzv379HdnY2wsPDcfr0aQBA1apV0b59e9kZNldXV8FuLVWhAzQpEfRQFWba7gYn7Ie3CgbCfEFpGh/j09DFka/u6CTpRsUV5Vsk32h8lONjjO7evSu4BSNOTk68JKqVXkaUXpaUR/rYx5ccy7NOc3NzLFq0CC9fvsTmzZsxZ84cnDx5ktOxUsOHD8f+/fuxYsUK2Nvby11hChTmgluxYgUYhsHw4cNVagMoPPvn7u4Od3d3TJ8+HQUFBbh8+TIiIiIQGRmJCxcuIDs7W7aC9sSJE7Ln6OXlhcOHD6vcprZVigCtKszwKdNR293gpIDNBwDoMxXzmnpZ8TI+13jqjIY9XtOOU7n6QcVXbJV1jE5KuC37F6q3b98CKHzjJvLxMUbSjP+aw/B2Bg08fyFu1KgRAODJkyfIz8+XO0fq8ePHxcpyrfPRo0elllG1TqmuXbti8+bNagWnnTp1QkBAAA4ePIgxY8Zg48aN6Nq1q2x7p8TERBw5cgS3b98Gy7Lo06cPvvjiC5Xb+Zi+vj48PDzg4eGBmTNnIj8/H9HR0YiMjERERAQuXbqE7OxsZGRk4OjRo2VuTxsqRYAmJHTmTDEaH+XKOkadRH156oluErMFAAA9hvvbX0UPWj9GZxfLpnXr1jA0NERubi4uX74sm/dV1NmzZwGA8yXFdu0Kv7DFx8fj6dOncudxqVqnVEFBQbH/q2rHjh1gGAYHDhzArVu3EBcXV+xx6Y6SX331FbZt26ZWG8oYGBigffv2sLW1hbW1NSwtLfHHH3/IzgYLEQVoZcT1LAdQ8kyHPKxGclpXHDQ+ytEYKabO+HANWrm8H3B5H9CGokGoID7UWB7TbPD8J2NmZobOnTvjyJEj2LJlS4kA7eHDh7I5UwEBAZzqbNSoEZydnXHr1i1s2bJFtquA1OnTp/Ho0SMYGhoW22WAC+kOAq1bt1bpOCkTExPs27cPo0aNwi+//IILFy4gLS0NDMPA2toaHh4eGD58OHx8fNSqX5H4+HjZvLTIyEgkJycD+C8otLGxUWvxgy6gAI1USqoE1lzp6gcvIaoSyqRqvldx8mn27Nk4evQofvvtN3h6emLkyJFgGAapqakYMGAAJBIJevbsiZYtWxY7rl69egCAVatWlQje5s6di4CAACxfvhxt2rRBt27dABTmPRsxYgQAYOzYsahZs2ax4wIDA/HNN9/A09Oz2NnR169fY8mSJdi1axcAyPYOVZefn59shwRNSUxMlF3GjIyMRFJSEoD/ArJPPvkE3t7esluDBg002h9NogBN5wjjjVF7Ks/4qB/wVZ4xUg+NjzJCCdB0mZubG1avXo1JkyZh1KhRWLRoEWrUqIE7d+4gNzcXjRs3xtatW0scl5iYCKBwu6iP9enTB0FBQVizZg26d++O+vXrw9TUFHFxcRCLxWjfvj2WLl1a4rj9+/dj69atMDExQYMGDVC1alW8efMGDx8+hFgshp6eHhYvXizL9K9Lnjx5UuwMmXR8pAGZg4NDsYBMGuBWBJUiQGvo4qixieH8nzXR4a+EOoHGRzkaI8U0Nz4V5SyqRCLRdheU0kSaDb4FBQXB2dkZISEhiI6OxvPnz2Fvb4+AgABMnz4dpqamKtf5ww8/wMPDAxs3bsT169eRkpKCpk2b4ptvvsHEiRPlLkj4+eefcfLkSVy6dAmpqalIT09HlSpV0KxZM3h5eWHUqFFo3rw5H0+Zd/Xq1ZN9YWBZFg0bNiwWkNWtW1djbUdFRWmkXmmyXWUqRYAmLOq/4fA9H04366Vv9srRGClG4yNPJ1Ff2Tw0kYi2aeaLv78//P39OZdnOVy37du3L/r25b6YJyAggPNct7K4ePEibt68idevXyM/P19h2Tlz5qhUt7W1NaZOnYoBAwagVq1aZekmZz4+Pho5m2xtbc1puysK0HQOnf1QjJ/xqR90SWOBp/bRa0gxGh9luAQJuoC/NBukLE6dOoXAwEDZ5UcuuAZotWvXxrNnz5CamopJkyZh0qRJaNy4sewMmo+PD6ytrdXtulKa+FvgWicFaIRUENKAU/JhSxjRh8zjHxNWsEm0QTABmrY7QHD58mV07dpVtsOBg4MDbG1t1drXU57U1FTcu3dPNgftzJkzuHfvHu7du4ctW7YAABo0aAAfHx9ZwKZsyylVWFtbIyUlhbf6VDk7rfII1qtXD0ZGRrKtJKZPn47+/fsXK3P69GlMmzYNmZmZYBgGXbp0wbJlyyASiZCQkID69evD2dlZVv7QoUOoX78+AGDBggUICwtDQEAAZs6cCQAYOnQodu/ejXv37sHRsTAL/JQpU2Bqaop58+Zx6vdJyQFB5HcqSw4rVc8KCRHlQeOAJngrJKTXkLbSdlAeNMLVwoULkZeXhyZNmmD//v0amcvWpEkTNGnSBKNHjwaAYgFbZGQkHj58iIcPH+Lnn38GADg6OhYL2DQ5T02T1Apx9+3bh1atWpX6ePXq1bF37144OjoiJycHHTt2xM6dOzF06FAAhTlirl+/XuK4Bw8e4ObNm4iNjUWfPn3w8OFDNGzYEABQp04dzJw5E3v27FGny4JRXjmsHq9px/mNXZXAT9V6VfF4TTulZ4dUqbfCBrQCOfuhLZU1TxyX17rjuhD8O36yMPKggS5x6oKLFy+CYRj89ttv5bbQ4OOA7e7du7LUG2fOnMHjx4/x+PFj/PLLLwAKz+op2oGhNObm5rCwsOC176rUqZFLnEWT3RkbG6NVq1ZISEhQehzLsrIJeSKRqNhp9sDAQPz000+IjY2Fi4sL730mAsFz8ME1mBPCfDVpu1y2elJ3GylSOQjiEicL/q5xCuDp6qr379+jSpUqcHV11VofnJyc4OTkhDFjxgAAbt26hZUrV2LPnj0Qi8WIj49Xq943b97w2EvV61QrQBs8eDBYlkXbtm2xbNmyEknxikpLS8PBgweL7YWVlZUFNzc3iMVi9OzZEzNnzoSenh4aN26Mpk2bonXr1ujdu3ex/cRMTEwwd+5cBAcHq7yZq5QQLnMK6fKLVtClF6V0+TXEZ2Cobl26PD66Ql6qBkLksbe3x5MnT7TaB4lEgpiYGFny2nPnziErK0urfeKDygFaVFQU7OzskJ+fj1mzZmHIkCH466+/5JZ9+/YtunXrhqlTp6JNmzYACrddePr0KWrVqoXXr1+jf//+CAkJwdSpUwEA8+fPL7GFhdTQoUMREhKicoAmFouRlZUFsVj84ewCg8KvTNL/F75psx/9HL/crXA+j/TbJMMAEgkgEhW/78PPjsFXS9TxoRCn9gBAjAKwYIt9gy2trLw27CecU9qG9OcCFfpmP+Es5+dUoLCfqj8n6f8lOTmQ5OUV/g4kkpK/mw8/F7AFnMeb63OSZGcXBofS/FBF25Y9qcL7Cth8tdpQt28f/1z8NST/OElOTmH/lTwnMVvAa98kubmc/p64jGGJulhW7nOSnlGUPaci46PN3xOX4+wnnFVyHBT+vRX9+b/3BsV9851wFrtTfoJYLIZYLAbDMLJkpixbOG56enqyy6DyfmYYphxyqenuZumVSZ8+fbB06VJERUXBy8urXNpkWRYxMTGyy5rnz5/Hu3fvZI9JGRsbw8PDA76+vuXSL76pHKDZ2dkBKPyGFRQUVOwsV1Hv3r3D559/jh49emDSpEmy+42MjGQ5TCwtLTFs2DDs3r1bFqApoqenhyVLlmDatGka2dOL8OfflW05BTNAYWDLhUPwFdmHqz4MlHzY8cth2lWVgk5CCKkMpk2bhn379mHcuHGIjIyElZUV722wLItr164VO0P29u3bYo8D/yWA9fX1ha+vL9q1awdDQ0Pe+1NeVArQsrKykJ+fj2rVqgEA9uzZI3dz1czMTHz++ef4/PPPMWvWrGKPPX/+HNWrV4eBgQFyc3MRGhqq0gatPXv2xIoVKxAaGoohQ4ZwOkZPTw9Vq1YFoHhezscUTUSX2w5T9il9zIdvhHzUpU0iFf4oVHmuQhkfvud4qTIHTpKbCwAQGRmVWobrQu+Ete05t8vluTQMvsatMg5/p4qeX1Ef/80L5TWkTebm5gAge99Uh6aT3RbuJMBfXUQ9sbGxWLhwIcaNG4dmzZohMDAQn376KczMzBQex/VsW/fu3XHu3DlkZGTI7pMGZAYGBmjbti18fHzg6+sLDw8PGKv4ua1JeXl52Lt3L4DCqWGqUukd6tmzZ+jTpw/EYjFYloWjoyN27twJABgxYgS6d++O7t27Y+3atbh8+TKysrIQGhoKoDDz8cyZM3Hu3DnMmTMHenp6KCgogJ+fnyydBlfLly9X+1SqKvPQtDFBms7AKEbjw4EQJnhzwGeKiaJ1KVoJXN5/87q6WINWcRKuPs62v3jxYqXHMAyDgoICTvUXnb+ur68PV1dX2RkyT09PVKlSRfVOl5N3795h6NChEIlEmg/QHB0dce2a/G/A0vwjADBz5sxSg67evXujd+/eqjSL7du3F/t3hw4dhLHKiGe6teUSf+2r0gdJTg4cgq+oVDchRDW0WTpRhaqfx6qUd3FxgZ+fH3x9fdGhQwe19i/VNnXjFTrHTwj4P5PB9xkPVep7uKwVr20TorPoDJrWaXoxyNWr3OYoV0QUoBFSwUjPMKoy31KouCZGrrBJiTVEEFcoWB6v5gvg6RLtiIqKUvvYovPm1FEpAzRN50MryweBsgnelT5xKMOA8lgpRuMjn/RvR8wWzn3RhUUCuvr3TFs9EaHIzs7GmzdvkJ+fr7CcNAOFqj6eY1eetP8ORYrTwjdXXfiQ4HyGg2U1slCgIp1hoYUUitH4KNfVdCAOZ+zUdjeUo19lpZSZmYkVK1Zg7969ePz4sdLyqixKKI02zipTgEbIB7oQqPIlfrmbymliFKlIY0MI0Yzk5GRcuHABycnJyMrKUhjUzJkzR602nj9/Di8vLzx8+JBz0FSW4MrS0hLp6en4+eef4e/vr9Kxr1+/LtMWWJU2QNPZbZ80nDtI8EQiuoSnBAOmQryOuJ7V5DoPTUrZ60dXU1+UJwYM9PV1/+OB0mzohpcvX2L06NH4448/lAZD0j231Q3QZs6ciQcPHqBKlSqYPHkyOnfujNq1a2vs9eri4oLw8HCkpqbC3t5epWPLuuJU9/8CBagsb9xcNrqu1MRiukSlBAsWEEgeK23QxdcPnznf+MCCRZeqXyOC/aPc2lSL7v0qK52srCz4+Pjg7t27MDQ0RMuWLXH58mUYGhqibdu2SEtLw6NHjwAUno1ydnYuU3tHjx4FwzDYvn07AgIC+HgKCrm6uuLUqVOIiYnReFsfE/7XbFJhcPoAYpjCPVKJYpTHihBSDjZu3Ig7d+6gcePG+Pfff3HpUuH7uKWlJaKiovDgwQPEx8ejX79+ePPmDT7//HNERESo3V5GRgYMDQ3Rq1cvvp6CQi4uLgAKd0wob3QGTcfQ5TslKPBQigEDx+CrWlulyOclQk0s3qC/MeWEMkZ0iVP7wsLCwDAMli5dChsbG7ll7O3tsXfvXnz99deYMWMG2rRpo/J8LqlPPvkEKSkp5bbS2MvLC3PnzgXDMLLLs1xZWloiPj5e7ba1FqDVq1cPRkZGMDExAQBMnz4d/fv3x9GjRzF37lw0atQIv/76K4yNjbF9+3b873//w86dOzFo0CAAhac5V61ahcjISLX7oIvz0HTx8otOEUJ+Ji2raK8hvi/tKRsfvtsT4pw2QbyGWPB3iVMAT1dX3bt3DwDw+eefF7tfXtqLxYsXY+/evVi/fr3aAVrPnj2xatUqXLlyBW5umr+aUrt2bcydO1etYxmGUXneWlFaPYO2b98+tGrVqth9ixYtQlRUFLZu3Ypdu3ZhxIgRAAoj8Dlz5qB///6C3p2+suJrOynpHD0um2kTQsqmk6gvTkoOaLsbRIfl5OSgevXqMCqSu9PY2BiZmZklyjo4OMDCwgKXL19Wu72pU6fiwIEDGD16NMLDw1GtWjW169J1OnmJk2EY6OnpFdtColWrVtDT08PGjRsxceJELfZO0+iUvWL/jY8m9hAVSp2K0WtIMRof5YQwRgz466cQnq9uql27Nl69elXsvpo1ayI5ORnJycmoW7eu7H6xWIysrCy8f/9e7fasrKxw6tQpfP3112jatClGjRqFNm3awMzMTOFxXl5earepLVoN0AYPHgyWZdG2bVssW7YMNWvWxPTp09G+fXs0bNgQO3bsKFZ+yZIl8Pb2xvDhw7XU4/JA59oVo/FR7r8x4vvymhAv15VEryHlaIwIN3Z2dkhKSsLz589Rq1YtAIUnVJKTkxEWFobvvvtOVvbPP/9EQUEB6tSpU6Y29fX1Ua9ePVy+fBkLFixQWp6PRLXKrF69GpmZmWqnD5FHawFaVFQU7OzskJ+fj1mzZmHIkCH466+/0KNHD/To0UPuMY0bN0b37t2xfPlyuLu7c25LGrWLxWIwDAOGYSCRSCASiRCa8Qu6mw8CA0Y276K0nwu/ZbFF/l96WXWPE+NDGoki74+60reyHCfJySn+S2GY/+aTiUSFaSEYBmCY/y5jymmj6PhIcnP/q6NofQwDSCSF9X64T8wWcHpOkpycknWxHzb909MrrPfD/f/1U/HvSW4/5bWhoJ/qvoZkbSt5TgVs/kftyX9Okuxs2e9J0XPiOt7l+5pFifEpaxvxy92Uvvag6HVa5OfC15N6z0mT70OZmZkQi8XQ09MDy7JgWRZ6enoQf0jlIu9n6XusxlEcqXXu7u44f/48zp49iz59+gAA+vfvjyNHjmD69OnIyclBq1atcOPGDSxatAgMw+CLL75Qu72EhAS0b98eqampALgloS2PXQBWrlyJ58+fV4wATbovloGBAYKCgtCoUSNOx82bNw8tW7ZEvXr1NNg7beJz5ut//l3hxjmYcQy+yrneeHn1yglmwLKyTbwBZR8oivw3Po5Tr3D+IOJ6CcMh+AriV7TlVFZ3aeY1VHHQ+CgnkDESQBcrut69e2PlypX47bffZAHagAED8PPPPyMyMhLTpk2TlWVZFtbW1pg3b57a7c2ZMwcpKSmoWbMmli1bJktUWxH3j9VKgJaVlYX8/HzZ5L49e/agdevWnI61tbXFiBEjsGTJEs6rI/T09FC1atVSH9eppLAf3nD47lNpm6/Lo0p6BlXq5eU5aWh8imoYfI1bQcaA0yU/EVS4hLi2Pbe2FdVZZIwaBl/j1MfEtR049bHh9BvcOqcDG5GXisfXEJ/baenq+5C62dBFFWA3C6Lcp59+WuJsKcMwOHbsGBYtWoR9+/YhKSkJFhYW+Pzzz7Fo0SLY2tqq3V54eDgYhsHu3bvVXgkqFFp5F3327Bn69OkDsVgMlmXh6OiInTu5b8w7bdo0bNmyhbf+6FK6DaHkH9IWGh/laIwU43N8VJlrpyxQVnXLKk0SzGuI8qDpLBMTEyxevBiLFy/mtd43b97AxMQEfn5+vNari7QSoDk6OuLaNY5nKQAMHToUQ4cOlf3bwsKixKqRikJT+Yc09cZf3h8ogsjPpGU0RorR+ChXdIx0NdUGC/7SItIrQjjs7e2RmJioUsJYodLh6xCkotFUuomKkRrjv7r4zpxPCCEVRb9+/bBw4UKcPn1ap86iaWIhAgVoOkYwlxa0pDKMT1mDU0luLoDi8wM1EZhywWe7fAXCleE1VFaCGCM+1zHQKTROnjx5AqBwcZ90WyfpfaqSLhRUVXBwMEJDQzFy5EicOnUKDg4OatXDt6tXr8pWM/OFArQPND0PjesHnyQnp9hqR1IcXZ7igLbDUkgTr6HyDDC5tleWNunvjMgjDYaaNGmC27dvF7tPFWXJS3bgwAGMGDEC8+bNg7OzM/r06YO2bdsqTVQ7ePBgtdrjqmhCXr5QgKaD4pe7cV4dpiuTirlQ5fKdKhOm6bIgIZqlq/PQaJFA+ZJexit6OU+dS3tluRw4dOhQ2fwzlmWxa9cu7Nq1S+ExDMNoPEDTBArQdE0lmPhYFuV16UUoQZ+8IFbMFn4zVSVdStH6hPC8y0IQl++0TAhjxABgeDrRp/vPVjfEx8cDKLzE+fF95cXOzk4nFgi8f/8eV65cQUpKCl68eIGcnBxYWVmhZs2acHJyQsOGDcvcBgVouoYuTylEl16UK68x0sb8Mj6CR+muFiJjY97OQFe0wJb+zog88nKPcs1HypeEhIRyba+o5ORkbNu2DcePH0dsbKzCy7S1a9eGt7c3Bg4ciC5duqgVVFKAVoQm56Fx/SCQbh+kU0krCSFKled0A74Dwo/rKhrESjmuC8G/4yfz1iYvKI4k5eDcuXNYsWIF/v77b0gkkmKXaEUiESwsLGBiYoLXr18j58PfTlpaGvbt24f9+/ejTp06GDVqFCZMmKBS4mcK0HSO9k/dalLZ56HJHx+u9ar6oSakOX7/qdivoTLTgcsjOo/GiBA8fPgQU6dOxZ9//inbg7Zjx47w8vLCp59+itatW8PS0rLY2bGcnBzEx8cjOjoa0dHROHbsGJKTkzFnzhysX78e8+fPx8iRIznttEEBms6hr4SKVZ7xUX+lXtnGSJhBqQrKYxNvoRPKGNEigXIVFRXFW11eXl681aUpzZo1Q0FBAZo2bYqRI0diwIABqFWrlsJjjI2N4eTkBCcnJwwdOhQsy+LMmTPYuXMndu/ejbFjx+L169eYPn260vYpQPuI9rd9ojccxWh8lNOtMeI7kW9ZFXxYRKHP6Gs8XYUmaXTemxD20aQ8aOXOx8eHlwn6XNNsrFu3DlWrVsXw4cPL3KY6dTZq1AizZ89Gv3791H7eDMPAx8cHPj4+WLBgAZYsWcJ5n1q1A7Rff/0Vw4YNQ1hYGHr27FnssRMnTiA4OFj27+fPn8Pa2hqxsbGyDjdv3ly2+/z69evRoUMHAMDWrVvx448/wtPTE+vXrwfDMJg3bx7mz5+PqKgoWbkNGzbg6tWr2L59u7pPgRd8v0HKm/vBhS5+gJSmbB8s9E6qHI2RYpVnfLimq/m4TKlzYcfz1jUiUHxkzOdaR1BQEGxsbHgN0FSp89atW7yuGK1bty5+/PFHzs9frQAtISEBW7duRbt28j9kO3fujM6dO8v+3bVrV/j6+hYrc/bsWVSrVq3YfVlZWdi5cyeuXLmCKVOmIDw8HB07dgQA1KtXD8HBwbhw4YI6XSY6RhMBpSqBnyrtn0i5walcZ9uWnOvkoqKtDCSEd5Un1tYJklIufR85cgRDhgyBlZUVpk6dCj8/P1ni1qdPnyI8PByrVq3Cy5cvsWPHDnTt2pVzm5rYQolrnZpK58G1XpUDNIlEghEjRmD9+vWYPFn5ip6UlBSEh4fjl19+UVqWZVlZx/X09Iq9GLp3744LFy4gLCwMvXr1UrXbwkGTcxUSQn4mPqkTyPIxRkK+9KdMZXsNqUMwY0QBmtbFxsaiX79++PTTT/H333/DxMSk2OOOjo5wdHTEoEGD8Pnnn6Nv3764ePEiWrVqxan+zMxMLFiwQAM9130qB2irV6+Gp6cnXF1dOZXfvn07vvzyyxIT6/z9/VFQUAB/f38sXLgQVatWhampKb7++mu4ubnB3d0dnTp1kpVnGAbLli3Dt99+i+7du6vabZWoMg9N1bMcyj7QPr60QGdQiqP8TMrRGBUq7W/n42kEQgwypbi8/3C9zFm0HnWnWpDKZ9myZcjLy8OmTZtKBGdFGRsb46effkKzZs2wbNky7N27l1P9WVlZmD9/Pl/dFRSVArS4uDgcOnSI80oOlmXxyy+/YN26dcXuT0xMhJ2dHbKysjB69Gh8//33+PHHHwEAo0ePxujRo+XW5+/vj08++YTT2biixGIxsrKyIBaLwTAMGIaBRCKBSCQCy7Ky5bPSjU719PRkgRIDpsgHHoPCr2zS/xc+Ln0zA8P8l2hW3s8MI7feoj+LUVD484dD7SecLbVs0Z8LSulbacf9u7zNf32TSAonBZfSd4eplzmPhbJ+QnY0l7L/tRH/ob+SvDxAIin84JA3xjk5nJ6TKr/ft+/EYFnAQJ9Bgbjwfj09BmLxf2d8WZaFmC1Q6TmpNm7cjyv+GlKvPbmvaZEIEIsL7/twf+E4av45qXOcRPpa+OhyhvQ1JH1OqrwWtP2cSh6Hks9Tzd+TJDdXVkexMSry91RvxWLcHP1diffLj3+WvsdqHK3i1Lpz587B3NwcTZo0UVrWyckJFhYWnGMILy8vjVxmtLS05L1OebKysvDdd9+BYRhs27ZN5eNVCtDOnj2LhIQE2RYGaWlpCAwMRGpqKsaMGVOi/JkzZ5CTk1NsPhrw3y72VatWxdixYxEYGMi5D8uWLUOPHj3w3XffqdJ1wRDMpQVtkX7olKJwo3kuH3bc9WrkXEodHwedhfuoApD7ISnrP8vCIfiqCj1QDR+vIYfgK/89l4pGyWuIgMaIcJaeng4AspMeikgkEuTk5MiSuSoTGRlZ1u5pVU5ODrZv314+AdqYMWOKBWI+Pj4ICgoqsYpTatu2bRg6dKhstSZQ+Ms0MjJClSpVIJFIsG/fPrRu3ZpzH1xcXNC+fXv89NNP8Pb25nSMnp4eqlatyrkNQLVM/qpcBlBWbwGrevvq4LPP5eHj/pbWf233leu46quxTyZXfL2GGk67rryQCm2U97y20vpfYoWiDry+y4LLa47La0FkZMSpbnNzc279KodUHXztxUnUV6dOHcTHx+OPP/5A7969FZb9448/kJubC0dHx3LqnbDx9ikxZ84c2Nrayi5PZmRkIDQ0FLdu3SpW7t69exg1apQsD4qLiwvWrl2rUluLFy/mdDq1LDQ1D01ZOXlzP1T5wOJzPhwhRHXlvfcon/uJSinacq5TUF+clBzgpc0yoTxoOqFXr14ICQlBYGAgLC0t4ePjI7dcVFQUAgMDwTBMxV7ox6MyBWhFTz9+vMrCwsICWVlZJY5xd3fHzZs3VWpn3rx5xf7t6OiIvLw8leoQjApwWUETQaK0nPhDklE9BWegtBmk6kJqDLpMrhiNj3I0RoSrmTNn4sCBA3jy5An8/f3h6ekJPz8/1KlTB0Bhmo2IiAicO3cOLMvCzs4OM2fO1HKvuSvLCtL379+XqW3aSUDXaCDnS0VSUVYocl1Zpw5dHSNdOWOrq+OjS2iMCFfVqlVDZGQk+vbti5iYGJw7dw7nz58vVkaad8zFxQUHDhwokQNVl82bN09j+dCUoQCNJ7pw5oQQolnlPY9OV4JaXUVz0HRDvXr1EB0djUOHDmHv3r24evUqnj9/DgCoVasW2rRpg/79+6NPnz7F5qQLSe3atWEkZ56mIhKJBElJSWq3SQEajx7128y5bGlZ54vuE1iULswt04U+gC69cEBjpBiNj3I0RkQ1IpEIffv2Rd++2tzLmn92dnZISkrCmjVr0K9fP5WOffnypdLN1RWhAE3n0FdCxZSPj7bPOnA9m6q5y5z0GlKMxkc5IYwRw2MeNApIiXyurq5ISkqS7ZigirJeGqUATefQG4ViND7Klf8Y8X3pT5P1SXJzAZRMK6HtwF630N8ZIUDhvLmwsDDExsaWe9sUoCmgSqoNgK/NsoXwzVWbaHyUozFSqAwLcbQRxJX3vLfHa9op3erJcV0I/h2vfC9mjaOXuk7Jy8vD9evXkZycjKysLIWbkg8ePLgce6Y+6baW6gRoenp6sLOzUzsnIAVoFZCmLp2pWqcmPlik2e25JOekMyKEVHAUoOmE3NxczJw5E1u2bJGbXutjDMOoHaCJRCKIRCLcu3cPDRo0UKsOVXh7eyMiIgJA4WpUVS5bVqtWDQkJCWq3TQGajqH8Q0oIJE+cJoJDrgFvvQnneG9bGUGtYhbIa0iraIwIRwUFBejcuTPOnj0LlmVRq1YtPH/+HCKRCLa2tnj58qVsaydTU1NYWVmVqT0TExMYGBiUS3AmbY/rrkV8owBNx1D+ISUoT5xSuvwa4np2l++FFlyz5JMPBPJ3Rmk2tG/btm2IiopCnTp1cPjwYbi4uEAkEqFWrVp48uQJJBIJzp49i5kzZyI2NhaLFi3CwIED1W6vbt26SE5O5vEZ6C6NBGi//vorhg0bhrCwsBL7dCYkJKB+/fpwdnaW3Xfo0CHUr18fQGHW3rCwMAQEBMiyDQ8dOhS7d+/GvXv3ZHt4TZkyBaampiV2GeCbqvPQAM1l0hfMGQpNEsgHByF8Ke9L9fWDLuHhUuXzabU+D422etIJe/bsAcMwWLx4MVxcXEo8LhKJ4O3tjTNnzuCLL77AsGHD4OTkJLcsF126dMHatWtx5swZrZ3ZKi+8B2gJCQnYunUr2rUrPZgwMzPD9evXS9z/4MED3Lx5E7GxsejTpw8ePnyIhg0bAijckHXmzJnYs2cP313WKZXxEqcqc+Ycp8UAULzV08d1c6Gp/U75bpuLyvgaUgWNDwcCTSZKyl9cXBwAICAgoNj9YrG42L/19PSwevVqtGjRAqtWrcLu3bvVam/69OnYvXs3xowZg/DwcNjY2KjXcZ716dMHb968QXh4OG918hqgSSQSjBgxAuvXr8fkyap/syo6AU8kEhVbARIYGIiffvoJsbGxakfeQqDLl6d0QWUeH66BXIGWxkiTlyX5VJlfQ5xJJNruATf0q9S6d+/ewcLCAlWqVJHdZ2hoiMzMzBJlmzdvDjMzM5w9e1bt9u7evYvFixdj4sSJaNq0KQYNGgRPT0/UqlVL4S4FXl5earfJxYULF2S7J/CF1wBt9erV8PT0lC1LLU1WVhbc3NwgFovRs2dPzJw5E3p6emjcuDGaNm2K1q1bo3fv3mjUqJHsGBMTE8ydOxfBwcE4efIkn91W6qTkABzXhZRrm4QQUhSX4JevoNYh+IpsxTQhitSqVQtv374tdp+VlRXS0tLw/PnzYpn0WZZFXl4eXrx4oXZ7Pj4+xVZSbty4ERs3blR4DMMwKCgoULtNbeEtQIuLi8OhQ4cQFRWlsJyNjQ2ePn2KWrVq4fXr1+jfvz9CQkIwdepUAMD8+fMxf/58uccOHToUISEhKgdoYrEYWVlZEIvFYBgGDMNAIpHIztKxLAs9PT3ZKVl5P0tycgpXNkkkgEj031wohinxs0PwFTBginxTZ1D4VU/6f8geLyjyMwBIIC78ucg3Q+nj9hPOFiurqI2P6+V6nKKyqh5nP+Fs4Zt80TGSPaki94lEeLi0JRymXVXaRtHx4dI3aT4neb+noj8XThznNhay14KS5wSxuPA+eW0XuU/MFvD6eyr+GlL39wsVymp2vMsyFvKek6qvofLpm/Lj5I6tVJFx5es1JE3oq+h97+3bt3LfL6XvsZpGiwS0r27durh8+TLevHkj2wS9efPmSEtLw/Hjx4ul04iMjERubi5q1qxZpjYV5Vfjo7yu4C1AO3v2LBISEmRzxtLS0hAYGIjU1FSMGTNGVs7IyEgWUVtaWmLYsGHYvXu3LEBTRE9PD0uWLMG0adPg4+PDV9d1Cvvhv8qoRDAnJ5iR5OUBEklhHjRFQcCHDxSHqZcL7+LwIRm/wq1Ee7KfWbZwXo5EIicAB+c25H1I8p21vTK/hrig8VGuMIAVwBjxttUTUZebmxsuX76MCxcu4MsvvwQA9OrVCydPnsSUKVNgYmKCVq1a4caNG5g0aRIYhoGfn5/a7ZVH4K8reAvQxowZUywQ8/HxQVBQUIlVnM+fP0f16tVhYGCA3NxchIaGonXr1pzb6dmzJ1asWIHQ0FAMGTKE0zF6enqoWrUq5zbk4ZIYVapMy/dZHurQIaqMmybqVWUcP976h486tULF1xCfCykaTrvOqb7EtR041aeRLPoC/Rvj8prn7Tmxhe0pa9Pc3LzUx9TNnk6EpWfPntiwYQP27t0rC9CGDx+OH3/8EXFxcfjqq69kZVmWhampKebOnaut7gpKueRBmzNnDmxtbTF69GicO3cOc+bMgZ6eHgoKCuDn5ydLp8HV8uXLNT7h72P/jp+scroNVUg/iJRtsQJQhnxCdAGfwSNfK4P53EXEIfiK0oCvU1BfnJQc4KU9tQjgJF9F5+vri/j4eOjr/xdOGBgYIDw8HEFBQQgLC0NOTg4YhkH79u2xZs0aNGnSRIs91oy6devCmOcTEhoL0CIjI2U/L1iwQPZz79690bt3b5Xq2r59e7F/d+jQQbDXlMubJnKyqYLvOjWZZJRyzREiHAzL3xw0msumPoZhYG9vX+L+mjVr4vfff0dBQQFevHgBc3PzMl/J+phEIkFMTAwSExPx/v17re7veeXKFd7rpJ0EdA1tsaKQpnNYCeHspLIgUjq5u2HwNU71CeE584nyoClHY0S4ki4MbNGihWyRQFH6+voayVW2fv16LFq0CC9fvpTdVzRAS09PR4cOHVBQUIAzZ86gdu3avPdB0yhA0zV0ZlAhmtzNgUBeQ3zPL+Nan/0E9XMwFcXnGVe+n2NZCebvTCDdrMh8fHygp6fHew4wRcaNG4dNmzaBZVmYm5sjMzOzxFW16tWrw8XFBb///jsOHDiAb7/9ttz6xxcK0FSg6rZPJ1JuqFD7DXS2bcn5Ep62L10SQsqf1hZWKNBJpOV5aESrLCwsoKenh+rVq5dLe8ePH8dPP/0EMzMz7Ny5Ez169ICNjY3cAPHrr7/Grl27cOrUKd4DtEePHmH//v24efMm0tPTkZ+fX2pZhmHU2mGAAjQdI6RLC5oKEhXVK8nLAwCIDA0518dn++rWWa5o9ZxCQvob0xahjBHNHdO+Bg0a4ObNm8jNzYURx5XwZbFp0yYwDIMFCxagR48eCsu6u7sDAG7dusVrH2bMmIGVK1dCIpFwmg/PqDl1iQI0HSOYSwva8tH+bpWR0ktrH8ZIlRV9fAalfAfDfG8Npa2tsIREMO9DAulmRfbVV18hJiYG+/fvx6BBgzTeXnR0NABg2LBhSstaWFjA3NwcaWlpvLX/448/YtmyZQAABwcH+Pv7o3bt2sVWsfKFAjQVqXKZs7NtSxUvcxKlaBGFcjRG5UYbZ1G5BLWP+m1WWqYBRpX6GJd0P4SbiIgIhISEIDo6GpmZmbC3t0ffvn0xbdo0tVc1Hjp0CBs2bMD169eRl5eHhg0b4ptvvsGECRNgYFByeszTp08RGhqK8PBwXLt2DWlpaTAwMED9+vXRtWtXBAUFqZ3df8KECQgNDcW3334LKysrWS40TXn9+jUsLCxgZmbGqbxIJOI1ue1PP/0EhmEwdOhQbN26VaP5/ihA07DOti05l328pp1sBR6XpKnavsSmqfYV1StmC/dT02MKX7qUFkMOCtAUEsrlO60SymtIx8+grV+/HhMmTADLsqhbty4++eQT3LlzB4sWLcKhQ4dw7tw5WFpaqlTnlClTEBJSuDd0/fr1UbVqVcTFxeH777/HkSNH8M8//5S41NiuXTskJycDKNzBp3nz5khPT0dcXBxu3ryJn3/+GcePH1cpabzUkiVL4OXlhVu3bqFbt25o1qwZp83L58yZo3JbQGFyZOmcL3nBaFGvX79GRkYGbG1t1WpLnkePHgEo3Htc08mYKUDTNQJZgactH1960XbuNm3NV1NUnzq54ipTDjjBXL7TJnofKrOYmBgEBQUBADZv3oyRI0eCYRikpKSge/fuiImJwciRI3Ho0CHOdYaFhSEkJARGRkbYv38/unfvDgC4d+8evvzyS0RFRWHGjBmyAE7KyMgIY8aMwfDhw+Hi4iKbE3X37l188803iI2NRa9evXDv3j2Vk63OmzcPDMPI5mLFxcXh9u3bSo9TN0BzdnbGmTNnEB0djfbt2yssu2fPHrAsizZt2qjVljzVq1dHTk4OLCwseKuzNBSgEUIA8B9EaiPg49KmJCcHDsHKk0oKfrFIRcdjolpNxOwLFy6ERCLB4MGDERgYKLvf1tYWe/bsQZMmTRAaGoqbN2+iRYsWnOqcP38+ACA4OFgWnAFAkyZN8PPPP8Pf3x8bN27EtGnTil2yjI6OhpWVVYn6nJycEBoaioYNGyIxMRHHjx8vsT2jMl5eXmpPgldHQEAAIiMjMW/ePPzzzz+lnsW6ceMGZs2aBYZhMGDAAN7ab9u2LY4ePYqXL1+iRo0avNUrj9oB2q+//ophw4YhLCysxC/01q1bGDduHJ4/fw59fX20bdsWGzduhImJCYDCFQ3NmzeXnf5cv349OnToAADYunUrfvzxR3h6emL9+vVgGAbz5s3D/PnzERUVJSu3YcMGXL16tcQuA0JWP+gSHi5X/RRz5SKQSy9aRWOkEMNAV8eIr6C2wf5RSgPH+lB0FrZwKoE+w+0jQutbPumYzMxMHD9+HACKBWdSDRs2hJ+fH06dOoUDBw5wCtAePnyIGzdulFqnn58fGjRogEePHuHPP//E8OHDZY/JC86k7O3t4eTkhJs3b+L+/ftK+/GxorsGlYeRI0fixx9/REREBDp16oSJEydC/GFh1MOHD5GQkIAjR45g27ZtyM7Ohru7O/r25W+bxu+//x7Hjh3D4sWL8cMPP/BWrzxqBWgJCQnYunUr2rWT/2ZibGyMDRs2oEWLFhCLxfj666+xfPlyzJs3T1bm7NmzJbIOZ2VlYefOnbhy5QqmTJmC8PBwdOzYEQBQr149BAcH48KFC+p0WTg0eGmhYuROK59LL8K+3EeXpxRiWdAYKUPjUxbXrl2TpZ1o27at3DIdOnTAqVOncOkSt/daaTlHR0fUqVOn1DofPXqES5cuFQvQlMnOzgYAVKlShfMxfLt06RLy8vKU7rNtYGCAY8eO4fPPP0dERESxALHoHp8sy8LZ2RmHDh3i9Qyfp6cnfvrpJ4wbNw7Z2dmYNm0a6tWrx1v9RakcoEkkEowYMQLr16/H5MmT5ZZp2LCh7Gc9PT24ubkhLi5Oad0sy8oGUk9Pr9jKi+7du+PChQsICwtDr169VO22cAhlcq7W6Nb46OZ8Nd0YI13Lji+jw2fQdIdAxkdH48gHDx4AAOzs7EqdyF6/fn0A4HzWSlqn9Dg+6gQK58o9fPgQAGRXqLShV69eePHiBQoKCpSWtbe3R0xMDEJCQvDLL78gMTGx2ON16tTByJEjMXnyZN73/wSAESNG4NWrV5g+fTq2bt0KS0tLhatKGYbB48ePVW5H5QBt9erV8PT0hKurK6fyWVlZ+Pnnn7F06dJi9/v7+6OgoAD+/v5YuHAhqlatClNTU3z99ddwc3ODu7s7OnXqJCvPMAyWLVuGb7/9tti19wqHJucqQeOjnLDGiM+ztVzqki6i4KMuvunOmWthvIb4TlR79+5dzp9tQOGlxlGjSqYref36NQAoXKEpfSw9PZ1TW5qoMz8/H2PHjgUAdO7cGa1ateJ0nKZwSfoqVaVKFcyePRuzZ89GSkoKUlJSIBaLYW1tLXfzdr6IxWIMHjwYe/fuBVDY51evXuHVq1elHlMuiWrj4uJw6NAh2eaoyuTl5aF///747LPPip31SkxMhJ2dHbKysjB69Gh8//33+PHHHwEAo0ePxujRo+XW5+/vj08++QS//PKLKt2GWCxGVlYWxGIxGIYBwzCQSCQQiURgWRYsy0JPT092HVvez9LjxGIxwt7+im5m3wAoXLIvXRVW2s8Ag/jlbQq/uUtfgNKfWRbQ0wM+nC2U5OXBfvZV6OO/b12l1SsGg3+Xtylen7w2pD9/yG1U4n6JpDD7fJH7pB9iip5T4Zu49P9cx0Lxc1LWhhgFhY+zmujbf8dJPh6rj35P0vuLftgra0OSk8Pp9yRv7FV5TkXHSFu/J908DiXGR3f6pr3fU4n3EHzYsUMiKcyDxjBwmHpZad98mZ44mvm77P2Sz9xT5SU7OxuxsbGcy6empsq9P+fD+4ehgh1PpKkwpJcXldFEnd999x0uX76MatWqYfNm5bnzdJWtrS2vqTQUWbNmDfbs2QOg8Ixj586ddSNR7dmzZ5GQkCC7hJmWlobAwECkpqZizJgxxcrm5+ejf//+sLGxwdq1a4s9ZmdnBwCoWrUqxo4dK3fCY2mWLVuGHj164LvvvlOl68LBMBBanqb45W6FPygJZgBwWj2nSHmNjbSfqnxIcquTywfxhzHlEEgXfnAWJ7TXT3mj8eGAYYQx3YLnM2gmJiZwcnLiXN7Gxkbu/dJUFXkftqaTJ/dDzkvp4jll+K5zwYIF2Lx5M4yMjHDo0CGNnnWqSLZt2waGYTB9+nQsWrRIo22pFKCNGTOmWCDm4+ODoKCgEqs4CwoK8NVXX8HS0hJbtmwpdnovPT0dRkZGqFKlCiQSCfbt26dScjwXFxe0b98eP/30E7y9vTkdo6enx/t1aFVyTAGqZeTWgz7n+jWV6VuV56dKH1Qdt48VsPzUo+u4jqm8cZA3RnzPf9NWCgo+2q0sryGuFL3WpI9xHaui77OaTuKpCU5OToiJiSlzPdKNw6WXJeWRPsZ1k3E+6wwJCcHcuXNhYGCAAwcOwM/Pj1MfdAnLsggNDcXevXtx9epV2WbptWrVQps2bfDVV1+hV69evL8OExISZAGapvF2Tm7OnDmwtbXF6NGjsW/fPoSGhqJFixay4MvT0xMbN27EvXv3MGrUKDAMg4KCAri4uJQ4w6bM4sWLi63W0AZVtnwihBCuyjv4lVePOsmOtUJHp8o1atQIAPDkyZNSM95LJ41Ly3KtU5rJXh4udW7YsAFTpkyBnp4edu3ahW7dunFqX5c8efIE/fr1w5UrhVc6is5dS0xMxJMnTxAaGgpXV1ccOHCA17OD1atXR3Z2tkYWH3ysTAFa0eWtCxYskP08cOBADBw4UO4x7u7uuHnzpkrtFE3PARQuM1Z0mlfQGAbxK9qiYfA1TsV1YVKxKlnoVdnAWx66PKUcjZFiND7KCWKMWB4XCfAc6LVu3RqGhobIzc3F5cuX4enpWaLM2bNnARR+JnIhTWsVHx+Pp0+fyk21oazOrVu3Yvz48WAYBtu2bUO/fv04ta1LMjIy4O3tjSdPnoBlWXh4eMDPz082Hk+fPkVERATOnz+Pq1evwtfXF9euXeMt87+Xlxf2799f6u+AT7STgK6hVZwKVZZtergGvfLKlGWja64BtJC3hqosr6GyoDEqGzMzM3Tu3BlHjhzBli1bSgRoDx8+xOnTpwEUZsbnolGjRnB2dsatW7ewZcsW2a4CUqdPn8ajR49gaGgoN9PBrl27MHr0aLAsi02bNmHIkCFqPjvtWrx4MRITE2FpaYl9+/bB399fbrmIiAj07dsXiYmJWLJkCZYvX85L+9OnT8fhw4cxdepU/P7777zUWRoK0AghatHG/DJdOGOsaUIOfsudDseRs2fPxtGjR/Hbb7/B09NTthdnamoqBgwYAIlEgp49e6Jly5bFjpMmPV21alWJ4G3u3LkICAjA8uXL0aZNG9nlyfv372PEiBEAgLFjxxbb5gkAQkNDMXToUEgkEqxdu1ZuahChCAsLA8Mw2LRpU6nBGQD4+vpi06ZN6NevHw4dOsRbgNaiRQuEhobi66+/xhdffIGpU6eibdu2GrnkSQFaGZyUHIDjuhDlBT/g8uEi/rDFCjhusVLZCOLSi7YJYfWdFlW215A6ga+6Y9RJVH5bPjHg7xKnJl4Rbm5uWL16NSZNmoRRo0Zh0aJFqFGjBu7cuYPc3Fw0btwYW7duLXGcNOlqZmZmicf69OmDoKAgrFmzBt27d0f9+vVhamqKuLg4iMVitG/fvkTOUQAYMGAAxGIxqlSpgv3792P//v1y+/zll19ixowZZXzmmpWcnAxDQ0P07t1badlevXrByMgIT58+5a196RaVAPDPP//gn3/+UXqMdM69qigK0DHlcWlBE1s+qXpm40TKDU7lOtsW/3apaHwqxlZWPKDL5ArR5TvlaIz4ERQUBGdnZ4SEhCA6OhrPnz+Hvb09AgICMH36dJiamqpc5w8//AAPDw9s3LgR169fR0pKCpo2bYpvvvkGEydOlLsgQTpn+/379zh//nypdTdo0EDl/pQ36SR9Lqsz9fT0YGxszDmVCReqJNMtKwrQCClnml6lV54r8Mp7xWFZF5mQCkYAcaS/v7/CS3Ef4xIA9O3bV6UNwMszqNA0Dw8PhIWF4cGDB0pXwD548AAZGRnFdiUqq4iICN7qUoYCNJ1TuS6/qI7GRzkaI6D04FHyIZmn6EPWdS74zA/HdRFGebZXEr2GSPlyd3fntEXVtGnTcPToUYwdOxbHjh2T7Z7wsby8PIwdOxYGBgaYNm0ab/3kmn+VDxSgldG/4ydznofG7du/+t90KsclvorzTVBzaIwUEuAWROVPIK8hgXSTKBcaGsqpXJs2bbB//34MGTIErVq1wtSpU+Hr61sizcaqVauQmpqKgwcPwsXFRZNd1xgK0HRO5fjm+vHcMkWKBp7qnP3QNZoPjivHa0htAsxwX/4E8BrS4TxolQnXvbmljI2NUa1aNdSvX7/YhHt5lD3+9u1b2erV0vTs2VPtSfraRgGazqF3CoUq0FwKzSm/MeIz2OQ7cC2tPsFkydcq+jsj3Pj4+BTbzpErY2Nj+Pv7Y+rUqWjfvr3cMro4d+6ff/7BV199hc8//xy7d+9WWLZ3796IjIzEoUOH4Ovrq3JbWg3Qfv31VwwbNgxhYWHo2bMnoqOjMWHCBFhZWWHHjh2oUaMGIiMj4evriwULFmD27NkAgLi4OHTt2hUJCQna7L6McC8XEkL4xOd7AV+50PhcWMGlT47rQvDv+Mm8tKeU7n1+V0rqBFLZ2dk4evQo/vrrL4SEhGDChAklypTnhHyu9u3bh4yMDAwYMEBp2f79++OPP/7A3r17hRWgJSQkYOvWrbLtKwBg1qxZOHz4MC5evIg1a9bIdoq3trbG+vXrMWbMGNSoUUNbXS4XlS1HExdFP1ykeeL0KE9cqeg1pBiNj3KCGSMK0LROIpHg6NGjGDJkCGrXro3vv/8ePj4+xeaERUZGYtWqVXj27Bl27twJDw8PXLlyBcuXL8fp06cxefJkdOjQocRcsfKckM/VpUuXwDAMfHx8lJb98ssvwTAMLl68qFZbWvmUk0gkGDFiBNavX4/Jk//7psWyLBiGgZ6eHiRFJvLWrl0b/v7+WLhwocobqwsN5R9SjM/xqaiLKsr7NVTeqTbKiv7GlKMxIlxdu3YNffv2Rfv27XH06NESqyodHBzg4OCAgQMHokuXLggICEB0dDQ6deqETp06oWvXrvjrr7+wceNGbNu2TUvPgrvk5GRUq1YNZmZmSsuamZmhWrVqaifK1UqAtnr1anh6esLV1bXY/QsWLEC3bt1klziLmjlzJpo0aYKgoKBy7CkhRBfxHRTq4jZTfPa9ouJtkQBR29KlS5GXl4eNGzeWmvICAAwNDbFhwwY4OTlh6dKlsvlb8+fPx19//aXyYgNtKSgoUOmSbn5+vtoLFMo9QIuLi8OhQ4fk/jI8PDwQHR0t9zhLS0sEBQVh1qxZmD59ukptisViZGVlQSwWg2EYMAwDiUQCkUgElmXBsiz09PQgFosBQO7P0uPEYjH09PSKHXfozTa02LS+cIsd6S9O3s9F7nMMvir7lsqAkf0sgbjw5yK///gVbf+rSyQCxOLCuj5uIycHDsFXATn1fvxzgawB5kN5htNxbJmPgwplS7ZRdHzK2jdJTo7S35P05wI2X2PPie/jir+GNP97kuTmljpuisawLGNR6u+OZQE9PVkqDTFbUOI5yXsNcXktFK1Lm7/fj39PJfou5z2icGGE8jb+Xd6msM78fEAiKVwtzTCF4ykSfXiPuaK0b74TzkLSitKZVAbnzp2Dubm50qSxANC4cWNYWFggMjJSdp+rqyuMjY2RkpKictspKSm4efMm0tPTkZ+fr7Ds4MGDVa5fHltbW/z777949OiR0p0XHj16hMzMTNjb26vVVrkHaGfPnkVCQgIaNmwIAEhLS0NgYCBSU1MxZswYhccGBQWhUaNG+Pzzz8ujq1rBfvivPMQvdyv+5qvgw9Uh+Ar3epe1KfYhWaw+KSUfKMXKFOkDl/GJX+HG6TkBgOPUK5w/JIWiPF9DQkTjw4E02NV1AuhiRZeeng6GYWRTlBSRSCTIyclBTk5OsftNTEyQ+yGFEhfXrl3DhAkTFG5bVRTDMLwFaO3bt8e///6LFStWYMuWLQrLLl++HAzDoEOHDmq1Ve4B2pgxY4oFYj4+PggKCkLPnj2VHlulShXMnj0bc+bMUalNPT09jew0X5TI2Fil8qVOcv/whlM0BYAqOb/0VZg8r0qfVUlJIOJx37MSfZAzPiXaV2G8tLnYQFOX6SQf3vxUfU2q23bD4Guc6nq8ltubFKc2p13nVBfk/X7l/Y1xGCtdXZjCpe9c/34/rkte3Zzr0nS+OZbyoOkCW1tbJCQk4MiRI+jevbvCskePHkVubi4cHBxk9+Xk5CA9PZ3zWaZr167By8sL79+/B8uyMDIyQo0aNaCvXz5/n2PGjMGOHTuwbds21KhRA/PmzYOhoWGxMnl5eZg7dy62bdsGhmGUnnwqjW6+4ygwfPhwrF69WqVoW0gEs3pKS2h8OFAjJ1Flou5rSFcXldQPuqS0b1xTbUjL0GppwlX37t2xdu1ajBw5EjVq1ICHh4fcchcvXkRgYCAYhikWyN2+fRsA4OjoyKm9WbNmISsrC/Xr18eWLVvg7e2t+S8DRbRt2xbfffcd1q9fj+XLl+Pnn39Gp06dZAFmYmIiTp48iVevXgEAxo0bB3d3d7Xa0vpfX9Fr0fL4+Pjg+vXrsn/r6+vj/v37mu2UGlTZ8kkReZdeNPVmryv1qvLBR5emOBDCpSktoteQcoIZI4F0syKbNWsW9u/fj9TUVHh5ecHLywve3t6wtbUFwzBISUlBZGQkoqKiIJFIYGNjg1mzZsmO37VrFwBw3lD+/PnzYBgG+/fvR+vWrTXynJT54YcfYGxsjJCQELx8+RJ79+4t9rh0fvr3338vSxemDq0HaISUVwZ5XaOp580lU35lXvlHCOGPlZUVIiIiEBAQgLi4OERGRuLMmTPFykhXPTZr1gwHDx6ElZWV7LEePXrAx8enWE5URViWRdWqVbUWnAGFl++XL1+OESNGYMeOHbhw4QLS0tLAMAysra3h4eGBoUOHon79+mVqhwI0nUOXpxSj8VFON8dIdwLnkuOjSt8qR3Crm6+hEugMmk5o1KgRYmNjsW/fPhw4cACxsbF48eIFAKBmzZpwcXFBQEAA+vfvDwOD4l8cuSR8LapBgwa4c+eOLKOCNjVs2LBMZ8iUoQCNR/+On4xOor5lrIXecRSj8VGOxkixijc+/Od7K/sYPYz9t8x1KCOQMLJS0NfXx8CBAzFw4ECNtjN06FAEBQXh8OHD6N27t0bb0jYK0HSO/LccXZmgrImzB6r1l96SlaMxUozGRzkaI6Kbxo4di6NHj2LUqFGwsbFRewI+FytXrsS3334LEx4zE1y9ehUvXrzAF198obQsBWg6p+J9u+cX/+OjK8EvX+I/JBtVln5BCM9FM+hvTDmBjJFAukn4o6enhyNHjmDKlClo3749OnToADc3N6VbL6mangsAgoODsXr1akydOhX/+9//UK1aNTV7XZjQd9myZfj7778xd+5cCtAIIcKli9svqdJmefdfV8dLUxjwlweNzhfy4+LFi7h58yZev36tNLO/OgGT1KlTp3D06FGwLIuzZ8/i7NmzSo9Rp70ZM2bghx9+wJQpUzBjxgx06dIFAwYMQIcOHVCrVi2Fx+bn5+P69ev4888/sXv3biQkJIBlWbRt25ZT3leAAjTenZQcKNPxWVlZAFC2xLrjwcNcON1EedA4oDxoCtFrSDkaI6KKU6dOITAwEImJiZyPUTdAO3v2LHr27CnbjrF+/fqoXbu2RhLVLlq0CGPGjMGMGTOwe/duhIaGIiwsDADwySefoGXLlqhZsyYsLS1hZGSE9PR0vH79Gv/++y9u3LiBvLw8AIUrT+vXr4+FCxfiq6++4tw+BWg6RvqiK6uyBorlajz3om/fvgUAmJuba6gzSqjQV60FyZQHTSHB5PjSIkGMEQv+LnEK4OnqqsuXL6Nr166yYMTBwQG2trYay+y/YMECFBQUoE2bNti7dy/nBLfqqlOnDnbs2IGlS5diy5Yt+OWXX5CcnIwnT57gyZMncre3kqYV0dfXR5cuXTBq1Ch07txZ6VZYH2NYVbZlFxhXV1fExsbCxMQETk5O2u4OJ0U3aScl0fgoR2Mkn3RVYdGNvTUpt67ys+BGyVk62R4fY5SFd5BADBcXF8TExKhdz8dk7+s166LhgEm81Plwz2pkv0jmva+VQbdu3XDs2DE0adIE+/fvR/PmzTXanqWlJTIyMnDv3j3Znt7lLS4uDlFRUYiOjkZKSgpevHiBnJwcWFlZoWbNmmjatCm8vLzg6empdG6cIpXiDFp2djZiY2O13Q1CSGWS/EZpkTwht6cLKuzpBeG4ePEiGIbBb7/9pvHgDCjccN3MzExrwRkANG/eHM2bN8fYsWM12k6FDtCaNGmi7S4QQkilpsn3Yd42Sydqe//+PapUqQJXV9dyac/JyQmxsbHIzc2FkZFRubSpLRU6QPv999+13QVCCCGkwrK3t8eTJ0/Krb1Ro0Zh2LBh2LVrF4YPH15u7WpD+W0BTwghhPCJ5elG1NanTx/k5OQgKiqqXNobOnQohgwZggkTJpTYpLyiqdBn0AghhFRcdIlT+6ZNm4Z9+/Zh3LhxiIyMLLYRuiYMGzYMDMPA0NAQAwcOxPTp09GmTRuFk/EZhsG2bds02i9NoACNEEIIIWqJjY3FwoULMW7cODRr1gyBgYH49NNPla5e9PLyUqu97du3g2EYWSqLxMTEUvOvSctRgEYIIYSUF8qDphN8fHyK5fdavHix0mMYhkFBQYFa7Q0ePFjlfGJCRXPQNCg3NxfffvstGjZsCGdnZ3zzzTcAgM8++wwtWrRAq1at0KFDB1y7dk12zNGjR+Hq6ooBAwYgJycHubm5MDExQXJysqxMx44d4ePjI/t3WloajI2NkZ2dXW7PjS/yxignJwc9e/ZEo0aN0LJlS3Tq1AmPHj2SHRMdHY127dqhS5cuePnyJYDC5Ijnzp2TlRkxYgTq1asn+3dBQQHMzMzw+PHjcntufCjtNTR+/HjUq1cPDMPg+vXrxY6h11DhGD18+BAeHh5o1KgR3NzccPv2bdkxlW2M6tWrh8aNG6NVq1Zo1aoV9u3bBwA4fvw42rRpgxYtWqBdu3a4ceOG7JjK9HdGyoZlWZVuEolE7ba2b9+OX3/9VeWbEFGApkHTpk0DwzB48OABbt26hVWrVgEA9u/fj5s3b+L69euYNGkShg4dKjtm0aJFiIqKwqeffopdu3bByMgI7u7uiIyMBADk5eUhPj4eqampyMnJAQBERETg008/hYmJSXk/xTIrbYwCAwNx//593LhxAz169MCIESNkx8yaNQuHDx/GyJEjsWbNGgCAr6+vbIyAwo1prayskJCQAAC4cuUKLC0tUb9+/fJ6arwobXwCAgJw7tw52NvblziGXkOFYzRq1CgEBgbiwYMHCA4OrtR/ZwCwb98+XL9+HdevX0f//v2Rnp6OgQMHYseOHbh58yZWrlyJgQMHysoL4e+MYfm5EfVJJBK1bkQ5CtA0JCsrC9u2bcPixYtlp2Otra0BANWqVZOVy8jIKHG6lmEY6OnpyV7ERd8Uo6Oj4ebmhk8//RSXLhVufBwZGQlfX18NPyP+lTZGxsbG+PLLL2X3tWvXTvYBAEA2p6C0MUpKSkL16tXRpUsX2X1CHCNFryEvLy/UrVu31GMr+2vo+fPnuHr1quxsWp8+fZCUlFTsTGxlGaPSPH78GFZWVmjWrBkAoEOHDnjy5Iksqbcg/s5oFSepwChA05DHjx/D0tISS5YsQZs2bdChQweEh4fLHh88eDA++eQTzJ49G7/99pvs/unTp6N9+/Y4d+4cBg8eDKDwTTEiIgJA4bd4Hx8feHt7F7vPz8+vHJ8dP5SNkdTatWvRo0cP2b8XLFiAbt264aeffsLEiRMBFI7RhQsXkJeXh4iICHh7ewt+jLiOz8foNRSOpKQk2NjYyPYDZBgGdnZ2snxNlWmMpAYPHgxnZ2cMHz4cL168QMOGDfHq1StcuHABAPDnn3/i3bt3si9DleXvjBBdRYsENKSgoACJiYlo2rQpli1bhmvXrqFTp064ffs2ateujZ07dwIAduzYgeDgYPz1118AgB49ehQLRgCgbdu2SEtLQ1JSEiIjI/Hjjz9CX18fw4cPR0pKCp4+fYp27dqV+3MsK2VjBABLlizBo0ePigUmHh4eiI6OLlZX3bp1UadOHURHRyMyMhL9+vWDu7s7Ro8ejfz8fFy4cEFwq3i4jI889BrqhGPHjik8rjKNEQBERUXBzs4O+fn5mDVrFoYMGYK//voLBw8exPTp05GZmQl3d3c0bdpUFtQK4u+Mzn5VOupsjs4wjCDnRVKApiF2dnYQiUSyOR2tW7eGg4MDbt26VezDdciQIRg9ejRevXpVav4YQ0NDeHp64vjx40hISJBtnZKUlIS//voLHh4eMDQ01PyT4pmyMVq1ahVCQ0Nx6tQpVKlSRWl90jMg586dw7p161ClShXUqlULe/fuhY2NDT755BNNPyVecX0NcVHZXkOJiYlITU1FQUEB9PX1wbIsnjx5Ajs7u1LrqqhjBED2vA0MDBAUFIRGjRoBKPybkV6SzM3NhbW1NZo2baqwLl36O6P5Y+VLemLBwsJC9gVHep+qpGeuVVV0uosiRVNxCHXVJwVoGlKjRg34+/vjxIkT+PLLLxEfH4/4+Hg4OTkhJSUFtra2AIA//vgDVlZWsLS0VFifr68vVq5cibZt28rua9euHVasWFFs8rOQKBqj1atXY8+ePTh16lSxOXuK+Pr6Yu7cubCysoKpqSkAwNvbGwsXLhTk3CFF46OOyvQa8vT0hIuLC3bt2oWhQ4fi0KFDqFu3Lho0aKCwvoo4RllZWcjPz5f9He3ZswetW7cGAKSmpsLGxgYAsHDhQvj5+XEao4r0d0a4Gzp0KBiGQePGjWUBmvQ+VTAMo3aApmxFZkZGBqKjoxEaGgpTU1MsWLCA0xd8XUQBmgZt2rQJw4cPR3BwMEQiETZv3oyCggL07dsX2dnZEIlEqFmzJo4ePar0Be7r64sZM2Zg0qRJsvu8vb2xZ88eQc/5kDdGLMti8uTJcHR0lL3hGxkZlbjc8jEfHx88fPgQvXv3lt3n7e2NpUuXYsGCBRp9Hpoib3zq1KmDUaNG4dixY0hLS0Pnzp1hZmZWbAK8PJXpNVSnTh1s3rwZQ4cOxZIlS2Bubs5pqX1FHKNnz56hT58+EIvFYFkWjo6OsrMec+bMwdmzZ1FQUAB3d3dOlyd15u+M8qCVOzs7OzAMIzvBUPS+8jJkyBBO5e7evYtOnTrh999/L7byWEgYVnoOkBBCCNFxrq6uiI2NhYlVXTj1mqT8AA7uhq1G9qtkuLi4ICYmhpc6ifYdPnwYvXr1wooVKzBlyhRtd0dltIqTEEKI4DAAGJbl56btJ0M0okuXLjA0NCyWKUFI6BInIYQQYaLrP0QBfX19GBkZCXIFJ0ABGiGEEEJ48u7dO8TGxuL58+cAgFq1asHFxUXp5uma8ODBA7x79w4WFhbl3jYfKEAjhBAiSJRmQ3fcunULM2fOxN9//11iKyeRSIQuXbpg4cKFcHZ2Lpf+PH36VLbCtE2bNuXSJt8oQCOEECJMFKDphNDQUHzzzTfIzc2FvHWHYrEYR44cwT///IPff/8dvXr1UrutYcOGKXw8JycHSUlJuHLlCvLz88EwjCAXCAAUoBFCCCFETfHx8Rg4cCByc3NRr149TJ06FZ06dZLtFZycnIyTJ09i5cqVsrK3b9+Gg4ODWu1t3769WBJaRUxNTbFmzRp07txZrba0jQI0QgghwsPyeImTzsSpbeXKlcjNzYW7uztOnDghS14sVb9+fdSvXx+DBg3CZ599hkuXLiEkJAQbNmxQq73BgwcrzLumr6+P6tWro2XLlujWrRvMzc3VakcXUIBGCCGEELWcOnUKDMNg06ZNJYKzoqpWrYpNmzahZcuW+Oeff9Rub/v27WofKzQUoBFCCBEmOvOldcnJyTAzM+M0+d/Z2Rnm5uZITk4uh54JHwVohBBCBIlWcWqfgYEB8vPzOZVlWRZ5eXkwMDDQcK8qBgrQCCGEEKKWBg0a4Pr16zhx4oTSyfgnTpxATk4OnJyceGs/JycH6enpSoNEOzs73tosLxSgEUIIESY6g6Z1PXr0wLVr1zBy5EicOHGi1ODrzp07CAwMBMMw6NmzZ5nafP/+PVasWIE9e/bg0aNHSsszDIOCgoIytakNFKARQgghRC1BQUHYunUrkpOT0bp1a/Tt2xf+/v6oU6cOgMI5auHh4Th48CDy8vJQt25dBAUFqd3emzdv4OXlhdu3b3NKtQGAczldQwEaIYQQQaI5aNpnbm6O48ePo1u3bkhISMDu3buxe/fuEuVYloWDgwP+/PPPMm37tHDhQsTFxcHAwADfffcdevToAVtbW+jrV7xwpuI9I0IIIRUfyxbe+KqLqK1Zs2a4efMmNm7ciP379+PmzZsQi8UAAD09PbRo0QJfffUVxowZozAVBxd//PEHGIbBmjVrMGbMGD66r7MoQCOEEEJImZiamiI4OBjBwcHIz8/H69evAQCWlpa8rtp8+vQpRCIR/ve///FWp66iAI0QQojgMODvEmfpeemJOgwMDFC7dm2N1G1paYmcnBwYGxtrpH5dItJ2BwghhBC1sDzdiGC0b98eGRkZePr0qba7onF0Bo0QQgghaomKilKpvLGxMapVq4b69etDT09P5faCg4Nx+PBhLFy4EJs2bVL5eCGhAI0QQoggMRJt94D4+Pgo3Ly8NMbGxvD398fUqVPRvn17zse5urpi+/btGDZsGPLz8zFz5kw4Ojqq3L4QUIBGCCGEELWpk2csOzsbR48exV9//YWQkBBMmDCB03HSYExPTw/bt2/H9u3bYWlpqTB1B8MwePz4scp91Daag0YIIUR4+Jp/RvPQykQikeDPP/9E9erV0aRJE2zbtg2PHz9GTk4OcnJy8PjxY2zbtg1OTk6wtLTE0aNH8fr1a5w4cQJ+fn6QSCSYPHkyYmNjObWXkJCAhIQEvH//HizLgmVZvHr1SnZ/aTchojNohBBCBIkS1WrftWvX0LdvX7Rv3x5Hjx6FkZFRsccdHBzg4OCAgQMHokuXLggICEB0dDQ6deqETp06oWvXrvjrr7+wceNGbNu2TWl7v/76q6aeis6hAI0QQgghalm6dCny8vKwcePGEsFZUYaGhtiwYQOcnJywdOlS2W4D8+fPx19//cV5scGQIUN46bcQUIBGCCFEmGgHAK07d+4czM3N0ahRI6VlGzduDAsLC0RGRsruc3V1hbGxMVJSUjTYS2GiAI0QQogg0SVO7UtPTwfDMGBZVulqTolEIpubVpSJiQlyc3M12U1BokUChBBCCFGLra0tcnNzceTIEaVljx49itzcXNja2sruy8nJQXp6OmrWrKlSu8nJyZg0aRKaNWsGU1PTEpulp6enY8mSJVi6dCkKCgpUqltX0Bk0QgghwkRn0LSue/fuWLt2LUaOHIkaNWrAw8NDbrmLFy8iMDAQDMOge/fusvtv374NACrlMjt58iT69euHt2/fylJ8fHz2rnr16vjjjz8QExODZs2aFWtTKChAI4QQQohaZs2ahf379yM1NRVeXl7w8vKCt7c3bG1twTAMUlJSEBkZiaioKEgkEtjY2GDWrFmy43ft2gUA8Pf359ReUlISAgIC8O7dO3Tv3h2DBw/GyJEj8ebNmxJlhw0bhqtXr+LYsWMUoBFCCCHlguVxDhqdiVOblZUVIiIiEBAQgLi4OERGRuLMmTPFykjPcjVr1gwHDx6ElZWV7LEePXrAx8cH7dq149ReSEgI3r17h379+mHv3r0AgHHjxskt27lzZwDAlStXVH5euoACNEIIIcJEqzh1QqNGjRAbG4t9+/bhwIEDiI2NxYsXLwAANWvWhIuLCwICAtC/f38YGBgUO9bHx0eltk6cOAGGYbBw4UKlZR0cHGBkZIT4+HiV2tAVFKARQgghpEz09fUxcOBADBw4UKPtPHnyBCYmJmjYsCGn8qampsjIyNBonzSFAjRCCCGCw4C/S5yqb/VNtEUkEkEsFnMqW1BQgLdv38Lc3FzDvdIMSrNBCCFEmASwD2dERAS6du2KmjVrwsTEBE2aNMHs2bORlZWldp2HDh2Cr68vqlevjqpVq6JVq1ZYtWoV8vPz5ZaXSCT4+++/sWDBAnTr1g3W1tZgGAYMw5R5n0qRSIQ6depwLu/g4FAiJYYq7O3tkZubiydPnigtGxUVhfz8fM5n23QNBWiEEEKIBqxfvx7+/v44duwYjI2N4eTkhISEBCxatAhubm54/fq1ynVOmTIFAQEBiIyMhJWVFRo0aIC4uDh8//336Nixo9yEr2/fvsWXX36JuXPn4ujRo3j27BkfT0+GVXEuoKrli+rYsSMAYNOmTQrL5efnY+bMmWAYBl988YXa7WkTBWiEEEIEiWH5uWlCTEwMgoKCAACbN2/GkydPEBsbi3///Reurq64e/cuRo4cqVKdYWFhCAkJgZGREQ4fPoxHjx7hxo0biIuLg4ODA6KiojBjxowSx4lEIrRu3RojR47Eli1bcO7cOT6eolry8vIgEqkfekycOBGGhoYICQkpdXP12NhYdOzYEdHR0TAzM8PYsWPVbk+bKEAjhBBCeLZw4UJIJBIMGjRIlqAVKMy8v2fPHohEIoSGhuLmzZuc65w/fz4AIDg4uFheryZNmuDnn38GAGzcuFG2glLK3NwcsbGx2LJlC0aOHImWLVuW9emp5c2bN3j+/DmqV6+udh329vb4+eefIRaLERgYiNq1ayM9PR0A4OHhgTp16sDNzQ1nz56Fvr4+du7ciRo1avD1FMoVLRIghBAiPCwACU+nv3g+i5aZmYnjx48DAAIDA0s83rBhQ/j5+eHUqVM4cOAAWrRoobTOhw8f4saNG6XW6efnhwYNGuDRo0f4888/MXz48DI+C/lu3ryJ69evF7svOzsbO3fuLPUYlmXx5s0bHDx4EBKJBK1bty5THwYOHIhatWph3LhxePTokez+S5cuyX5u0KABNm3aBD8/vzK1pU0UoBFCCBEmHU2Ddu3aNeTm5sLIyAht27aVW6ZDhw44depUsaBCEWk5R0fHUifld+jQAY8ePcKlS5c0FqCFhYVhwYIFxe57+/Yt/ve//yk9Vrqh+qRJk8rcj06dOuH+/fuIiorC+fPnkZKSArFYDGtra3h6esLX1xd6enplbkebKEAjhBBCePTgwQMAgJ2dXYnErFL169cHANy/f1+lOqXH8VGnOqpVqwY7OzvZvxMTEyESiVC3bt1SjxGJRDA3N0fz5s0RGBiIDh068NIXhmHg7e0Nb29vXurTNRSgEUIIESS+J/jfvXsXrq6unMsHBgZi1KhRJe6Xrs60tLQs9VjpY9L5U8pook51TJgwARMmTJD9WyQSoWbNmuWWrT85OVlhMFiRUIBGCCFEmHje6ik7OxuxsbGcy6empsq9PycnBwBgaGhY6rFGRkayNrnQRJ18mDt3LkxNTcutvXr16sHHxweDBw9Gnz59ULVq1XJru7xRgEYIIYQAMDExgZOTE+fyNjY2cu83NjYGUJhSojTSfGUmJiac2tJEnXyYO3duubUFFCbdjYiIQEREBMaOHYtevXph0KBB6NSpk2ylbEVBARohhBDh4TOH2Yd6nJycEBMTU+bqpGkkFCWilT7GNeWEJuoUovDwcOzcuROhoaF49+4ddu/ejd27d8Pa2hoDBw7EoEGD4OzsrO1u8oICNEIIIYRHjRo1AlC4sXd+fr7chQKPHz8uVpZrnUXTSpS1Tj4MGzZM5WMYhik1yawyvr6+8PX1xU8//YQ//vgDO3fuxMmTJ5GamoqQkBCEhISgRYsWGDJkCAYMGIDatWur1Y4uoACNEEKIMOlomo3WrVvD0NAQubm5uHz5Mjw9PUuUOXv2LADA3d2dU53t2rUDAMTHx+Pp06dyU22oWicftm/fDoZhSt2+6ePLjtJUG+oGaFLGxsb46quv8NVXX+H58+fYvXs3du3ahdjYWNy4cQOTJ0/G1KlT0bFjRwwZMgT9+/cvU3vaQAEaIYQQAWLB8LZIgN9Iz8zMDJ07d8aRI0ewZcuWEgHaw4cPcfr0aQBAQEAApzobNWoEZ2dn3Lp1C1u2bJHtKiB1+vRpPHr0CIaGhsV2GdC0wYMHK5z7lZGRgatXryI5ORlWVlbo2rUr732oVasWgoKCEBQUhLt372Lnzp3YvXs3kpKScPz4cZw4cYICNEIIIYQAs2fPxtGjR/Hbb7/B09MTI0eOBMMwSE1NxYABAyCRSNCzZ88S2y7Vq1cPALBq1aoSwdvcuXMREBCA5cuXo02bNujWrRuAwrxnI0aMAACMHTsWNWvW1PwT/GD79u1Ky7Asi+3bt2PMmDGwsLDAmjVrNNYfJycnLF26FAEBARgzZgyuXr2qsbY0jfbiJIQQIkwSnm4a4ObmhtWrVwMARo0aBXt7e7i4uMDBwQExMTFo3Lgxtm7dWuK4xMREJCYmIjMzs8Rjffr0QVBQEHJzc9G9e3c0aNAArVq1QrNmzRAfH4/27dtj6dKlcvvTo0cP1KhRAzVq1JAFgQDg4uIiu9/FxYWfJ/8RhmHwv//9D0uXLsX69esRGhqqkXaePn2KFStWwNnZGW3btpUt+CgtWbCuowCNEEII0YCgoCCcPHkSX3zxBbKysnDnzh3Y29tjxowZuHr1qlqbeP/www/Yv38/vL298fLlSzx48ABNmzbF8uXLcfr0aVk6jo9lZGTg1atXsptUenq67D5FK0T5MGLECDAMg/Xr1/NWZ1ZWFnbu3IlOnTqhXr16mD59Om7fvg2WZeHq6op169bh6dOnvLVXnhi2tJl9hBBCiI5xdXVFbGwszExt4eb2LS91XrmyAe8yU+Di4sJLmg1SOktLS7AsW6bdDliWxcmTJ7Fz50788ccfyM7Oli1S+OSTT/DNN99g8ODBaNy4MV/d1gqag0YIIUSY6PSCoLx+/Rpv3rxBlSpV1K5jypQp2LNnD9LS0gAUBmtmZmbo06cPBg8eDB8fH556q30UoBFCCCFE46ZNmwYAZTqzJZ3Xp6enh44dO2LQoEHo1atXue6eUF4oQCOEECJMNENH63bu3Knw8ZycHCQlJSEsLAx3796VLRhQV4sWLTBo0CAMHDgQ1tbWatcjBBSgEUIIESTetnoiahs6dCinPTClc8QGDx6Mb79Vf+7g9evX1T5WaChAI4QQQoha7OzsFAZo+vr6qF69Olq2bIkBAwbAz8+vHHsnbBSgEUIIESa6xKl1CQkJ2u5ChUV50AghhBAiKDdu3EBgYCCaNm0Kc3Nz6OnplXrT1xfmuShh9poQQkjlxgIMX7sA0Ik4QdmwYQMmTZoEsVhc6ibtFQEFaIQQQoSpAn84C1FeXh5OnjyJq1ev4vnz5wAKNzJ3c3NDx44dYWhoWOY2oqOjMWHCBACF+4526dIFX375JSwtLbF//36kpaXh1KlT2L17N8zNzbFu3TrY2NiUuV1toACNEEIIIWWyZcsWzJ49Gy9fvpT7eI0aNbBo0SKMHDmyTO2sW7cOLMsiKChIlhMNAAwNDWULEL7++muMHz8enTt3xuzZsxEbG1umNrWF5qARQggRJpanGymT4OBgjBkzBi9evADLsrC1tUXbtm3Rtm1b2NragmVZvHjxAqNHj5Ylq1XX+fPnwTCM7Cya1MeXOlu1aoX169fj8ePHWLlyZZna1BYK0AghhAgQC4bl50ZRmvrOnDmDlStXgmVZ9OnTB3fu3EFSUhIuXryIixcvIikpCXfv3kVAQABYlsXKlStx9uxZtdt79uwZjIyMYG9vL7tPJBIhJyenRNlevXrBwMAAoaGharenTRSgEUIIIUQtGzduBAAMHz4cBw4cQJMmTUqUady4Mfbv34/hw4eDZVls2LBB7faqVKlSYi9PMzMzvH37Frm5ucXuNzAwQJUqVZCYmKh2e9pEARohhBDhYVG4SICXm7afjHBduHABIpEIixcvVlp20aJFYBgG58+fV7u9OnXq4O3btygoKJDdV79+fQDAlStXipVNSUlBRkaGYFd6UoBGCCGEELW8fPkSFhYWqFWrltKytWvXRrVq1UpdSMCFk5MTxGIxbt26JbvPx8cHLMtiwYIFskudeXl5GD9+PADA2dlZ7fa0iQI0QgghwiTh6UbUZmZmhnfv3smdA/ax7OxsvHv3Dqampmq399lnn4FlWRw5ckR237hx42BkZITw8HDUrVsXnp6eqFOnDsLCwsAwTJn2/tQmCtAIIYQIEn+LBIi6WrRoAbFYjF9++UVp2V9++QUFBQVo2bKl2u316dMHc+fOha2trew+BwcH7N69G2ZmZnj9+jUuXryIV69egWEYTJ06FQMHDlS7PW2iPGiEEEIIUcvAgQMRERGByZMnw8jICMOHD5db7ueff8bkyZPBMAwGDRqkdnvVqlXD3LlzS9zfq1cveHt746+//kJSUhIsLCzw2WefoUGDBmq3pW0MK9TZc4QQQiodV1dXxMbGwqyKDdydAnmp8+LdLXj3PhUuLi6IiYnhpc7KQiKRwN/fH2fOnAHDMKhbty58fX1Rp04dAEBycjIiIiLw9OlTsCwLHx8fhIeHg2EYLfdc99EZNEIIIcIjXcXJV11ELSKRCIcPH8awYcMQGhqKpKQk/Pbbb8XKSM8D9enTB9u2baPgjCMK0AghhBCiNnNzcxw8eBCXL1/Gvn37SuzF2aZNG3z11Vdwc3Mrc1ve3t7w9/eHj48P3N3dYWBgUOY6dRUFaIQQQoSJVmDqFOn2Tpp09uxZnDt3DvPnz4exsTHc3d3h6+sLX19ffPrpp9DT09No++WJAjRCCCGEaJWNjQ1evHhRLAGtPIsXL0ZERATOnz+P7OxsnD59GhEREQAKdxlo3769LGBzdXWFSCTcZBUUoBFCCBEcBvylyGBoEppO4LJmcfr06Zg+fTry8/Nx6dIlRERE4PTp07h06RKysrJw4sQJ/PPPPwAKc7R16NABfn5+mDhxoqa7zztaxUkIIUQwpKs4zU2s4d5wBC91Xnz4M95mp9EqTi2ysbHB8+fPIRaL1To+JycH58+fl51Ru3r1quxsHMMwaterTXQGjRBCCCGCZmxsDB8fH5iYmMDY2Bj5+fmIjY0V7D6cAAVohBBChIjSbBAAsbGxOH36NE6fPo1z584hKysLQOHlUlNTU7Rv3x5+fn5a7qV6KEAjhBBCiCDcuXNHFpCdOXMGb968AVAYkBkbG8PX1xd+fn7w9fVF27ZtBb2qkwI0QgghwiTgy1dEPc2bN5clutXX14enp6csKHN3d4ehoaGWe8gfCtAIIYQIE+VBq7TMzc0xbtw4dO3aFW3bthV0Oo3SVLxnRAghhJAKqVOnTjAxMUFGRgaWLl0KT09PVK9eHd26dcPq1atx/fp1bXeRN3QGjRBCiCDxlQeNCMeJEydQUFCA6Oho2Vy0S5cu4dixY/jrr78AAJaWlvD29oafnx/8/PzQpEkTLfdaPRSgEUIIER6W5XEVJwV6QiKde+bp6YnZs2cjNzcXFy5cQHh4OE6fPo2rV68iNDQUYWFhAApzrCUnJ2u516qjAI0QQgghgmVkZCTb3qmgoAAnT57EggULEB0dDQBITU3Vcg/VQwEaIYQQYZLQma+KQt2EsizLIiYmRna58/z583j//n2xMkZGRnx0sdxRgEYIIeT/7d1tUFRl/wfw71ndhSAeItBwV4FAwSZ8iLBMZI0a7WGmkZCmQsfKpMYcIbUxnSFH0pkctByFFzE+vHCiEQhuYsa7iYBAlDAhUYIRoQcWUBZucwUHdmP3/F/43+3m5sFlPcvuqe9nZl949rp++1vGF9+5zl7nInKp69ev2z22qanJFsiqq6thMBgA/BXylEolYmNjbY/feOqpp5zSs7MxoBERkTzxt2P/ODNnzkRfXx+AvwLZtGnTsHjxYtsDauPi4uDt7e3KNiXBgEZERPLEgOY2GhsbkZOTg5qaGnR2dtqOXBqLIAi2g8wnq7e3F4IgIDo62hbItFotfH19HW3dbTGgERERkcOys7OxdetWmM1mpx9OXlhYCK1WiwcffPCe6iQlJeHmzZsoLy+XqDPpMaAREZH88LB0t1BXV4e0tDQAwKZNm/Diiy/ihRdeQEBAAPLz83H9+nV89913yMvLg6+vLw4fPozg4GCHP+/ll1+WpO9z585Br9dLUstZGNCIiEiGRAl3cTKhOerw4cMQRRHp6en49NNPbddVKhUSEhIAAK+//jq2bNmCVatWISMjAw0NDa5qV1Z41BMRERE55OzZsxAEwbaKZvW/tzoXLVqEI0eOoL29HVlZWVPZomwxoBERkTyJFmle5LCenh54eHggJCTEdk2hUGBoaGjU2MTERCiVShQVFU1li7LFW5xERETkEC8vLwiCMOKaj48Pbt26BaPROOIhsUqlEl5eXvj999+nuk1Z4goaERHJk/U8znt9kcPUajVu3bo14rEZ4eHhAIAff/xxxNju7m4YDAan7/T8u2BAIyIi+RFxZ5OAFC/mBYfNnz8fZrMZly9ftl1bsWIFRFFEZmam7VanyWTCli1bAADR0dEu6VVuGNCIiIjIIStXroQoiigtLbVde++99+Dh4YHy8nJoNBosW7YMarUaxcXFEAQBmzdvdmHH8sHfoBERkQxJeXuSS2iOSkpKQmdnJ2bNmmW7FhYWhry8PLz55pu4ceMGamtrAdzZPPDBBx8gJSXFVe3KCgMaERHJE3/L5HL+/v7YvXv3qOuJiYnQarU4ffo0dDod/Pz8sHLlSkRERLigS3liQCMiIiLJBQQEYO3ata5uQ7YY0IiISJ64gkYOksNOUgY0IiIiumcmkwllZWW4cOGC7ZzLGTNmIDY2Fs8++yxUKpWLO/xLcXExTCaTq9uYEAMaERHJjwjAItEpAO6/mOL2cnNzkZGRgb6+vjHfDwwMxN69e7Fx48Yp7mxsS5cudXULd8WARkREMsRdnO5ix44dOHDggO22oVqthkajAQB0dnaiq6sLvb29ePfdd9He3o5PPvnEle3KBp+DRkRERA6pqqpCVlYWRFFEUlISmpubodPpUFtbi9raWuh0OrS0tGDNmjUQRRFZWVk4c+aMq9uWBQY0IiKSJx715HI5OTkAgA0bNqCgoABRUVGjxkRGRiI/Px8bNmyAKIrIzs6e6jZliQGNiIjkh0c9uYVz585BoVBg3759dx27d+9eCIKAs2fPTkFn8seARkRERA7p6+uDn58fZsyYcdexM2fOhL+//7gbCWgkbhIgIiJZEkWJdnGSw3x8fGAwGDA0NARPT88Jxw4ODqK/vx++vr5T1J28cQWNiIiIHLJgwQKYzWYcP378rmOPHz+O4eFhLFy4cAo6kz8GNCIikiGJfn9mEcEfoTkuJSUFoihi27ZtOHbs2Ljjjh49im3btkEQBKxbt24KO5QvQZTDeQdEREQAYmJi0NDQAN9pD2Kpz2pJatb2/wu3zP/BY489hvr6eklq/lNYLBY888wzqKqqgiAI0Gg0ePrpp6FWqwHceQ5aZWUlurq6IIoiVqxYgfLycgiC4OLO3R9/g0ZEREQOUSgUKCkpwVtvvYWioiLodDqcPHlyxBjrOlBSUhKOHTvGcGYnBjQiIpIfHvXkNnx9fVFYWIjz58/j1KlTo87ifPzxx/Hqq68iNjbWxZ3KCwMaEREROaSjowPTpk2DWq3GkiVLsGTJkgnHd3d3Y3h4GHPmzJmiDuWLAY2IiOSJP6F2udDQUAQHB6Orq8uu8cuWLYNOp8Pw8LCTO5M/BjQiIpIdESJEiW5xirzHeU8mu9eQexPtw8dsEBER0ZQYGhrC9OlcG7IH/0pERCQ/IqS7xckFnSnR3d2N3t5eu46FIgY0IiKSKwuT1VSrrq7G999/P+LawMAAMjMzx50jiiJu3ryJ06dPQxRFPPHEE07u8u+BAY2IiIjsUllZiT179ox4ltnt27exZ8+eu84VRRGenp7YuXOnM1v822BAIyIiGRIByQ5Ld95KXGVlJQ4ePIi6ujoMDAwgJCQEycnJ+PDDD+Ht7e1Qza+++grZ2dm4ePEiTCYT5s6di7Vr1yItLQ1KpXLceXq9Hvv27UNpaSm6u7vh7+8PrVaLnTt3YtGiRXZ9dmhoKLRare3fVVVVUCqVWLp06bhzFAoFfH198eijj2L9+vWIiIiw+7v+k/GoJyIikg3rUU8+wgNYqnpekpq1pn+jX/xD8qOejhw5grS0NIiiCI1Gg6CgIDQ3N8NoNGL+/PmoqalBQEDApGpu374dBw8eBACEh4fD29sbP//8M8xmM+Lj4/Htt9/Cw8Nj1Ly2tjbExcWhp6cH3t7eiIyMRGdnJ/R6PVQqFQoKCvDSSy9N+jsqFAo89NBD6O7unvRcmhh3cRIRkfyIgGgRJXk5YwGtvr4e6enpAIDPP/8cHR0daGhowC+//IKYmBi0tLRg48aNk6pZXFyMgwcPwsPDAyUlJWhra0NjYyOampoQFhaG6upq7Nq1a9Q8URSRnJyMnp4ePPfcc+jq6kJ9fT26urqQkZEBk8mElJQUXLt2bdLf88SJEzh06NCk59HdMaAREZE8iRZpXk7w8ccfw2KxYN26dUhNTbX9ZmvWrFn48ssvoVAoUFRUhEuXLtld0/o7rx07doxY7YqKisLRo0cBADk5Oejt7R0xr6SkBBcvXoSfnx/y8vLg5+cHAJg+fToyMzMRHx+PgYEBHDhwYNLfc/369XjllVcmPY/ujgGNiIhIQgMDA/jmm28AAKmpqaPenzt3LhISEgAABQUFdtW8evUqGhsbx62ZkJCAiIgIGI1GfP311yPes35GcnIyHnjggVFzrfXy8/Pt6oWmBgMaERHJkmS3OCX2008/wWg0wsPDY9yzKZcvXw4A+OGHH+yqaR338MMPQ61WT6qm9d/x8fETzuvs7LT7yCZyPgY0IiKSIVHCW5zShrTW1lYAwJw5c8bdVRkeHg4AuHLlyqRqWufZW9NkMuG3336bcO7s2bOhUqkm1Q85Hx+zQUREsnMb/agTv5OsFgC0tLQgJibG7nmpqal45513Rl2/ceMGAEy4Q9P63h9//GHXZzla02AwwPL/Z5aON1cQBPj7+0Ov19vdDzkfAxoREcmOBWb046akNQcHB9HQ0GD3+PF2PQ4NDQGAbVVqLNZHYQwODtr1WY7WtM6Tuh9yPgY0IiKSjaioKKfU7evrQ39/P8LCwuyeExwcPOZ1T09PAHduL47HaDQCAO677z67PsvRmtZ5UvdDzseARkREsvHFF1+4uoW7su6UtN6WHIv1vbF2VUpZ08/PDwqFAhaLZdy51rMyJ9MPOR83CRAREUlo3rx5AICOjg78+eefY45pb28fMdbemm1tbeOOGaumSqVCSEjIhHN1Op1tdc3efsj5GNCIiIgktHjxYqhUKhiNRpw/f37MMWfOnAGACc+w/G9PPvkkAODXX38d91EY49W0zrW+P948jUYDjUZjVz/kfAxoREREEvLx8cGqVasAALm5uaPev3r1KioqKgAAa9assavmvHnzEB0dPW7NiooKtLW1QaVSjTpT0/oZBQUFY+7StNZLTk62qxeaGgxoREREEsvIyIAgCDh58iRyc3MhineetXbt2jW89tprsFgsWL16NRYuXDhiXmhoKEJDQ1FYWDiq5u7duwEA+/fvR2lpqe36lStX8PbbbwMANm3ahKCgoBHzVq9ejQULFsBgMCAlJQUGgwEAYDab8dFHH6G6uhpeXl7Yvn27dH8AumeCaP1fQ0RERJI5dOgQtm7dClEUMXv2bAQGBqK5uRlGoxGRkZGoqalBYGDgiDnWMztPnDiBN954Y1TN999/33Y4eXh4OO6//340NTXBbDYjLi4OZWVlI3ZuWrW2tmL58uXQ6/Xw9vZGVFQUdDod9Ho9lEolTp06hcTERMn/BuQ4rqARERE5QXp6OsrKyvD888/j9u3baG5uRkhICHbt2oULFy6MCmf2+Oyzz5Cfnw+tVou+vj60trbikUcewf79+1FRUTFmOAPu3CK9dOkSNm/ejKCgIFy+fBnAndufdXV1DGduiCtoRERERG6GK2hEREREboYBjYiIiMjNMKARERERuRkGNCIiIiI3w4BGRERE5GYY0IiIiIjcDAMaERERkZthQCMiIiJyMwxoRERERG6GAY2IiIjIzTCgEREREbkZBjQiIiIiN8OARkRERORmGNCIiIiI3Mz/ATePESpELxZaAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# in an even better way \n", + "fig = plt.figure()\n", + "ax = plt.axes(projection=ccrs.PlateCarree())\n", + "# ax.set_extent([-20, -10, 30, 60])\n", + "# out[\"1\"].plot(ax=ax, transform=ccrs.PlateCarree())\n", + "# ax.pcolormesh(out[\"1\"].longitude, out[\"1\"].latitude, out[\"1\"].values)\n", + "ds.isel(band=0).Rad.plot.pcolormesh(x=\"longitude\", y=\"latitude\", transform=ccrs.PlateCarree())\n", + "\n", + "\n", + "# ax.set(xlim=[-140, -70,],\n", + "# ylim=[ -40, 10])\n", + "\n", + "# # Add map features with Cartopy \n", + "# ax.add_feature(cfeature.NaturalEarthFeature('physical', 'land', '10m', \n", + "# edgecolor='face', \n", + "# facecolor='lightgray'))\n", + "ax.coastlines()\n", + "# Plot lat/lon grid \n", + "gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,\n", + " linewidth=0.1, color='k', alpha=1, \n", + " linestyle='--')\n", + "gl.top_labels = False\n", + "gl.right_labels = False\n", + "gl.xformatter = LONGITUDE_FORMATTER\n", + "gl.yformatter = LATITUDE_FORMATTER\n", + "gl.xlabel_style = {'size': 8}\n", + "gl.ylabel_style = {'size': 8} \n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "03e23e79-2d76-4e18-b722-46e26770f70c", + "metadata": {}, + "source": [ + "## DataLoading" + ] + }, + { + "cell_type": "markdown", + "id": "aae9ef67-603d-490e-8cfd-65a82717d4fd", + "metadata": {}, + "source": [ + "We can start using any dataloader framework right away.\n", + "In this example, we will use PyTorch." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "1d9b5d86-625c-4f6f-9dc5-46ca6d305a4a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/data.py:519: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n", + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/NEW.py:188: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n" + ] + } + ], + "source": [ + "from rs_tools._src.utils.io import get_list_filenames\n", + "from rs_tools._src.datamodule.utils import load_nc_file\n", + "from rs_tools._src.datamodule.editor import StackDictEditor, CoordNormEditor\n", + "from toolz import compose_left" + ] + }, + { + "cell_type": "markdown", + "id": "23ac0d26-6441-432c-802a-48fff58b7005", + "metadata": {}, + "source": [ + "We will create a very simple demo dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "9ba21c4b-89a9-45d8-87e6-1ee34f436e8f", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import Dataset, DataLoader\n", + "from typing import Optional, Callable\n", + "\n", + "class NCDataReader(Dataset):\n", + " def __init__(self, data_dir: str, ext: str=\".nc\", transforms: Optional[Callable]=None):\n", + " self.data_dir = data_dir\n", + " self.data_filenames = get_list_filenames(data_dir, ext)\n", + " self.transforms = transforms\n", + "\n", + " def __getitem__(self, ind) -> np.ndarray:\n", + " nc_path = self.data_filenames[ind]\n", + " x = load_nc_file(nc_path)\n", + " if self.transforms is not None:\n", + " x = self.transforms(x)\n", + " return x\n", + "\n", + " def __len__(self):\n", + " return len(self.data_filenames)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "4f9af252-b6e1-4577-82df-0846f466a391", + "metadata": {}, + "outputs": [], + "source": [ + "ds = NCDataReader(f\"{save_dir}/msg/analysis\")\n", + "dl = DataLoader(ds, batch_size=8)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "91200aa6-6e72-40bc-855f-eeadb0e3f3bd", + "metadata": {}, + "outputs": [], + "source": [ + "out = next(iter(dl))" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "3b5904f6-e7f1-4cef-a9ca-42470b226330", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['data', 'wavelengths', 'coords', 'cloud_mask']" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(out.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "19a8ee9e-7b14-42fa-92e7-b77cf87dcb26", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([8, 11, 32, 32]), torch.Size([8, 2, 32, 32]))" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out[\"data\"].shape, out[\"coords\"].shape" + ] + }, + { + "cell_type": "markdown", + "id": "1e4b12eb-91fd-4239-ab67-cae234e11953", + "metadata": {}, + "source": [ + "### Transforms/Editors" + ] + }, + { + "cell_type": "markdown", + "id": "c0cd3715-b63e-4246-b668-b7178df1040a", + "metadata": {}, + "source": [ + "We can also use custom transformations within the dataset (just like standard PyTorch) to transform our dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "12a71034-aa32-47bb-9aae-0f04c2082f8f", + "metadata": {}, + "outputs": [], + "source": [ + "transforms = compose_left(\n", + " CoordNormEditor(), \n", + " StackDictEditor(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9521f77-6876-4b14-8a1c-632e61a69257", + "metadata": {}, + "outputs": [], + "source": [ + "# initialize dataset with transforms\n", + "ds = NCDataReader(f\"{save_dir}/msg/analysis\", transforms=transforms)\n", + "\n", + "# initialize dataloader\n", + "dl = DataLoader(ds, batch_size=8)\n", + "\n", + "# do one iteration\n", + "out = next(iter(dl))\n", + "\n", + "# inspect a batch\n", + "out.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c949aed0-f3a3-47cb-a6c7-2de263587e30", + "metadata": {}, + "outputs": [], + "source": [ + "ge" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bc474dd0-7ef6-4155-a5f9-f1903126e922", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:rs_tools]", + "language": "python", + "name": "conda-env-rs_tools-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/scripts/gen_pages.py b/docs/scripts/gen_pages.py new file mode 100644 index 0000000..637e233 --- /dev/null +++ b/docs/scripts/gen_pages.py @@ -0,0 +1,82 @@ +from pathlib import Path + +import mkdocs_gen_files +from mkdocs_gen_files import Nav +from typing import Iterable, Mapping, Union +import dataclasses + + +class CustomNav(Nav): + def __init__(self): + super().__init__() + + @dataclasses.dataclass + class Item: + level: int + title: str + filename: Union[str, None] + + @classmethod + def _items(cls, data: Mapping, level: int) -> Iterable[Item]: + for key, value in data.items(): + if key is not None: + if key == "rs_tools": + title = "RSTOOLS" + elif key == "_src": + title = "Source" + elif key == "modis": + title = "MODIS" + elif key == "msg": + title = "MSG" + elif key == "goes": + title = "GOES" + else: + title = key.title() + + # title = title.replace("_", " ") + # title = title.replace("Matern", "Matérn") + + yield cls.Item(level=level, title=title, filename=value.get(None)) + yield from cls._items(value, level + 1) + + +nav = CustomNav() + +for path in sorted(Path("rs_tools").rglob("*.py")): + module_path = path.relative_to(".").with_suffix("") + doc_path = path.relative_to("rs_tools").with_suffix(".md") + full_doc_path = Path("api", doc_path) + + parts = list(module_path.parts) + + if parts[-1] == "__init__": + parts = parts[:-1] + doc_path = doc_path.with_name("index.md") + full_doc_path = full_doc_path.with_name("index.md") + continue + elif parts[-1] == "__main__": + continue + + # final_part = parts[-1].title() + # parts = parts[:-1] + [final_part] + nav[parts] = doc_path.as_posix() + + # print(full_doc_path) + with mkdocs_gen_files.open(full_doc_path, "w") as fd: + identifier = ".".join(parts) + title = identifier.split(".")[-1].replace("_", " ").title() + # if title == "Gps": + # title = "GPs" + # elif title == "Rbf": + # title = "RBF" + + # if "Matern" in title: + # title = title.replace("Matern", "Matérn") + + print(f"# {title}\n", file=fd) + print("::: " + identifier, file=fd) # + + mkdocs_gen_files.set_edit_path(full_doc_path, path) + +with mkdocs_gen_files.open("api/SUMMARY.md", "w") as nav_file: + nav_file.writelines(nav.build_literate_nav()) \ No newline at end of file diff --git a/environment.yaml b/environments/environment.yaml similarity index 68% rename from environment.yaml rename to environments/environment.yaml index d52ff73..b142e29 100644 --- a/environment.yaml +++ b/environments/environment.yaml @@ -13,6 +13,7 @@ dependencies: - earthaccess - eumdac - pyinterp + - satpy # - conda-forge::torchgeo - pandas # Data structure - scikit-learn # Machine Learning @@ -36,7 +37,9 @@ dependencies: - toolz - typer - einops + - cartopy # formatting + - rasterio - black - pylint - isort @@ -57,5 +60,23 @@ dependencies: # experiment - hydra-core - hydra-zen + # Docs + - mkdocs-gen-files + - mkdocs-literate-nav + - mkdocs-git-authors-plugin + - mkdocstrings + - markdown-katex + - pytkdocs + - mdx-truly-sane-lists + - mkdocs-jupyter + - mkdocs-bibtex + - pygments + - mknotebooks + - pymdown-extensions + - mkdocs-material + - mkdocs + - aiohttp + # ITI + - git+https://github.com/spaceml-org/InstrumentToInstrument.git@development - wandb - \ No newline at end of file + diff --git a/environment-iti.yaml b/environments/environment_iti.yaml similarity index 93% rename from environment-iti.yaml rename to environments/environment_iti.yaml index 7fbba5e..751fd89 100644 --- a/environment-iti.yaml +++ b/environments/environment_iti.yaml @@ -16,17 +16,15 @@ dependencies: # - conda-forge::torchgeo - pandas # Data structure - scikit-learn # Machine Learning - # - joblib # Parallelization # PLOTTING LIBRARY - matplotlib # standard plotting library - seaborn # Stats viz library - # - conda-forge::hvplot # Storage - netCDF4 - zarr - h5netcdf + - pyhdf - nvidia/label/cuda-12.2.0::cuda - # - gdal>=3.4.1,<=3.6.3 # - h5py # GUI - ipywidgets diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 0000000..f2ea5ee --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,98 @@ +site_name: RS-Tools +site_description: The documentation for the RS-Toolz Library +site_url: https://spaceml-org.github.io/rs_tools/ +repo_url: https://github.com/spaceml-org/rs_tools/ +repo_name: rs_tools + +edit_uri: "" + +nav: + - Home: index.md + - Getting Started: + - 🛠️ Installation: installation.md + - Datasets: + - 🛰 MODIS: datasets/modis.md + - 🛰 MSG: datasets/msg.md + - 🛰 GOES16: datasets/goes.md + - Pipelines: + - 🛰 GOES-16: pipelines/goes16.ipynb + - 🛠️ MODIS-Aqua: pipelines/modis_aqua.ipynb + - MSG: pipelines/msg.ipynb + - 🛠️ Analysis-Ready Data: pipelines/analysis_datasets.ipynb + - 🛠️ ML-Ready Data: pipelines/ml_ready_datasets.ipynb + - 📕 Reference: api/ + +theme: + name: material + features: + - navigation.instant + - navigation.tracking + - navigation.sections + - navigation.expand + - navigation.top # Show a back to top button + - content.code.copy + - search.suggest # Show search suggestions + - search.highlight # Highlight search results in results + - content.code.annotate # Allow individual lines of code to be annotated + +markdown_extensions: + - pymdownx.arithmatex: + generic: true + - admonition + - pymdownx.details # Enhance admonitions with collapse/expand + - markdown_katex: + no_inline_svg: True + insert_fonts_css: True + - pymdownx.tabbed: + alternate_style: true + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.superfences + - pymdownx.snippets: + check_paths: true + - pymdownx.tabbed + - toc: + permalink: '' + toc_depth: 4 + - footnotes + # - pymdownx.arithmatex: + # generic: true + - attr_list + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + +plugins: + - mkdocs-jupyter + - search + - gen-files: + scripts: + - docs/scripts/gen_pages.py # or any other name or path + - literate-nav: + nav_file: SUMMARY.md + - mkdocstrings: + watch: + - rs_tools + default_handler: python + handlers: + python: + rendering: + show_root_heading: true + show_root_full_path: true + show_if_no_docstring: true + show_signature_annotations: true + show_source: false + members_order: source # order methods according to their order of definition in the source code, not alphabetical order + heading_level: 4 + options: + inherited_members: true # Allow looking up inherited methods + docstring_style: "google" + + +extra_javascript: + - javascripts/katex.js + - https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.7/katex.min.js + - https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.7/contrib/auto-render.min.js + +extra_css: + - https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.7/katex.min.css \ No newline at end of file diff --git a/notebooks/1.0-pipeline-modis.ipynb b/notebooks/1.0-pipeline-modis.ipynb index fb12b03..74d0546 100644 --- a/notebooks/1.0-pipeline-modis.ipynb +++ b/notebooks/1.0-pipeline-modis.ipynb @@ -18,16 +18,18 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "5d7511e4-80b3-4053-8c5c-bb430d8a0c14", "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/data.py:519: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n", + "/home/juanjohn/miniconda/envs/rs_tools/lib/python3.11/site-packages/goes2go/NEW.py:188: FutureWarning: 'H' is deprecated and will be removed in a future version. Please use 'h' instead of 'H'.\n", + " within=pd.to_timedelta(config[\"nearesttime\"].get(\"within\", \"1H\")),\n" ] } ], @@ -59,14 +61,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "67205ce7-1b02-40ff-87d4-ef3622a60fc4", "metadata": {}, "outputs": [], "source": [ - "save_dir_raw = \"/home/juanjohn/data/rs/modis/raw/modis\"\n", - "save_dir_analysis = \"/home/juanjohn/data/rs/modis/analysis/\"\n", - "save_dir_mlready = \"/home/juanjohn/data/rs/modis/mlready/\"" + "save_dir_raw = \"/pool/usuarios/juanjohn/data/rs/modis/raw/modis\"\n", + "save_dir_analysis = \"/pool/usuarios/juanjohn/data/rs/modis/analysis/\"\n", + "save_dir_mlready = \"/pool/usuarios/juanjohn/data/rs/modis/mlready/\"" ] }, { @@ -94,17 +96,17 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "b0015f0f-cece-4c03-80aa-6f1ba63535b3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -123,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "1ec716a2-82d4-43d1-9d7a-ae467988dfad", "metadata": {}, "outputs": [ @@ -138,7 +140,7 @@ "data": { "text/html": [ "\n", - "
\n", + "
\n", "