diff --git a/.gitignore b/.gitignore
index 520bac6..16ba66f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@
*/*/*.log
*/*/geom
*/*/weather_files
+*/*/*/tmp.yaml
diff --git a/notebooks/HRRR_Availability.ipynb b/notebooks/HRRR_Availability.ipynb
new file mode 100644
index 0000000..7dd89b5
--- /dev/null
+++ b/notebooks/HRRR_Availability.ipynb
@@ -0,0 +1,261 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 90,
+ "id": "b410f20b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Automatic pdb calling has been turned OFF\n",
+ "(ARIA) 2023-09-07 09:27:21.243326\n"
+ ]
+ }
+ ],
+ "source": [
+ "import os\n",
+ "from pathlib import Path\n",
+ "from datetime import datetime\n",
+ "from herbie import Herbie\n",
+ "%pdb off\n",
+ "%matplotlib inline\n",
+ "print (os.getenv('CONDA_PROMPT_MODIFIER'), datetime.now())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 81,
+ "id": "0784f49b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = 'hrrr'\n",
+ "product = 'nat'\n",
+ "fxx = 0\n",
+ "wd = Path(os.getenv('dataroot', './'))\n",
+ "wd = wd / 'HRRR_availability'\n",
+ "valid_range = (datetime(2016, 7, 15, 0), datetime.today())\n",
+ "available_dates = dates = pd.date_range(valid_range[0], valid_range[1], freq='H')\n",
+ "n_dt = len(available_dates)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 84,
+ "id": "73955f15",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Started at: 2023-09-06 19:36:59.289994\n",
+ "Date 0 of 62636\n",
+ "Date 5000 of 62636\n",
+ "Date 10000 of 62636\n",
+ "Date 15000 of 62636\n",
+ "Date 20000 of 62636\n",
+ "Date 25000 of 62636\n",
+ "Date 30000 of 62636\n",
+ "Date 35000 of 62636\n",
+ "Date 40000 of 62636\n",
+ "Date 45000 of 62636\n",
+ "Date 50000 of 62636\n",
+ "Date 55000 of 62636\n",
+ "Finished at: 2023-09-07 09:06:18.240831\n"
+ ]
+ }
+ ],
+ "source": [
+ "lst_exist = []\n",
+ "lst_miss = []\n",
+ "srcs = []\n",
+ "print ('Started at:', datetime.now())\n",
+ "for i, dt in enumerate(available_dates):\n",
+ " if i % 5000 == 0:\n",
+ " print (f'Date {i} of {n_dt}')\n",
+ " \n",
+ " H = Herbie(\n",
+ " dt.strftime('%Y-%m-%d %H:%M'),\n",
+ " model=model,\n",
+ " product=product,\n",
+ " fxx=fxx,\n",
+ " overwrite=False,\n",
+ " verbose=False,\n",
+ " save_dir=wd\n",
+ " )\n",
+ " \n",
+ " src = H.grib_source\n",
+ " if src is None:\n",
+ " lst_miss.append(dt)\n",
+ " else:\n",
+ " lst_exist.append(dt)\n",
+ " srcs.append(src)\n",
+ "\n",
+ "print ('Finished at:', datetime.now())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 85,
+ "id": "0ed67a9b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "61739"
+ ]
+ },
+ "execution_count": 85,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(lst_exist)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 86,
+ "id": "432f163a",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "897"
+ ]
+ },
+ "execution_count": 86,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(lst_miss)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 96,
+ "id": "b7708ccf",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Percent Missing: 1.43%\n"
+ ]
+ }
+ ],
+ "source": [
+ "print (f'Percent Missing: {100*len(lst_miss)/n_dt:.2f}%')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 107,
+ "id": "d70ad257",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Text(0, 0.5, 'Number of hours')"
+ ]
+ },
+ "execution_count": 107,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, axes = plt.subplots(figsize=(12,8))\n",
+ "pd.DataFrame(lst_miss).hist(ax=axes)\n",
+ "axes.set_ylabel('Number of hours')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 115,
+ "id": "08c14d63",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "aws 61651\n",
+ "pando 87\n",
+ "local 1\n",
+ "dtype: int64"
+ ]
+ },
+ "execution_count": 115,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ser_srcs = pd.Series(srcs)\n",
+ "ser_srcs.value_counts() # local is one I downloaded"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.15"
+ },
+ "latex_envs": {
+ "LaTeX_envs_menu_present": true,
+ "autoclose": false,
+ "autocomplete": false,
+ "bibliofile": "biblio.bib",
+ "cite_by": "apalike",
+ "current_citInitial": 1,
+ "eqLabelWithNumbers": true,
+ "eqNumInitial": 1,
+ "hotkeys": {
+ "equation": "Ctrl-E",
+ "itemize": "Ctrl-I"
+ },
+ "labels_anchors": false,
+ "latex_user_defs": false,
+ "report_style_numbering": false,
+ "user_envs_cfg": false
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/RAiDER_ARIA/ariaTesting.ipynb b/notebooks/RAiDER_ARIA/ariaTesting.ipynb
new file mode 100644
index 0000000..c8f98d1
--- /dev/null
+++ b/notebooks/RAiDER_ARIA/ariaTesting.ipynb
@@ -0,0 +1,387 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "eb49726a",
+ "metadata": {
+ "init_cell": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Tutorial directory: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/RAiDER_ARIA\n",
+ "Work directory: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/RAiDER_ARIA\n"
+ ]
+ }
+ ],
+ "source": [
+ "import os, os.path as op\n",
+ "import shutil\n",
+ "import yaml\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
+ "\n",
+ "import pandas as pd\n",
+ "import xarray as xr\n",
+ "from wand.image import Image as WImage\n",
+ "\n",
+ "## Defining the home and data directories\n",
+ "tutorial_home_dir = os.path.abspath(os.getcwd())\n",
+ "work_dir = os.path.abspath(os.getcwd())\n",
+ "print(\"Tutorial directory: \", tutorial_home_dir)\n",
+ "print(\"Work directory: \", work_dir)\n",
+ "\n",
+ "# Verifying if RAiDER is installed correctly\n",
+ "try:\n",
+ " import RAiDER\n",
+ "except:\n",
+ " raise Exception('RAiDER is missing from your PYTHONPATH')\n",
+ "\n",
+ "os.chdir(work_dir)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6f52403a",
+ "metadata": {},
+ "source": [
+ "### helpers"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "78fe0d71",
+ "metadata": {
+ "init_cell": true
+ },
+ "outputs": [],
+ "source": [
+ "def new_yaml_group(example_yaml, dct_group, dst='tmp.yaml'):\n",
+ " \"\"\" Write a temporary yaml file with the new 'value' for 'key', preserving parms in example_yaml\"\"\"\n",
+ " with open(example_yaml, 'r') as f:\n",
+ " try:\n",
+ " params = yaml.safe_load(f)\n",
+ " except yaml.YAMLError as exc:\n",
+ " print(exc)\n",
+ " raise ValueError(f'Something is wrong with the yaml file {example_yaml}')\n",
+ " \n",
+ " params = {**params, **dct_group}\n",
+ " dst = op.join(os.path.dirname(example_yaml), dst)\n",
+ "# print (params)\n",
+ " \n",
+ " with open(dst, 'w') as fh:\n",
+ " yaml.dump(params, fh, default_flow_style=False)\n",
+ " \n",
+ " print ('Wrote new cfg file:', dst)\n",
+ " return dst"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4a1bd772",
+ "metadata": {},
+ "source": [
+ "#### Pieces of prepARIA"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "233bae03",
+ "metadata": {},
+ "source": [
+ "These are just for temporarily making the config file"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "4e488967",
+ "metadata": {
+ "init_cell": true
+ },
+ "outputs": [],
+ "source": [
+ "def makeLatLonGrid1(f:str, reg, out_dir):\n",
+ " ds0 = xr.open_dataset(f, group='science/grids/data')\n",
+ "\n",
+ " Lat, Lon = np.meshgrid(ds0.latitude.data, ds0.longitude.data)\n",
+ " print (Lat.shape, Lon.shape)\n",
+ "\n",
+ " da_lat = xr.DataArray(Lat.T, coords=[Lon[0, :], Lat[:, 0]], dims='lon lat'.split())\n",
+ " da_lon = xr.DataArray(Lon.T, coords=[Lon[0, :], Lat[:, 0]], dims='lon lat'.split())\n",
+ " dst_lat = op.join(out_dir, 'lat_HR.geo')\n",
+ " dst_lon = op.join(out_dir, 'lon_HR.geo')\n",
+ " da_lat.to_netcdf(dst_lat)\n",
+ " da_lon.to_netcdf(dst_lon)\n",
+ " logger.debug('Wrote: %s', dst_lat)\n",
+ " logger.debug('Wrote: %s', dst_lon)\n",
+ " return"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "bd10c986",
+ "metadata": {
+ "init_cell": true
+ },
+ "outputs": [],
+ "source": [
+ "def parse_time_GUNW(f:str):\n",
+ " \"\"\" Get the center time of the secondary date from the filename \"\"\"\n",
+ " tt = op.basename(f).split('-')[7]\n",
+ " return f'{tt[:2]}:{tt[2:4]}:{tt[4:]}'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "7a565639",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def makeLatLonGrid_dep(f:str, reg, out_dir):\n",
+ " '''\n",
+ " Convert the geocoded grids to lat/lon files for input to RAiDER\n",
+ " '''\n",
+ " from RAiDER.utilFcns import writeArrayToRaster\n",
+ " group = 'science/grids/data'\n",
+ " lat_f = os.path.join(f'NETCDF:\"{f}\":{group}/latitude')\n",
+ " lon_f = os.path.join(f'NETCDF:\"{f}\":{group}/longitude')\n",
+ "\n",
+ " ds0 = xr.open_dataset(f, group='science/grids/data')\n",
+ "\n",
+ " \n",
+ " gt = (0, 1, 0, 0, 0, 1)\n",
+ " proj = ds['crs'].crs_wkt\n",
+ "\n",
+ " lats = ds.latitude.data\n",
+ " lons = ds.longitude.data\n",
+ "\n",
+ " ySize = len(lats)\n",
+ " xSize = len(lons)\n",
+ "\n",
+ " # ISCE lats are ordered from smallest to biggest\n",
+ " LATS = np.flipud(np.tile(lats, (xSize, 1)).T)\n",
+ " LONS = np.tile(lons, (ySize, 1))\n",
+ "\n",
+ " dst_lat = op.join(out_dir, f'lat_{reg}.geo')\n",
+ " dst_lon = op.join(out_dir, f'lon_{reg}.geo')\n",
+ "\n",
+ " writeArrayToRaster(LATS, dst_lat, 0., 'GTiff', proj, gt)\n",
+ " writeArrayToRaster(LONS, dst_lon, 0., 'GTiff', proj, gt)\n",
+ "\n",
+ " logger.debug('Wrote: %s', dst_lat)\n",
+ " logger.debug('Wrote: %s', dst_lon)\n",
+ " return LATS, LONS"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "78874fc4",
+ "metadata": {},
+ "source": [
+ "## Hampton Roads Test"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "9148bfce",
+ "metadata": {
+ "init_cell": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3934, 2253) (3934, 2253)\n"
+ ]
+ }
+ ],
+ "source": [
+ "yaml_base = op.join(work_dir, 'example_yamls', 'raider.yaml')\n",
+ "gunw = op.join(work_dir, 'data', 'S1-GUNW-A-R-004-tops-20181219_20181113-230629-37654N_35778N-PP-ede0-v2_0_2.nc')\n",
+ "orb1 = op.join(work_dir, 'orbits', 'S1A_OPER_AUX_POEORB_OPOD_20181203T120749_V20181112T225942_20181114T005942.EOF')\n",
+ "orb2 = op.join(work_dir, 'orbits', 'S1A_OPER_AUX_POEORB_OPOD_20190108T120818_V20181218T225942_20181220T005942.EOF')\n",
+ "orb3 = op.join(work_dir, 'orbits', 'S1A_OPER_AUX_POEORB_OPOD_20210309T234202_V20181112T225942_20181114T005942.EOF')\n",
+ "makeLatLonGrid1(gunw, 'HR', op.join(work_dir, 'data'));"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0f314c11",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# first just use config file option"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "id": "3264dfcc",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Wrote new cfg file: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/RAiDER_ARIA/example_yamls/tmp.yaml\n",
+ "/Users/buzzanga/Miniconda3/envs/RAiDER/lib/python3.10/site-packages/rasterio/__init__.py:304: NotGeoreferencedWarning: Dataset has no geotransform, gcps, or rpcs. The identity matrix will be returned.\n",
+ " dataset = DatasetReader(path, driver=driver, sharing=sharing, **kwargs)\n",
+ "Starting to run the weather model calculation\n",
+ "Time: 20181113\n",
+ "Beginning weather model pre-processing\n",
+ "\u001b[33;21mWARNING: Weather model already exists, please remove it (\"['/Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/RAiDER_ARIA/weather_files/ERA-5_2018_11_13_T23_06_29.nc']\") if you want to download a new one.\u001b[0m\n",
+ "Extent of the weather model is (xmin, ymin, xmax, ymax):-78.93, 35.38, -74.93, 37.88\n",
+ "Extent of the input is (xmin, ymin, xmax, ymax): -78.53, 35.78, -75.26, 37.65\n",
+ "\u001b[33;21mWARNING: The processed weather model file already exists, so I will use that.\u001b[0m\n",
+ "Output SNWE: [35.78, 37.660000000000004, -78.54, -75.24]\n",
+ "Output cube spacing: 0.02\n",
+ "/Users/buzzanga/Miniconda3/envs/RAiDER/lib/python3.10/site-packages/rasterio/__init__.py:304: NotGeoreferencedWarning: Dataset has no geotransform, gcps, or rpcs. The identity matrix will be returned.\n",
+ " dataset = DatasetReader(path, driver=driver, sharing=sharing, **kwargs)\n",
+ "Using existing DEM: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/RAiDER_ARIA/GLO30_fullres_dem.tif\n",
+ "\u001b[31;21mERROR: Date 2018-11-13 23:06:29 failed\u001b[0m\n",
+ "Traceback (most recent call last):\n",
+ " File \"rasterio/_base.pyx\", line 302, in rasterio._base.DatasetBase.__init__\n",
+ " File \"rasterio/_base.pyx\", line 213, in rasterio._base.open_dataset\n",
+ " File \"rasterio/_err.pyx\", line 217, in rasterio._err.exc_wrap_pointer\n",
+ "rasterio._err.CPLE_OpenFailedError: '/Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/RAiDER_ARIA/orbits/S1A_OPER_AUX_POEORB_OPOD_20210309T234202_V20181112T225942_20181114T005942.EOF' not recognized as a supported file format.\n",
+ "\n",
+ "During handling of the above exception, another exception occurred:\n",
+ "\n",
+ "Traceback (most recent call last):\n",
+ " File \"/Users/buzzanga/Software_InSAR/RAiDER_git/tools/RAiDER/losreader.py\", line 111, in __call__\n",
+ " LOS_enu = inc_hd_to_enu(*rio_open(self._file))\n",
+ " File \"/Users/buzzanga/Software_InSAR/RAiDER_git/tools/RAiDER/utilFcns.py\", line 146, in rio_open\n",
+ " with rasterio.open(fname) as src:\n",
+ " File \"/Users/buzzanga/Miniconda3/envs/RAiDER/lib/python3.10/site-packages/rasterio/env.py\", line 444, in wrapper\n",
+ " return f(*args, **kwds)\n",
+ " File \"/Users/buzzanga/Miniconda3/envs/RAiDER/lib/python3.10/site-packages/rasterio/__init__.py\", line 304, in open\n",
+ " dataset = DatasetReader(path, driver=driver, sharing=sharing, **kwargs)\n",
+ " File \"rasterio/_base.pyx\", line 304, in rasterio._base.DatasetBase.__init__\n",
+ "rasterio.errors.RasterioIOError: '/Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/RAiDER_ARIA/orbits/S1A_OPER_AUX_POEORB_OPOD_20210309T234202_V20181112T225942_20181114T005942.EOF' not recognized as a supported file format.\n",
+ "\n",
+ "During handling of the above exception, another exception occurred:\n",
+ "\n",
+ "Traceback (most recent call last):\n",
+ " File \"/Users/buzzanga/Software_InSAR/RAiDER_git/tools/RAiDER/cli/raider.py\", line 285, in main\n",
+ " wet_delay, hydro_delay = tropo_delay(\n",
+ " File \"/Users/buzzanga/Software_InSAR/RAiDER_git/tools/RAiDER/delay.py\", line 84, in tropo_delay\n",
+ " wetDelay = los(wetDelay)\n",
+ " File \"/Users/buzzanga/Software_InSAR/RAiDER_git/tools/RAiDER/losreader.py\", line 117, in __call__\n",
+ " LOS_enu = state_to_los(svs,\n",
+ " File \"/Users/buzzanga/Software_InSAR/RAiDER_git/tools/RAiDER/losreader.py\", line 524, in state_to_los\n",
+ " los_ang, slant_range = get_radar_pos(target_llh, orb, out=\"lookangle\")\n",
+ " File \"/Users/buzzanga/Software_InSAR/RAiDER_git/tools/RAiDER/losreader.py\", line 629, in get_radar_pos\n",
+ " raise e\n",
+ " File \"/Users/buzzanga/Software_InSAR/RAiDER_git/tools/RAiDER/losreader.py\", line 610, in get_radar_pos\n",
+ " aztime, slant_range = isce.geometry.geo2rdr(\n",
+ "RuntimeError: geo2rdr failed to converge\n"
+ ]
+ }
+ ],
+ "source": [
+ "# ISCE lat/lon files (Hampton Roads)\n",
+ "# this downloads the DEM and intersects it\n",
+ "\n",
+ "grp = {'aoi_group': {'lat_file': f'{work_dir}/data/lat_HR.geo', 'lon_file': f'{work_dir}/data/lon_HR.geo'}, \n",
+ " 'height_group': {'dem': f'{work_dir}/GLO30_fullres_dem.tif'},\n",
+ " 'weather_model': 'ERA5',\n",
+ " 'date_group': {'date_start': '20181113'},\n",
+ " 'time_group': {'time': parse_time_GUNW(gunw)},\n",
+ " 'los_group' : {'orbit_file': orb3}\n",
+ " }\n",
+ "\n",
+ "cfg = new_yaml_group(yaml_base, grp)\n",
+ "!raider.py {cfg}\n",
+ "\n",
+ "## store it for use later\n",
+ "# shutil.copy(f'{work_dir}/GLO30_fullres_dem.tif', f'{work_dir}/data/GLO30_fullres_dem_HR.tif')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "868da2c7",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Driver: GTiff/GeoTIFF\n",
+ "Files: ERA5_wet_20181219T230629_ztd.GTiff\n",
+ "Size is 3934, 2253\n",
+ "Image Structure Metadata:\n",
+ " INTERLEAVE=BAND\n",
+ "Corner Coordinates:\n",
+ "Upper Left ( 0.0, 0.0)\n",
+ "Lower Left ( 0.0, 2253.0)\n",
+ "Upper Right ( 3934.0, 0.0)\n",
+ "Lower Right ( 3934.0, 2253.0)\n",
+ "Center ( 1967.0, 1126.5)\n",
+ "Band 1 Block=3934x1 Type=Float32, ColorInterp=Gray\n",
+ " Minimum=0.055, Maximum=0.134, Mean=0.082, StdDev=0.022\n",
+ " NoData Value=0\n",
+ " Metadata:\n",
+ " STATISTICS_MAXIMUM=0.13444668054581\n",
+ " STATISTICS_MEAN=0.082404273144709\n",
+ " STATISTICS_MINIMUM=0.055032920092344\n",
+ " STATISTICS_STDDEV=0.021799223611822\n",
+ " STATISTICS_VALID_PERCENT=100\n"
+ ]
+ }
+ ],
+ "source": [
+ "!gdalinfo ERA5_wet_20181219T230629_ztd.GTiff -stats"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d2eb9163",
+ "metadata": {},
+ "source": [
+ "## LA Test"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f5722180",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Initialization Cell",
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/RAiDER_ARIA/example_yamls/GUNW_20200112-20200106.yaml b/notebooks/RAiDER_ARIA/example_yamls/GUNW_20200112-20200106.yaml
new file mode 100644
index 0000000..f439fe7
--- /dev/null
+++ b/notebooks/RAiDER_ARIA/example_yamls/GUNW_20200112-20200106.yaml
@@ -0,0 +1,14 @@
+aoi_group:
+ bounding_box: 37.129123314154995 37.9307480710763 -118.44814585278701 -115.494195892019
+date_group:
+ date_list: (20200112, 20200106)
+height_group:
+ height_levels: '[-1500.0, 0.0, 3000.0, 9000.0]'
+look_dir: right
+los_group:
+ ray_trace: false
+runtime_group:
+ raster_format: nc
+time_group:
+ time: '13:51:39'
+weather_model: GMAO
diff --git a/notebooks/RAiDER_ARIA/example_yamls/GUNW_20200112-20200106_1.yaml b/notebooks/RAiDER_ARIA/example_yamls/GUNW_20200112-20200106_1.yaml
new file mode 100644
index 0000000..c7fa751
--- /dev/null
+++ b/notebooks/RAiDER_ARIA/example_yamls/GUNW_20200112-20200106_1.yaml
@@ -0,0 +1,20 @@
+aoi_group:
+ lat_file: lat.geo
+ lon_file: lon.geo
+date_group:
+ date_list: [20200112]
+height_group:
+ height_levels:
+look_dir: right
+los_group:
+ ray_trace: True
+ orbit_file: ./orbits/S1A_OPER_AUX_POEORB_OPOD_20210316T215224_V20200111T225942_20200113T005942.EOF
+runtime_group:
+ output_directory: .
+ output_projection: null
+ raster_format: GTiff
+ verbose: true
+ weather_model_directory: null
+time_group:
+ time: '13:51:39'
+weather_model: ERA5
diff --git a/notebooks/RAiDER_ARIA/example_yamls/GUNW_20200112-20200106_bbox.yaml b/notebooks/RAiDER_ARIA/example_yamls/GUNW_20200112-20200106_bbox.yaml
new file mode 100644
index 0000000..df20818
--- /dev/null
+++ b/notebooks/RAiDER_ARIA/example_yamls/GUNW_20200112-20200106_bbox.yaml
@@ -0,0 +1,19 @@
+aoi_group:
+ bounding_box: [37.129123314154995, 37.9307480710763, -118.44814585278701, -115.494195892019]
+date_group:
+ date_list: [20200112]
+height_group:
+ height_levels:
+look_dir: right
+los_group:
+ ray_trace: True
+ orbit_file: ./orbits/S1A_OPER_AUX_POEORB_OPOD_20210316T215224_V20200111T225942_20200113T005942.EOF
+runtime_group:
+ output_directory: .
+ output_projection: null
+ raster_format: GTiff
+ verbose: true
+ weather_model_directory: null
+time_group:
+ time: '13:51:39'
+weather_model: ERA5
diff --git a/notebooks/RAiDER_ARIA/example_yamls/raider.yaml b/notebooks/RAiDER_ARIA/example_yamls/raider.yaml
new file mode 100644
index 0000000..1ebe8ee
--- /dev/null
+++ b/notebooks/RAiDER_ARIA/example_yamls/raider.yaml
@@ -0,0 +1,127 @@
+# vim: set filetype=yaml:
+##------------------------ raiderDelay.yaml ------------------------##
+##
+## There are three basic options for calculating tropospheric delays:
+## 1. Calculate Zenith delays (ZTD; Default option if nothing else is passed)
+## 2. Calculate slant delays (STD) by projecting ZTD using the incidence angle:
+## STD = ZTD / cos(incidence_angle)
+## 3. Calculate slant delays (STD) using raytracing:
+## STD = 1e-6 * \int_H^{Top} N(l(x,y,z)) dl
+## where H is the ground pixel elevation, "Top" is the top of the troposphere,
+## N is the refractivity (point-wise delay), and l is a ray which is traced
+## from the ground pixel to the top of the troposphere.
+##
+## In addition, RAiDER supports a number of options for specifying query points,
+## heights, and different weather models. Full options are listed below.
+
+########## PARAMETERS
+## Satellite look direction:
+## Sentinel-1: right
+## NISAR: left
+look_dir: right
+
+
+########## 1. Weather model
+## REQUIRED: TRUE
+## FORMATS: string, Select name from list below
+##
+## Currently implemented weather models include:
+## ERA-5, ERA-5T, HRES, ERA-I, NCMR, HRRR, GMAO, MERRA-2
+## See https://github.com/dbekaert/RAiDER/blob/10686ee3f3533a33ca0788d866003c363f58fd5e/WeatherModels.md
+## for more details and information on licensing
+weather_model:
+
+
+########## 2. Date
+## REQUIRED: TRUE
+## FORMATS: YYYYMMDD
+##
+## Dates can be a single date, two dates that define a set of dates every day, or two dates with an interval
+## These will be ignored in the case that date_list is specified
+date_group:
+ date_start:
+ date_end:
+ date_step: # date interval to download. Default is 1, i.e. every day between date_start and date_end
+
+ ## Alternatively, you can also directly specify a comma-delimited list.
+ date_list: # e.g. [20200101, 20200201, 20200301]
+
+
+########## 3. Time in UTC
+## REQUIRED: TRUE
+## FORMATS: HH:MM:SS; HH:MM
+##
+## Time is in UTC time and should be specified as HH:MM:SS or HH:MM
+## The specified time should be the start time of the acquisition to within a minute
+## end_time will be the end time of the acquition, if not supplied it will be assumed to be 30 seconds post start time
+## For downloading weather models, RAiDER currently rounds to the nearest hour rather than interpolating
+time_group:
+ time:
+ end_time:
+
+
+########## 4. Area of Interest
+## REQUIRED: FALSE
+## FORMATS: string or list of floats
+##
+## There are several options for specifying query points
+## 1. A bounding box in lat/lon specified as a space-separated list: South North West East
+## 2. Specify a geocoded file, e.g. ARIA GUNW product, from which the AOI will be determined
+## 3/4. lat/lon raster files (such as those produced by the ISCE software)
+## 5. A comma-delimited file (station_file) containing at least the columns Lat and Lon, and optionally Hgt_m
+aoi_group:
+ bounding_box:
+ geocoded_file:
+ lat_file:
+ lon_file:
+ station_file:
+
+
+########## 5. Height info
+## REQUIRED: FALSE
+## FORMATS: None, string, list of floats
+##
+## Height information is used from one of the following possible sources:
+## 1. (Default for bounding box) Weather model height levels (model-specific)
+## 2. (Default for lat/lon points) Copernicus 30m DEM (GLO-30), downloaded on the fly
+## 3. Georeferenced DEM
+## NOTE: If "use_dem_latlon" is set to true, then delays will be calculated at the DEM pixels.
+## 4. Height file in radar coordinates matching lat/lon input files (Query points Option 1)
+## 5. List of height levels, which will be used for all input query points
+height_group:
+ dem:
+ use_dem_latlon: False
+ height_file_rdr:
+ height_levels:
+
+
+########## 6. Line-of-sight or zenith calculations
+## REQUIRED: FALSE
+## FORMATS: string
+##
+## ZTD calculation: No additional inputs required
+## STD calculation:
+los_group:
+ ray_trace: False # Use projected slant delay by default
+ zref: # Integration height. Only used in raytracing.
+
+ # raster file in radar or geocoordinates
+ los_file:
+ los_convention: isce # can be "isce" or "hyp3", see *** for details
+
+ # NETCDF (HDF5?) file containing look vectors, see *** for details
+ los_cube:
+
+ # File containing orbit statevectors, see *** for details
+ orbit_file:
+
+
+########## 7. Run-time parameters
+## REQUIRED: FALSE
+##
+runtime_group:
+ verbose: True
+ raster_format: GTiff # Can be any rasterio-compatible format
+ output_directory: . # uses the runtime directory by default
+ weather_model_directory: # Defaults to
Note The full stack trace of the root cause is available in the server logs.
Apache Tomcat/7.0.106
\u001b[0m\n",
+ "Weather model point bounds are 32.53/34.47/-118.72/-116.22\n",
+ "Query datetime: 2020-01-30 13:52:45\n",
+ "\u001b[31;21mERROR: Downloading and/or preparation of GMAO failed.\u001b[0m\n",
+ "\u001b[31;21mERROR: No weather model data available on: 2020-01-30\u001b[0m\n"
+ ]
+ },
+ {
+ "ename": "FileNotFoundError",
+ "evalue": "[Errno 2] No such file or directory: '/Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/weather_files/GMAO_2020_01_30_T13_52_45_32N_35N_120W_115W.nc' -> '/Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/weather_files/GMAO_2020_01_30_T13_52_45_32N_35N_120W_115W_REAL.nc'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[0;32mIn[173], line 31\u001b[0m\n\u001b[1;32m 28\u001b[0m get_ipython()\u001b[38;5;241m.\u001b[39msystem(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mraider.py \u001b[39m\u001b[38;5;132;01m{cfg}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 30\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m op\u001b[38;5;241m.\u001b[39mexists(path_wm_real):\n\u001b[0;32m---> 31\u001b[0m \u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrename\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath_wm\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpath_wm_real\u001b[49m\u001b[43m)\u001b[49m\n",
+ "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/weather_files/GMAO_2020_01_30_T13_52_45_32N_35N_120W_115W.nc' -> '/Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/weather_files/GMAO_2020_01_30_T13_52_45_32N_35N_120W_115W_REAL.nc'"
+ ]
+ }
+ ],
+ "source": [
+ "## run it through with the real weather model file\n",
+ "\n",
+ "# remove the weather model file for a clean run\n",
+ "path_wm_real = f'{op.splitext(path_wm)[0]}_REAL.nc'\n",
+ "\n",
+ "# use existing if possible\n",
+ "if op.exists(path_wm_real):\n",
+ " os.remove(path_wm)\n",
+ " os.symlink(path_wm_real, path_wm)\n",
+ "else:\n",
+ " try:\n",
+ " os.remove(f'{wd}/weather_files/{WM}_{dts}.nc')\n",
+ " except:\n",
+ " pass\n",
+ "\n",
+ "grp = {\n",
+ " 'aoi_group': {'bounding_box': list(SNWE)},\n",
+ " 'height_group': {\n",
+ " 'height_levels': hgt_lvls.tolist(),\n",
+ " },\n",
+ " 'date_group': {'date_list': datetime.strftime(dt, '%Y%m%d')},\n",
+ " 'cube_spacing_in_m': str(cube_spacing),\n",
+ " 'los_group': {'ray_trace': True, 'orbit_file': orbit},\n",
+ " 'weather_model': WM\n",
+ " }\n",
+ "\n",
+ "cfg = new_yaml_group(yaml_GUNW, grp)\n",
+ "!raider.py {cfg}\n",
+ "\n",
+ "if not op.exists(path_wm_real):\n",
+ " os.rename(path_wm, path_wm_real)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7412c867",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "## run it again with the synthetic model\n",
+ "const = 7.0\n",
+ "Obj = GMAOsynth(wm_bounds, k1=const, k2=0, k3=0, lh=True)\n",
+ "path_wm_synth = update_GMAO(Obj, path_wm_real)\n",
+ "\n",
+ "os.remove(path_wm) if op.exists(path_wm) or op.islink(path_wm) else ''\n",
+ "os.symlink(path_wm_synth, path_wm)\n",
+ "\n",
+ "!raider.py {cfg}\n",
+ "\n",
+ "# get the just created synthetic delays\n",
+ "ds = xr.open_dataset(f'{wd}/{WM}_tropo_{dts.replace(\"_\", \"\")}_ray.nc')\n",
+ "da = ds['hydro']\n",
+ "ds.close()\n",
+ "del ds\n",
+ "\n",
+ "## or just run tropo delay\n",
+ "# ds = tropo_delay(dt, path_wm_synth, aoi, los, hgt_lvls, cube_spacing_m=cube_spacing)[0]\n",
+ "# da = ds['wet']\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8da58158",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "## plot a profile of delays and the height levels\n",
+ "\n",
+ "lalo_ix = (1,2) # random index of lat lon\n",
+ "\n",
+ "fig, axes = plt.subplots()\n",
+ "da.isel(y=lalo_ix[0], x=lalo_ix[1]).plot(ax=axes, color='k')\n",
+ "da.isel(y=lalo_ix[0]+1, x=lalo_ix[1]).plot(ax=axes, color='red');\n",
+ "axes.set_title('Neighboring Pixel Profiles')\n",
+ "\n",
+ "fig, axes = plt.subplots(ncols=2, nrows=2, sharex=True, sharey=True, figsize=(8,6))\n",
+ "for i, ax in enumerate(axes.ravel()):\n",
+ " da.isel(z=i).plot(ax=ax, cmap='cmc.lajolla')#, vmin=0.058, vmax=0.061)\n",
+ " ax.set_xlabel('')\n",
+ " ax.set_ylabel('')\n",
+ "fig.subplots_adjust(wspace=0.4)\n",
+ "plt.show()\n",
+ "\n",
+ "## ensure there are no nans/0s\n",
+ "print ('Min:', round(da.min().item(), 3))\n",
+ "print ('Any nan:', da.isnull().any().item())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "4676d277",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Mean delay over height level -500.0: 0.71219\n",
+ "Mean delay over height level 0.0: 0.70547\n",
+ "Mean delay over height level 500.0: 0.69872\n",
+ "Mean delay over height level 1000.0: 0.69199\n"
+ ]
+ }
+ ],
+ "source": [
+ "## now build the rays at the unbuffered wm nodes , scaled by k1\n",
+ "targ_xyz = [da.x.data, da.y.data, da.z.data]\n",
+ "ifWet, ifHydro = getInterpolators(path_wm_synth, 'pointwise')\n",
+ "ray_data = build_ray_het(targ_xyz, los, ifHydro)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "aba09280",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "## compare the delays in the cube vs the scaled rays\n",
+ "\n",
+ "# in case of running in terminal\n",
+ "# da = xr.open_dataset(f'{wd}/{WM}_tropo_20200130T135245_ray.nc')['hydro']\n",
+ "\n",
+ "raid_data = da.data\n",
+ "# print (np.allclose(ray_data[0], raid_data[0])) \n",
+ "\n",
+ "print (np.allclose(ray_data, raid_data)) \n",
+ "da.close()\n",
+ "del da"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3e12328e",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "# Test 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "30c4bbef",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "Test the wet calculation\n",
+ "- k2'= a number; \n",
+ "- k1=k3'=0; \n",
+ "\n",
+ "- then E=T or like E=1/100*T; \n",
+ "\n",
+ "- Integral would be k2'*1(or 1/100) * ray length. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb64c697",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "## Scenario 2a"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "644d5023",
+ "metadata": {
+ "hidden": true
+ },
+ "source": [
+ "No horizontal/vertical variation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "79517106",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "!rm {wd}/weather_files/{WM}*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "id": "3077e7d6",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "S/N/W/E: 33 34 -118.25 -117.25\n",
+ "Grid Spacing: 50000.0 m\n"
+ ]
+ }
+ ],
+ "source": [
+ "print ('S/N/W/E:', *SNWE)\n",
+ "print ('Grid Spacing:', cube_spacing, 'm')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "3bfc2e8b",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Wrote new cfg file: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/tmp.yaml\n",
+ "\u001b[33;21mWARNING: Weather model only extends to the surface topography; height levels below the topography will be interpolated from the surface and may be inaccurate.\u001b[0m\n",
+ "Invalid extension GTiff for cube. Defaulting to .nc\n",
+ "Starting to run the weather model calculation\n",
+ "Date: 20200130\n",
+ "Beginning weather model pre-processing\n",
+ "Weather model GMAO is available from 2014-02-20 to Present\n",
+ "\u001b[33;21mWARNING: Rounded given datetime from 2020-01-30 13:52:45 to 2020-01-30 15:00:00\u001b[0m\n",
+ "Number of weather model nodes: 24360\n",
+ "Shape of weather model: (12, 14, 145)\n",
+ "Bounds of the weather model: 32.00/34.75/-119.38/-115.31 (SNWE)\n",
+ "Weather model: GMAO\n",
+ "Mean value of the wet refractivity: 5.758169\n",
+ "Mean value of the hydrostatic refractivity: 105.635017\n",
+ "\n",
+ "======Weather Model class object=====\n",
+ "Weather model time: 2020-01-30 13:52:45\n",
+ "Latitude resolution: 0.25\n",
+ "Longitude resolution: 0.3125\n",
+ "Native projection: EPSG:4326\n",
+ "ZMIN: -100.0\n",
+ "ZMAX: 15000.0\n",
+ "k1 = 0.776\n",
+ "k2 = 0.233\n",
+ "k3 = 3750.0\n",
+ "Humidity type = q\n",
+ "=====================================\n",
+ "Class name: gmao\n",
+ "Dataset: gmao\n",
+ "=====================================\n",
+ "A: []\n",
+ "B: []\n",
+ "Number of points in Lon/Lat = 12/14\n",
+ "Total number of grid points (3D): 24360\n",
+ "=====================================\n",
+ "\n",
+ "Output SNWE: [32.5, 34.5, -119.0, -116.5]\n",
+ "Output cube spacing: 0.5\n",
+ "Processing slice 1 / 4: -500.0\n",
+ "\n",
+ "Mean delay over height level -500.0: 3.12396\n",
+ "Processing slice 2 / 4: 0.0\n",
+ "\n",
+ "Mean delay over height level 0.0: 2.95872\n",
+ "Processing slice 3 / 4: 500.0\n",
+ "\n",
+ "Mean delay over height level 500.0: 2.79494\n",
+ "Processing slice 4 / 4: 1000.0\n",
+ "\n",
+ "Mean delay over height level 1000.0: 2.63673\n",
+ "\n",
+ "Successfully wrote delay cube to: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/GMAO_tropo_20200130T135245_ray.nc\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# remove the weather model file for a clean run\n",
+ "path_wm_real = f'{op.splitext(path_wm)[0]}_REAL'\n",
+ "\n",
+ "# use existing if possible\n",
+ "if op.exists(path_wm_real):\n",
+ " os.remove(path_wm)\n",
+ " os.symlink(path_wm, f'{op.splitext(path_wm)[0]}_REAL')\n",
+ "else:\n",
+ " try:\n",
+ " os.remove(f'{wd}/weather_files/{WM}_{dts}.nc')\n",
+ " except:\n",
+ " pass\n",
+ "\n",
+ "\n",
+ "\n",
+ "## run it through with the real weather model file\n",
+ "grp = {\n",
+ " 'aoi_group': {'bounding_box': list(SNWE)},\n",
+ " 'height_group': {#'dem': 'GLO30_fullres_dem.tif', \n",
+ " 'height_levels': hgt_lvls.tolist(),\n",
+ " },\n",
+ " 'date_group': {'date_list': datetime.strftime(dt, '%Y%m%d')},\n",
+ " 'cube_spacing_in_m': str(cube_spacing),\n",
+ " 'los_group': {'ray_trace': True, 'orbit_file': orbit},\n",
+ " 'weather_model': WM\n",
+ " }\n",
+ "\n",
+ "cfg = new_yaml_group(yaml_GUNW, grp)\n",
+ "!raider.py {cfg}\n",
+ "\n",
+ "\n",
+ "if not op.exists(path_wm_real):\n",
+ " os.rename(path_wm, path_wm_real)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "66d2273d",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Wrote synthetic weather model file to: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/weather_files/GMAO_2020_01_30_T13_52_45_32N_35N_120W_115W_SYNTH.nc\n",
+ "\u001b[33;21mWARNING: Weather model only extends to the surface topography; height levels below the topography will be interpolated from the surface and may be inaccurate.\u001b[0m\n",
+ "Invalid extension GTiff for cube. Defaulting to .nc\n",
+ "Starting to run the weather model calculation\n",
+ "Date: 20200130\n",
+ "Beginning weather model pre-processing\n",
+ "\u001b[33;21mWARNING: Weather model already exists, please remove it (\"['/Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/weather_files/GMAO_2020_01_30_T13_52_45.nc']\") if you want to download a new one.\u001b[0m\n",
+ "Extent of the weather model is (xmin, ymin, xmax, ymax):-119.38, 32.00, -115.31, 34.75\n",
+ "Extent of the input is (xmin, ymin, xmax, ymax): -118.72, 32.53, -116.22, 34.47\n",
+ "\u001b[33;21mWARNING: The processed weather model file already exists, so I will use that.\u001b[0m\n",
+ "Output SNWE: [32.5, 34.5, -119.0, -116.5]\n",
+ "Output cube spacing: 0.5\n",
+ "Processing slice 1 / 4: -500.0\n",
+ "\n",
+ "Mean delay over height level -500.0: 0.12887\n",
+ "Processing slice 2 / 4: 0.0\n",
+ "\n",
+ "Mean delay over height level 0.0: 0.12763\n",
+ "Processing slice 3 / 4: 500.0\n",
+ "\n",
+ "Mean delay over height level 500.0: 0.12639\n",
+ "Processing slice 4 / 4: 1000.0\n",
+ "\n",
+ "Mean delay over height level 1000.0: 0.12515\n",
+ "\n",
+ "Successfully wrote delay cube to: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/GMAO_tropo_20200130T135245_ray.nc\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "## run it again with the synthetic model\n",
+ "const = 2.0\n",
+ "Obj = GMAOsynth(wm_bounds, k1=0, k2=const, k3=0)\n",
+ "\n",
+ "path_wm_synth = update_GMAO(Obj, path_wm_real)\n",
+ "\n",
+ "os.remove(path_wm) if op.exists(path_wm) or op.islink(path_wm) else ''\n",
+ "os.symlink(path_wm_synth, path_wm)\n",
+ "\n",
+ "!raider.py {cfg}\n",
+ "\n",
+ "# get the just created synthetic delays\n",
+ "ds = xr.open_dataset(f'{wd}/{WM}_tropo_{dts.replace(\"_\", \"\")}_ray.nc')\n",
+ "da = ds['wet']\n",
+ "ds.close()\n",
+ "del ds\n",
+ "\n",
+ "## or just run tropo delay\n",
+ "# ds = tropo_delay(dt, path_wm_synth, aoi, los, hgt_lvls, cube_spacing_m=cube_spacing)[0]\n",
+ "# da = ds['wet']\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "id": "8ad4d482",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Min: 0.112\n",
+ "Any nan: False\n"
+ ]
+ }
+ ],
+ "source": [
+ "## plot a profile of delays and the height levels\n",
+ "\n",
+ "lalo_ix = (1,2) # random index of lat lon\n",
+ "\n",
+ "fig, axes = plt.subplots()\n",
+ "da.isel(y=lalo_ix[0], x=lalo_ix[1]).plot(ax=axes, color='k')\n",
+ "da.isel(y=lalo_ix[0]+1, x=lalo_ix[1]).plot(ax=axes, color='red');\n",
+ "axes.set_title('Neighboring Pixel Delay Profiles')\n",
+ "\n",
+ "fig, axes = plt.subplots(ncols=2, nrows=2, sharex=True, sharey=True, figsize=(8,6))\n",
+ "for i, ax in enumerate(axes.ravel()):\n",
+ " da.isel(z=i).plot(ax=ax, cmap='cmc.lajolla')#, vmin=0.058, vmax=0.061)\n",
+ " ax.set_xlabel('')\n",
+ " ax.set_ylabel('')\n",
+ "fig.subplots_adjust(wspace=0.4)\n",
+ "plt.show()\n",
+ "\n",
+ "## ensure there are no nans/0s\n",
+ "print ('Min:', round(da.min().item(), 3))\n",
+ "print ('Any nan:', da.isnull().any().item())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "id": "a09886e5",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Mean delay over height level -500.0: 0.12887\n",
+ "Mean delay over height level 0.0: 0.12763\n",
+ "Mean delay over height level 500.0: 0.12639\n",
+ "Mean delay over height level 1000.0: 0.12515\n"
+ ]
+ }
+ ],
+ "source": [
+ "## now build the rays at the unbuffered wm nodes , scaled by k2\n",
+ "# just do 4 corners\n",
+ "targ_xyz = [da.x.data, da.y.data, da.z.data]\n",
+ "ray_data = build_ray_const(targ_xyz, Obj._zs, los, constant=const)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "id": "8ac69d39",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "## compare the delays in the cube vs the scaled rays; normalize by other dataset\n",
+ "\n",
+ "# ds = xr.open_dataset(f'{wd}/{WM}_tropo_{dts.replace(\"_\", \"\")}_ray.nc')['wet']\n",
+ "raider_data = da.data\n",
+ "print (np.allclose(ray_data, raider_data)) \n",
+ "da.close()\n",
+ "del da "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 198,
+ "id": "180a733b",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[[[1869637.47251098, 1822722.36253525, 1777614.40421987, ...,\n",
+ " 1460066.77373754, 1435623.19527207, 1413577.7501727 ],\n",
+ " [1877161.62082643, 1830091.73357712, 1784814.52786441, ...,\n",
+ " 1464902.67304134, 1440083.35499981, 1417636.87981808],\n",
+ " [1884695.40632423, 1837475.07733437, 1792033.12164515, ...,\n",
+ " 1469806.47331471, 1444617.78872532, 1421776.72098447],\n",
+ " ...,\n",
+ " [1937624.78738718, 1889470.98299805, 1842999.64819356, ...,\n",
+ " 1505931.29296276, 1478334.62496268, 1452911.7344863 ],\n",
+ " [1945202.78961418, 1896932.47945621, 1850331.50557409, ...,\n",
+ " 1511334.17802492, 1483418.693889 , 1457652.66337991],\n",
+ " [1952782.25879141, 1904399.59812122, 1857673.27203974, ...,\n",
+ " 1516793.95186521, 1488565.8856961 , 1462463.10264464]],\n",
+ "\n",
+ " [[1870462.04664559, 1823474.93767837, 1778298.17583163, ...,\n",
+ " 1460269.29831615, 1435788.16599241, 1413708.68417927],\n",
+ " [1877997.74983439, 1830855.54955965, 1785509.22394055, ...,\n",
+ " 1465112.59556577, 1440255.18277509, 1417774.08654157],\n",
+ " [1885543.11786162, 1838250.16563351, 1792738.7777199 , ...,\n",
+ " 1470023.89049179, 1444796.58059952, 1421920.31837444],\n",
+ " ...,\n",
+ " [1938554.26364723, 1890325.77187013, 1843782.93093706, ...,\n",
+ " 1506203.71990198, 1478564.99251876, 1453103.1912073 ],\n",
+ " [1946144.03205822, 1897798.75511087, 1851125.99479329, ...,\n",
+ " 1511614.80503969, 1483656.80944789, 1457851.37846317],\n",
+ " [1953735.28559202, 1905277.38265726, 1858478.99382838, ...,\n",
+ " 1517082.85891048, 1488811.8384576 , 1462669.17526001]],\n",
+ "\n",
+ " [[1871288.44505162, 1824229.16740605, 1778983.44299149, ...,\n",
+ " 1460472.26403251, 1435953.49703851, 1413839.90501744],\n",
+ " [1878835.73058952, 1831621.04631685, 1786205.44055046, ...,\n",
+ " 1465322.97509724, 1440427.38563354, 1417911.59364749],\n",
+ " [1886392.70877789, 1839026.96105137, 1793445.97946546, ...,\n",
+ " 1470241.78074586, 1444975.76252948, 1422064.22993996],\n",
+ " ...,\n",
+ " [1939485.81696736, 1891182.45649194, 1844567.93948694, ...,\n",
+ " 1506476.73771959, 1478795.86075009, 1453295.0650582 ],\n",
+ " [1947087.38039412, 1898666.95405247, 1851922.23613792, ...,\n",
+ " 1511896.04048429, 1483895.44227155, 1458050.5262476 ],\n",
+ " [1954690.44725873, 1906157.11816128, 1859286.49420524, ...,\n",
+ " 1517372.39210891, 1489058.32526035, 1462875.6963524 ]],\n",
+ "\n",
+ " [[1872116.67330462, 1824985.05670784, 1779670.21015508, ...,\n",
+ " 1460675.67214667, 1436119.18944539, 1413971.41350969],\n",
+ " [1879675.56876382, 1832388.2289274 , 1786903.18223258, ...,\n",
+ " 1465533.81294116, 1440599.96464555, 1418049.40199672],\n",
+ " [1887244.18484213, 1839805.46875655, 1794154.73150382, ...,\n",
+ " 1470460.14542689, 1445155.33562772, 1422208.45658041],\n",
+ " ...,\n",
+ " [1940419.4538244 , 1892041.04268895, 1845354.67907464, ...,\n",
+ " 1506750.34810178, 1479027.23108489, 1453487.35723017],\n",
+ " [1948032.84120329, 1899537.08220388, 1852720.23493042, ...,\n",
+ " 1512177.88609486, 1484134.59383595, 1458250.10796896],\n",
+ " [1955647.75047881, 1907038.81065431, 1860095.77858426, ...,\n",
+ " 1517662.5532478 , 1489305.34762744, 1463082.6672019 ]]],\n",
+ "\n",
+ "\n",
+ " [[[ 796286.79876037, 776190.66682288, 756877.03051198, ...,\n",
+ " 621128.75839555, 610693.67496992, 601283.97260561],\n",
+ " [ 799510.60255954, 779346.73309578, 759959.31305296, ...,\n",
+ " 623193.44942013, 612597.59619536, 603016.42425961],\n",
+ " [ 802738.77149522, 782509.00406456, 763049.70772099, ...,\n",
+ " 625287.20704216, 614533.28688937, 604783.37619442],\n",
+ " ...,\n",
+ " [ 825425.34242748, 804785.07684299, 784875.21197509, ...,\n",
+ " 640713.68050682, 628928.60739217, 618074.01833349],\n",
+ " [ 828674.40021605, 807982.65065352, 788015.81369579, ...,\n",
+ " 643021.25431415, 631099.55382016, 620098.05186958],\n",
+ " [ 831924.33476906, 811182.86818014, 791160.88067169, ...,\n",
+ " 645353.22317966, 633297.5394924 , 622151.83422975]],\n",
+ "\n",
+ " [[ 796640.0867339 , 776512.96203377, 757169.73693042, ...,\n",
+ " 621215.22503891, 610764.09546424, 601339.8549874 ],\n",
+ " [ 799868.86737713, 779673.86507185, 760256.71570807, ...,\n",
+ " 623283.0778126 , 612670.9461402 , 603074.98554212],\n",
+ " [ 803102.02587474, 782840.98710086, 763351.82258414, ...,\n",
+ " 625380.03876288, 614609.61222311, 604844.66691957],\n",
+ " ...,\n",
+ " [ 825823.84280174, 805151.38078702, 785210.72227108, ...,\n",
+ " 640830.03202573, 629026.97489638, 618155.75521991],\n",
+ " [ 829077.97594345, 808353.90422038, 788356.14802577, ...,\n",
+ " 643141.1130276 , 631201.23365648, 620182.89049413],\n",
+ " [ 832332.99453741, 811559.08169334, 791506.05102017, ...,\n",
+ " 645476.62360516, 633402.57007255, 622239.8172083 ]],\n",
+ "\n",
+ " [[ 796994.15914729, 776835.96812946, 757463.08540511, ...,\n",
+ " 621301.88015462, 610834.66985509, 601395.85984143],\n",
+ " [ 800227.92855638, 780001.71927804, 760554.77122615, ...,\n",
+ " 623372.90147012, 612744.45629389, 603133.67508943],\n",
+ " [ 803466.08860854, 783173.70378224, 763654.60118514, ...,\n",
+ " 625473.07262788, 614686.10417076, 604906.09180627],\n",
+ " ...,\n",
+ " [ 826223.23741779, 805518.5001959 , 785546.97431463, ...,\n",
+ " 640946.63614983, 629125.55636216, 618237.67030442],\n",
+ " [ 829482.4584522 , 808725.98520882, 788697.23551268, ...,\n",
+ " 643261.23186918, 631303.13455918, 620267.91398062],\n",
+ " [ 832742.57369215, 811936.13465029, 791851.98600016, ...,\n",
+ " 645600.29175678, 633507.82890483, 622327.99180079]],\n",
+ "\n",
+ " [[ 797349.01840933, 777159.68726283, 757757.07785643, ...,\n",
+ " 621388.72428149, 610905.39858492, 601451.98751901],\n",
+ " [ 800587.78854826, 780330.29790629, 760853.48156348, ...,\n",
+ " 623462.9209508 , 612818.12711391, 603192.49326932],\n",
+ " [ 803830.96219011, 783507.15633998, 763958.04551666, ...,\n",
+ " 625566.30921485, 614762.76320794, 604967.65123903],\n",
+ " ...,\n",
+ " [ 826623.52907918, 805886.43758789, 785883.97036439, ...,\n",
+ " 641063.49360087, 629224.3524006 , 618319.76409637],\n",
+ " [ 829887.85059191, 809098.89617977, 789039.07845486, ...,\n",
+ " 643381.6115821 , 631405.25715956, 620353.12285727],\n",
+ " [ 833153.07512935, 812314.02965513, 792198.68794993, ...,\n",
+ " 645724.22839952, 633613.31664105, 622416.35855469]]]])"
+ ]
+ },
+ "execution_count": 198,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ray_data / "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "id": "ec2b5ea8",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# plot the residual at one height level\n",
+ "hgt_lvl = 2\n",
+ "plt.imshow(ray_data[hgt_lvl] - raider_data[hgt_lvl], cmap='cmc.lajolla')\n",
+ "plt.title('Wet Residual (Ray*Constant) - (Constant Delay)')\n",
+ "plt.colorbar();"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6a16d16b",
+ "metadata": {
+ "heading_collapsed": true,
+ "hidden": true
+ },
+ "source": [
+ "## Scenario 2b"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "id": "646c56d4",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "!rm {wd}/weather_files/{WM}*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "id": "a02edf9b",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "S/N/W/E: 33 34 -118.25 -117.25\n",
+ "Grid Spacing: 50000.0 m\n"
+ ]
+ }
+ ],
+ "source": [
+ "print ('S/N/W/E:', *SNWE)\n",
+ "print ('Grid Spacing:', cube_spacing, 'm')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "id": "1624735b",
+ "metadata": {
+ "hidden": true,
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Wrote new cfg file: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/tmp.yaml\n",
+ "\u001b[33;21mWARNING: Weather model only extends to the surface topography; height levels below the topography will be interpolated from the surface and may be inaccurate.\u001b[0m\n",
+ "Invalid extension GTiff for cube. Defaulting to .nc\n",
+ "Starting to run the weather model calculation\n",
+ "Date: 20200130\n",
+ "Beginning weather model pre-processing\n",
+ "Weather model GMAO is available from 2014-02-20 to Present\n",
+ "\u001b[33;21mWARNING: Rounded given datetime from 2020-01-30 13:52:45 to 2020-01-30 15:00:00\u001b[0m\n",
+ "Number of weather model nodes: 24360\n",
+ "Shape of weather model: (12, 14, 145)\n",
+ "Bounds of the weather model: 32.00/34.75/-119.38/-115.31 (SNWE)\n",
+ "Weather model: GMAO\n",
+ "Mean value of the wet refractivity: 5.758169\n",
+ "Mean value of the hydrostatic refractivity: 105.635017\n",
+ "\n",
+ "======Weather Model class object=====\n",
+ "Weather model time: 2020-01-30 13:52:45\n",
+ "Latitude resolution: 0.25\n",
+ "Longitude resolution: 0.3125\n",
+ "Native projection: EPSG:4326\n",
+ "ZMIN: -100.0\n",
+ "ZMAX: 15000.0\n",
+ "k1 = 0.776\n",
+ "k2 = 0.233\n",
+ "k3 = 3750.0\n",
+ "Humidity type = q\n",
+ "=====================================\n",
+ "Class name: gmao\n",
+ "Dataset: gmao\n",
+ "=====================================\n",
+ "A: []\n",
+ "B: []\n",
+ "Number of points in Lon/Lat = 12/14\n",
+ "Total number of grid points (3D): 24360\n",
+ "=====================================\n",
+ "\n",
+ "Output SNWE: [32.5, 34.5, -119.0, -116.5]\n",
+ "Output cube spacing: 0.5\n",
+ "Processing slice 1 / 4: -500.0\n",
+ "\n",
+ "Mean delay over height level -500.0: 3.12396\n",
+ "Processing slice 2 / 4: 0.0\n",
+ "\n",
+ "Mean delay over height level 0.0: 2.95872\n",
+ "Processing slice 3 / 4: 500.0\n",
+ "\n",
+ "Mean delay over height level 500.0: 2.79494\n",
+ "Processing slice 4 / 4: 1000.0\n",
+ "\n",
+ "Mean delay over height level 1000.0: 2.63673\n",
+ "\n",
+ "Successfully wrote delay cube to: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/GMAO_tropo_20200130T135245_ray.nc\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "## run it through with the real weather model file\n",
+ "\n",
+ "# remove the weather model file for a clean run\n",
+ "path_wm_real = f'{op.splitext(path_wm)[0]}_REAL.nc'\n",
+ "\n",
+ "# use existing if possible\n",
+ "if op.exists(path_wm_real):\n",
+ " os.remove(path_wm)\n",
+ " os.symlink(path_wm_real, path_wm)\n",
+ "else:\n",
+ " try:\n",
+ " os.remove(f'{wd}/weather_files/{WM}_{dts}.nc')\n",
+ " except:\n",
+ " pass\n",
+ "\n",
+ "grp = {\n",
+ " 'aoi_group': {'bounding_box': list(SNWE)},\n",
+ " 'height_group': {\n",
+ " 'height_levels': hgt_lvls.tolist(),\n",
+ " },\n",
+ " 'date_group': {'date_list': datetime.strftime(dt, '%Y%m%d')},\n",
+ " 'cube_spacing_in_m': str(cube_spacing),\n",
+ " 'los_group': {'ray_trace': True, 'orbit_file': orbit},\n",
+ " 'weather_model': WM\n",
+ " }\n",
+ "\n",
+ "cfg = new_yaml_group(yaml_GUNW, grp)\n",
+ "!raider.py {cfg}\n",
+ "\n",
+ "if not op.exists(path_wm_real):\n",
+ " os.rename(path_wm, path_wm_real)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "id": "a60aefeb",
+ "metadata": {
+ "hidden": true,
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Wrote synthetic weather model file to: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/weather_files/GMAO_2020_01_30_T13_52_45_32N_35N_120W_115W_SYNTH.nc\n",
+ "\u001b[33;21mWARNING: Weather model only extends to the surface topography; height levels below the topography will be interpolated from the surface and may be inaccurate.\u001b[0m\n",
+ "Invalid extension GTiff for cube. Defaulting to .nc\n",
+ "Starting to run the weather model calculation\n",
+ "Date: 20200130\n",
+ "Beginning weather model pre-processing\n",
+ "\u001b[33;21mWARNING: Weather model already exists, please remove it (\"['/Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/weather_files/GMAO_2020_01_30_T13_52_45.nc']\") if you want to download a new one.\u001b[0m\n",
+ "Extent of the weather model is (xmin, ymin, xmax, ymax):-119.38, 32.00, -115.31, 34.75\n",
+ "Extent of the input is (xmin, ymin, xmax, ymax): -118.72, 32.53, -116.22, 34.47\n",
+ "\u001b[33;21mWARNING: The processed weather model file already exists, so I will use that.\u001b[0m\n",
+ "Output SNWE: [32.5, 34.5, -119.0, -116.5]\n",
+ "Output cube spacing: 0.5\n",
+ "Processing slice 1 / 4: -500.0\n",
+ "\n",
+ "Mean delay over height level -500.0: 0.20348\n",
+ "Processing slice 2 / 4: 0.0\n",
+ "\n",
+ "Mean delay over height level 0.0: 0.20156\n",
+ "Processing slice 3 / 4: 500.0\n",
+ "\n",
+ "Mean delay over height level 500.0: 0.19963\n",
+ "Processing slice 4 / 4: 1000.0\n",
+ "\n",
+ "Mean delay over height level 1000.0: 0.19771\n",
+ "\n",
+ "Successfully wrote delay cube to: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/GMAO_tropo_20200130T135245_ray.nc\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "## run it again with the synthetic model\n",
+ "const = 2.0\n",
+ "Obj = GMAOsynth(wm_bounds, k1=0, k2=const, k3=0, lh=True)\n",
+ "\n",
+ "path_wm_synth = update_GMAO(Obj, path_wm_real)\n",
+ "\n",
+ "os.remove(path_wm) if op.exists(path_wm) or op.islink(path_wm) else ''\n",
+ "os.symlink(path_wm_synth, path_wm)\n",
+ "\n",
+ "!raider.py {cfg}\n",
+ "\n",
+ "# get the just created synthetic delays\n",
+ "ds = xr.open_dataset(f'{wd}/{WM}_tropo_{dts.replace(\"_\", \"\")}_ray.nc')\n",
+ "da = ds['wet']\n",
+ "ds.close()\n",
+ "del ds\n",
+ "\n",
+ "## or just run tropo delay\n",
+ "# ds = tropo_delay(dt, path_wm_synth, aoi, los, hgt_lvls, cube_spacing_m=cube_spacing)[0]\n",
+ "# da = ds['wet']\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "id": "3a249c9c",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Min: 0.112\n",
+ "Any nan: False\n"
+ ]
+ }
+ ],
+ "source": [
+ "## plot a profile of delays and the height levels\n",
+ "\n",
+ "lalo_ix = (1,2) # random index of lat lon\n",
+ "\n",
+ "fig, axes = plt.subplots()\n",
+ "da.isel(y=lalo_ix[0], x=lalo_ix[1]).plot(ax=axes, color='k')\n",
+ "da.isel(y=lalo_ix[0]+1, x=lalo_ix[1]).plot(ax=axes, color='red');\n",
+ "axes.set_title('Neighboring Pixel Profiles')\n",
+ "\n",
+ "fig, axes = plt.subplots(ncols=2, nrows=2, sharex=True, sharey=True, figsize=(8,6))\n",
+ "for i, ax in enumerate(axes.ravel()):\n",
+ " da.isel(z=i).plot(ax=ax, cmap='cmc.lajolla')#, vmin=0.058, vmax=0.061)\n",
+ " ax.set_xlabel('')\n",
+ " ax.set_ylabel('')\n",
+ "fig.subplots_adjust(wspace=0.4)\n",
+ "plt.show()\n",
+ "\n",
+ "## ensure there are no nans/0s\n",
+ "print ('Min:', round(da.min().item(), 3))\n",
+ "print ('Any nan:', da.isnull().any().item())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "id": "441f6258",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Mean delay over height level -500.0: 0.20348\n",
+ "Mean delay over height level 0.0: 0.20156\n",
+ "Mean delay over height level 500.0: 0.19963\n",
+ "Mean delay over height level 1000.0: 0.19771\n"
+ ]
+ }
+ ],
+ "source": [
+ "## now build the rays at the unbuffered wm nodes , scaled by k1\n",
+ "targ_xyz = [da.x.data, da.y.data, da.z.data]\n",
+ "ifWet, ifHydro = getInterpolators(path_wm_synth, 'pointwise')\n",
+ "ray_data = build_ray_het(targ_xyz, los, ifWet)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "id": "5bd947ac",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "## compare the delays in the cube vs the scaled rays\n",
+ "\n",
+ "# in case of running in terminal\n",
+ "# da = xr.open_dataset(f'{wd}/{WM}_tropo_20200130T135245_ray.nc')['hydro']\n",
+ "\n",
+ "raid_data = da.data\n",
+ "# print (np.allclose(ray_data[0], raid_data[0])) \n",
+ "\n",
+ "print (np.allclose(ray_data, raid_data)) \n",
+ "da.close()\n",
+ "del da"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f65a73dc",
+ "metadata": {},
+ "source": [
+ "# Misc"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "00d62141",
+ "metadata": {
+ "heading_collapsed": true
+ },
+ "source": [
+ "## Estimate Projection Conversion Error"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "id": "756a19b2",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [],
+ "source": [
+ "# this is only a fair comparison at the lowest height level\n",
+ "# you build the ray between two height levels. at the bottom of the height level, the unit \n",
+ "def estimate_proj_error(xpts, ypts, low_ht, los:object):\n",
+ " \"\"\" Estimate the error due to projecting back and forth at a certain height level\n",
+ " \n",
+ " Only compare at the single height, where the ray starts. As the ray builds it moves horiontally. \n",
+ " Lat/lons error is within nnumerical precision but height is off by about 1e-4\n",
+ " \"\"\"\n",
+ " from pyproj import CRS, Transformer\n",
+ " \n",
+ " # Create a regular 2D grid\n",
+ " xx, yy = np.meshgrid(xpts, ypts)\n",
+ "\n",
+ " llh = [xx, yy, np.full_like(yy, low_ht)]\n",
+ " xyz = np.stack(lla2ecef(llh[1], llh[0], llh[2]), axis=-1)\n",
+ " \n",
+ " # Step 2 - get LOS vectors for targets (at the requested height level)\n",
+ " LOS = los.getLookVectors(low_ht, llh, xyz, yy)\n",
+ "\n",
+ " ecef_to_model = Transformer.from_crs(CRS.from_epsg(4978), CRS.from_epsg(4326))\n",
+ " low_xyz = getTopOfAtmosphere(xyz, LOS, low_ht, factor=None)\n",
+ "\n",
+ " # ray point in ECEF\n",
+ " ff = 0 # only care about the ray point on the ground, at the same x/y\n",
+ " pts_xyz = low_xyz + ff #*(high_xyz - low_xyz)\n",
+ "\n",
+ " # Ray point in model coordinates\n",
+ " pts = ecef_to_model.transform(\n",
+ " pts_xyz[..., 0],\n",
+ " pts_xyz[..., 1],\n",
+ " pts_xyz[..., 2]\n",
+ " )\n",
+ " new_zs = pts[2] # the new z at each lat lon\n",
+ " resid = new_zs-low_ht\n",
+ " return resid"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "id": "86456404",
+ "metadata": {
+ "hidden": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(re)Projection induced error: -0.45 +/- 0.87 mm\n"
+ ]
+ }
+ ],
+ "source": [
+ "resid_llh = estimate_proj_error(Obj._xs, Obj._ys, -500, los)*1000\n",
+ "print (f'(re)Projection induced error: {resid_llh.mean():.2f} +/- {resid_llh.std():.2f} mm')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7b7e22a6",
+ "metadata": {},
+ "source": [
+ "## Check Difference in Rays from Total vs height levels"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0ca81191",
+ "metadata": {},
+ "source": [
+ "Differences are due to truncation stuff we do to speed things up"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 192,
+ "id": "c39543c5",
+ "metadata": {
+ "code_folding": []
+ },
+ "outputs": [],
+ "source": [
+ "def test_ray(target_xyz:list, model_zs, los):\n",
+ " \"\"\" This builds rays only; no impact of delays \n",
+ " \n",
+ " Target xyz is a list of lists (xpts, ypts, hgt_levels)\n",
+ " Model_zs are all the model levels over which ray is calculated\n",
+ " los in los object (has the orbit info)\n",
+ " constant is the value to scale the rays by\n",
+ " \"\"\"\n",
+ " # Create a regular 2D grid\n",
+ " xx, yy = np.meshgrid(target_xyz[0], target_xyz[1])\n",
+ " hgt_lvls = target_xyz[2]\n",
+ " outputArrs = np.zeros((hgt_lvls.size, target_xyz[1].size, target_xyz[0].size))\n",
+ "\n",
+ " # iterate over height levels\n",
+ " ray_lengths = [], []\n",
+ " for hh, ht in enumerate(hgt_lvls):\n",
+ " \n",
+ " outSubs = outputArrs[hh, ...] # a 2d array where output is stored and added to (at one heihgt level)\n",
+ " \n",
+ " llh = [xx, yy, np.full(yy.shape, ht)]\n",
+ "\n",
+ " xyz = np.stack(lla2ecef(llh[1], llh[0], np.full(yy.shape, ht)), axis=-1)\n",
+ " LOS = los.getLookVectors(ht, llh, xyz, yy)\n",
+ " \n",
+ " cos_factor = None\n",
+ " \n",
+ " low_xyz = getTopOfAtmosphere(xyz, LOS, model_zs[0], factor=cos_factor)\n",
+ " # cant just force it because zz will do a bunch more iteration/sums\n",
+ " high_xyz = getTopOfAtmosphere(xyz, LOS, model_zs[-1], factor=cos_factor)\n",
+ " ray_lengths[1].append(np.linalg.norm(high_xyz - low_xyz, axis=-1))# * 1e-6)\n",
+ " \n",
+ " ray_length = np.zeros_like(yy)\n",
+ " for zz in range(model_zs.size-1):\n",
+ " low_ht = model_zs[zz]\n",
+ " high_ht = model_zs[zz + 1]\n",
+ " \n",
+ " # turn all these off to match exactly the full ray\n",
+ "# if (high_ht <= ht) or (low_ht >= 50000):\n",
+ "# print (ht, zz)\n",
+ "# continue\n",
+ " \n",
+ "# If high_ht > max_tropo_height - integral only up to max tropo\n",
+ " if high_ht > 50000:\n",
+ " high_ht = 50000\n",
+ " \n",
+ " # If low_ht < height of point - integral only up to height of point\n",
+ "# if low_ht < ht:\n",
+ "# low_ht = ht\n",
+ " \n",
+ " # Continue only if needed - 1m troposphere does nothing\n",
+ "# if np.abs(high_ht - low_ht) < 1.0:\n",
+ "# continue\n",
+ "\n",
+ " low_xyz = getTopOfAtmosphere(xyz, LOS, low_ht, factor=cos_factor)\n",
+ " high_xyz = getTopOfAtmosphere(xyz, LOS, high_ht, factor=cos_factor)\n",
+ " ray_length += np.linalg.norm(high_xyz - low_xyz, axis=-1)\n",
+ " ray_lengths[0].append(ray_length)\n",
+ " \n",
+ " #ray_lengths[0] = summation\n",
+ " #ray_lengths[1] = integral over whole ray\n",
+ " return ray_lengths\n",
+ "\n",
+ "ray_data = test_ray(targ_xyz, Obj._zs, los)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 193,
+ "id": "1b733751",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0 False\n",
+ "1 False\n",
+ "2 False\n",
+ "3 False\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "False"
+ ]
+ },
+ "execution_count": 193,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# check if hgt level\n",
+ "for i in range(4):\n",
+ " print (i, np.allclose(ray_data[0][i], ray_data[1][i]))\n",
+ "\n",
+ "np.allclose(ray_data[0], ray_data[1])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 194,
+ "id": "bc9de01c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "hgt_lvl = 0\n",
+ "resid_hgt = ray_data[1][hgt_lvl] - ray_data[0][hgt_lvl]\n",
+ "\n",
+ "# plot the residual at one height level\n",
+ "plt.imshow(resid_hgt, cmap='cmc.lajolla')\n",
+ "plt.title('Ray Length Residual (Full - Interval)')\n",
+ "plt.colorbar();"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d861d252",
+ "metadata": {},
+ "source": [
+ "## Test Lateral Homogeneity with Interpolation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 166,
+ "id": "e7e32187",
+ "metadata": {
+ "code_folding": [
+ 0
+ ],
+ "init_cell": true
+ },
+ "outputs": [],
+ "source": [
+ "def build_ray_het(target_xyz:list, los, interpolator):\n",
+ " \"\"\" This builds rays and interpolates the delays to them\n",
+ " \n",
+ " Target xyz is a list of lists (xpts, ypts, hgt_levels)\n",
+ " Model_zs are all the model levels over which ray is calculated\n",
+ " los in los object (has the orbit info)\n",
+ " \n",
+ " \"\"\"\n",
+ " # Create a regular 2D grid\n",
+ " xx, yy = np.meshgrid(target_xyz[0], target_xyz[1])\n",
+ " hgt_lvls = target_xyz[2]\n",
+ " outputArrs = np.zeros((hgt_lvls.size, target_xyz[1].size, target_xyz[0].size))\n",
+ " \n",
+ " model_zs = interpolator.grid[-1]\n",
+ " \n",
+ " ecef_to_model = Transformer.from_crs(CRS.from_epsg(4978), CRS.from_epsg(4326))\n",
+ "\n",
+ " # iterate over height levels\n",
+ " for hh, ht in enumerate(hgt_lvls):\n",
+ " \n",
+ " outSubs = outputArrs[hh, ...] # a 2d array where output is stored and added to (at one height level)\n",
+ " \n",
+ " llh = [xx, yy, np.full(yy.shape, ht)]\n",
+ "\n",
+ " xyz = np.stack(lla2ecef(llh[1], llh[0], np.full(yy.shape, ht)), axis=-1)\n",
+ " LOS = los.getLookVectors(ht, llh, xyz, yy)\n",
+ " \n",
+ " cos_factor = None\n",
+ " \n",
+ " # iterate over all model levels\n",
+ " nn=0\n",
+ " for zz in range(model_zs.size-1):\n",
+ " low_ht = model_zs[zz]\n",
+ " high_ht = model_zs[zz + 1]\n",
+ " \n",
+ " if (high_ht <= ht) or (low_ht >= 50000):\n",
+ " continue\n",
+ " \n",
+ " # If high_ht > max_tropo_height - integral only up to max tropo\n",
+ " if high_ht > 50000:\n",
+ " high_ht = 50000\n",
+ " \n",
+ " # If low_ht < height of point - integral only up to height of point\n",
+ " if low_ht < ht:\n",
+ " low_ht = ht\n",
+ " \n",
+ " # Continue only if needed - 1m troposphere does nothing\n",
+ " if np.abs(high_ht - low_ht) < 1.0:\n",
+ " continue\n",
+ "\n",
+ " low_xyz = getTopOfAtmosphere(xyz, LOS, low_ht, factor=cos_factor)\n",
+ " high_xyz = getTopOfAtmosphere(xyz, LOS, high_ht, factor=cos_factor)\n",
+ " ray_length = np.linalg.norm(high_xyz - low_xyz, axis=-1)\n",
+ " nParts = int(np.ceil(ray_length.max() / 1000)) + 1\n",
+ "\n",
+ " if cos_factor is None:\n",
+ " cos_factor = (high_ht - low_ht) / ray_length\n",
+ "\n",
+ " # fractions of ray\n",
+ " fracs = np.linspace(0., 1., num=nParts)\n",
+ "\n",
+ " # Integrate over the ray\n",
+ " for findex, ff in enumerate(fracs):\n",
+ " pts_xyz = low_xyz + ff * (high_xyz - low_xyz)\n",
+ "\n",
+ " # Ray point in model coordinates\n",
+ " pts = ecef_to_model.transform(\n",
+ " pts_xyz[..., 0],\n",
+ " pts_xyz[..., 1],\n",
+ " pts_xyz[..., 2]\n",
+ " )\n",
+ " \n",
+ " pts = np.stack(pts, axis=-1)\n",
+ " ## adjust the lowest level by ~ 1 mm to account for transformation error\n",
+ " if (pts[:, :, -1] < ht).all():\n",
+ " pts[:, :, -1] = ht\n",
+ "\n",
+ " \n",
+ " # Trapezoidal integration with scaling\n",
+ " wt = 0.5 if findex in [0, fracs.size-1] else 1.0\n",
+ " wt *= ray_length * 1e-6 / (nParts - 1.0)\n",
+ " \n",
+ " val = interpolator(pts)\n",
+ " outSubs += wt * val\n",
+ "\n",
+ " nn+1 # counter for stopping\n",
+ "\n",
+ " print (f'Mean delay over height level {ht}: {outSubs.mean():.5f}')\n",
+ "# break\n",
+ " \n",
+ " return outputArrs"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7ac56168",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# would use something like this; note that weather model class would be adjusted to have self._p != self._t/self._e"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f7d874f9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "## run it again with the synthetic model\n",
+ "const = 7.0\n",
+ "Obj = GMAOsynth(wm_bounds, k1=const, k2=0, k3=0, lh=True)\n",
+ "path_wm_synth = update_GMAO(Obj, path_wm_real)\n",
+ "\n",
+ "os.remove(path_wm) if op.exists(path_wm) or op.islink(path_wm) else ''\n",
+ "os.symlink(path_wm_synth, path_wm)\n",
+ "\n",
+ "!raider.py {cfg}\n",
+ "\n",
+ "# get the just created synthetic delays\n",
+ "ds = xr.open_dataset(f'{wd}/{WM}_tropo_{dts.replace(\"_\", \"\")}_ray.nc')\n",
+ "da = ds['hydro']\n",
+ "ds.close()\n",
+ "del ds\n",
+ "\n",
+ "## or just run tropo delay\n",
+ "# ds = tropo_delay(dt, path_wm_synth, aoi, los, hgt_lvls, cube_spacing_m=cube_spacing)[0]\n",
+ "# da = ds['wet']\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3aa6e24f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ " \n",
+ "## now build the rays at the unbuffered wm nodes , scaled by constant\n",
+ "targ_xyz = [da.x.data, da.y.data, da.z.data]\n",
+ "ifWet, ifHydro = getInterpolators(path_wm_synth, 'pointwise')\n",
+ "ray_data = build_ray_het(targ_xyz, los, ifHydro)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d19157e",
+ "metadata": {},
+ "source": [
+ "## Golden Data for Ray"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a8ae25c5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# targ_xyz = [da.x.data, da.y.data, da.z.data]\n",
+ "xx, yy = np.meshgrid(targ_xyz[0], targ_xyz[1])\n",
+ "hgt_lvls = targ_xyz[2]\n",
+ "llh = [xx, yy, np.full(yy.shape, ht)]\n",
+ "xyz = np.stack(lla2ecef(llh[1], llh[0], np.full(yy.shape, ht)), axis=-1)\n",
+ "LOS = los.getLookVectors(ht, llh, xyz, yy)\n",
+ "low_xyz = getTopOfAtmosphere(xyz, LOS, Obj._zlevels[0])\n",
+ "high_xyz = getTopOfAtmosphere(xyz, LOS, Obj._zlevels[-1])\n",
+ "ray_length = np.linalg.norm(high_xyz - low_xyz, axis=-1)\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "celltoolbar": "Initialization Cell",
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.9"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/Synthetic_Test/golden_data/GMAO_tropo_20181113T230000_ray.nc b/notebooks/Synthetic_Test/golden_data/GMAO_tropo_20181113T230000_ray.nc
new file mode 100644
index 0000000..d0d225e
Binary files /dev/null and b/notebooks/Synthetic_Test/golden_data/GMAO_tropo_20181113T230000_ray.nc differ
diff --git a/notebooks/Synthetic_Test/temp/GMAO_refractivity_hgt500_and_15000m.pdf b/notebooks/Synthetic_Test/temp/GMAO_refractivity_hgt500_and_15000m.pdf
new file mode 100644
index 0000000..7a1d444
Binary files /dev/null and b/notebooks/Synthetic_Test/temp/GMAO_refractivity_hgt500_and_15000m.pdf differ
diff --git a/notebooks/Synthetic_Test/temp/GMAO_tropo_20200130T135245_ray.nc b/notebooks/Synthetic_Test/temp/GMAO_tropo_20200130T135245_ray.nc
new file mode 100644
index 0000000..205f9ed
Binary files /dev/null and b/notebooks/Synthetic_Test/temp/GMAO_tropo_20200130T135245_ray.nc differ
diff --git a/notebooks/Synthetic_Test/temp/GMAO_weather_hgt500_and_15000m.pdf b/notebooks/Synthetic_Test/temp/GMAO_weather_hgt500_and_15000m.pdf
new file mode 100644
index 0000000..7db4d5d
Binary files /dev/null and b/notebooks/Synthetic_Test/temp/GMAO_weather_hgt500_and_15000m.pdf differ
diff --git a/notebooks/Synthetic_Test/temp/weather_files/GMAO_2020_01_30_T13_52_45.nc b/notebooks/Synthetic_Test/temp/weather_files/GMAO_2020_01_30_T13_52_45.nc
new file mode 100644
index 0000000..4fe627d
Binary files /dev/null and b/notebooks/Synthetic_Test/temp/weather_files/GMAO_2020_01_30_T13_52_45.nc differ
diff --git a/notebooks/Synthetic_Test/temp/weather_files/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W.nc b/notebooks/Synthetic_Test/temp/weather_files/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W.nc
new file mode 100644
index 0000000..eb64ab7
Binary files /dev/null and b/notebooks/Synthetic_Test/temp/weather_files/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W.nc differ
diff --git a/notebooks/Synthetic_Test/tmp.yaml b/notebooks/Synthetic_Test/tmp.yaml
new file mode 100644
index 0000000..0ab1818
--- /dev/null
+++ b/notebooks/Synthetic_Test/tmp.yaml
@@ -0,0 +1,26 @@
+aoi_group:
+ bounding_box:
+ - 33
+ - 34
+ - -118.25
+ - -117.25
+cube_spacing_in_m: '50000.0'
+date_group:
+ date_list: '20200130'
+height_group:
+ height_levels:
+ - -500
+ - 0
+ - 500
+ - 1000
+look_dir: right
+los_group:
+ orbit_file: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test/S1B_OPER_AUX_POEORB_OPOD_20210317T025713_V20200129T225942_20200131T005942.EOF
+ ray_trace: true
+runtime_group:
+ output_directory: /Users/buzzanga/Software_InSAR/RAiDER-docs_git/notebooks/Synthetic_Test
+ raster_format: nc
+time_group:
+ interpolate_time: false
+ time: '13:52:45'
+weather_model: GMAO
diff --git a/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45.nc b/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45.nc
new file mode 100644
index 0000000..7dfa01b
Binary files /dev/null and b/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45.nc differ
diff --git a/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W.nc b/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W.nc
new file mode 100644
index 0000000..d9af6d4
Binary files /dev/null and b/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W.nc differ
diff --git a/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W_REAL b/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W_REAL
new file mode 100644
index 0000000..3d050db
Binary files /dev/null and b/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W_REAL differ
diff --git a/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W_SYNTH.nc b/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W_SYNTH.nc
new file mode 100644
index 0000000..d9af6d4
Binary files /dev/null and b/notebooks/Synthetic_Test/weather_files_GMAO/GMAO_2020_01_30_T13_52_45_33N_35N_120W_116W_SYNTH.nc differ