flux_gate-Conrad-MP-pw-Clarke.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.7313000567495327"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import pylab\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.ticker as ticker\n",
    "from osgeo import gdal\n",
    "import salem\n",
    "from salem import *\n",
    "\n",
    "import fiona, rasterio\n",
    "import geopandas as gpd\n",
    "from rasterio.plot import show\n",
    "from rasterio.features import rasterize\n",
    "from rasterstats import zonal_stats\n",
    "from sklearn.metrics import mean_squared_error as MSE\n",
    "import pwlf\n",
    "import math\n",
    "from scipy import stats\n",
    "from scipy.stats import chisquare\n",
    "from scipy.optimize import curve_fit\n",
    "from scipy.interpolate import interp1d\n",
    "import statsmodels.api as stm\n",
    "import statsmodels.formula.api as smf\n",
    "from hydroeval import *\n",
    "import xarray as xr\n",
    "import pickle\n",
    "\n",
    "def cm2inch(*tupl):### plots in cm ##frontiers 180 mm for full width, 85 mm half width (1 column) figures\n",
    "    inch = 2.54\n",
    "    if isinstance(tupl[0], tuple):\n",
    "        return tuple(i/inch for i in tupl[0])\n",
    "    else:\n",
    "        return tuple(i/inch for i in tupl)\n",
    "    \n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "years = [2016, 2017, 2018]\n",
    "fl_path = '/home/pelto/Desktop/ice_flux/' + 'Conrad' + '/'\n",
    "ZS_df_2016 = pd.read_csv(fl_path+'ZS_2016.csv')\n",
    "ZS_df_2017 = pd.read_csv(fl_path+'ZS_2017.csv')\n",
    "ZS_df_2018 = pd.read_csv(fl_path+'ZS_2018.csv')\n",
    "\n",
    "sVSTAKE=1.10; sVOFFice=1.1; sVCoreg=2.0; sVRAND=1.5\n",
    "sVsys=np.sqrt((sVOFFice**2)+(sVCoreg)**2)\n",
    "sVZ=np.sqrt((sVsys**2)+((sVRAND)**2))\n",
    "sVZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VZ -ITS: 4.6101437\n",
      "VZ DIFF ratio: 0.24903749\n",
      "nan\n",
      "nan\n",
      "Mean Vel. vz 18.51 14.0\n",
      "Mean Vel. ITS 13.76 11.02\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n",
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017\n",
      "VZ -ITS: 6.9110003\n",
      "VZ DIFF ratio: 0.36834776\n",
      "nan\n",
      "nan\n",
      "Mean Vel. vz 18.76 12.67\n",
      "Mean Vel. ITS 11.82 9.19\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n",
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018\n",
      "VZ -ITS: 8.979787\n",
      "VZ DIFF ratio: 0.4727351\n",
      "nan\n",
      "nan\n",
      "Mean Vel. vz 19.0 12.74\n",
      "Mean Vel. ITS 10.02 8.62\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n",
      "Original vector layer projection:  epsg:32611\n",
      "New vector layer projection (PROJ4):  epsg:32611\n",
      "\n",
      "\n",
      "(0, 'min')\n",
      "(1, 'max')\n",
      "(2, 'mean')\n",
      "(3, 'count')\n",
      "(4, 'sum')\n",
      "(5, 'std')\n",
      "(6, 'median')\n",
      "(7, 'majority')\n",
      "(8, 'minority')\n",
      "(9, 'unique')\n",
      "(10, 'range')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "findfont: Font family ['Helvetica'] not found. Falling back to DejaVu Sans.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 510.236x141.732 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 510.236x141.732 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 510.236x233.858 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 510.236x233.858 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 510.236x233.858 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "font = {'family' : 'Helvetica', 'weight' : 'normal',  'size'   : 8}\n",
    "mfc='none'; mew=1.1; elw=0.9\n",
    "plt.rc('font', **font)\n",
    "pylab.rcParams['xtick.major.pad']='1.'; pylab.rcParams['ytick.major.pad']='1.'\n",
    "\n",
    "fig1, ax1 = plt.subplots(1,3, sharex=True, sharey=True, figsize=(cm2inch(18, 5))) #obs. and flux gate SMB boxplot/errorbar plot\n",
    "fig2, ax2 = plt.subplots(1,3, sharex=True, sharey=True, figsize=(cm2inch(18, 5))) ##mass conservation plot\n",
    "count = 0\n",
    "\n",
    "for yr in range(len(years)):\n",
    "    # season\n",
    "    balance = 'Ba'  # Bw or Ba (winter or annual)\n",
    "    # rho_snow = 445. # 470 kg m-3 geodetic or 457 glaciological, or...take given years obs. value\n",
    "    year = years[yr] # any of: 2016, 2017, 2018\n",
    "    I = np.abs(year - 2016) # for selecting raster inputs\n",
    "\n",
    "    gl = 1 # number to select glacier\n",
    "    Glacier = ['Kokanee', 'Conrad', 'Illecillewaet']\n",
    "    glacier = ['kokanee', 'conrad', 'illecillewaet']\n",
    "#     d = 20. #20.  #distance (m) between flux gate points\n",
    "    Dint = 0.85 #depth integrated velocity ratio, 1.0= all sliding\n",
    "    sVSTAKE=1.10; sVOFFice=1.8; sVCoreg=3.0; sVRAND=2.0\n",
    "    sVsys=np.sqrt((sVSTAKE**2)+(sVOFFice**2))\n",
    "    sVZ=np.sqrt((sVsys**2)+(sVRAND**2))\n",
    "    sHopt = 0.078 #10.2 ## ME:10.2 m,  MAE:0.223 (percent ratio) 0.16 is 2x the ME of Conrad, Illec, Kokanee\n",
    "    cb = 6 ##center bin use this to assure flux in is from bins cb+1 and cb+2\n",
    "    top =10 ## top bin\n",
    "\n",
    "    fl_path = '/home/pelto/Desktop/ice_flux/' + Glacier[gl] + '/'\n",
    "    gpr_path = '/home/pelto/GIS/GPR/ComparisonData/'\n",
    "    path = '/home/pelto/Desktop/lidar_cbt_analysis/' + glacier[gl] + '/'\n",
    "\n",
    "    VDIR = 'individual'  # 'average' or 'individual'\n",
    "    ITS_LIVE = False\n",
    "    firn = False\n",
    "    fit='PW' # or 'LIN'\n",
    "    \n",
    "    if VDIR == 'individual':  \n",
    "\n",
    "        ## DEMs\n",
    "#         vf_list = ['img1_20160417__img1_20170521_vmap_10m_35px_spm2/', 'img1_20160417__img1_20170521_vmap_10m_35px_spm2/',\n",
    "#               'img1_20170521__img2_20180426_vmap_10m_35px_spm2/'] #'img1_20170521__img2_20180426_vmap_10m_35px_spm2/']##backups  img1_20170917__img1_20180426_vmap_5m_35px_spm2/\n",
    "\n",
    "#         vdir = '/home/pelto/Desktop/velocity_mapping/' +Glacier[gl] + '_DEMs/bedem5_spm2/' + vf_list[I]\n",
    "# #         vdir = '/home/pelto/Desktop/velocity_mapping/conrad_planet/' + vf_list[I]\n",
    "#         VX = vdir+ vf_list[I][:-1] + '-F_vx.tif' \n",
    "#         VY = vdir+ vf_list[I][:-1] + '-F_vy.tif' \n",
    "#         VM = '/home/pelto/Desktop/velocity_mapping/Conrad_DEMs/spm2/3m/' + 'conrad_all_3mdems+planet_25m_vm.tif'    \n",
    "        vf_list = ['conrad_2016_vy_25m_pos.tif','conrad_2017_vy_25m_pos.tif','conrad_2018_vy_25m_pos_17mos.tif']\n",
    "#         vf_list = ['conrad_2016_vy_25m_pos_blur1.tif','conrad_2017_vy_25m_pos_blur1.tif','conrad_2018_vy_25m_pos_17mos_blur1.tif']\n",
    "        vdir = '/home/pelto/Desktop/velocity_mapping/' +Glacier[gl] + '_DEMs/spm2/3m/'\n",
    "        ITS = fl_path + 'ITS_Live/' + str(year) + '_conrad_ITS_LIVE.tif'\n",
    "        if year == 2017:\n",
    "            print(year)\n",
    "            VX = vdir+ vf_list[I][:-14] + 'vx_25m.tif' \n",
    "            VY = vdir+ vf_list[I]\n",
    "           # VM = vdir+ vf_list[I][:-14] + 'vm_25m.tif'\n",
    "        if year == 2018:\n",
    "            print(year)\n",
    "            VX = vdir+ vf_list[I][:-20] + 'vx_25m.tif'\n",
    "            VY = vdir+ vf_list[I]\n",
    "           # VM = vdir+ vf_list[I][:-20] + 'vm_25m.tif'\n",
    "        elif year == 2016:\n",
    "            VX = vdir+ vf_list[I][:-14] + 'vx_25m.tif' \n",
    "            VY = vdir+ vf_list[I]\n",
    "           # VM = vdir+ vf_list[I][:-14] + 'vm_25m.tif' \n",
    "\n",
    "    # # if VDIR == 'individual':  \n",
    "    #     vf_list = ['img1_20160417__img1_20170521_vmap_5.0m_35px_spm2/', 'img1_20160417__img1_20170521_vmap_5.0m_35px_spm2/',\n",
    "    #            'img1_20170521__img2_20180426_vmap_5.0m_35px_spm2/']##backups  img1_20170917__img1_20180426_vmap_5m_35px_spm2/\n",
    "    #     vdir = '/home/pelto/Desktop/velocity_mapping/' +Glacier[gl] + '_DEMs/spm2/' + vf_list[I]\n",
    "    #     VX = vdir+ vf_list[I][:-1] + '-F_vx.tif' \n",
    "    #     VY = vdir+ vf_list[I][:-1] + '-F_vy.tif' \n",
    "    else:\n",
    "    #     vf_list = ['illec_all_spm2_5m', 'illec_all_spm2_5m', 'illec_all_spm2_5m']\n",
    "        vdir = '/home/pelto/Desktop/velocity_mapping/Conrad_DEMs/spm2/3m/' #bedem5_spm2/'  \n",
    "        VX = vdir+ 'conrad_all_3mdems+planet_25m_vx.tif' #'conrad_fast_vy.tif'\n",
    "        VY = vdir+ 'conrad_all_3mdems+planet_25m_vy.tif' #'conrad_all_dem3m_vy_new_blur3_5m.tif'\n",
    "        #VM = vdir + 'conrad_all_3mdems+planet_25m_vm.tif'\n",
    "        ITS = fl_path + 'ITS_Live/' + 'mosaic_conrad_ITS_LIVE.tif'\n",
    "    ## velocity_mapping/conrad_planet/img1_20170904__img2_20180822_vmap_10m_35px_spm2\n",
    "#     topo_list = ['140911_conrad_update_dem1_clip.tif', '20160912_conrad_dem1_clip_slave.tif', '20170917_conrad_dem1_clip_slave.tif']\n",
    "    topo = path + '20160912_conrad_dem1_clip_slave.tif' #path + topo_list[I]\n",
    "    \n",
    "    clarke = gpr_path+ glacier[gl]+ '/conrad_c_200m.tif' #gpr_path + 'RGI60-02.02171_thickness.tif'\n",
    "\n",
    "    dhW_list = ['conrad_2016_winter_dh_dt14s.tif', 'conrad_2017_winter_dh_dt16s.tif', 'conrad_2018_winter_dh_dt.tif']\n",
    "    dhA_list = ['conrad_2015_2016_dh_dt_filled_1416+50cm.tif',  'conrad_2017_2016_dh_dt_17s14m.tif' ,'conrad_2018_2017_dh_dt.tif'] #'conrad_2016_2017_dh_dt+50cm.tif'\n",
    "    if balance == 'Bw':\n",
    "        dh_r = path+ dhW_list[I]   #winter height change TIFF\n",
    "    else:\n",
    "        dh_r = path+  dhA_list[I] #Annual height change TIFF\n",
    "    \n",
    "    SLOPE = '/home/pelto/GIS/DEM/Slope/ConradSlope160912_20m.tif'\n",
    "    pts_file = fl_path + 'gis/conrad_bins_11_pts_25m_wgs84.shp'  #'conrad_points_17gates_C_20m_wgs84_b.shp'  # 'conrad_points_gates_20m_wgs84.shp'  ##must be WGS84\n",
    "    gates = fl_path+'conrad_flux_gates_new11.shp'  #'conrad_flux_gates_17_C.shp' #conrad_flux_gates_17_C    conrad_flux_gates\n",
    "    shpf = path + Glacier[gl] + '/conrad_all_glaciers_2014.shp'  #GLIMS_BC/glims_all/all_glaciers_2016.shp' \n",
    "    bins=fl_path+'gis/conrad_bins_11_2016.shp' #'_bins_2017_C'+'.shp' #_bins_2017_C  _bins\n",
    "    obs = pd.read_csv(fl_path+ 'Conrad_bdot.csv') \n",
    "    rho = pd.read_csv(fl_path + 'RHO.csv')  ## MUST MATCH NUMBER OF BINS  conrad_rho_new11.csv\n",
    "    \n",
    "    # open GeoTIFFs as arrays\n",
    "    vy = salem.open_xr_dataset(VY);#vy = vy.to_array(name='vy')\n",
    "    vx = salem.open_xr_dataset(VX);#vx = vx.to_array(name='vx')\n",
    "    msk = salem.open_xr_dataset('/home/pelto/Desktop/lidar_cbt_analysis/conrad/conrad_total_msk.tif') \n",
    "    # msk = salem.open_xr_dataset('/home/pelto/Desktop/velocity_mapping/Conrad_DEMs/bedem5_spm2/conrad_2016_ice_msk_5m_glacieronly.tif') \n",
    "    msk_conrad = salem.open_xr_dataset('/home/pelto/Desktop/lidar_cbt_analysis/conrad/conrad_2014_extent_5m.tif')\n",
    "\n",
    "    gpr = salem.open_xr_dataset(fl_path + 'gpr_25_100m_5m.tif') #'gpr_outlines_all_25_25m_re5m.tif'\n",
    "    clarke = salem.open_xr_dataset(clarke);clarke = clarke.to_array(name='clarke')\n",
    "\n",
    "    H_opt = salem.open_xr_dataset(fl_path+'Conrad_opt_thick_final.tif')  #'opt_thick_251sw.tif') \n",
    "    gates = salem.read_shapefile(gates)\n",
    "    \n",
    "    gpr_reproj = clarke.salem.transform(gpr);gpr = gpr_reproj.to_array(name='gpr')\n",
    "    slope=salem.open_xr_dataset(SLOPE);slope_reproj = clarke.salem.transform(slope)\n",
    "    slope = slope_reproj.to_array(name='slope')\n",
    "    \n",
    "    msk_reproj = clarke.salem.transform(msk)  #note succeeding trying to use gdalwarp to go from 2955 --> 32611\n",
    "    msk = msk_reproj.to_array(name='msk')\n",
    "    msk_conrad_reproj = clarke.salem.transform(msk_conrad);msk_conrad = msk_conrad_reproj.to_array(name='msk_conrad')\n",
    "\n",
    "    ITS = salem.open_xr_dataset(ITS); ITS_reproj = clarke.salem.transform(ITS);ITS = ITS_reproj.to_array(name='ITS')\n",
    "    \n",
    "    H_opt_reproj = clarke.salem.transform(H_opt);H_opt = H_opt_reproj.to_array(name='H_opt')\n",
    "    \n",
    "    vx_reproj= clarke.salem.transform(vx);vx = vx_reproj.to_array(name='vx')\n",
    "    vy_reproj= clarke.salem.transform(vy);vy = vy_reproj.to_array(name='vy')\n",
    "    srtm_corr = fl_path + 'conrad_SRTM_diff_30m.tif'\n",
    "    srtm_corr = salem.open_xr_dataset(srtm_corr)\n",
    "    srtm_corr = clarke.salem.transform(srtm_corr)\n",
    "    srtm_corr = srtm_corr.to_array(name='srtm_corr')\n",
    "    srtm_corr.data[srtm_corr.data>10.0] = 0.0  ##remove positive anomalous values\n",
    "    srtm_corr.data[srtm_corr.data<-50.0] = 0.0 ##remove negative anomalous values\n",
    "    clarke_corr = clarke + srtm_corr\n",
    "    clarke_corr= clarke_corr.rename('clarke_corr')\n",
    "    \n",
    "    gpr.data[gpr.data<0.5] = np.nan; # no data on file set to zero,\n",
    "    slope.data[slope.data<0.0]=np.nan\n",
    "    \n",
    "    vy.data[vy.data<0.01]=np.nan\n",
    "    vz = vy; vz.data = np.sqrt(vx.data**2 + vz.data**2 )\n",
    "    vz.data[msk_conrad.data!=1.0] = np.nan;ITS.data[msk_conrad.data!=1.0] = np.nan;\n",
    "    vz=xr.DataArray(vz.data, coords=vz.coords, name='vz')\n",
    "#     np.savetxt(), vz[0].data, delimiter=',')\n",
    "    \n",
    "    \n",
    "#     with open(fl_path+str(year)+'_vz.pkl', 'wb') as f:\n",
    "#         pickle.dump(vz[0].data, f)\n",
    "#     with open(fl_path+str(year)+'_ITS.pkl', 'wb') as f:\n",
    "#         pickle.dump(ITS[0].data, f)\n",
    "#     vx.data[msk.data==0] = np.nan;vy.data[msk.data==0] = np.nan;VZ[msk_conrad.data<0.0] = np.nan \n",
    "    VZ_off_ice = vz.copy(); VZ_off_ice.data[msk.data==1.0] = np.nan  \n",
    "       \n",
    "    DIFF = vz - ITS\n",
    "    print(\"VZ -ITS:\", np.nanmean(DIFF))\n",
    "    print(\"VZ DIFF ratio:\", np.nanmean(DIFF)/np.nanmean(vz))\n",
    "    dh = salem.open_xr_dataset(dh_r); dh_reproj = clarke.salem.transform(dh); dh = dh_reproj.to_array(name='dh')#dh.data[dh.data<1] = np.nan\n",
    "    \n",
    "    dem = salem.open_xr_dataset(topo);dem_reproj = clarke.salem.transform(dem); dem = dem_reproj.to_array(name='dem')\n",
    "    dem.data[dem.data<1] = np.nan\n",
    "    \n",
    "    #     # map extent\n",
    "    # grid = mercator_grid(center_ll=(-117.43, 51.238), extent=(4500, 4500)) ##zoomed out view\n",
    "    # 487892.000 5509738.000 491232.000 5512358.000\n",
    "    fig, ax = plt.subplots(1,1, sharex=True, sharey=True, figsize=(cm2inch(18, 8.25))) \n",
    "    grid = clarke.salem.grid  ##full view\n",
    "    sm = Map(grid, countries=False)\n",
    "    sm.set_lonlat_contours(interval=0)\n",
    "    sm.set_scale_bar()\n",
    "    sm.set_data(ITS) #, label='m')\n",
    "    sm.set_vmax(val=50.)\n",
    "    #      Change the lon-lat countour setting\n",
    "    sm.set_lonlat_contours(add_ytick_labels=True, interval=0.05, linewidths=0.75, linestyles='--', colors='0.25')\n",
    "    off_ice_V = np.nanmean(VZ_off_ice)\n",
    "    print(off_ice_V)\n",
    "    print(np.nanstd(VZ_off_ice))\n",
    "    print('Mean Vel. vz', round(np.nanmean(vz),2), round(np.nanstd(vz),2))\n",
    "    print('Mean Vel. ITS', round(np.nanmean(ITS),2), round(np.nanstd(ITS),2))\n",
    "    gdf = salem.read_shapefile(shpf)\n",
    "    sm.set_shapefile(gdf, linewidth=1)\n",
    "    sm.set_shapefile(gates, linewidth=1.5, color='r')\n",
    "    sm.visualize()\n",
    "#     fig.savefig(fl_path+ 'products/'+ glacier[gl] + str(year) +'_thickness_gates_diff.png', dpi=300)\n",
    "#     fig.show()\n",
    "\n",
    "    ## Functions for calculating zonal statistics over each flux gate bin\n",
    "    # https://community.esri.com/groups/python-snippets/blog/2019/05/07/calculating-zonal-statistics-with-python-rasterstats\n",
    "    # For loading shapefiles into geopandas dataframe\n",
    "\n",
    "    def enum_items(source):\n",
    "        print(\"\\n\")\n",
    "        for ele in enumerate(source): \n",
    "            print(ele)\n",
    "\n",
    "    def list_columns(df):\n",
    "        field_list = list(df)\n",
    "        enum_items(field_list)\n",
    "        return field_list\n",
    "\n",
    "    def loadshp_as_gpd(shp):\n",
    "        data_shp = gpd.read_file(shp)\n",
    "        return data_shp\n",
    "\n",
    "    # For loading feature classes into geopandas dataframe\n",
    "    def loadfc_as_gpd(fgdb):\n",
    "        layers = fiona.listlayers(fgdb)\n",
    "        enum_items(layers)\n",
    "        index = int(input(\"Which index to load? \"))\n",
    "        fcgpd = gpd.read_file(fgdb,layer=layers[index])\n",
    "        return fcgpd\n",
    "\n",
    "    # For re-projecting input vector layer to raster projection\n",
    "    def reproject(fcgpd, raster):\n",
    "        proj = raster.crs.to_proj4()\n",
    "        print(\"Original vector layer projection: \", fcgpd.crs)\n",
    "        reproj = fcgpd.to_crs(proj)\n",
    "        print(\"New vector layer projection (PROJ4): \", reproj.crs)\n",
    "#         fig, ax = plt.subplots(figsize=(15, 15))\n",
    "#         rplt.show(raster, ax=ax)\n",
    "#         reproj.plot(ax=ax, facecolor='none', edgecolor='red')\n",
    "#         fig.show()\n",
    "        return reproj\n",
    "\n",
    "    def dissolve_gpd(df):\n",
    "        field_list = list_columns(df)\n",
    "        index = 1 #int(input(\"Dissolve by which field (index)? \"))\n",
    "        dgpd = df.dissolve(by=field_list[index])\n",
    "        return dgpd\n",
    "\n",
    "    # For selecting which raster statistics to calculate\n",
    "    def stats_select():\n",
    "        stats_list = stats_list = ['min', 'max', 'mean', 'count', \n",
    "                  'sum', 'std', 'median', 'majority', \n",
    "                  'minority', 'unique', 'range']\n",
    "        enum_items(stats_list)\n",
    "    #     indices = input(\"Enter raster statistics selections separated by space: \")\n",
    "        indices='2 3 5 6'\n",
    "        stats  = list(indices.split())\n",
    "        out_stats = list()\n",
    "        for i in stats:\n",
    "            out_stats.append(stats_list[int(i)])\n",
    "        return out_stats\n",
    "\n",
    "    def get_zonal_stats(vector, raster, stats):\n",
    "        # Run zonal statistics, store result in geopandas dataframe\n",
    "        result = zonal_stats(vector, raster, stats=stats, geojson_out=True)\n",
    "        geostats = gpd.GeoDataFrame.from_features(result)\n",
    "        return geostats\n",
    "\n",
    "    ## make an ice velocity quiver plot\n",
    "#     fig, ax = plt.subplots(1,1,figsize=(10,10))\n",
    "    df = salem.read_shapefile(pts_file) \n",
    "    df_file = loadshp_as_gpd(pts_file)\n",
    "#     df_file.crs\n",
    "\n",
    "    coords = np.array([p.xy for p in df.geometry]).squeeze()\n",
    "    df['lon'] = coords[:, 0]; df['lat'] = coords[:, 1]\n",
    "\n",
    "    # ax.scatter(df.lon, df.lat, s=10, c='r' )#c='depth',cmap='viridis', s=10, ax=ax);\n",
    "    xx, yy = salem.transform_proj(salem.wgs84, grid.proj, df['lon'].values, df['lat'].values)\n",
    "    df['x'] = xx; df['y'] = yy\n",
    "\n",
    "    # shp_plt = reproject(df, VX)\n",
    "\n",
    "    X, Y = np.meshgrid(vx.coords['x'],vx.coords['y'])\n",
    "    U = vx.data[0]; V = vy.data[0]\n",
    "\n",
    "    vns = ['vx','vy','vz', 'ITS', 'gpr','H_opt','dem','clarke_corr','dh','slope']\n",
    "\n",
    "    M = xr.merge([vx,vy,vz,ITS,gpr,H_opt,dem,clarke_corr,dh,slope])\n",
    "\n",
    "    for vn in vns:\n",
    "        df[vn] = M[vn][0].interp(x=('z', df.x), y=('z', df.y))\n",
    "\n",
    "    df_agg = df[['ID', 'len', 'distance', 'angle', 'geometry', 'lon', 'lat']].copy()\n",
    "    ii, jj = grid.transform(df['lon'], df['lat'], crs=salem.wgs84, nearest=True)\n",
    "    df_agg['i'] = ii; df_agg['j'] = jj\n",
    "    # # We trick by creating an index of similar i's and j's\n",
    "    # df_agg['ij'] = ['{:04d}_{:04d}'.format(i, j) for i, j in (vx.coords['x'], vx.coords['y'])]\n",
    "    df_agg['ij'] = ['{:04d}_{:04d}'.format(i, j) for i, j in zip(ii, jj)]\n",
    "    df_agg = df_agg.groupby('ij').mean()\n",
    "\n",
    "    # Select\n",
    "    for vn in vns:\n",
    "    #     M_maksed = np.ma.masked_invalid(M[vn][0])\n",
    "    #     df_agg[vn] = .interp(x=('z', df_agg.i), y=('z', df_agg.j))\n",
    "        df_agg[vn] = M[vn][0].isel(x=('z', df_agg.i), y=('z', df_agg.j))  \n",
    "    df_test = df_agg.copy()\n",
    "    #add in missing IPR data\n",
    "    D = df_agg[['ID', 'len', 'distance', 'angle', 'lon', 'lat', 'vx', 'vy', 'vz','ITS', 'gpr', 'slope','H_opt', 'dem', 'clarke_corr']].copy()  \n",
    "    #D['vz'] = np.sqrt(D.vx**2 + D.vy**2 )  # np.sqrt(U**2 + V**2 )\n",
    "    D['vzdir'] = np.arcsin(D.vx/D.vz) *180/math.pi #degrees from north\n",
    "    # fill any missing vel. direction\n",
    "    for i in range(len((D))):   \n",
    "        if np.isnan(D.vzdir[i])==True:\n",
    "            G=D.ID[i];V=np.nanmedian(D.vzdir[D.ID==G]) \n",
    "            D.vzdir[i]=V\n",
    "    \n",
    "    ## fill in velocity nans at edges (sometimes 1-2 nan pts at edge due to mask res.)\n",
    "#     for i in range(D.ID.nunique()):\n",
    "#         d=D[(D.ID==i)&(D.distance<230)]\n",
    "#         dist=d.distance[np.isnan(d.vz)].values; \n",
    "#         x=d.distance[np.logical_not(np.isnan(d.vz))].values;y=d.vz.values; y=y[np.logical_not(np.isnan(y))]\n",
    "#         coefficients = np.polyfit(x, y, 1); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "#         new_y = poly(new_x);fill=poly(dist);#plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "#         for f in range(len(dist)):\n",
    "#             D.vz[(D.ID==i)&(D.distance==dist[f])]=fill[f]\n",
    "#         d=D[(D.ID==i)&(D.distance>(D.len - 100))]\n",
    "#         dist=d.distance[np.isnan(d.vz)].values; \n",
    "#         x=d.distance[np.logical_not(np.isnan(d.vz))].values;y=d.vz.values; y=y[np.logical_not(np.isnan(y))]\n",
    "#         coefficients = np.polyfit(x, y, 1); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "#         new_y = poly(new_x);fill=poly(dist);#plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "#         for f in range(len(dist)):\n",
    "#             D.vz[(D.ID==i)&(D.distance==dist[f])]=fill[f] \n",
    "            \n",
    "    ### fill ice thickness gaps \n",
    "    #last and first points in each line are zero depth (except gate 7 end, gates 6, 8, 9 start)\n",
    "    D.distance[(D.ID==0)&(D.distance==511.4)]=522.8\n",
    "    D.gpr[D.distance==0.0]=0.0;D.gpr[(D.distance==D.len)]=0.0;\n",
    "    D.gpr[(D.ID==8)&(D.distance==0.0)]=np.nan;D.gpr[(D.ID==9)&(D.distance==0.0)]=np.nan;\n",
    "    D.gpr[(D.ID==7)&(D.distance==D.len)]=np.nan;D.gpr[(D.ID==6)&(D.distance==0.0)]=np.nan;D.gpr[(D.ID==6)&(D.distance==D.len)]=np.nan\n",
    "    \n",
    "    D.H_opt[(D.gpr==0.0)&(D.distance==0.0)]=0.0;D.H_opt[(D.gpr==0.0)&(D.distance==D.len)]=0.0;\n",
    "    D.clarke_corr[(D.gpr==0.0)&(D.distance==0.0)]=0.0;D.clarke_corr[(D.gpr==0.0)&(D.distance==D.len)]=0.0;\n",
    "        \n",
    "    ## start with gates where left bound is not bedrock\n",
    "    d=D[(D.ID==8)&(D.distance<200)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 2); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist);#plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==8)&(D.distance==dist[f])]=fill[f]\n",
    "\n",
    "    d=D[(D.ID==8)&(D.distance>350)&(D.distance<700)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 2); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist);#plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==8)&(D.distance==dist[f])]=fill[f]\n",
    "\n",
    "    d=D[(D.ID==8)&(D.distance>700)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 2); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist);#plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==8)&(D.distance==dist[f])]=fill[f]\n",
    "    \n",
    "    d=D[(D.ID==9)&(D.distance>800)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 4); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist)#;plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==9)&(D.distance==dist[f])]=fill[f]\n",
    "    \n",
    "    #first point in each line is zero except gates 8 and 9\n",
    "#     D.gpr[(D.distance==0.0)&(D.gpr==np.nan)]=0.0\n",
    "#     D.H_opt[(D.gpr==0.0)&(D.distance==0.0)]=0.0;D.clarke_corr[(D.gpr==0.0)&(D.distance==0.0)]=0.0;\n",
    "    \n",
    "    d=D[(D.ID==0)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 6); poly = np.poly1d(coefficients);new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist);#plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==0)&(D.distance==dist[f])]=fill[f]\n",
    "        \n",
    "    d=D[(D.ID==1)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 5); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist)#;plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==1)&(D.distance==dist[f])]=fill[f]\n",
    "\n",
    "    d=D[(D.ID==2)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 6); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist)#;plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==2)&(D.distance==dist[f])]=fill[f]\n",
    "        \n",
    "    d=D[(D.ID==3)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 8); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist);#plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==3)&(D.distance==dist[f])]=fill[f]\n",
    "        \n",
    "    d=D[(D.ID==4)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 6); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist);#plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==4)&(D.distance==dist[f])]=fill[f]\n",
    "    \n",
    "    d=D[(D.ID==5)&(D.distance<1400)];dist=d.distance[np.isnan(d.gpr)].values;\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 3); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist);plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==5)&(D.distance==dist[f])]=fill[f]\n",
    "        \n",
    "    d=D[(D.ID==7)];dist=d.distance[np.isnan(d.gpr)].values;#&(D.distance<500)\n",
    "    x=d.distance[np.logical_not(np.isnan(d.gpr))].values;y=d.gpr.values; y=y[np.logical_not(np.isnan(y))]\n",
    "    coefficients = np.polyfit(x, y, 7); poly = np.poly1d(coefficients); new_x = np.linspace(x[0], x[-1]);\n",
    "    new_y = poly(new_x);fill=poly(dist);#plt.scatter(dist,fill,color='r');plt.plot(x, y, \"o\", new_x, new_y)\n",
    "    for f in range(len(dist)):\n",
    "        D.gpr[(D.ID==7)&(D.distance==dist[f])]=fill[f]\n",
    "        \n",
    "\n",
    "    D_all=D.copy()\n",
    "    if ITS_LIVE == True:\n",
    "        D['vfg'] = D.ITS\n",
    "    else:\n",
    "        #multiply velocity vector by cosine of angle between vector and flux gate (line or line segment)\n",
    "        D['vfg'] = np.abs(D.vz * np.cos((D.vzdir-(D.angle-90.))*(math.pi/180.))) #velocity normal to gate per slice\n",
    "#     D.to_csv(fl_path+ glacier[gl]+ 'D_test.csv')\n",
    "    for i in range(len((D))):   #D.ID.nunique()):\n",
    "        if np.isnan(D.vfg[i])==True:\n",
    "            G=D.ID[i]\n",
    "            V=np.nanmean(D.vfg[D.ID==G]) \n",
    "            D.vfg[i]=V\n",
    "#     with open(fl_path + str(year)+'_Dvfg.pkl', 'wb') as f:\n",
    "#         pickle.dump(D.vfg.values, f)\n",
    "        \n",
    "##### correct ice thickness for thinning ##############  \n",
    "    DH=[]\n",
    "#     for i in range(len(D1)):\n",
    "#     #     if D.loc[d].ID < 5:\n",
    "#         fl_id=D1.loc[i].ID\n",
    "# #     for i in range(len(D)):\n",
    "# #         fl_id= D[D.index==i].ID.values[0]\n",
    "#         if year == 2016:\n",
    "#             del_h=ZS_df_2016.loc[fl_id].dh_mean\n",
    "#         elif year == 2017:\n",
    "#             del_h=ZS_df_2016.loc[fl_id].dh_mean+ZS_df_2017.loc[fl_id].dh_mean\n",
    "#         elif year == 2018:\n",
    "#             del_h=ZS_df_2016.loc[fl_id].dh_mean+ZS_df_2017.loc[fl_id].dh_mean+ZS_df_2018.loc[fl_id].dh_mean\n",
    "#         DH.append(del_h)\n",
    "    D1=D.copy(); D1.reset_index(inplace=True,drop=True);DH=[]\n",
    "    for i in range(len(D1)):\n",
    "        fl_id=D1.loc[i].ID\n",
    "        if year == 2016:\n",
    "            del_h = 0.0\n",
    "        elif year == 2017:\n",
    "            del_h=new16.loc[fl_id].dh_mean\n",
    "        elif year == 2018:\n",
    "            del_h=new17.loc[fl_id].dh_mean\n",
    "        DH.append(del_h)\n",
    "    D['DH']=DH #used to correct ice thickness for surface height change due to mass loss\n",
    "    D.H_opt = D.H_opt + D.DH\n",
    "    D.H_opt[D.H_opt<0.] = 0.0\n",
    "    D.gpr = D.gpr + D.DH \n",
    "    D.gpr[D.gpr<0.] = 0.0\n",
    "    D.clarke_corr = D.clarke_corr + D.DH\n",
    "    D.clarke_corr[D.clarke_corr<0.] = 0.0\n",
    "##### end correct ice thickness for thinning ############## \n",
    "\n",
    "    D.sort_values(by=['distance','ID'],ascending=[True,True], inplace=True) \n",
    "    \n",
    "    for n in range(D.ID.nunique()):\n",
    "\n",
    "        for c in range(len(D.ID[D.ID==n])): #.count()-1)#range(D.ID[D.ID==n].count()-1):\n",
    "            idx=D[(D.ID==n)&(D.distance==D[D.ID==n].distance[c])].index\n",
    "\n",
    "            if c==0:  ## first point in line\n",
    "                L= D.distance[D.ID==n][c+1] - D.distance[D.ID==n][c]\n",
    "                G= L * D.H_opt[D.ID==n][c+1]*0.5;J= L * D.clarke_corr[D.ID==n][c+1]*0.5 #area of triangle\n",
    "                 \n",
    "            elif c==1: #second point from start\n",
    "                L= (D.distance[D.ID==n][c+1] - D.distance[D.ID==n][c])/2\n",
    "                G= L * D.H_opt[D.ID==n][c]; J= L * D.clarke_corr[D.ID==n][c]\n",
    "                 \n",
    "            elif c==len(D.ID[D.ID==n])-2: #second to last point\n",
    "                L= (D.distance[D.ID==n][c] - D.distance[D.ID==n][c-1])/2 \n",
    "                G= L * D.H_opt[D.ID==n]; J= L * D.clarke_corr[D.ID==n]\n",
    "                \n",
    "            elif c==len(D.ID[D.ID==n])-1:  #last point in line\n",
    "                L= (D.distance[D.ID==n][c] - D.distance[D.ID==n][c-1])\n",
    "                G= L * D.H_opt[D.ID==n][c-1]*0.5; J= L * D.clarke_corr[D.ID==n][c-1]*0.5 #area of triangle\n",
    "                \n",
    "            else:\n",
    "                L=(((D.distance[D.ID==n][c+1]-D.distance[D.ID==n][c])/2) + ((D.distance[D.ID==n][c] -\n",
    "                        D.distance[D.ID==n][c-1])/2))\n",
    "                G=L* D.H_opt[D.ID==n][c] ; J=L* D.clarke_corr[D.ID==n][c]  \n",
    "                \n",
    "            D.loc[idx,'A_Hopt']= G;D.loc[idx,'A_clarke']= J; D.loc[idx,'Len_mod']= L     \n",
    "    D_all=D.copy()\n",
    "\n",
    "    D['Qopt'] = D.A_Hopt * (D.vfg) * Dint;D['Qclarke'] = D.A_clarke * (D.vfg) * Dint    \n",
    "\n",
    "    ### Uncertainties\n",
    "    D['sQout'] = np.sqrt((sVZ * D.A_Hopt)**2 + ((D.vfg*Dint) * D.Len_mod * (sHopt*D.H_opt))**2)\n",
    "    D['sQout_low'] = np.sqrt((sVZ * D.A_Hopt)**2 + ((D.vfg*0.80) * D.Len_mod * (sHopt*D.H_opt))**2)\n",
    "    D['sQout_high'] = np.sqrt((sVZ * D.A_Hopt)**2 + ((D.vfg*1.00) * D.Len_mod * (sHopt*D.H_opt))**2)\n",
    "    D['sQoutF'] = np.sqrt((sVZ * D.A_clarke)**2 + ((D.vfg*Dint) * D.Len_mod * (sHopt*D.clarke_corr))**2)\n",
    "\n",
    "    # D['sQout'] = np.sqrt((sVZ**2) * ((D.H_opt**2 + (sHopt*D.H_opt)**2) * (D.vfg*Dint)**2) * d**2)\n",
    "    # D['sQoutF'] = np.sqrt((sVZ**2) * ((D.clarke_corr**2 + (sHopt*D.clarke_corr)**2) * (D.vfg*Dint)**2) * d**2)\n",
    "\n",
    "    Q_out= [0.,] #flux out per gate\n",
    "    cr_area = [0.,] # cross-section area per gate\n",
    "    vzdir = [0.,]; sQout= [0.,];sQout_low= [0.,];sQout_high= [0.,];vfg_all=[];gate_elev=[];v_gate_mean=[0.,];\n",
    "    GPR=[0.,];HF=[0.,];Hopt=[0.,];gate_width=[0.,];Len_mod=[0.,];\n",
    "    DV= D.copy(); DV = DV.dropna(subset=['vfg'])\n",
    "    \n",
    "    for n in range(D.ID.nunique()):\n",
    "        vfg_all.append(DV.vfg[DV.ID==n])\n",
    "        gate_elev.append(D.dem[D.ID==n].mean())\n",
    "        \n",
    "####### calculate flux per bin by summing slices #######\n",
    "    for n in range(D.ID.nunique()+1):\n",
    "            Q_out.append(D.Qopt[D.ID==n].sum()) \n",
    "            cr_area.append(D.A_Hopt[D.ID==n].sum())\n",
    "            vzdir.append(D.vzdir[D.ID==n].mean())\n",
    "            sQout.append(D.sQout[D.ID==n].sum());sQout_low.append(D.sQout_low[D.ID==n].sum()); sQout_high.append(D.sQout_high[D.ID==n].sum()) \n",
    "            v_gate_mean.append(D.vfg[D.ID==n].mean())\n",
    "            Hopt.append(D.H_opt[D.ID==n].mean())\n",
    "            gate_width.append(D.len[D.ID==n].max())\n",
    "            Len_mod.append(D.Len_mod[D.ID==n].sum())\n",
    "            GPR.append(D.gpr[D.ID==n].mean())\n",
    "    Q_in = [Q_out[1:]]; \n",
    "    sQin = [sQout[1:]+ [0.0]] ##1.0 instead of zero to prevent uncertainty nan\n",
    "    sQin_low = [sQout_low[1:]+ [0.0]];sQin_high = [sQout_high[1:]+ [0.0]]    \n",
    "    Q_in = np.squeeze(Q_in);sQin = np.squeeze(sQin);sQin_low = np.squeeze(sQin_low);sQin_high = np.squeeze(sQin_high)\n",
    "    \n",
    "\n",
    "    Q_outF= [0.,] #flux out per gate\n",
    "    cr_areaF = [0.,]; sQoutF = [0.,]\n",
    "    for n in range(D.ID.nunique()+1):\n",
    "            Q_outF.append(D.Qclarke[D.ID==n].sum()) \n",
    "            cr_areaF.append(D.A_clarke[D.ID==n].sum()) \n",
    "            sQoutF.append(D.sQoutF[D.ID==n].sum())\n",
    "            HF.append(D.clarke_corr[D.ID==n].mean())\n",
    "\n",
    "    Q_inF = [Q_outF[1:]] #flux in per bin\n",
    "    Q_inF = np.squeeze(Q_inF)\n",
    "    sQinF = [sQoutF[1:]+ [0.0]]\n",
    "    sQinF = np.squeeze(sQinF)\n",
    "\n",
    "    FG = pd.DataFrame(list(zip(Q_out, Q_in, cr_area, sQout, sQout_low, sQout_high, sQin, sQin_low, sQin_high, Q_outF, Q_inF, sQoutF, sQinF, cr_areaF, vzdir, \n",
    "           v_gate_mean, gate_width,GPR,Hopt, HF,Len_mod)), columns=['Q_out', 'Q_in', 'cr_area', 'sQout', 'sQout_low', 'sQout_high', 'sQin', 'sQin_low', 'sQin_high','Q_outF', 'Q_inF',\n",
    "            'sQoutF', 'sQinF', 'cr_areaF', 'vzdir', 'v_gate_mean','gate_width','gpr','Hopt','HF','Len_mod']) \n",
    "\n",
    "    FG.loc[cb, 'Q_in'] = FG.Q_out[cb+1]+ FG.Q_out[cb+2] ## Q_in for cb (center bin)\n",
    "    FG.loc[cb, 'Q_inF'] = FG.Q_outF[cb+1]+ FG.Q_outF[cb+2] ## Q_in for cb (center bin)\n",
    "    FG.loc[(cb+1), 'Q_in'] = 0.0  ## set Q_in to zero (one to prevent uncertainty nan) for top of west wing\n",
    "    FG.loc[(cb+1), 'Q_inF'] = 0.0  ## set Q_in to zero (one to prevent uncertainty nan) for top of west wing\n",
    "    \n",
    "    FG['vel_fg'] = FG.Q_out / FG.cr_area #net velocity per gate\n",
    "    FG['vel_fgF'] = FG.Q_outF / FG.cr_area\n",
    "    FG['bin']=np.arange(0,len(range(D.ID.nunique()+1)),1)\n",
    "    # FG['sQnet_opt'] = np.sqrt(FG.sQopt**2 + FG.sQin**2)\n",
    "\n",
    "    FG['spQout'] = FG.sQout / FG.Q_out * 100. #%err on flux\n",
    "    FG['spQin'] = FG.sQin / FG.Q_in * 100. #%err on flux\n",
    "    FG['spQoutF'] = FG.sQoutF / FG.Q_outF * 100. #%err on flux\n",
    "    FG['spQinF'] = FG.sQinF / FG.Q_inF * 100. #%err on flux\n",
    "\n",
    "    ### import data per bin: height change, elevation, surface area, obs.SMB etc. \n",
    "\n",
    "    FG_df = FG.copy(); dem_r = topo;vel_r = VY; shp = loadshp_as_gpd(bins)\n",
    "\n",
    "    rasters = [dh_r, dem_r, vel_r,SLOPE]; names = ['dh','dem','vy','slope']\n",
    "    for i in range(len(rasters)):\n",
    "        raster = rasters[i]\n",
    "        rst = rasterio.open(raster)\n",
    "        shp = reproject(shp, rst) #shp is in correct projection, trying anyway for calculation\n",
    "        # dhdt= vx.salem.transform(dhdt)\n",
    "        name = names[i]\n",
    "    #     shp_vec = dissolve_gpd(shp)  ## only if more columns exist\n",
    "        stat = stats_select()  #'['min', 'max', 'mean', 'count', 'sum', 'std', 'median', 'majority', 'minority', 'unique', 'range']\n",
    "        ZS = (get_zonal_stats(shp, raster, stat))\n",
    "        ZS.drop(['geometry'], axis=1, inplace=True)\n",
    "        ZS.rename(columns={\"mean\": name+\"_mean\", \"median\":name+\"_med\", \"std\": name+\"_std\", \"count\":name+\"_count\"}, inplace=True)\n",
    "        ZS.sort_values(by=['bin'],ascending=True, inplace=True)\n",
    "        ZS.set_index('bin', inplace=True)\n",
    "        FG_df =  pd.concat([FG_df, ZS], axis=1)\n",
    "\n",
    "    rho.sort_values(by='bin',ascending=True, inplace=True) # sort by bin\n",
    "    rho.set_index('bin', inplace=True) # set bin as index for sorting\n",
    "    FG_df =  pd.concat([FG_df, rho], axis=1)\n",
    "\n",
    "    WR= np.array(FG_df.dem_count[1:])\n",
    "    WR= np.append(WR,[0]) # calculate area of flux in (area of bin above a given bin)\n",
    "\n",
    "    FG_df['Q_net'] = FG_df.Q_in - FG_df.Q_out  #net flux per gate\n",
    "#     FG_df.loc[cb, 'Q_net'] = FG_df.Q_out[cb+1]+ FG_df.Q_out[cb+2] - FG_df.Q_out[cb] # flux for middle bin\n",
    "    FG_df['Q_netA']= FG_df.Q_net / FG_df.dem_count\n",
    "\n",
    "    FG_df['Q_netF'] = FG_df.Q_inF - FG_df.Q_outF  #net flux per gate\n",
    "#     FG_df.loc[cb, 'Q_netF'] = FG_df.Q_outF[cb+1]+ FG_df.Q_outF[cb+2] - FG_df.Q_outF[cb] # flux for middle bin\n",
    "    FG_df['Q_netAF']= FG_df.Q_netF / FG_df.dem_count\n",
    "\n",
    "    FG_df['area_Qin']= WR\n",
    "    FG_df.loc[cb, 'area_Qin'] = FG_df.dem_count[cb+1]+ FG_df.dem_count[cb+2]\n",
    "\n",
    "    FG_df['sQoptA'] = FG_df.sQout / FG_df.dem_count\n",
    "    FG_df['sQoptA_low'] = FG_df.sQout_low / FG_df.dem_count;FG_df['sQoptA_high'] = FG_df.sQout_high / FG_df.dem_count    \n",
    "    FG_df['sQ_inA'] = FG_df.sQin / (FG_df.area_Qin+0.001)\n",
    "    FG_df['sQ_inA_low'] = FG_df.sQin_low / (FG_df.area_Qin+0.001);FG_df['sQ_inA_high'] = FG_df.sQin_high / (FG_df.area_Qin+0.001)\n",
    "    FG_df['sQnetA_opt'] = np.sqrt(FG_df.sQoptA**2 + FG_df.sQ_inA**2)\n",
    "    FG_df['sQnetA_opt_low'] = np.sqrt(FG_df.sQoptA_low**2 + FG_df.sQ_inA_low**2);FG_df['sQnetA_opt_high'] = np.sqrt(FG_df.sQoptA_high**2 + FG_df.sQ_inA_high**2)\n",
    "\n",
    "    FG_df['sQoutFA'] = FG_df.sQoutF / FG_df.dem_count\n",
    "    FG_df['sQ_inFA'] = FG_df.sQinF / (FG_df.area_Qin+0.001)\n",
    "    FG_df['sQnetFA'] = np.sqrt(FG_df.sQoutFA**2 + FG_df.sQ_inFA**2)\n",
    "\n",
    "    ##calculate height change due to mass balance for highest bins considering firn compaction\n",
    "    if firn == False:\n",
    "        FG_df.Vfirn = 0.00\n",
    "    if year==2017:\n",
    "        FG_df.loc[top, 'dh_mean'] = -0.78 # correct top bin dh for void, took median of highest avail. data\n",
    "    if year==2018:\n",
    "        FG_df.loc[top-1, 'dh_mean'] = 0.55\n",
    "        FG_df.loc[top, 'dh_mean'] = 0.62\n",
    "    FG_df['b_fg_h'] = FG_df.dh_mean - FG_df.Q_netA + FG_df.Vfirn\n",
    "    FG_df['b_fg_hF'] = FG_df.dh_mean - FG_df.Q_netAF + FG_df.Vfirn\n",
    "    FG_df.column_depth = FG_df.column_depth * FG_df.firn_area ## adjust firn column height for firn area\n",
    "    FG_df['RHO'] = ((FG_df.column_density * FG_df.column_depth) + (910. * (FG_df.Hopt-FG_df.column_depth)))/ FG_df.Hopt\n",
    "    FG_df['RHO_F'] = ((FG_df.column_density * FG_df.column_depth) + (910. * (FG_df.HF-FG_df.column_depth)))/ FG_df.HF \n",
    "    FG_df.loc[0, 'RHO'] = 910.;FG_df.loc[0, 'RHO_F'] = 910.\n",
    "#     for r in range(len(FG_df.dem_count)):  ## set density of mass change to density of snow if Bn>0.0 (Pelto et al. (2019))\n",
    "#         if FG_df.b_fg_h[r] < 0.0:\n",
    "#             FG_df['rho_%s'%year][r]=FG_df['rho_%s'%year][r]\n",
    "#         else:\n",
    "#             FG_df['rho_%s'%year][r]=572.\n",
    "    \n",
    "    if balance == 'Bw':\n",
    "        FG_df['b_fg_we'] = FG_df.rho_snow/1000 * FG_df.b_fg_h\n",
    "        FG_df['b_fg_weF'] = FG_df.rho_snow/1000 * FG_df.b_fg_hF\n",
    "    else:\n",
    "        FG_df['b_fg_we'] = FG_df['RHO']/1000. * FG_df.b_fg_h           #FG_df['rho_%s'%year]/1000. * FG_df.b_fg_h\n",
    "        FG_df['b_fg_weF'] = FG_df['RHO_F']/1000. * FG_df.b_fg_hF\n",
    "\n",
    "    ### Uncertainties\n",
    "    #sDHdt = 0.21 #0.04 #m Bias dh from Pelto et al. 2019\n",
    "    if I==0:\n",
    "        sDHdt = 0.21 #NMAD from Pelto et al. 2019\n",
    "    if I==1:\n",
    "        sDHdt = 0.31\n",
    "    elif I==2:\n",
    "        sDHdt = 0.59\n",
    "    sVfirn = 0.10; sRHO = 0.10 #0.05 # percent uncertainty in density\n",
    "\n",
    "    FG_df['sDH_opt'] = np.sqrt(sDHdt**2 + (FG_df.sQnetA_opt)**2 + (FG_df.Vfirn*sVfirn)**2)\n",
    "    FG_df['sBwe_opt'] = np.sqrt((FG_df.sDH_opt * (FG_df['RHO']/1000.))**2+\n",
    "                   (FG_df.b_fg_h * (FG_df['RHO']/1000.*sRHO))**2)\n",
    "\n",
    "    FG_df['sDH_F'] = np.sqrt(sDHdt**2 + (FG_df.sQnetFA)**2 + (FG_df.Vfirn*sVfirn)**2)\n",
    "    FG_df['sBwe_F'] = np.sqrt((FG_df.sDH_F * (FG_df['RHO_F']/1000.))**2+\n",
    "                   (FG_df.b_fg_hF * (FG_df['RHO_F']/1000.*sRHO))**2)\n",
    "\n",
    "    D['Agpr']=np.NaN;D.gpr[D.len==0.]=np.nan;  #D.gpr[D.ID==6]=np.nan;\n",
    "    D.gpr[(D.ID==6)]=0.0 ## &(D.distance==0.0)temp. add false point to avoid instability\n",
    "    D = D.dropna(subset=['gpr']); D.sort_values(by=['distance','ID'],ascending=[True,True], inplace=True) \n",
    "\n",
    "    for n in range(D.ID.nunique()):\n",
    "\n",
    "        for c in range(len(D.ID[D.ID==n])): #.count()-1)#range(D.ID[D.ID==n].count()-1):\n",
    "            idx=D[(D.ID==n)&(D.distance==D[D.ID==n].distance[c])].index\n",
    "\n",
    "            if c==0:  ## first point in line\n",
    "                L= D.distance[D.ID==n][c+1] - D.distance[D.ID==n][c]\n",
    "                G= L * D.gpr[D.ID==n][c+1]*0.5;J= L * D.clarke_corr[D.ID==n][c+1]*0.5 #area of triangle\n",
    "                 \n",
    "            elif c==1: #second point from start\n",
    "                L= (D.distance[D.ID==n][c+1] - D.distance[D.ID==n][c])/2\n",
    "                G= L * D.gpr[D.ID==n][c]; J= L * D.clarke_corr[D.ID==n][c]\n",
    "                 \n",
    "            elif c==len(D.ID[D.ID==n])-2: #second to last point\n",
    "                L= (D.distance[D.ID==n][c] - D.distance[D.ID==n][c-1])/2 \n",
    "                G= L * D.gpr[D.ID==n]; J= L * D.clarke_corr[D.ID==n]\n",
    "                \n",
    "            elif c==len(D.ID[D.ID==n])-1:  #last point in line\n",
    "                L= (D.distance[D.ID==n][c] - D.distance[D.ID==n][c-1])\n",
    "                G= L * D.gpr[D.ID==n][c-1]*0.5; J= L * D.clarke_corr[D.ID==n][c-1]*0.5 #area of triangle\n",
    "                \n",
    "            else:\n",
    "                L=(((D.distance[D.ID==n][c+1]-D.distance[D.ID==n][c])/2) + ((D.distance[D.ID==n][c] -\n",
    "                        D.distance[D.ID==n][c-1])/2))\n",
    "                G=L* D.gpr[D.ID==n][c] ; J=L* D.clarke_corr[D.ID==n][c]  \n",
    "                \n",
    "            D.loc[idx,'Agpr']= G; D.loc[idx,'Len_gpr']= L \n",
    "    #         D['Q_gpr'] = (D.vfg * 0.9 *D['Agpr'])\n",
    "    #     D['A'] = D.vfg[D.ID==n] * D.gpr[D.ID==n]\n",
    "\n",
    "    #calculate flux out using GPR thicknesses\n",
    "    sGPR = 0.10 #0.0516 #gpr error %\n",
    "    D['sInterp_gpr'] = np.nan\n",
    "    for n in range(len(D.Len_gpr)):\n",
    "        if D.Len_gpr[n] > 50.:\n",
    "            D.sInterp_gpr[n] = D.gpr[n] * 0.10  \n",
    "        else: \n",
    "            D.sInterp_gpr[n] = 0.0\n",
    "    sH_gpr = np.sqrt(D.sInterp_gpr**2+ (D.gpr*sGPR)**2)\n",
    "\n",
    "    D['Qo_gpr'] = D.Agpr * (D.vfg) * Dint#* 0.9\n",
    "    D['sQo_gpr'] =  np.sqrt((sVZ * (D.gpr) * D.Len_gpr)**2 + ((D.vfg*Dint) * D.Len_gpr * (sH_gpr))**2)\n",
    "\n",
    "    # D['sQo_gpr'] = np.sqrt((sVZ**2) * ((D.gpr**2 + (sH_gpr)**2) * (D.vfg*Dint)**2) * d**2)\n",
    "\n",
    "    Qo_gpr = [0.,] #flux out per gate\n",
    "    cr_area_gpr = [0.,] # cross-section area per gate\n",
    "    vzdir_gpr = [0.,];  sQo_gpr= [0.,]; Len_gpr=[0.,]\n",
    "    for n in range(D.ID.nunique()):  #for n in D.ID.unique(): the ID's are out of order here\n",
    "            Qo_gpr.append(D.Qo_gpr[D.ID==n].sum()) \n",
    "            cr_area_gpr.append(D.Agpr[D.ID==n].sum())\n",
    "            vzdir_gpr.append(D.vzdir[D.ID==n].mean())\n",
    "            sQo_gpr.append(D.sQo_gpr[D.ID==n].sum())\n",
    "            Len_gpr.append(D.Len_gpr[D.ID==n].sum())\n",
    "    Qin_gpr = [Qo_gpr[1:]+ [0.0]] #flux in per bin, add zero to end for top bin \n",
    "    Qin_gpr = np.squeeze(Qin_gpr); sQin_gpr = [sQo_gpr[1:]+ [0.0]]; sQin_gpr = np.squeeze(sQin_gpr)\n",
    "\n",
    "    FG_gpr = pd.DataFrame(list(zip(Qo_gpr, Qin_gpr, cr_area_gpr, sQo_gpr,sQin_gpr,Len_gpr)), \n",
    "                          columns=['Qo_gpr', 'Qin_gpr', 'cr_area_gpr', 'sQo_gpr','sQin_gpr','Len_gpr']) \n",
    "    FG_gpr['bin'] = np.arange(0,len(range(D.ID.nunique()+1)),1)#[0,1,2,3]\n",
    "    # FG_gpr['vfg'] = FG_gpr.Qo_gpr / FG_gpr.cr_area_gpr #net velocity per gate\n",
    "    # FG['bin']=np.arange(0,14,1)\n",
    "\n",
    "    FG_gpr.loc[cb+1, 'Qo_gpr'] = FG_df.Q_out[cb+1] #flux out for top of west wing, which has no radar measurements\n",
    "    FG_gpr.loc[cb, 'Qin_gpr'] = FG_gpr.Qo_gpr[cb+1]+ FG_gpr.Qo_gpr[cb+2] #flux in for center bin\n",
    "    FG_gpr.loc[(cb+1), 'Qin_gpr'] = 0.0  ## set Q_in to zero for top of west wing\n",
    "    \n",
    "    FG_gpr['spQo_gpr'] = FG_gpr.sQo_gpr / FG_gpr.Qo_gpr * 100. #%err on flux\n",
    "    FG_gpr['spQin_gpr'] = FG_gpr.sQin_gpr / FG_gpr.Qin_gpr * 100. #%err on flux\n",
    "\n",
    "    FG_all = FG_df.merge(FG_gpr, how='left') #on='bin')  \n",
    "    FG_all['Q_net_gpr'] = FG_all.Qin_gpr - FG_all.Qo_gpr \n",
    "\n",
    "    FG_all['Q_netA_gpr']= FG_all.Q_net_gpr / FG_all.dem_count \n",
    "    FG_all.loc[cb+1, 'Q_netA_gpr'] = np.nan # no flux est for bin without IPR measurements\n",
    "    FG_all['b_fg_h_gpr'] = FG_all.dh_mean - FG_all.Q_netA_gpr+ FG_all.Vfirn #dh1516_mean\n",
    "#     FG_all.loc[cb, 'b_fg_h_gpr'] = np.nan # SMB center bin since flux in from cb+1 cannot be calc.\n",
    "    FG_all.loc[cb+1, 'b_fg_h_gpr'] = np.nan # SMB for top of west wing, which has no radar measurements\n",
    "    FG_all['sQoutA_gpr'] = FG_all.sQo_gpr / FG_all.dem_count\n",
    "    FG_all['sQ_inA_gpr'] = FG_all.sQin_gpr / (FG_all.area_Qin+0.001)\n",
    "    FG_all['sQnetA_gpr'] = np.sqrt(FG_all.sQoutA_gpr**2 + FG_all.sQ_inA_gpr**2)\n",
    "    FG_all['RHO_g'] = ((FG_all.column_density * FG_all.column_depth) + (910. * (FG_all.gpr-FG_all.column_depth)))/ FG_all.gpr; \n",
    "    FG_all.loc[0, 'RHO_g'] = 910.\n",
    "    if balance == 'Bw':\n",
    "        FG_all['b_fg_we_gpr'] = FG_df.rho_snow/1000. * FG_all.b_fg_h_gpr\n",
    "    else:\n",
    "        FG_all['b_fg_we_gpr'] = FG_all['RHO_g']/1000. * FG_all.b_fg_h_gpr\n",
    "    \n",
    "    #FG_all.loc[len(FG_gpr)-1,'b_fg_we_gpr'] = np.nan #no radar data available for flux calculation for top bin\n",
    "    \n",
    "    FG_all['sDH_gpr'] = np.sqrt(sDHdt**2 + (FG_all.sQnetA_gpr)**2 + (FG_all.Vfirn*sVfirn)**2)\n",
    "    FG_all['sBwe_gpr'] = np.sqrt((FG_all.sDH_gpr * (FG_all['RHO_g']/1000.))**2+\n",
    "                   (FG_all.b_fg_h_gpr * (FG_all['RHO_g']/1000.*sRHO))**2)\n",
    "\n",
    "    n = 0;    a = 0.7; s= 10 #markersize\n",
    "    obs=obs[(obs.Year==year)]\n",
    "    obs.reset_index(inplace=True)\n",
    "    \n",
    "#remove obs from west wing\n",
    "#     T =pd.DataFrame()\n",
    "#     for i in range(len(obs.name)):\n",
    "#         if 'W' not in obs.name[i] and 'w' not in obs.name[i] :\n",
    "#             T=T.append(obs[obs.index == i],ignore_index=True)\n",
    "#     obs = T\n",
    "\n",
    "    obs = obs.dropna(subset=['Ba'])\n",
    "    y_ax_obs=obs[(obs.Year==year)].Ba\n",
    "    x_ax_obs=obs[(obs.Year==year)].Elev\n",
    "\n",
    "    new = FG_all.copy();#new.drop([7],inplace=True);new.reset_index(inplace=True)\n",
    "#     new.drop([cb+1],inplace=True); new.reset_index(inplace=True) ##remove top bin west wing\n",
    "    \n",
    "    yerr = [0.0, new.sBwe_gpr, new.sBwe_opt, new.sBwe_F] #new.sBwe_gpr\n",
    "    new['xerr'] = new.dem_std * 1.5 #2 std dev -- 95% of data\n",
    "    xerr = new.xerr \n",
    "  \n",
    "    x_ax_fg_gpr=new.dem_med;y_ax_fg_gpr=new.b_fg_we_gpr\n",
    "    x_ax_fg_opt=new.dem_med;y_ax_fg_opt=new.b_fg_we;x_ax_fg_F=new.dem_med ;y_ax_fg_F=new.b_fg_weF\n",
    "    x = [x_ax_obs, x_ax_fg_gpr, x_ax_fg_opt, x_ax_fg_F]\n",
    "    y = [y_ax_obs, y_ax_fg_gpr, y_ax_fg_opt, y_ax_fg_F]\n",
    "    \n",
    "    letter=['A','B','C']\n",
    "    color = ['k', '#51c2d5','#663f3f','#ec4646'] #'teal', '#74c476', '#238b45']\n",
    "#     label = ['Obs.', 'Fg IPR', 'Fg OGGM','Clarke']\n",
    "    label=['Observed', 'FG IPR', 'FG OGGM', 'FG Clarke']\n",
    "    sym = ['o', '^', 's', 'd']\n",
    "    # Call function to create error bars \n",
    "    shift = [-50,0,50]\n",
    "    ax1[count].scatter(x[0],y[0],color=color[0], label=label[0], alpha=a+.2, s=s,facecolor='', zorder=3)\n",
    "    for i in range(3):\n",
    "        ax1[count].errorbar((x[i+1]+shift[i]), y[i+1], xerr=None, yerr=yerr[i+1], fmt=sym[i+1], ecolor=color[i+1], zorder=2,\n",
    "                              label=label[i+1], alpha=0.8, mfc=mfc, mew=mew, c=color[i+1], ms=4, elinewidth=0.7) #elinewidth=0.7\n",
    "\n",
    "        ## plot data and regression lines\n",
    "    ytxt = [0.2, 0.15, 0.1, 0.05]     \n",
    "        \n",
    "#         ax1[count].text(0.2, ytxt[i], txt[i]+str(np.round(1000*rlm_results.params[1],2))+ ' +/- ' + \n",
    "#                 str(np.round(1000*stdE,2)), transform=ax1[count].transAxes)        \n",
    "        \n",
    "#         slope, intercept, r_value, p_value, std_err = stats.linregress(np.array(x[i]),np.array(y[i]))\n",
    "    txt= ['Observed', 'FG IPR     ', 'FG OGGM   ', 'FG Clarke']\n",
    "\n",
    "#         #################### RLM  https://www.statsmodels.org/stable/rlm.html\n",
    "#         ###https://www.statsmodels.org/devel/generated/statsmodels.robust.robust_linear_model.RLMResults.html\n",
    "#         exog = stm.add_constant(x[i]) #obs_data.Elev)\n",
    "#         rlm_model = stm.RLM(y[i],exog, M=stm.robust.norms.HuberT()) #data.endog, data.exog,\n",
    "#         rlm_results = rlm_model.fit()\n",
    "#         stdE=rlm_results.bse[1]\n",
    "#         # print(rlm_results.params)\n",
    "#         ax1[count].plot(x[i],rlm_results.params[1]*x[i]+rlm_results.params[0], color=color[i],label='', alpha=a, \n",
    "#                 linewidth=0.8, zorder=3) # linestyle='--'\n",
    "#         print('slope RLM:', rlm_results.params[1])\n",
    "#         #############################\n",
    "#         ax1[count].text(0.2, ytxt[i], txt[i]+str(np.round(1000*rlm_results.params[1],2))+ ' +/- ' + \n",
    "#                 str(np.round(1000*stdE,2)), transform=ax1[count].transAxes)\n",
    "\n",
    "    if balance == 'Ba':\n",
    "        ax1[count].axhline(linewidth=1, color='k', ls='--', alpha=a+.2, zorder=0)\n",
    "        ax2[count].axhline(linewidth=1, color='k', ls='--', alpha=a+.2, zorder=0)\n",
    "\n",
    "    ############ obs data box plot ################\n",
    "    obs_data=obs[(obs.Year==year)]\n",
    "    obs_data.reset_index(inplace=True)\n",
    "    if year == 2017:\n",
    "        obs_data[balance]= obs_data[balance]-0.32 ## GPS survey correction between LiDAR 9-17-2017 and field 9-8-2017\n",
    "    bin_size = 100.\n",
    "    z_range = np.arange(1950., 3250., bin_size)\n",
    "\n",
    "    i = 0\n",
    "    # for n in range(len(obs_data.Ba)):\n",
    "    Z_F = []; Zor_F= []; OB_F=[]\n",
    "\n",
    "    for z in z_range: \n",
    "        W=0;bin_size = 100.; COU=1\n",
    "        while W==0:\n",
    "            OBS = [];Z = [];Zor = [];\n",
    "            for n in range(len(obs_data[balance])):\n",
    "                if ((z - bin_size/2.) <= obs_data.Elev[n]) and (obs_data.Elev[n] <=  (z + bin_size/2.)):\n",
    "                    O = obs_data[balance][n]\n",
    "                    Z.append(z);Zor.append(obs_data.Elev[n]);OBS.append(O)\n",
    "\n",
    "            if len(OBS)<2:\n",
    "                bin_size=bin_size*(1+(.2*COU))\n",
    "                COU=COU+1\n",
    "            else:\n",
    "                OB_F.append(np.array(OBS)); Z_F.append(np.array(Z));  Zor_F.append(np.array(Zor))\n",
    "                W=1\n",
    "        i += 1\n",
    "        \n",
    "##################Difference###########################################################\n",
    "       \n",
    "    GPR = [];OPT = [];CLARKE = []  \n",
    "    for z in z_range:\n",
    "        W=0; COU=1;bin_size = 100.\n",
    "        while W==0:\n",
    "            GG=[];PP=[];FF=[]\n",
    "            ####collect balance values for each elevation bin\n",
    "            for n in range(len(new.dem_mean)): #for n in new.bin:  # \n",
    "                if ((z - bin_size/2.) <= new.dem_mean[n]) and (new.dem_mean[n] <=  (z + bin_size/2.)):\n",
    "                    G = new.b_fg_we_gpr[n]\n",
    "                    P = new.b_fg_we[n]\n",
    "                    F = new.b_fg_weF[n]\n",
    "                    GG.append(G);FF.append(F);PP.append(P)\n",
    "            GG=np.array(GG)\n",
    "            GG = GG[np.logical_not(np.isnan(GG))]\n",
    "            \n",
    "            if len(GG)<1:\n",
    "                bin_size=bin_size*(1+(0.1*COU))\n",
    "                COU=COU+1\n",
    "                \n",
    "            else:\n",
    "                GPR.append(GG);OPT.append(np.array(PP));CLARKE.append(np.array(FF))\n",
    "                W=1\n",
    "\n",
    "    if count == 0:\n",
    "        gpr_bdiff=[];opt_bdiff=[];clarke_bdiff=[];z_range_all=[];obs_all=obs_data;obs_bin_all=[];gpr_all=[];\n",
    "        opt_all=[];clarke_all=[];elev_all=[];elev_gpr_all=[];gpr_bin_all=[];opt_bin_all=[];clarke_bin_all=[];\n",
    "        NSE=[];PBias=[];RSR=[];RSQ=[];SE=[];SL=[];ME=[];MAE=[];MSE_ABL=[];MSE_ACC=[];MSE_ALL=[];RLM_SL=[];\n",
    "        RLM_SE=[];SL_L=[];SE_L=[];RSQ_L=[];gpr_bd_fg=[];opt_bd_fg=[];clarke_bd_fg=[];obs_fg_all=[];ELA_pw=[];ELA_lin=[]\n",
    "      \n",
    "    ###### bfinned observations for each flux bin ##############\n",
    "    OB_FG=[];OB_FG_h=[]\n",
    "    for i in range(len(new.dem_mean)): \n",
    "        f = new.dem_mean[i]\n",
    "        W=0;bin_size = new.dem_std[i]*2; COU=1\n",
    "        while W==0:\n",
    "            OBSFG = []; OBSFGh=[]\n",
    "            for n in range(len(obs_data[balance])):\n",
    "                if ((f - bin_size) <= obs_data.Elev[n]) and (obs_data.Elev[n] <=  (f + bin_size)):\n",
    "                    O = obs_data[balance][n]\n",
    "                    Oh= obs_data['Ba_h'][n]\n",
    "                    OBSFG.append(O);OBSFGh.append(Oh)\n",
    "\n",
    "            if len(OBSFG)<3:#and bin_size<175:\n",
    "                bin_size=bin_size*(1+(.2*COU))\n",
    "                COU=COU+1\n",
    "            else:\n",
    "                OB_FG.append(np.array(OBSFG));OB_FG_h.append(np.array(OBSFGh));\n",
    "                W=1\n",
    "    \n",
    "    ##### boxplot of observations ######\n",
    "    meanlineprops = dict(linestyle='--', linewidth=1., color='0.5'); medianprops = dict(linestyle='-', linewidth=1, color='k')\n",
    "    boxprops = dict(linewidth=0.5);\n",
    "    BOX=ax1[count].boxplot(OB_FG,meanprops=meanlineprops,medianprops=medianprops,showmeans=True, meanline=True,sym='',\n",
    "                    positions=new.dem_med,widths=75,boxprops=boxprops,whiskerprops=boxprops)\n",
    "    # [1950, 2050, 2150, 2250, 2350, 2450, 2550, 2650, 2750, 2850, 2950, 3050,3150]\n",
    "    \n",
    "    OBF=[];GPRq=[];OPTq=[];CLARKEq=[];OB_FGmean=[];OB_FG_hmean=[]\n",
    "    ###calculate mean of balance values within each elevation bin\n",
    "    for i in range(len(OB_F)):\n",
    "        OBF.append(np.round(OB_F[i].mean(),3));GPRq.append(np.round(GPR[i].mean(),3))\n",
    "        OPTq.append(np.round(OPT[i].mean(),3));CLARKEq.append(np.round(CLARKE[i].mean(),3))\n",
    "    for i in range(len(OB_FG)): ##OBS means for each FG bin\n",
    "        OB_FGmean.append(np.round(OB_FG[i].mean(),3))   \n",
    "        OB_FG_hmean.append(np.round(OB_FG_h[i].mean(),3))\n",
    "    \n",
    "    FG_all['OB_FG']=OB_FGmean\n",
    "    FG_all.dropna(subset=['b_fg_we_gpr'], inplace=True)  ## remove data for bins where GPR is nan \n",
    "    \n",
    "    \n",
    "    obs_fg_all.extend(OB_FGmean);obs_bin_all.extend(OBF);gpr_bin_all.extend(GPRq);opt_bin_all.extend(OPTq);clarke_bin_all.extend(CLARKEq);z_range_all.extend(z_range) ##all binned data\n",
    "    elev_gpr_all.extend(FG_all.dem_mean);gpr_all.extend(FG_all.b_fg_we_gpr);opt_all.extend(new.b_fg_we);\n",
    "    clarke_all.extend(new.b_fg_weF);elev_all.extend(new.dem_mean) ## all point and gate data\n",
    "       \n",
    "    gpr_bdiff.extend((np.array(OBF) - np.array(GPRq))); \n",
    "    opt_bdiff.extend((np.array(OBF) - np.array(OPTq))); clarke_bdiff.extend((np.array(OBF) - np.array(CLARKEq)))\n",
    "    \n",
    "    gpr_bd_fg.extend((np.array(OB_FGmean) - np.array(new.b_fg_we_gpr)))#; gpr_bd_fg.extend([np.nan,np.nan])\n",
    "    opt_bd_fg.extend((np.array(OB_FGmean) - np.array(new.b_fg_we))); clarke_bd_fg.extend((np.array(OB_FGmean) - np.array(new.b_fg_weF)))\n",
    "    \n",
    "############## piecewise function ########################################         \n",
    "#     y_bin=[OBF,GPRq[:-2],OPTq,CLARKEq]; x_bin=[z_range,z_range[:-2],z_range,z_range]\n",
    "    \n",
    "#     y_bin=[OB_FGmean,FG_all.b_fg_we_gpr, new.b_fg_we,new.b_fg_weF]; x_bin=[new.dem_med,FG_all.dem_med,new.dem_med,new.dem_med]\n",
    "#     bp = [2525,2575,2500] # break point (~ELA)\n",
    "#     ELA = [2530,2600,2645];    s_ELA = [135,110,90]\n",
    "#     def piecewise_linear(x, x0, y0, k1, k2):\n",
    "#         x0=bp[I]\n",
    "#         return np.piecewise(x, [x < x0], [lambda x:k1*x + y0-k1*x0, lambda x:k2*x + y0-k2*x0])   \n",
    "    \n",
    "#     for i in range(4):      \n",
    "#         x0=[ELA[I]]#bp[I]\n",
    "#         Y=np.array(y_bin[i]);  X=np.array(x_bin[i])\n",
    "#         model = pwlf.PiecewiseLinFit(X, Y)\n",
    "#         breakpoints = [1950.,x0,3300.]\n",
    "#         model.fit_guess([x0]) #model.fit_with_breaks(breakpoints)\n",
    "#         breaks =model.fit_guess([x0]); x0 =breaks[1];\n",
    "#         x_hat = np.linspace(1950, 3200, 10);  y_hat = model.predict(x_hat)         \n",
    "#         sl=model.slopes; se=model.standard_errors(); rsq=model.r_squared()\n",
    "#         SL.append(sl);SE.append(se);RSQ.append(rsq)\n",
    "#         x1=np.array(x_bin[i]); y1=np.array(y_bin[i])\n",
    "#         p , e = curve_fit(piecewise_linear, x1, y1 )\n",
    "#         xd = np.arange(1950., 3200., 10.)\n",
    "#         ela = (0.0 - model.intercepts[0]) / sl[0]; ELA_pw.append(ela)\n",
    "#         if fit == 'PW':\n",
    "#             ax1[count].plot(x_hat, y_hat, lw=1.1, alpha=a, color=color[i], zorder=1)#label=label[i])\n",
    "# #             ax1[count].plot(xd, piecewise_linear(xd, *p), color=color[i], lw=1., alpha=0.9)\n",
    "#         # mean square error of the lines\n",
    "#         for Line in range(2):\n",
    "#             Pred=[];Act=[]\n",
    "#             if Line ==0:\n",
    "#                 INDEX= np.where(x1<x0)[0]\n",
    "#                 for ix in INDEX:\n",
    "#                     Pred.append( p[2]*x1[ix]+(p[1]-p[2]*x0))\n",
    "#                     Act.append(y1[ix])\n",
    "\n",
    "#                 MSE_ABL.append(MSE(Act,Pred))\n",
    "#             if Line==1:\n",
    "#                 INDEX= np.where(x1>=x0)[0]\n",
    "#                 for ix in INDEX:\n",
    "#                     Pred.append( p[3]*x1[ix]+(p[1]-p[3]*x0))\n",
    "#                     Act.append(y1[ix])\n",
    "#                 MSE_ACC.append(MSE(Act,Pred))\n",
    "# ########## Linear fit ##################                \n",
    "#     for i in range(4): \n",
    "#         Y=np.array(y_bin[i]);X=np.array(x_bin[i])\n",
    "#         model = pwlf.PiecewiseLinFit(X, Y)\n",
    "#         breakpoints = [1950.,3300.]\n",
    "#         model.fit_with_breaks(breakpoints)\n",
    "#         x_hat = np.linspace(1950, 3120, 10); y_hat = model.predict(x_hat)\n",
    "#         if fit == 'LIN':\n",
    "#             ax1[count].plot(x_hat, y_hat, lw=1.1, alpha=a, color=color[i], zorder=1)#label=label[i])\n",
    "#         sll=model.slopes; sel=model.standard_errors(); rsql=model.r_squared()\n",
    "#         SL_L.append(sll);SE_L.append(sel);RSQ_L.append(rsql)\n",
    "#         x1=np.array(x_bin[i]); y1=np.array(y_bin[i])\n",
    "#         p , e = curve_fit(piecewise_linear, x1, y1 )\n",
    "#         xd = np.arange(1950., 3150., 10.)\n",
    "#         ela = (0.0 - model.intercepts[0]) / SL_L[0]; ELA_lin.append(ela)\n",
    "#     # mean square error of the lines  \n",
    "#         for Line in range(2):\n",
    "#             x0=2900\n",
    "#             Pred=[];Act=[]\n",
    "#             if Line ==0:\n",
    "#                 INDEX= np.where(x1<x0)[0]\n",
    "#                 for ix in INDEX:\n",
    "#                     Pred.append( p[2]*x1[ix]+(p[1]-p[2]*x0))\n",
    "#                     Act.append(y1[ix])\n",
    "#                 MSE_ALL.append(MSE(Act,Pred))\n",
    "                \n",
    "                #         ax1[count].text(0.2, ytxt[i], txt[i]+ ' L1: '+ str(np.round(p[2]*1000,2)) +' L2: ' + \n",
    "#                         str(np.round(p[3]*1000,2)) + ' AABR: ' + str(np.round(p[2]/p[3],2)),\n",
    "#                         fontsize=6, transform=ax1[count].transAxes)  \n",
    "#     ax1[count].text(0.2, ytxt[i], txt[i] + ' L1: '+ str(round(sl[0]*1000,2))+u\" \\u00B1 \"+ str(round(se[1]*1000*1.96,2)) +' L2: ' + \n",
    "#              str(round(sl[1]*1000,2))+u\" \\u00B1 \"+ str(round(se[2]*1000*1.96,2)),fontsize=6,transform=ax1[count].transAxes)\n",
    "    y_bin=[OB_FGmean,FG_all.b_fg_we_gpr, new.b_fg_we,new.b_fg_weF]; x_bin=[new.dem_med,FG_all.dem_med,new.dem_med,new.dem_med]\n",
    "    bp = [2525,2575,2500] # break point (~ELA)\n",
    "    ELA = [2530,2600,2645];    s_ELA = [135,110,90]\n",
    "    def piecewise_linear(x, x0, y0, k1, k2):\n",
    "        x0=bp[I]\n",
    "        return np.piecewise(x, [x < x0], [lambda x:k1*x + y0-k1*x0, lambda x:k2*x + y0-k2*x0])   \n",
    "    \n",
    "    for i in range(4):     \n",
    "        x0=bp[I];Y=np.array(y_bin[i]);  X=np.array(x_bin[i])\n",
    "        p , e = curve_fit(piecewise_linear, X, Y )\n",
    "        xd = np.arange(1950., 3200., 10.); yd = piecewise_linear(xd, *p)\n",
    "        model = pwlf.PiecewiseLinFit(xd, yd)\n",
    "        breaks = model.fit_guess([x0]); #breakpoints = [2150.,x0,2900.]\n",
    "        sl=model.slopes; se=model.standard_errors(); rsq=model.r_squared()\n",
    "        SL.append(sl);SE.append(se);RSQ.append(rsq)\n",
    "        #x_hat = np.linspace(2150, 2900, 10);  y_hat = model.predict(x_hat) \n",
    "        ela = (0.0 - model.intercepts[0]) / sl[0]; ELA_pw.append(ela)\n",
    "        if fit == 'PW':\n",
    "            ax1[count].plot(xd, piecewise_linear(xd, *p), color=color[i], lw=1., alpha=0.9)#0.9\n",
    "\n",
    "########## Linear fit ##################                \n",
    "    for i in range(4): \n",
    "        Y=np.array(y_bin[i]);X=np.array(x_bin[i])\n",
    "        model = pwlf.PiecewiseLinFit(X, Y)\n",
    "        breakpoints = [1950.,3300.]\n",
    "        model.fit_with_breaks(breakpoints)\n",
    "        x_hat = np.linspace(1950, 3120, 10); y_hat = model.predict(x_hat)\n",
    "        if fit == 'LIN':\n",
    "            ax1[count].plot(x_hat, y_hat, lw=1.1, alpha=a, color=color[i], zorder=1)#label=label[i])\n",
    "        sll=model.slopes; sel=model.standard_errors(); rsql=model.r_squared()\n",
    "        SL_L.append(sll);SE_L.append(sel);RSQ_L.append(rsql)\n",
    "        x1=np.array(x_bin[i]); y1=np.array(y_bin[i])\n",
    "        p , e = curve_fit(piecewise_linear, x1, y1 )\n",
    "        xd = np.arange(1950., 3150., 10.)\n",
    "        ela = (0.0 - model.intercepts[0]) / sll[0]; ELA_lin.append(ela)\n",
    "########################### end piecewise ################################\n",
    "   \n",
    "    ## add ELA to plot                 \n",
    "    ax1[count].errorbar(ELA[I],0., xerr=s_ELA[I], yerr=None, fmt='o', c='limegreen', mec='b',\n",
    "            mfc='limegreen',mew=mew, elinewidth=elw+0.4, label='ELA Satellite', alpha=0.85, zorder=4)   \n",
    "    \n",
    "    ax1[count].set(xlim=(1845,3270), ylim=(-7.5,4.2))\n",
    "    ax1[2].legend(loc='best', bbox_to_anchor=(0.48, 0.57), labelspacing=0.2, handletextpad=0.1)\n",
    "    ax1[count].xaxis.set_major_locator(ticker.MultipleLocator(200))\n",
    "    ax1[count].text(0.92, 0.03, letter[count], transform=ax1[count].transAxes)\n",
    "    ax1[count].text(0.03, 0.92, year, transform=ax1[count].transAxes)\n",
    "    ax2[count].text(0.03, 0.92, year, transform=ax2[count].transAxes)\n",
    "    ax1[count].set_xticklabels(['',2000, '', 2400, '', 2800, '', 3200])\n",
    "    ################### mass conservation plot ####################################\n",
    "   \n",
    "    BM= []; BMh=[]\n",
    "    for i in range(len(OB_FG)):\n",
    "        B = OB_FG[i].mean();Bh = np.mean(OB_FG_h[i])  # choose median or mean\n",
    "        BM.append(B);BMh.append(Bh)\n",
    "    new['SMB'] = OB_FGmean; new['BH']= BMh # or OB_FG_hmean\n",
    "    new['BMC'] = new.BH  + new.Q_netA - new.Vfirn\n",
    "    new['BMC_gpr'] = new.BH + new.Q_netA_gpr - new.Vfirn \n",
    "    new['BMCF'] = new.BH + new.Q_netAF - new.Vfirn \n",
    "\n",
    "######################  https://pypi.org/project/hydroeval/  ##############################\n",
    "\n",
    "############### STATS using elev binned data\n",
    "    EST=[np.array(GPRq[:-2]),np.array(OPTq),np.array(CLARKEq)] ## must be arrays not lists\n",
    "    OBFa=np.array(OBF);OBFGma=np.array(OB_FGmean)\n",
    "    ME.append(0.0);MAE.append(0.0),RSR.append(0.0);PBias.append(0.0);NSE.append(0.0)\n",
    "    for e in range(3):\n",
    "        FLB=np.array(y_bin[e+1])\n",
    "        if e==0:\n",
    "#             NSE.extend(evaluator(nse, EST[e], OBFa[:-2]))\n",
    "            PBias.extend(evaluator(pbias, FLB, np.array(FG_all.OB_FG)))  #def pbias(simulations, evaluation):\n",
    "#             RMSE=evaluator(rmse, EST[e], OBFa[:-2])\n",
    "#             RSR.extend((RMSE/(np.std(OBFa))))\n",
    "            ME.append((np.array(FG_all.OB_FG)-FLB).mean())  \n",
    "            MAE.append(np.abs(np.array(FG_all.OB_FG)-FLB).mean())  \n",
    "        else:\n",
    "#             NSE.extend(evaluator(nse, EST[e], OBFa))\n",
    "            PBias.extend(evaluator(pbias, FLB, OBFGma))\n",
    "#             RMSE=evaluator(rmse, EST[e], OBFa)\n",
    "#             RSR.extend((RMSE/(np.std(OBFa))))\n",
    "            ME.append((OBFGma-FLB).mean())\n",
    "            MAE.append(np.abs(OBFGma-FLB).mean())\n",
    "################### STATS using FG binned data    \n",
    "#     EST=[np.array(FG_all.b_fg_we_gpr), np.array(new.b_fg_we), np.array(new.b_fg_weF)]     #[np.array(GPRq[:-2]),np.array(OPTq),np.array(CLARKEq)] ## must be arrays not lists\n",
    "#     ME.append(0.0);MAE.append(0.0),RSR.append(0.0);PBias.append(0.0);NSE.append(0.0)\n",
    "#     O= FG_all.OB_FG.values;O1=np.array(OB_FGmean)\n",
    "    \n",
    "#     for e in range(3):\n",
    "#         if e==0:\n",
    "#             NSE.extend(evaluator(nse, EST[e],O))\n",
    "#             PBias.extend(evaluator(pbias, EST[e],O))\n",
    "#             RMSE=evaluator(rmse, EST[e],O)\n",
    "#             RSR.extend((RMSE/(np.std(np.array(O)))))\n",
    "#             ME.append((np.array(O)-EST[e]).mean())  \n",
    "#             MAE.append(np.abs(np.array(O)-EST[e]).mean())  \n",
    "#         else:\n",
    "#             NSE.extend(evaluator(nse, EST[e], O1))\n",
    "#             PBias.extend(evaluator(pbias, EST[e], O1))\n",
    "#             RMSE=evaluator(rmse, EST[e], O1)\n",
    "#             RSR.extend((RMSE/(np.std(O1))))\n",
    "#             ME.append((O1-EST[e]).mean())\n",
    "#             MAE.append(np.abs(O1-EST[e]).mean())\n",
    "################### End difference ##########################           \n",
    "\n",
    "    MC = [new.BMC_gpr,new.BMC, new.BMCF]\n",
    "#     MC= [new.b_fg_h_gpr, new.b_fg_h, new.b_fg_hF]\n",
    "    Yvv = [new.Q_netA_gpr, new.Q_netA, new.Q_netAF]\n",
    "    Yvv_lbl=[r'$V^{\\uparrow}_{IPR}$',r'$V^{\\uparrow}_{OGGM}$',r'$V^{\\uparrow}_{Clarke}$']\n",
    "    \n",
    "    yerr_dh= [new.sBwe_gpr/(new['RHO_g']/1000) , new.sBwe_opt/(new['RHO']/1000),\n",
    "              new.sBwe_F/(new['RHO_F']/1000)]\n",
    "    if I == 0:\n",
    "        overlap=[];overlap_gpr=[];overlapF=[]\n",
    "        MC_LIST=[overlap_gpr,overlap,overlapF]\n",
    "    for i in range(3):\n",
    "#         ax2[count].scatter(new.dem_mean, Yvv[i], edgecolor='r', marker='^', alpha=0.8, label=Yvv_lbl[i], s=s+10, \n",
    "#                        color=color[i+1], zorder=4, linewidth=0.25)\n",
    "        if i == 0:\n",
    "            ax2[count].errorbar(new.dem_med+shift[i]+5,MC[i], xerr=None, yerr=yerr_dh[i], fmt=sym[i+1], \n",
    "                     c=color[i+1], mfc=mfc,mew=mew, elinewidth=elw,mec=color[i+1], label=txt[i+1], alpha=0.8, zorder=3)\n",
    "        else:\n",
    "            ax2[count].errorbar(new.dem_med+shift[i],MC[i], xerr=None, yerr=yerr_dh[i], fmt=sym[i+1], \n",
    "                c=color[i+1], mec=color[i+1], mfc=mfc,mew=mew, elinewidth=elw, label=txt[i+1], alpha=0.8, zorder=3)\n",
    "        ####count the number of SMB obs. +/- 1-error which fall within the uncertainty bounds of the LiDAR height change            \n",
    "        OL = MC_LIST[i] ## select which list to append to\n",
    "        for r in range(len(MC[i])):\n",
    "            M_min = MC[i][r] - yerr_dh[i][r]; M_max = MC[i][r]+ yerr_dh[i][r]\n",
    "            L_min = new.dh_mean[r] - sDHdt*2; L_max = new.dh_mean[r] + sDHdt*2\n",
    "            if (i==0) and r>5 and r<8: ## gpr bins without data\n",
    "                OL.append(np.nan)\n",
    "            elif M_min > L_min and M_min < L_max:\n",
    "                OL.append(1);# W=0\n",
    "            elif M_max < L_max and M_max > L_min:\n",
    "                OL.append(1); #W=0\n",
    "            elif M_max > L_max and M_min < L_min:\n",
    "                OL.append(1); #W=0\n",
    "            elif M_max < L_max and M_min > L_min:\n",
    "                OL.append(1); #W=0\n",
    "            else:\n",
    "                OL.append(0)\n",
    "        #     for i in range(3):\n",
    "#         ax2[count].scatter(new.dem_mean, Yvv[i], edgecolor='k', marker='^', alpha=a+.2, label=Yvv_lbl[i], s=s+5, \n",
    "#                            color=color[i+1], zorder=3, linewidth=0.2)\n",
    "#         if i == 0:\n",
    "#             ax2[count].errorbar(new.dem_mean+shift[i]+5,MC[i], xerr=None, yerr=yerr[i+1], fmt=sym[i+1], \n",
    "#                      c=color[i+1],  mfc=None, label=label[i+1], alpha=0.4, zorder=2)\n",
    "#         else:\n",
    "#             ax2[count].errorbar(new.dem_mean+shift[i],MC[i], xerr=None, yerr=yerr[i+1], fmt=sym[i+1], \n",
    "#                      c=color[i+1], mfc=None,label=label[i+1], alpha=0.4, zorder=2)\n",
    "    \n",
    "    Ybd = [BM, new.b_fg_we_gpr, new.b_fg_we, new.b_fg_weF]\n",
    "    #     for i in range(4):   ### plot SMB\n",
    "#         ax2[count].scatter(new.dem_mean, Ybd[i], color=color[i], marker='o', alpha=a+.2, s=s,facecolor='', zorder=3)\n",
    "        \n",
    "    ax2[count].errorbar(new.dem_med,new.dh_mean, xerr=50, yerr=sDHdt*2, fmt='o', c='k', label='LiDAR',alpha=0.8, zorder=2, mfc='none', elinewidth=elw)\n",
    "    ax2[count].text(0.92, 0.92, letter[count], transform=ax2[count].transAxes)\n",
    "    ax2[count].set(xlim=(1845,3250), ylim=(-7.,3.5))\n",
    "    ax2[count].set_xticklabels(['',2000, '', 2400, '', 2800, '', 3200])\n",
    "#     ax1[count].set(ylim=(-9.,3.5)) #xlim=(1850,3300)\n",
    "    ax2[2].legend(loc='lower center', ncol=2,columnspacing=0.5,handletextpad=0.5)\n",
    "    ax1[count].tick_params(which='major', length=3); ax2[count].tick_params(which='major', length=3) \n",
    "    count+=1\n",
    "\n",
    "    bin_df = pd.DataFrame(list(zip(z_range, OB_F, GPR, OPT, CLARKE)), columns=['Elev', 'OBS', 'GPR', 'OGGM', 'CLARKE']) \n",
    "#     bin_df.to_csv(fl_path+'bin_df_' + str(year) +'.csv')\n",
    "    if year==2016:\n",
    "        new16=new.copy();#new16.to_pickle(fl_path+'conrad_new16.pkl')\n",
    "    elif year==2017:\n",
    "        new17=new.copy();#new17.to_pickle(fl_path+'conrad_new17.pkl')\n",
    "#     else:\n",
    "#         new.to_pickle(fl_path+'conrad_new18.pkl')\n",
    "#     if year == 2016:\n",
    "#         VEL_LIST = [D.vfg.mean()]\n",
    "#     else:\n",
    "#         VEL_LIST.append(D.vfg.mean())\n",
    "        \n",
    "# fig2.text(0.008, 0.6, 'Height change (m ice $a^{-1}$)', rotation=90); fig1.text(0.008, 0.6, 'Mass balance (m w.e.)', rotation=90)\n",
    "# fig1.text(0.45, 0.01, 'Elevation (m a.s.l.)');fig2.text(0.45, 0.01, 'Elevation (m a.s.l.)')\n",
    "ax1[0].set_ylabel('Mass balance (m w.e.)');ax2[0].set_ylabel('Height change (m ice $a^{-1}$)')\n",
    "ax1[1].set_xlabel('Elevation (m a.s.l.)');ax2[1].set_xlabel('Elevation (m a.s.l.)')\n",
    "\n",
    "fig1.subplots_adjust(bottom=0.09, top=0.98, hspace=0.1, left=0.06, right=0.99, wspace=0.05)#left=0.07, right=0.9,wspace=0.05, \n",
    "fig2.subplots_adjust(bottom=0.09, top=0.98, hspace=0.1, left=0.06, right=0.99, wspace=0.05)\n",
    "\n",
    "if firn==True:\n",
    "    fig1.savefig(fl_path+'products/'+glacier[gl]+'_bdot_'+ fit +'_11bins_25m_OBFG_dcalc_' +str(Dint)+'_'+balance +'_indV25m_cd_CLARKE.pdf', dpi=300)    #_NOfirn\n",
    "#     fig2.savefig(fl_path+'products/'+glacier[gl]+'_mass_con_' + fit + '_11bins_' + str(Dint)+'_'+balance +'_cd.pdf', dpi=300)\n",
    "else:\n",
    "    fig1.savefig(fl_path+'products/'+glacier[gl]+'_bdot_'+ fit +'_11bins_25m_OBFG_dcalc_' +str(Dint)+'_'+balance +'_indV25m_NOfirn_cd_CLARKE.pdf', dpi=300)    #_ITS_LIVE\n",
    "#     fig2.savefig(fl_path+'products/'+glacier[gl]+'_mass_con_' + fit + '_11bins_' +str(Dint)+'_'+balance +'_NOfirn_cd.pdf', dpi=300) #_ITS_LIVE\n",
    "\n",
    "SE=np.array(SE);SL=np.array(SL);SE_L=np.array(SE_L);SL_L=np.array(SL_L);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ipr nan 21.0 33 nan: 6\n",
      "OGGM 0.606 20 33\n",
      "Farin 0.545 18 33\n",
      "all 0.634 59.0 93\n"
     ]
    }
   ],
   "source": [
    "print('ipr',np.sum(MC_LIST[0])/ len(MC_LIST[0]), np.nansum(MC_LIST[0]), len(MC_LIST[0]), 'nan:',len(np.array(MC_LIST[0])[np.isnan(np.array(MC_LIST[0]))]))\n",
    "print('OGGM',round(np.sum(MC_LIST[1])/ len(MC_LIST[1]),3), np.sum(MC_LIST[1]), len(MC_LIST[1]))\n",
    "print('Farin',round(np.sum(MC_LIST[2])/ len(MC_LIST[2]),3), np.sum(MC_LIST[2]), len(MC_LIST[2]))\n",
    "print('all',round(np.nansum(MC_LIST)/ (len(MC_LIST[0])+len(MC_LIST[1])+len(MC_LIST[2])-6),3), np.nansum(MC_LIST), (len(MC_LIST[0])+len(MC_LIST[1])+len(MC_LIST[2]))-6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig,ax=plt.subplots(1,1, figsize=cm2inch(24,12))\n",
    "plt.plot(new.sQnetA_opt_high/new.sQnetA_opt-1, label='full slip (1.0)')\n",
    "plt.plot(new.sQnetA_opt_low/new.sQnetA_opt-1, label='plug flow (0.80)')\n",
    "plt.plot(new.sQnetA_opt/new.sQnetA_opt-1, label= 'best estimate (0.85)')\n",
    "# plt.plot(new.sQnetA_opt_high/np.abs(new.Q_netA))\n",
    "# plt.plot(new.sQnetA_opt_low/np.abs(new.Q_netA))\n",
    "# plt.plot(new.sQnetA_opt/np.abs(new.Q_netA))\n",
    "ax.set(ylabel='Percent Deviation',xlabel='Flux bin') #ylim=(0.2,0.6))\n",
    "ax.legend()\n",
    "plt.savefig(fl_path+'products/'+glacier[gl]+'Plug_flow_vs_full_slip effect.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "residuals= [z_range_all,gpr_bdiff,farin_bdiff,opt_bdiff,obs_bin_all]\n",
    "\n",
    "r = pd.DataFrame(list(zip(z_range_all,elev_all,gpr_bdiff,farin_bdiff,opt_bdiff,gpr_bd_fg,opt_bd_fg,farin_bd_fg,obs_bin_all,obs_fg_all)), \n",
    "                  columns=['z_range_all','elev_all','gpr_bdiff','farin_bdiff','opt_bdiff','gpr_bd_fg','opt_bd_fg','farin_bd_fg',\n",
    "                           'obs_bin_all','obs_fg_all']) \n",
    "# r['zrel'] = r.elev_all-np.nanmin(dem.data[msk_conrad.data==1.0]) ## use minimum elevation\n",
    "# r.zrel= r.zrel / np.nanmax(dem.data[msk_conrad.data==1.0])  ## ## use minimum elevation\n",
    "r['zrel'] = r.elev_all-r.z_range_all.min()\n",
    "r.zrel= r.zrel / r.zrel.max()\n",
    "\n",
    "r['gpr_fr']=r.gpr_bdiff/np.abs(r.obs_bin_all);r['far_fr']=r.farin_bdiff/np.abs(r.obs_bin_all);\n",
    "r['opt_fr']=r.opt_bdiff/np.abs(r.obs_bin_all); \n",
    "## for FG bins\n",
    "r['opt_bd_fr']=r.opt_bd_fg/np.abs(r.obs_fg_all)\n",
    "r['farin_bd_fr']=r.farin_bd_fg/np.abs(r.obs_fg_all);r['gpr_bd_fr']=r.gpr_bd_fg/np.abs(r.obs_fg_all);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig_path= '/home/pelto/Desktop/ice_flux/figures/'\n",
    "\n",
    "# with open(fig_path + glacier[gl]+'_residuals.pkl', 'wb') as f: #_NOfirn\n",
    "#     pickle.dump(r, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r.gpr_bd_fg.mean(),r.gpr_bdiff.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r.opt_bd_fg.mean(),r.opt_bdiff.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y1=np.array([2016]*13);y2=np.array([2017]*13);y3=np.array([2018]*13);Years=np.concatenate([y1,y2,y3])\n",
    "r['year']=Years\n",
    "r.z_range_all[r.z_range_all==2750.0]=np.nan;#\n",
    "for n in range(len(r)):\n",
    "    if (r.z_range_all[n]==2550.0) and (r.year[n]<2018):\n",
    "        r.z_range_all[n]=np.nan\n",
    "    if (r.z_range_all[n]>2750.0) and (r.year[n]==2017):\n",
    "        r.z_range_all[n]=np.nan\n",
    "    if (r.z_range_all[n]>2450.0 or r.z_range_all[n]==2550.0) and (r.year[n]==2017):\n",
    "        r.z_range_all[n]=np.nan\n",
    "\n",
    "# r.z_range_all[ & r.year<2018]=np.nan\n",
    "r.dropna(subset=['z_range_all'],inplace=True)\n",
    "\n",
    "r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conrad Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>method</th>\n",
       "      <th>ALL</th>\n",
       "      <th>ALLse</th>\n",
       "      <th>ABL</th>\n",
       "      <th>ABLse</th>\n",
       "      <th>ACC</th>\n",
       "      <th>ACCse</th>\n",
       "      <th>ELA</th>\n",
       "      <th>ELA_sat</th>\n",
       "      <th>sELA_sat</th>\n",
       "      <th>ME</th>\n",
       "      <th>MAE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.24</td>\n",
       "      <td>0.6</td>\n",
       "      <td>9.59</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.43</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2520</td>\n",
       "      <td>2530</td>\n",
       "      <td>135</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>7.45</td>\n",
       "      <td>0.9</td>\n",
       "      <td>8.83</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.95</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2587</td>\n",
       "      <td>2530</td>\n",
       "      <td>135</td>\n",
       "      <td>0.05</td>\n",
       "      <td>0.91</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>7.60</td>\n",
       "      <td>1.2</td>\n",
       "      <td>10.63</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.17</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2541</td>\n",
       "      <td>2530</td>\n",
       "      <td>135</td>\n",
       "      <td>0.18</td>\n",
       "      <td>1.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>FG Clarke</td>\n",
       "      <td>5.94</td>\n",
       "      <td>1.0</td>\n",
       "      <td>7.11</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.62</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2575</td>\n",
       "      <td>2530</td>\n",
       "      <td>135</td>\n",
       "      <td>-0.32</td>\n",
       "      <td>0.80</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.72</td>\n",
       "      <td>0.8</td>\n",
       "      <td>10.58</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2577</td>\n",
       "      <td>2600</td>\n",
       "      <td>110</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>5.86</td>\n",
       "      <td>0.8</td>\n",
       "      <td>7.88</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2683</td>\n",
       "      <td>2600</td>\n",
       "      <td>110</td>\n",
       "      <td>-0.01</td>\n",
       "      <td>0.85</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>5.96</td>\n",
       "      <td>1.0</td>\n",
       "      <td>9.28</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.05</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2633</td>\n",
       "      <td>2600</td>\n",
       "      <td>110</td>\n",
       "      <td>0.24</td>\n",
       "      <td>1.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>FG Clarke</td>\n",
       "      <td>4.43</td>\n",
       "      <td>0.8</td>\n",
       "      <td>6.10</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.94</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2711</td>\n",
       "      <td>2600</td>\n",
       "      <td>110</td>\n",
       "      <td>-0.24</td>\n",
       "      <td>1.06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.81</td>\n",
       "      <td>0.5</td>\n",
       "      <td>9.76</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.88</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2515</td>\n",
       "      <td>2645</td>\n",
       "      <td>90</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>6.44</td>\n",
       "      <td>0.8</td>\n",
       "      <td>8.99</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.97</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2484</td>\n",
       "      <td>2645</td>\n",
       "      <td>90</td>\n",
       "      <td>-0.46</td>\n",
       "      <td>0.83</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>6.46</td>\n",
       "      <td>1.0</td>\n",
       "      <td>10.48</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.46</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2461</td>\n",
       "      <td>2645</td>\n",
       "      <td>90</td>\n",
       "      <td>-0.23</td>\n",
       "      <td>0.82</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>FG Clarke</td>\n",
       "      <td>4.94</td>\n",
       "      <td>0.8</td>\n",
       "      <td>7.36</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.53</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2455</td>\n",
       "      <td>2645</td>\n",
       "      <td>90</td>\n",
       "      <td>-0.69</td>\n",
       "      <td>1.11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.59</td>\n",
       "      <td>0.6</td>\n",
       "      <td>9.98</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.44</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2537</td>\n",
       "      <td>2592</td>\n",
       "      <td>112</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>6.58</td>\n",
       "      <td>0.8</td>\n",
       "      <td>8.57</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.31</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2584</td>\n",
       "      <td>2592</td>\n",
       "      <td>112</td>\n",
       "      <td>-0.14</td>\n",
       "      <td>0.86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>6.67</td>\n",
       "      <td>1.1</td>\n",
       "      <td>10.13</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.56</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2545</td>\n",
       "      <td>2592</td>\n",
       "      <td>112</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>FG Clarke</td>\n",
       "      <td>5.10</td>\n",
       "      <td>0.8</td>\n",
       "      <td>6.86</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.03</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2580</td>\n",
       "      <td>2592</td>\n",
       "      <td>112</td>\n",
       "      <td>-0.41</td>\n",
       "      <td>0.99</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       method   ALL  ALLse    ABL  ABLse   ACC  ACCse   ELA  ELA_sat  \\\n",
       "0    Observed  6.24    0.6   9.59    0.0  2.43    0.0  2520     2530   \n",
       "1      FG IPR  7.45    0.9   8.83    0.0  5.95    0.0  2587     2530   \n",
       "2     FG OGGM  7.60    1.2  10.63    0.0  4.17    0.0  2541     2530   \n",
       "3   FG Clarke  5.94    1.0   7.11    0.0  4.62    0.0  2575     2530   \n",
       "4    Observed  6.72    0.8  10.58    0.0  1.00    0.0  2577     2600   \n",
       "5      FG IPR  5.86    0.8   7.88    0.0  3.00    0.0  2683     2600   \n",
       "6     FG OGGM  5.96    1.0   9.28    0.0  1.05    0.0  2633     2600   \n",
       "7   FG Clarke  4.43    0.8   6.10    0.0  1.94    0.0  2711     2600   \n",
       "8    Observed  6.81    0.5   9.76    0.0  3.88    0.0  2515     2645   \n",
       "9      FG IPR  6.44    0.8   8.99    0.0  3.97    0.0  2484     2645   \n",
       "10    FG OGGM  6.46    1.0  10.48    0.0  2.46    0.0  2461     2645   \n",
       "11  FG Clarke  4.94    0.8   7.36    0.0  2.53    0.0  2455     2645   \n",
       "12   Observed  6.59    0.6   9.98    0.0  2.44    0.0  2537     2592   \n",
       "13     FG IPR  6.58    0.8   8.57    0.0  4.31    0.0  2584     2592   \n",
       "14    FG OGGM  6.67    1.1  10.13    0.0  2.56    0.0  2545     2592   \n",
       "15  FG Clarke  5.10    0.8   6.86    0.0  3.03    0.0  2580     2592   \n",
       "\n",
       "    sELA_sat    ME   MAE  \n",
       "0        135  0.00  0.00  \n",
       "1        135  0.05  0.91  \n",
       "2        135  0.18  1.01  \n",
       "3        135 -0.32  0.80  \n",
       "4        110  0.00  0.00  \n",
       "5        110 -0.01  0.85  \n",
       "6        110  0.24  1.01  \n",
       "7        110 -0.24  1.06  \n",
       "8         90  0.00  0.00  \n",
       "9         90 -0.46  0.83  \n",
       "10        90 -0.23  0.82  \n",
       "11        90 -0.69  1.11  \n",
       "12       112  0.00  0.00  \n",
       "13       112 -0.14  0.86  \n",
       "14       112  0.06  0.94  \n",
       "15       112 -0.41  0.99  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ELA_sat=[];sELA_sat=[]\n",
    "for i in range(len(ELA)):\n",
    "    ELA_sat= ELA_sat+ ([ELA[i]] * 4)\n",
    "    sELA_sat= sELA_sat+ ([s_ELA[i]] * 4)\n",
    "ELA_sat,sELA_sat\n",
    "\n",
    "# MSE_ABL,MSE_ACC, 'MSE_ABL','MSE_ACC',RSR, NSE,\n",
    "method=[]\n",
    "for i in range(4):\n",
    "    method.extend(label)\n",
    "len(method)\n",
    "STATS=pd.DataFrame(list(zip(method,SL_L[:,0], SE_L[:,1],SL[:,0], SE[:,1],SL[:,1], SE[:,2], ELA_pw ,ELA_sat,sELA_sat,ME,MAE)),#PBias \n",
    "                     columns=['method','ALL','ALLse','ABL', 'ABLse', 'ACC', 'ACCse', 'ELA', 'ELA_sat' ,'sELA_sat','ME','MAE']) #'PBias'\n",
    "STATS.ALL=STATS.ALL*1000;STATS.ALLse=STATS.ALLse*1000;STATS.ABL=STATS.ABL*1000;STATS.ABLse=STATS.ABLse*1000;\n",
    "STATS.ACC=STATS.ACC*1000;STATS.ACCse=STATS.ACCse*1000\n",
    "STATS\n",
    "\n",
    "# STATS.ACC[STATS.method=='Observed'].min()/STATS.ACC[STATS.method=='Observed'].max()\n",
    "# STATS.ACC.mean()/STATS.ABLse.mean()\n",
    "\n",
    "# STATS=pd.read_pickle(FLP+Glacier[1]+ '/' + glacier[1]+ '_NOfirn_PW_stats.pkl')\n",
    "# STATS\n",
    "\n",
    "M= ['Observed','FG IPR','FG OGGM','FG Clarke']\n",
    "for m in M:\n",
    "    L= STATS[STATS.method==m].values\n",
    "    MEAN= np.nanmean(L[:,1:],axis=0)\n",
    "    MEAN= np.insert(MEAN,0,m)\n",
    "    STATS= STATS.append(dict(zip(STATS.columns, MEAN)),ignore_index=True)\n",
    "STATS=STATS.round(2);STATS.ABLse=STATS.ABLse.round(1);STATS.ACCse=STATS.ACCse.round(1);STATS.ALLse=STATS.ALLse.round(1)\n",
    "STATS.ELA=STATS.ELA.round(0);STATS.ELA=pd.to_numeric(STATS.ELA, downcast='integer')  #.round(0)#STATS.PBias=STATS.PBias.round(1)\n",
    "STATS.ELA_sat=STATS.ELA_sat.round(0);STATS.ELA_sat=pd.to_numeric(STATS.ELA_sat, downcast='integer') \n",
    "STATS.sELA_sat=STATS.sELA_sat.round(0);STATS.sELA_sat=pd.to_numeric(STATS.sELA_sat, downcast='integer') \n",
    "if firn == True:\n",
    "    STATS.to_pickle(fl_path+glacier[gl]+'_stats_firn_LIN_stats_clarke.pkl')\n",
    "else:\n",
    "#     STATS.to_pickle(fl_path+glacier[gl]+'_stats_NOfirn_LIN_stats.pkl')\n",
    "#     STATS.to_pickle(fl_path+'conrad_stats_ITS_LIVE_NOfirn.pkl')\n",
    "#     STATS.to_pickle(fl_path+glacier[gl]+'_stats_mosaic_NOfirn.pkl')\n",
    "    STATS.to_pickle(fl_path+glacier[gl]+'_stats_NOfirn_LIN_clarke.pkl')\n",
    "STATS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.699999999999999"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5.1+1.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2261001517450683"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(STATS.ALL[12] - STATS.ALL[15]) / STATS.ALL[12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# STATS.ACC[STATS.method=='Observed'].min()/STATS.ACC[STATS.method=='Observed'].max()\n",
    "# STATS.ACC.mean()/STATS.ABLse.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# STATS=pd.read_pickle(FLP+Glacier[1]+ '/' + glacier[1]+ '_NOfirn_PW_stats.pkl')\n",
    "# STATS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>method</th>\n",
       "      <th>ALL</th>\n",
       "      <th>ALLse</th>\n",
       "      <th>ABL</th>\n",
       "      <th>ABLse</th>\n",
       "      <th>ACC</th>\n",
       "      <th>ACCse</th>\n",
       "      <th>ELA_pw</th>\n",
       "      <th>ME</th>\n",
       "      <th>MAE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.24</td>\n",
       "      <td>0.6</td>\n",
       "      <td>9.59</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.43</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2520</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>7.45</td>\n",
       "      <td>0.9</td>\n",
       "      <td>8.82</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.94</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2587</td>\n",
       "      <td>0.05</td>\n",
       "      <td>0.91</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>7.60</td>\n",
       "      <td>1.2</td>\n",
       "      <td>10.62</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.17</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2541</td>\n",
       "      <td>0.18</td>\n",
       "      <td>1.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>FG Farinotti</td>\n",
       "      <td>5.94</td>\n",
       "      <td>0.9</td>\n",
       "      <td>7.11</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.62</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2575</td>\n",
       "      <td>-0.32</td>\n",
       "      <td>0.80</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.72</td>\n",
       "      <td>0.8</td>\n",
       "      <td>10.58</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2577</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>5.86</td>\n",
       "      <td>0.8</td>\n",
       "      <td>7.88</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2683</td>\n",
       "      <td>-0.01</td>\n",
       "      <td>0.85</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>5.96</td>\n",
       "      <td>1.0</td>\n",
       "      <td>9.27</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.05</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2633</td>\n",
       "      <td>0.23</td>\n",
       "      <td>1.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>FG Farinotti</td>\n",
       "      <td>4.42</td>\n",
       "      <td>0.8</td>\n",
       "      <td>6.10</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.94</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2711</td>\n",
       "      <td>-0.24</td>\n",
       "      <td>1.05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.81</td>\n",
       "      <td>0.5</td>\n",
       "      <td>9.76</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.88</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2515</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>6.44</td>\n",
       "      <td>0.8</td>\n",
       "      <td>8.99</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.97</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2484</td>\n",
       "      <td>-0.46</td>\n",
       "      <td>0.83</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>6.46</td>\n",
       "      <td>1.0</td>\n",
       "      <td>10.48</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.46</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2461</td>\n",
       "      <td>-0.23</td>\n",
       "      <td>0.82</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>FG Farinotti</td>\n",
       "      <td>4.94</td>\n",
       "      <td>0.8</td>\n",
       "      <td>7.36</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.53</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2454</td>\n",
       "      <td>-0.69</td>\n",
       "      <td>1.11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.59</td>\n",
       "      <td>0.6</td>\n",
       "      <td>9.98</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.44</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2537</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>6.58</td>\n",
       "      <td>0.8</td>\n",
       "      <td>8.56</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.31</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2584</td>\n",
       "      <td>-0.14</td>\n",
       "      <td>0.86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>6.67</td>\n",
       "      <td>1.1</td>\n",
       "      <td>10.12</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.56</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2545</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>FG Farinotti</td>\n",
       "      <td>5.10</td>\n",
       "      <td>0.8</td>\n",
       "      <td>6.85</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.03</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2580</td>\n",
       "      <td>-0.42</td>\n",
       "      <td>0.99</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          method   ALL  ALLse    ABL  ABLse   ACC  ACCse  ELA_pw    ME   MAE\n",
       "0       Observed  6.24    0.6   9.59    0.0  2.43    0.0    2520  0.00  0.00\n",
       "1         FG IPR  7.45    0.9   8.82    0.0  5.94    0.0    2587  0.05  0.91\n",
       "2        FG OGGM  7.60    1.2  10.62    0.0  4.17    0.0    2541  0.18  1.01\n",
       "3   FG Farinotti  5.94    0.9   7.11    0.0  4.62    0.0    2575 -0.32  0.80\n",
       "4       Observed  6.72    0.8  10.58    0.0  1.00    0.0    2577  0.00  0.00\n",
       "5         FG IPR  5.86    0.8   7.88    0.0  3.00    0.0    2683 -0.01  0.85\n",
       "6        FG OGGM  5.96    1.0   9.27    0.0  1.05    0.0    2633  0.23  1.01\n",
       "7   FG Farinotti  4.42    0.8   6.10    0.0  1.94    0.0    2711 -0.24  1.05\n",
       "8       Observed  6.81    0.5   9.76    0.0  3.88    0.0    2515  0.00  0.00\n",
       "9         FG IPR  6.44    0.8   8.99    0.0  3.97    0.0    2484 -0.46  0.83\n",
       "10       FG OGGM  6.46    1.0  10.48    0.0  2.46    0.0    2461 -0.23  0.82\n",
       "11  FG Farinotti  4.94    0.8   7.36    0.0  2.53    0.0    2454 -0.69  1.11\n",
       "12      Observed  6.59    0.6   9.98    0.0  2.44    0.0    2537  0.00  0.00\n",
       "13        FG IPR  6.58    0.8   8.56    0.0  4.31    0.0    2584 -0.14  0.86\n",
       "14       FG OGGM  6.67    1.1  10.12    0.0  2.56    0.0    2545  0.06  0.94\n",
       "15  FG Farinotti  5.10    0.8   6.85    0.0  3.03    0.0    2580 -0.42  0.99"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M= ['Observed','FG IPR','FG OGGM','FG Farinotti']\n",
    "for m in M:\n",
    "    L= STATS[STATS.method==m].values\n",
    "    MEAN= np.nanmean(L[:,1:],axis=0)\n",
    "    MEAN= np.insert(MEAN,0,m)\n",
    "    STATS= STATS.append(dict(zip(STATS.columns, MEAN)),ignore_index=True)\n",
    "STATS=STATS.round(2);STATS.ABLse=STATS.ABLse.round(1);STATS.ACCse=STATS.ACCse.round(1);STATS.ALLse=STATS.ALLse.round(1)\n",
    "STATS.ELA_pw=STATS.ELA_pw.round(0);STATS.ELA_pw=pd.to_numeric(STATS.ELA_pw, downcast='integer')  #.round(0)#STATS.PBias=STATS.PBias.round(1)\n",
    "STATS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>method</th>\n",
       "      <th>ALL</th>\n",
       "      <th>ALLse</th>\n",
       "      <th>ABL</th>\n",
       "      <th>ABLse</th>\n",
       "      <th>ACC</th>\n",
       "      <th>ACCse</th>\n",
       "      <th>ELA_pw</th>\n",
       "      <th>ME</th>\n",
       "      <th>MAE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.24</td>\n",
       "      <td>0.6</td>\n",
       "      <td>9.59</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.43</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2520</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>7.45</td>\n",
       "      <td>0.9</td>\n",
       "      <td>8.82</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.94</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2587</td>\n",
       "      <td>0.05</td>\n",
       "      <td>0.91</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>7.60</td>\n",
       "      <td>1.2</td>\n",
       "      <td>10.62</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.17</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2541</td>\n",
       "      <td>0.18</td>\n",
       "      <td>1.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>FG Farinotti</td>\n",
       "      <td>5.94</td>\n",
       "      <td>0.9</td>\n",
       "      <td>7.11</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.62</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2575</td>\n",
       "      <td>-0.32</td>\n",
       "      <td>0.80</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.72</td>\n",
       "      <td>0.8</td>\n",
       "      <td>10.58</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2577</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>5.86</td>\n",
       "      <td>0.8</td>\n",
       "      <td>7.88</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.00</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2683</td>\n",
       "      <td>-0.01</td>\n",
       "      <td>0.85</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>5.96</td>\n",
       "      <td>1.0</td>\n",
       "      <td>9.27</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.05</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2633</td>\n",
       "      <td>0.23</td>\n",
       "      <td>1.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>FG Farinotti</td>\n",
       "      <td>4.42</td>\n",
       "      <td>0.8</td>\n",
       "      <td>6.10</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.94</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2711</td>\n",
       "      <td>-0.24</td>\n",
       "      <td>1.05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.81</td>\n",
       "      <td>0.5</td>\n",
       "      <td>9.76</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.88</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2515</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>6.44</td>\n",
       "      <td>0.8</td>\n",
       "      <td>8.99</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.97</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2484</td>\n",
       "      <td>-0.46</td>\n",
       "      <td>0.83</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>6.46</td>\n",
       "      <td>1.0</td>\n",
       "      <td>10.48</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.46</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2461</td>\n",
       "      <td>-0.23</td>\n",
       "      <td>0.82</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>FG Farinotti</td>\n",
       "      <td>4.94</td>\n",
       "      <td>0.8</td>\n",
       "      <td>7.36</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.53</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2454</td>\n",
       "      <td>-0.69</td>\n",
       "      <td>1.11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.59</td>\n",
       "      <td>0.6</td>\n",
       "      <td>9.98</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.44</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2537</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>6.58</td>\n",
       "      <td>0.8</td>\n",
       "      <td>8.56</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.31</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2584</td>\n",
       "      <td>-0.14</td>\n",
       "      <td>0.86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>6.67</td>\n",
       "      <td>1.1</td>\n",
       "      <td>10.12</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.56</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2545</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>FG Farinotti</td>\n",
       "      <td>5.10</td>\n",
       "      <td>0.8</td>\n",
       "      <td>6.85</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.03</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2580</td>\n",
       "      <td>-0.42</td>\n",
       "      <td>0.99</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>Observed</td>\n",
       "      <td>6.59</td>\n",
       "      <td>0.6</td>\n",
       "      <td>9.98</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.44</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2537</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>FG IPR</td>\n",
       "      <td>6.58</td>\n",
       "      <td>0.8</td>\n",
       "      <td>8.56</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.31</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2584</td>\n",
       "      <td>-0.14</td>\n",
       "      <td>0.86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>FG OGGM</td>\n",
       "      <td>6.67</td>\n",
       "      <td>1.1</td>\n",
       "      <td>10.12</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.56</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2545</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>FG Farinotti</td>\n",
       "      <td>5.10</td>\n",
       "      <td>0.8</td>\n",
       "      <td>6.86</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.03</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2580</td>\n",
       "      <td>-0.42</td>\n",
       "      <td>0.99</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          method   ALL  ALLse    ABL  ABLse   ACC  ACCse  ELA_pw    ME   MAE\n",
       "0       Observed  6.24    0.6   9.59    0.0  2.43    0.0    2520  0.00  0.00\n",
       "1         FG IPR  7.45    0.9   8.82    0.0  5.94    0.0    2587  0.05  0.91\n",
       "2        FG OGGM  7.60    1.2  10.62    0.0  4.17    0.0    2541  0.18  1.01\n",
       "3   FG Farinotti  5.94    0.9   7.11    0.0  4.62    0.0    2575 -0.32  0.80\n",
       "4       Observed  6.72    0.8  10.58    0.0  1.00    0.0    2577  0.00  0.00\n",
       "5         FG IPR  5.86    0.8   7.88    0.0  3.00    0.0    2683 -0.01  0.85\n",
       "6        FG OGGM  5.96    1.0   9.27    0.0  1.05    0.0    2633  0.23  1.01\n",
       "7   FG Farinotti  4.42    0.8   6.10    0.0  1.94    0.0    2711 -0.24  1.05\n",
       "8       Observed  6.81    0.5   9.76    0.0  3.88    0.0    2515  0.00  0.00\n",
       "9         FG IPR  6.44    0.8   8.99    0.0  3.97    0.0    2484 -0.46  0.83\n",
       "10       FG OGGM  6.46    1.0  10.48    0.0  2.46    0.0    2461 -0.23  0.82\n",
       "11  FG Farinotti  4.94    0.8   7.36    0.0  2.53    0.0    2454 -0.69  1.11\n",
       "12      Observed  6.59    0.6   9.98    0.0  2.44    0.0    2537  0.00  0.00\n",
       "13        FG IPR  6.58    0.8   8.56    0.0  4.31    0.0    2584 -0.14  0.86\n",
       "14       FG OGGM  6.67    1.1  10.12    0.0  2.56    0.0    2545  0.06  0.94\n",
       "15  FG Farinotti  5.10    0.8   6.85    0.0  3.03    0.0    2580 -0.42  0.99\n",
       "16      Observed  6.59    0.6   9.98    0.0  2.44    0.0    2537  0.00  0.00\n",
       "17        FG IPR  6.58    0.8   8.56    0.0  4.31    0.0    2584 -0.14  0.86\n",
       "18       FG OGGM  6.67    1.1  10.12    0.0  2.56    0.0    2545  0.06  0.94\n",
       "19  FG Farinotti  5.10    0.8   6.86    0.0  3.03    0.0    2580 -0.42  0.99"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M= ['Observed','FG IPR','FG OGGM','FG Farinotti']\n",
    "for m in M:\n",
    "    L= STATS[STATS.method==m].values\n",
    "    MEAN= np.nanmean(L[:,1:],axis=0)\n",
    "    MEAN= np.insert(MEAN,0,m)\n",
    "    STATS= STATS.append(dict(zip(STATS.columns, MEAN)),ignore_index=True)\n",
    "STATS=STATS.round(2);STATS.ABLse=STATS.ABLse.round(1);STATS.ACCse=STATS.ACCse.round(1);STATS.ALLse=STATS.ALLse.round(1)\n",
    "STATS.ELA_pw=STATS.ELA_pw.round(0);STATS.ELA_pw=pd.to_numeric(STATS.ELA_pw, downcast='integer')  #.round(0)#STATS.PBias=STATS.PBias.round(1)\n",
    "STATS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.060000000000000005, -0.14)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "np.mean(STATS.ME[STATS.method=='FG OGGM']),np.mean(STATS.ME[STATS.method=='FG IPR']),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.4175, 0.9875)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "np.mean(STATS.ME[STATS.method=='FG Farinotti']),np.mean(STATS.MAE[STATS.method=='FG Farinotti']),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.262500000000001"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(np.abs(STATS.ALL_pdiff[(STATS.method!='FG Farinotti')&(STATS.method!='Observed')]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "31.05"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[];pdiff=[];pdACC=[];pdABL=[]\n",
    "for i in range(4):\n",
    "    o=STATS.ALL[i*4];k=STATS.ABL[i*4];j=STATS.ACC[i*4];\n",
    "    for n in range(4):\n",
    "        b=STATS.ALL[(i*4)+n];ab=STATS.ABL[(i*4)+n]; ac=STATS.ACC[(i*4)+n];\n",
    "        d = ((o-b)/b)*100;dd = ((k-ab)/ab)*100;ddd = ((j-ac)/ac)*100;\n",
    "        pdiff.append(d.round(1));pdACC.append(dd.round(1));pdABL.append(ddd.round(1))\n",
    "\n",
    "STATS['ALL_pdiff']=pdiff;\n",
    "STATS.ALL_pdiff[STATS.method=='Observed']=np.nan;\n",
    "STATS\n",
    "\n",
    "np.nanmean(STATS.ALL_pdiff[:3]);\n",
    "\n",
    "np.mean(STATS.ALL_pdiff[-3:]),np.nanmean(pdABL[-3:]),np.nanmean(pdACC[-3:])\n",
    "np.mean(STATS.ALL_pdiff[STATS.method=='FG Farinotti'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# M= ['Observed','FG IPR','FG OGGM','FG Farinotti']\n",
    "# for m in M:\n",
    "#     L= STATS[STATS.method==m].values\n",
    "#     MEAN= np.nanmean(L[:,1:],axis=0)\n",
    "#     MEAN= np.insert(MEAN,0,m)\n",
    "#     STATS= STATS.append(dict(zip(STATS.columns, MEAN)),ignore_index=True)\n",
    "# STATS=STATS.round(2)\n",
    "# STATS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Could add PBias, MSE(ACC and ABL), RMSE (redunbdant with RSR), MAE, ME"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S1=STATS.copy()\n",
    "AB=[];AC=[];AL=[]\n",
    "for i in range(len(S1)):\n",
    "    AL.append(str(S1.ALL[i])+' $\\pm$ '+str(S1.ALLse[i]))\n",
    "    AB.append(str(S1.ABL[i])+' $\\pm$ '+str(S1.ABLse[i]))\n",
    "    AC.append((str(S1.ACC[i])+' $\\pm$ '+str(S1.ACCse[i])))\n",
    "S1.ABL=AB;S1.ACC=AC;S1.ALL=AL\n",
    "S1.drop(columns=['ABLse','ACCse','ALLse'], inplace=True)\n",
    "S1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(S1.to_latex(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "STATS[:-8].ABL.mean(),STATS.ACC[:-8].mean(),STATS.ALL[:-8].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "STATS[:-8].ABLse.mean(),STATS.ACCse[:-8].mean(),STATS.ALLse[:-8].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LNFS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "firn,fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(STATS.to_latex(index=False))  z\n",
    "# 'conrad_stats_ITS_LIVE_NOfirn.pkl' ##conrad_stats_ITS_LIVE.pkl') ##_NOfirn\n",
    "STATS.to_pickle(fl_path+)#'conrad_firn_LIN_stats.pkl') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LIN_firn_STATS=STATS\n",
    "LIN_NOfirn_STATS=STATS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open(fl_path+'conrad_NOfirn_PW_stats.pkl', 'rb') as f:\n",
    "#     PW_NOfirn_STATS = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PW_firn_stats=STATS\n",
    "PW_NOfirn_STATS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LFS=LIN_firn_STATS.tail(4)\n",
    "LNFS=LIN_NOfirn_STATS.tail(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LNFS.ALL[1:].mean(),LNFS.ALL_firn[1:].mean(),LNFS.ALL[12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LNFS['ALL_firn']=LFS.ALL\n",
    "LNFS['pdiff_obs']=(LNFS.ALL-LNFS.ALL_firn)/LNFS.ALL\n",
    "LNFS.pdiff_obs[1:].mean(),LNFS.pdiff_obs[1:].std(),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "LNFS['ALL_firn']=LFS.ALL\n",
    "LNFS['pdiff_obs']=(LNFS.ALL_firn-LNFS.ALL[12])/LNFS.ALL[12]\n",
    "LNFS.pdiff_obs[1:].mean(),LNFS.pdiff_obs[1:].std(),\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "LNFS['ALL_firn']=LFS.ALL\n",
    "LNFS['pdiff_obs']=(LNFS.ALL-LNFS.ALL[12])/LNFS.ALL[12]\n",
    "LNFS.pdiff_obs[1:].mean(),LNFS.pdiff_obs[1:].std(),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "STATS['pdiff_obs']=(STATS.ALL-STATS.ALL[12])/STATS.ALL[12]\n",
    "STATS.pdiff_obs[1:].mean(),STATS.pdiff_obs[1:].std(),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluator(pbias)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ITS_LIVE_dbdz_PBIAS=[28.47772615,23.91363761,31.07406395,20.38834951,21.9,22.48]\n",
    "print(np.nanmean(ITS_LIVE_dbdz_PBIAS),np.nanstd(ITS_LIVE_dbdz_PBIAS))\n",
    "dbdz_PBIAS=[-7.8,-18.2,-9.9,-16.9,-23,-6.6]\n",
    "print(np.nanmean(dbdz_PBIAS),np.nanstd(dbdz_PBIAS))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Calc PBIAS for slopes    \n",
    "for i in range(3):\n",
    "    D=STATS.ALL[STATS.method==(method[i+1])][:-1].values\n",
    "    O=STATS.ALL[STATS.method=='Observed'][:-1].values\n",
    "    e=evaluator(pbias, D,O)   #def pbias(simulations, evaluation):\n",
    "    print(method[i+1],e )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "STATS['AABR']= STATS.ABL/STATS.ACC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rng_ab=[];rng_ac=[]\n",
    "for m in M:\n",
    "    mn= STATS.ABL[STATS.method==m].min(); mx=STATS.ABL[STATS.method==m].max()\n",
    "    mnc= STATS.ACC[STATS.method==m].min(); mxc=STATS.ACC[STATS.method==m].max()\n",
    "    rng_ab.append(mn/mx);rng_ac.append(mnc/mxc);\n",
    "rng_ab, rng_ac"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(STATS.ABLse), np.mean(STATS.ACCse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1-5.11/6.58)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "STATS_LIN=STATS[['method','ALL','ALLse','PBias','ME','MAE']]\n",
    "SL1=STATS_LIN.tail(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AB=[];AC=[];AL=[]\n",
    "for i in SL1.index:\n",
    "    AL.append(str(SL1.ALL[i])+' $\\pm$ '+str(SL1.ALLse[i]))\n",
    "SL1.ABL=AB;SL1.ACC=AC;SL1.ALL=AL\n",
    "SL1.drop(columns=['ALLse'], inplace=True)\n",
    "SL1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(SL1.to_latex(index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# All glacier's stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Glacier = ['Kokanee', 'Conrad', 'Illecillewaet']\n",
    "glacier = ['kokanee', 'conrad', 'illecillewaet']\n",
    "FLP='/home/pelto/Desktop/ice_flux/' \n",
    "K_stats=pd.read_pickle(FLP+ Glacier[0]+ '/' + glacier[0]+ '_LIN_NOfirn_stats.pkl') #NO_firn\n",
    "C_stats=pd.read_pickle(FLP+Glacier[1]+ '/' + glacier[1]+ '_NOfirn_LIN_stats.pkl')#'_stats_ITS_LIVE_NOfirn.pkl')#'_firn_LIN_stats.pkl')\n",
    "I_stats=pd.read_pickle(FLP+Glacier[2]+ '/' + glacier[2]+ '_LIN_NOfirn_stats.pkl')#'_stats_ITS_LIVE_NOfirn.pkl') #'_LIN_firn_stats.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I_stats['glacier']=glacier[2];C_stats['glacier']=glacier[1];K_stats['glacier']=glacier[0]\n",
    "ALL_stats=C_stats.append(I_stats);#ALL_stats=ALL_stats.append(K_stats)\n",
    "ALL_stats.ME[ALL_stats.method=='Observed']=np.nan;ALL_stats.PBias[ALL_stats.method=='Observed']=np.nan\n",
    "ALL_stats.MAE[ALL_stats.method=='Observed']=np.nan;\n",
    "ALL_stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ALL_stats['ALL_pdiff']=ALL_stats.ALL[ALL_stats.method=='Observed']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.nanmean(pd.to_numeric(ALL_stats.PBias[ALL_stats.method!='Observed'].values)),np.nanstd(pd.to_numeric(ALL_stats.PBias[ALL_stats.method!='Observed'].values)))\n",
    "print(np.nanmean(pd.to_numeric(ALL_stats.ME[ALL_stats.method!='Observed'].values)),np.nanstd(pd.to_numeric(ALL_stats.ME[ALL_stats.method!='Observed'].values)))\n",
    "print(np.nanmean(pd.to_numeric(ALL_stats.MAE[ALL_stats.method!='Observed'].values)),np.nanstd(pd.to_numeric(ALL_stats.MAE[ALL_stats.method!='Observed'].values)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ALL_stats.drop(columns=['method'], inplace=True)\n",
    "M= ['Observed','FG IPR','FG OGGM','FG Farinotti']\n",
    "for m in M:\n",
    "    L= ALL_stats[ALL_stats.method==m].values\n",
    "    if m == 'Observed':\n",
    "        MEAN= np.nanmean(L[:,1:-3],axis=0) # MEAN= np.nanmean(L[:,1:],axis=0)np.nanmean(L[:,:-4],axis=0)\n",
    "        MEAN=np.append(MEAN,[1.0,1.0,1.0],axis=0)\n",
    "        #MEAN=MEAN.tolist()\n",
    "        #MEAN=np.array(MEAN.extend([1,1,1]))\n",
    "        \n",
    "    else:\n",
    "        MEAN= np.nanmean(L[:,1:],axis=0)  #L[:,:-1]\n",
    "    MEAN= np.insert(m,0,MEAN)\n",
    "    ALL_stats= ALL_stats.append(dict(zip(ALL_stats.columns, MEAN)),ignore_index=True)\n",
    "ALL_stats=ALL_stats.round(2)\n",
    "ALL_stats.tail(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ALL_stats.PBias[ALL.STATS.method]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### mean of all stats, instead currently report mean of means for STATS\n",
    "s1=ALL_stats.tail(4)\n",
    "# s1.drop(columns=['ABL','ABLse','ACC','ACCse','ALL','ALLse'],inplace=True)\n",
    "# Mean_stats_ALL.insert(0,'method',M[1:])\n",
    "cols=s1.columns.tolist()\n",
    "# cols=[cols[5],cols[4],cols[3],cols[2],cols[1],cols[0]]\n",
    "Cols=[cols[9],cols[0],cols[1],cols[6],cols[7],cols[8]] #[cols[9],cols[4],cols[5],cols[8],cols[7],cols[6]]\n",
    "for col in Cols[1:]:\n",
    "    s1[col] = pd.to_numeric(s1[col])\n",
    "m = s1[Cols]; \n",
    "m=m.round({'ALL': 2, 'ALLse': 2, 'PBias': 1,'ME': 2, 'MAE': 2,}) #'ABL': 2,'ABLse': 2,'ACC': 2,'ACCse': 2,\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AB=[];AC=[];AL=[]\n",
    "for i in m.index:\n",
    "    AL.append(str(m.ALL[i])+' $\\pm$ '+str(m.ALLse[i]))\n",
    "m.ABL=AB;m.ACC=AC;m.ALL=AL\n",
    "m.drop(columns=['ALLse'], inplace=True)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(m.to_latex(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=ALL_stats[:-4]\n",
    "B=pd.to_numeric(A.PBias);\n",
    "np.mean(B),np.std(B),\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(NF.ALL.values[:-4])\n",
    "len(ALL_stats.ALL.values[:-4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NF.ALL.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NF['lindiffp']=(NF.ALL[:-4]-ALL_stats.ALL[:-4])/ALL_stats.ALL[:-4]\n",
    "np.mean(NF.lindiffp), np.std(NF.lindiffp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.nanmean(pd.to_numeric(ALL_stats.PBias[ALL_stats.method!='Observed'].values)),np.nanstd(pd.to_numeric(ALL_stats.PBias[ALL_stats.method!='Observed'].values)))\n",
    "print(np.nanmean(pd.to_numeric(ALL_stats.ME[ALL_stats.method!='Observed'].values)),np.nanstd(pd.to_numeric(ALL_stats.ME[ALL_stats.method!='Observed'].values)))\n",
    "print(np.nanmean(pd.to_numeric(ALL_stats.MAE[ALL_stats.method!='Observed'].values)),np.nanstd(pd.to_numeric(ALL_stats.MAE[ALL_stats.method!='Observed'].values)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.nanmean(pd.to_numeric(ALL_stats.PBias[ALL_stats.method!='Observed'].values)),np.nanstd(pd.to_numeric(ALL_stats.PBias[ALL_stats.method!='Observed'].values)))\n",
    "print(np.nanmean(pd.to_numeric(ALL_stats.ME[ALL_stats.method!='Observed'].values)),np.nanstd(pd.to_numeric(ALL_stats.ME[ALL_stats.method!='Observed'].values)))\n",
    "print(np.nanmean(pd.to_numeric(ALL_stats.MAE[ALL_stats.method!='Observed'].values)),np.nanstd(pd.to_numeric(ALL_stats.MAE[ALL_stats.method!='Observed'].values)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new.Vfirn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sum(new.Vfirn[6:]*new.dem_count[6:])/np.sum(new.dem_count[6:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m[1:] ## nofirn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean([.07142857142857151,0.07711138310893506,0.08387942332896459])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1-(8.32/8.96))\n",
    "print(1-(7.54/8.17))\n",
    "print(1-(6.99/7.63))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('pbias', np.round(m[1:].PBias.mean(),2), round(np.nanstd(pd.to_numeric(m[1:].PBias)),2)) \n",
    "\n",
    "print('ME', round(m[1:].ME.mean(),2), round(np.nanstd(pd.to_numeric(m[1:].ME)),2)) \n",
    "\n",
    "print('MAE',round(m[1:].MAE.mean(),2), round(np.nanstd(pd.to_numeric(m[1:].MAE)),2)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Glacier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #########  ALL YEARS ALL GLACIERS  PW ####\n",
    "# Glacier = ['Conrad',  'Illecillewaet','Kokanee',]\n",
    "# with open('/home/pelto/Desktop/ice_flux/' + Glacier[1] +'/ALL_list.pkl', 'rb') as f:\n",
    "#     illec_all = pickle.load(f)\n",
    "# with open('/home/pelto/Desktop/ice_flux/' + Glacier[2] +'/ALL_list.pkl', 'rb') as f:\n",
    "#     kok_all = pickle.load(f)\n",
    "\n",
    "# font = {'family' : 'Helvetica', 'weight' : 'normal',  'size'   : 8}\n",
    "# plt.rc('font', **font)\n",
    "# SEa=[];SLa=[]\n",
    "# obs = pd.read_csv(fl_path+ 'Conrad_bdot.csv') \n",
    "# obs.dropna(subset=['Ba'],inplace=True)\n",
    "# # obs=obs[obs.Year==2016 and obs.Year==2017 and obs.Year==2018]\n",
    "\n",
    "# ############## piecewise function ########################################         \n",
    "# fig3, ax3 = plt.subplots(1,3, sharex=False, sharey=True, figsize=(cm2inch(18, 8.5)))#   figsize=(8,8))#(3.5,3.5)) \n",
    "\n",
    "# # y_bin=[obs_all,gpr_ALL,opt_all,farin_all]; x_bin=[z_range_all,zr_gpr,z_range_all,z_range_all]\n",
    "  \n",
    "# label=['Observed', 'FG IPR', 'FG OGGM', 'FG Farinotti']\n",
    "# for r in range(3):\n",
    "#     for i in range(4):      \n",
    "#         if r==0:\n",
    "#             y_bin=[obs.Ba,gpr_all,opt_all,farin_all]; x_bin=[obs.Elev,elev_gpr_all,elev_all,elev_all];\n",
    "#             x0=2525; breakpoints = [1850.,x0,3300.];xd = np.arange(1950., 3150., 10.);x_hat = np.linspace(1900, 3270, 10)\n",
    "#         elif r==1:\n",
    "#             x_bin=[illec_all[i+4],illec_all[i+4],illec_all[i+4],illec_all[i+4]];\n",
    "#             y_bin=[illec_all[i],illec_all[i],illec_all[i],illec_all[i]];\n",
    "#             x0=2500;  xd = np.linspace(2040, 2660, 10)\n",
    "#             breakpoints = [2040.,x0,2680.];x_hat = np.arange(2040.,2660.,10.)\n",
    "#         else:\n",
    "#             x_bin=[kok_all[i+4],kok_all[i+4],kok_all[i+4],kok_all[i+4]];\n",
    "#             y_bin=[kok_all[i],kok_all[i],kok_all[i],kok_all[i]];xd = np.arange(2280., 2800., 10.)\n",
    "#             x0=2560; breakpoints = [2200.,x0,2900.]; x_hat= np.arange(2280., 2800., 10.)\n",
    "                        \n",
    "#         def piecewise_linear(x, x0, y0, k1, k2):\n",
    "#             return np.piecewise(x, [x < x0], [lambda x:k1*x + y0-k1*x0, lambda x:k2*x + y0-k2*x0]) \n",
    "        \n",
    "#         Y=np.array(y_bin[i]);X=np.array(x_bin[i])\n",
    "#         model = pwlf.PiecewiseLinFit(X, Y)\n",
    "#         model.fit_with_breaks(breakpoints)\n",
    "#         y_hat = model.predict(x_hat)\n",
    "#         ax3[r].plot(x_hat, y_hat, lw=1., alpha=1, color=color[i],zorder=1)\n",
    "#         SLa.append(model.slopes); SEa.append(model.standard_errors())\n",
    "\n",
    "#         x1=np.array(x_bin[i]); y1=np.array(y_bin[i])\n",
    "#         p , e = curve_fit(piecewise_linear, x1, y1 )\n",
    "\n",
    "#         # mean square error of the lines\n",
    "#         MSE_results=[]\n",
    "#         for Line in range(2):\n",
    "#             Pred=[];Act=[]\n",
    "#             if Line ==0:\n",
    "#                 INDEX= np.where(x1<x0)[0]\n",
    "#                 for ix in INDEX:\n",
    "#                     Pred.append( p[2]*x1[ix]+(p[1]-p[2]*x0))\n",
    "#                     Act.append(y1[ix])\n",
    "\n",
    "#                 MSE_results.append(MSE(Act,Pred))\n",
    "#             if Line==1:\n",
    "#                 INDEX= np.where(x1>=x0)[0]\n",
    "#                 for ix in INDEX:\n",
    "#                     Pred.append( p[3]*x1[ix]+(p[1]-p[3]*x0))\n",
    "#                     Act.append(y1[ix])\n",
    "\n",
    "#                 MSE_results.append(MSE(Act,Pred))\n",
    "#         ax3[r].scatter(x_bin[i], y_bin[i], color=color[i], s=10, marker=sym[i], facecolors='none', lw=0.5, label=label[i],\n",
    "#                    zorder=2,alpha=0.7)\n",
    "#     ax3[2].xaxis.set_major_locator(ticker.MultipleLocator(200))\n",
    "#     ax3[r].text(0.92, 0.03, letter[r], transform=ax3[r].transAxes)\n",
    "#     ax3[0].legend(loc='bottom right', bbox_to_anchor=(0.5, 0.3), labelspacing=0.2, handletextpad=0.1)\n",
    "#     ax3[r].axhline(linewidth=1, color='k', ls='--', alpha=0.25, zorder=0)\n",
    "#     ax3[r].text(0.05, 0.95, Glacier[r], transform=ax3[r].transAxes)\n",
    "#     ax3[0].set(ylim=(-8.,3.),ylabel='Mass balance (m w.e.)')\n",
    "#     ax3[1].set(xlabel='Elevation (m a.s.l.)')\n",
    "# fig3.subplots_adjust(bottom=0.10, top=0.98, hspace=0.1, left=0.06, right=0.985, wspace=0.05)\n",
    "# fig3.savefig(fl_path + 'products/' + 'All_glaciers_all_years_combined_LIN.pdf', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('/home/pelto/Desktop/ice_flux/' + Glacier[1] +'/ALL_list.pkl', 'rb') as f:\n",
    "    illec_all = pickle.load(f)\n",
    "with open('/home/pelto/Desktop/ice_flux/' + Glacier[2] +'/ALL_list.pkl', 'rb') as f:\n",
    "    kok_all = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########  ALL YEARS ALL GLACIERS LIN ####\n",
    "Glacier = ['Conrad',  'Illecillewaet','Kokanee',]\n",
    "with open('/home/pelto/Desktop/ice_flux/' + Glacier[1] +'/ALL_list.pkl', 'rb') as f:\n",
    "    illec_all = pickle.load(f)\n",
    "with open('/home/pelto/Desktop/ice_flux/' + Glacier[2] +'/ALL_list.pkl', 'rb') as f:\n",
    "    kok_all = pickle.load(f)\n",
    "\n",
    "font = {'family' : 'Helvetica', 'weight' : 'normal',  'size'   : 8}\n",
    "plt.rc('font', **font)\n",
    "SEa=[];SLa=[]\n",
    "obs = pd.read_csv(fl_path+ 'Conrad_bdot.csv') \n",
    "obs.dropna(subset=['Ba'],inplace=True)\n",
    "# obs=obs[obs.Year==2016 and obs.Year==2017 and obs.Year==2018]\n",
    "\n",
    "############## linear function ########################################         \n",
    "fig3, ax3 = plt.subplots(1,3, sharex=False, sharey=True, figsize=(cm2inch(18, 8.5)))#   figsize=(8,8))#(3.5,3.5)) \n",
    "\n",
    "# y_bin=[obs_all,gpr_ALL,opt_all,farin_all]; x_bin=[z_range_all,zr_gpr,z_range_all,z_range_all]\n",
    "  \n",
    "label=['Observed', 'FG IPR', 'FG OGGM', 'FG Farinotti']\n",
    "for r in range(3):\n",
    "    for i in range(4):      \n",
    "        if r==0:\n",
    "            y_bin=[obs.Ba[(obs.Year>2015) & (obs.Year < 2019)],gpr_all,opt_all,farin_all]; x_bin=[obs.Elev[(obs.Year>2015) & (obs.Year < 2019)],elev_gpr_all,elev_all,elev_all];\n",
    "            x0=2525; breakpoints = [1850.,3300.];xd = np.arange(1950., 3150., 10.);x_hat = np.linspace(1900, 3180, 10)\n",
    "        elif r==1:\n",
    "            x_bin=[illec_all[i+4],illec_all[i+4],illec_all[i+4],illec_all[i+4]];\n",
    "            y_bin=[illec_all[i],illec_all[i],illec_all[i],illec_all[i]];\n",
    "            x0=2500;  xd = np.linspace(2040, 2660, 10)\n",
    "            breakpoints = [2040.,2680.];x_hat = np.arange(2040.,2660.,10.)\n",
    "        else:\n",
    "            x_bin=[kok_all[i+4],kok_all[i+4],kok_all[i+4],kok_all[i+4]];\n",
    "            y_bin=[kok_all[i],kok_all[i],kok_all[i],kok_all[i]];xd = np.arange(2280., 2800., 10.)\n",
    "            x0=2560; breakpoints = [2200.,2900.]; x_hat= np.arange(2280., 2800., 10.)\n",
    "                        \n",
    "        def piecewise_linear(x, x0, y0, k1, k2):\n",
    "            return np.piecewise(x, [x < x0], [lambda x:k1*x + y0-k1*x0, lambda x:k2*x + y0-k2*x0]) \n",
    "        \n",
    "        Y=np.array(y_bin[i]);X=np.array(x_bin[i])\n",
    "        model = pwlf.PiecewiseLinFit(X, Y)\n",
    "        model.fit_with_breaks(breakpoints)\n",
    "        y_hat = model.predict(x_hat)\n",
    "        ax3[r].plot(x_hat, y_hat, lw=1., alpha=1, color=color[i],zorder=1)\n",
    "        SLa.append(model.slopes); SEa.append(model.standard_errors())\n",
    "\n",
    "        x1=np.array(x_bin[i]); y1=np.array(y_bin[i])\n",
    "        p , e = curve_fit(piecewise_linear, x1, y1 )\n",
    "\n",
    "        # mean square error of the lines\n",
    "        MSE_results=[]\n",
    "        for Line in range(2):\n",
    "            Pred=[];Act=[]\n",
    "            if Line ==0:\n",
    "                INDEX= np.where(x1<x0)[0]\n",
    "                for ix in INDEX:\n",
    "                    Pred.append( p[2]*x1[ix]+(p[1]-p[2]*x0))\n",
    "                    Act.append(y1[ix])\n",
    "\n",
    "                MSE_results.append(MSE(Act,Pred))\n",
    "            if Line==1:\n",
    "                INDEX= np.where(x1>=x0)[0]\n",
    "                for ix in INDEX:\n",
    "                    Pred.append( p[3]*x1[ix]+(p[1]-p[3]*x0))\n",
    "                    Act.append(y1[ix])\n",
    "\n",
    "                MSE_results.append(MSE(Act,Pred))\n",
    "        ax3[r].scatter(x_bin[i], y_bin[i], color=color[i], s=10, marker=sym[i], facecolors='none', lw=0.5, label=label[i],\n",
    "                   zorder=2,alpha=0.7)\n",
    "    ax3[0].xaxis.set_major_locator(ticker.MultipleLocator(400));ax3[1].xaxis.set_major_locator(ticker.MultipleLocator(200));ax3[2].xaxis.set_major_locator(ticker.MultipleLocator(200))\n",
    "    ax3[r].text(0.92, 0.03, letter[r], transform=ax3[r].transAxes)\n",
    "    ax3[2].legend(loc='bottom right', bbox_to_anchor=(0.98, 0.34), labelspacing=0.2, handletextpad=0.1)\n",
    "    ax3[r].axhline(linewidth=1, color='k', ls='--', alpha=0.25, zorder=0)\n",
    "    ax3[r].text(0.05, 0.95, Glacier[r], transform=ax3[r].transAxes)\n",
    "    ax3[0].set(ylim=(-7.5,3.5),ylabel='Mass balance (m w.e.)')\n",
    "    ax3[1].set(xlabel='Elevation (m a.s.l.)')\n",
    "fig3.subplots_adjust(bottom=0.15, top=0.98, hspace=0.1, left=0.06, right=0.985, wspace=0.05)\n",
    "fig3.savefig(fl_path + 'products/' + 'All_glaciers_all_years_combined_LIN.pdf', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.nanmean(vz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "########  ALL YEARS CONRAD ONLY  ####\n",
    "\n",
    "font = {'family' : 'Helvetica', 'weight' : 'normal',  'size'   : 8}\n",
    "plt.rc('font', **font)\n",
    "\n",
    "obs = pd.read_csv(fl_path+ 'Conrad_bdot.csv') \n",
    "obs.dropna(subset=['Ba'],inplace=True)\n",
    "# obs=obs[obs.Year==2016 and obs.Year==2017 and obs.Year==2018]\n",
    "\n",
    "############## piecewise function ########################################         \n",
    "fig3, ax3 = plt.subplots(1, sharex=True, sharey=True, figsize=(cm2inch(8.5, 8.5)))#   figsize=(8,8))#(3.5,3.5)) \n",
    "\n",
    "# y_bin=[obs_all,gpr_ALL,opt_all,farin_all]; x_bin=[z_range_all,zr_gpr,z_range_all,z_range_all]\n",
    "def piecewise_linear(x, x0, y0, k1, k2):\n",
    "    x0=2525.\n",
    "    return np.piecewise(x, [x < x0], [lambda x:k1*x + y0-k1*x0, lambda x:k2*x + y0-k2*x0])   \n",
    "label=['Observed', 'FG IPR', 'FG OGGM', 'FG Farinotti'];SEa=[];SLa=[]\n",
    "y_bin=[obs.Ba,gpr_all,opt_all,farin_all]; x_bin=[obs.Elev,elev_gpr_all,elev_all,elev_all]\n",
    "\n",
    "for i in range(4):      \n",
    "\n",
    "\n",
    "\n",
    "    ##pwlf\n",
    "    Y=np.array(y_bin[i])\n",
    "    X=np.array(x_bin[i])\n",
    "    model = pwlf.PiecewiseLinFit(X, Y)\n",
    "    breakpoints = [1850.,x0,3300.]\n",
    "    model.fit_with_breaks(breakpoints)\n",
    "    x_hat = np.linspace(1900, 3270, 10)\n",
    "    y_hat = model.predict(x_hat)\n",
    "    plt.plot(x_hat, y_hat, lw=1., alpha=1, color=color[i],zorder=1)\n",
    "    SLa.append(model.slopes)\n",
    "    SEa.append(model.standard_errors())\n",
    "    x1=np.array(x_bin[i]); y1=np.array(y_bin[i])\n",
    "    p , e = curve_fit(piecewise_linear, x1, y1 )\n",
    "    xd = np.arange(1950., 3150., 10.)\n",
    "#     ax3.plot(xd, piecewise_linear(xd, *p), color=color[i], label=label[i], lw=1.0)\n",
    "    # mean square error of the lines\n",
    "    x0=2525.\n",
    "\n",
    "#     MSE_results=[]\n",
    "    for Line in range(2):\n",
    "        Pred=[];Act=[]\n",
    "        if Line ==0:\n",
    "            INDEX= np.where(x1<x0)[0]\n",
    "            for ix in INDEX:\n",
    "                Pred.append( p[2]*x1[ix]+(p[1]-p[2]*x0))\n",
    "                Act.append(y1[ix])\n",
    "\n",
    "#             MSE_results.append(MSE(Act,Pred))\n",
    "        if Line==1:\n",
    "            INDEX= np.where(x1>=x0)[0]\n",
    "            for ix in INDEX:\n",
    "                Pred.append( p[3]*x1[ix]+(p[1]-p[3]*x0))\n",
    "                Act.append(y1[ix])\n",
    "\n",
    "#             MSE_results.append(MSE(Act,Pred))\n",
    "    ax3.scatter(x_bin[i], y_bin[i], color=color[i], s=10, marker=sym[i], facecolors='none', lw=0.5, label=label[i],\n",
    "               zorder=2,alpha=0.7)\n",
    "#     meanlineprops = dict(linestyle='--', linewidth=1., color=color[i])\n",
    "#     medianprops = dict(linestyle='-', linewidth=1, color=color[i])\n",
    "#     if i == 1:\n",
    "#         BOX2=ax3.boxplot(y_bin[i],meanprops=meanlineprops,medianprops=medianprops,showmeans=True, meanline=True,sym='',\n",
    "#                     positions=[1950, 2050, 2150, 2250, 2350, 2450, 2550, 2650, 2750, 2850, 2950, 3050],widths=75)\n",
    "#     else:\n",
    "#         BOX2=ax3.boxplot(y_bin[i],meanprops=meanlineprops,medianprops=medianprops,showmeans=True, meanline=True,sym='',\n",
    "#                     positions=[1950, 2050, 2150, 2250, 2350, 2450, 2550, 2650, 2750, 2850, 2950, 3050,3150,3250],widths=75)\n",
    "\n",
    "#     ax3.text(0.2, ytxt[i], txt[i]+ ' L1: '+ str(np.round(p[2]*1000,2)) +' L2: ' + \n",
    "#                     str(np.round(p[3]*1000,2)) + ' AABR: ' + str(np.round(p[2]/p[3],2)),\n",
    "#                      transform=ax3.transAxes)  \n",
    "#     ax3.text(0.55, ytxt[i], txt[i] + ' L1: '+ str(round(SL[0]*1000,2))+u\" \\u00B1 \"+ str(round(SE[1]*1000*1.96,2)) +' L2: ' + \n",
    "#                    str(round(SL[1]*1000,2))+u\" \\u00B1 \"+ str(round(SE[2]*1000*1.96,2)) ,transform=ax3.transAxes) #+ ' AABR: ' + str(np.round(p[2]/p[3],2)),\n",
    "\n",
    "ax3.legend(loc='best')\n",
    "ax3.axhline(linewidth=1, color='k', ls='--', alpha=0.25, zorder=0)\n",
    "ax3.set(ylim=(-8.,3.1),xlim=(1870,3300),ylabel='Mass balance (m w.e.)',xlabel='Elevation (m a.s.l.)')\n",
    "#         print(MSE_results)\n",
    "fig3.savefig(fl_path + 'products/' + glacier[gl]+'_' + balance +'_all_years_combined.pdf', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Yvv_lbl=['$V^{\\uparrow}_{IPR}$','$V^{\\uparrow}_{OGGM}$','$V^{\\uparrow}_{Farin}$']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sVSTAKE=1.10; sVOFFice=1.8; sVRAND=3.0\n",
    "sVsys=np.sqrt((sVSTAKE**2)+(sVOFFice**2))\n",
    "sVZ=np.sqrt((sVsys**2)+(sVRAND**2))\n",
    "sVZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig4, ax4 = plt.subplots(1, sharex=True, sharey=True, figsize=(8,8))#(3.5,3.5)) \n",
    "import seaborn as sns\n",
    "scat_fmt={'marker':'^','linewidths':1,'edgecolor':'k'}\n",
    "\n",
    "\n",
    "sns.regplot( x=\"dem_mean\", y=\"b_fg_we\", data=new16, fit_reg=False, marker='o',scatter_kws=scat_fmt)\n",
    "\n",
    "sns.regplot(x=\"dem_mean\", y=\"dh_mean\", data=new16, fit_reg=False, marker='_',scatter_kws=scat_fmt)\n",
    "sns.regplot(x=\"dem_mean\", y=\"BMC\", data=new16, label=r'$V^{\\uparrow}_{IPR}$',fit_reg=False, marker='x',scatter_kws=scat_fmt)\n",
    "\n",
    "sns.regplot( x=\"dem_mean\", y=\"Q_netA\", data=new16, fit_reg=False, marker='^',scatter_kws=scat_fmt)\n",
    "sns.regplot( x=\"dem_mean\", y=\"Q_netAF\", data=new16, fit_reg=False, marker='^',scatter_kws=scat_fmt)\n",
    "sns.regplot( x=\"dem_mean\", y=\"Q_netA_gpr\", data=new16, fit_reg=False,marker='^',scatter_kws=scat_fmt)\n",
    "sns.regplot( x=\"dem_mean\", y=\"Q_netA\", data=new17, fit_reg=False, marker='^',scatter_kws=scat_fmt)\n",
    "sns.regplot( x=\"dem_mean\", y=\"Q_netAF\", data=new17, fit_reg=False, marker='^',scatter_kws=scat_fmt)\n",
    "sns.regplot( x=\"dem_mean\", y=\"Q_netA_gpr\", data=new17, fit_reg=False,marker='^',scatter_kws=scat_fmt)\n",
    "sns.regplot( x=\"dem_mean\", y=\"Q_netA\", data=new, fit_reg=False, marker='^',scatter_kws=scat_fmt)\n",
    "sns.regplot( x=\"dem_mean\", y=\"Q_netAF\", data=new, fit_reg=False, marker='^',scatter_kws=scat_fmt)\n",
    "sns.regplot( x=\"dem_mean\", y=\"Q_netA_gpr\", data=new, fit_reg=False,marker='^',scatter_kws=scat_fmt)\n",
    "# plt.scatter(D.velocity, D.vz, s=30, edgecolor='#3182bd', facecolor='#a6bddb', linewidth=1.4, label=D.Year)#, zorder=3)\n",
    "plt.plot(np.arange(0, 55), np.arange(0, 55), 'k--', linewidth=0.75, zorder=1)\n",
    "plt.xlabel('Elevation m a.s.l.)')\n",
    "plt.ylabel('Height change (m ice $a^{-1}$)')\n",
    "plt.xlim(1800,3200);plt.ylim(-5,5)\n",
    "plt.axhline(linewidth=1, color='k', ls='--', alpha=a+.2, zorder=0)\n",
    "plt.legend(loc=2)\n",
    "plt.grid(linestyle=':', linewidth=0.4, color='gray', alpha=0.5, zorder=0)\n",
    "plt.tight_layout(pad=0.2)\n",
    "\n",
    "plt.savefig(fl_path+ 'products/Conrad_emergence_vel.png',dpi=300)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig4, ax4 = plt.subplots(1, sharex=True, sharey=True, figsize=(8,4))#(3.5,3.5)) \n",
    "# import seaborn as sns\n",
    "# scat_fmt={'marker':'^','linewidths':1,'edgecolor':'k'}\n",
    "\n",
    "# V=[new16.vel_fg[1:],new17.vel_fg[1:],new.vel_fg[1:]]\n",
    "# for i in range(3):\n",
    "#     ax4.plot(new.dem_mean[1:],V[i])\n",
    "# # plt.scatter(D.velocity, D.vz, s=30, edgecolor='#3182bd', facecolor='#a6bddb', linewidth=1.4, label=D.Year)#, zorder=3)\n",
    "# # plt.plot(np.arange(0, 55), np.arange(0, 55), 'k--', linewidth=0.75, zorder=1)\n",
    "# plt.xlabel('Elevation m a.s.l.)')\n",
    "# plt.ylabel('Height change (m ice $a^{-1}$)')\n",
    "# plt.xlim(1800,3200);#plt.ylim(-5,5)\n",
    "# # plt.axhline(linewidth=1, color='k', ls='--', alpha=a+.2, zorder=0)\n",
    "# plt.legend(loc=2)\n",
    "# plt.grid(linestyle=':', linewidth=0.4, color='gray', alpha=0.5, zorder=0)\n",
    "# plt.tight_layout(pad=0.2)\n",
    "\n",
    "# # plt.savefig(fl_path+ 'products/Conrad_emergence_vel.png',dpi=300)\n",
    "# plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(round(np.mean(NSE),2), np.std(NSE))\n",
    "print(np.mean(PBias), np.std(PBias))\n",
    "print(np.mean(RSR), np.mean(RSR))\n",
    "print(np.mean(OBF), np.mean(GPRq), np.mean(OPTq), np.mean(FARq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g=0,3,6\n",
    "o=1,4,7\n",
    "f=2,5,8\n",
    "GPR_dat=[]; OPT_dat=[];FAR_dat=[]\n",
    "for n in range(3):\n",
    "    GPR_dat.append([NSE[g[n]],PBias[g[n]],RSR[g[n]]])\n",
    "    OPT_dat.append([NSE[o[n]],PBias[o[n]],RSR[o[n]]])\n",
    "    FAR_dat.append([NSE[f[n]],PBias[f[n]],RSR[f[n]]])\n",
    "\n",
    "\n",
    "GPR_dat_mean=np.mean(GPR_dat,axis=0);GPR_dat_min=np.min(GPR_dat,axis=0);GPR_dat_max=np.max(GPR_dat,axis=0)\n",
    "\n",
    "OPT_dat_mean=np.mean(OPT_dat,axis=0);OPT_dat_min=np.min(OPT_dat,axis=0);OPT_dat_max=np.max(OPT_dat,axis=0)\n",
    "\n",
    "FAR_dat_mean=np.mean(FAR_dat,axis=0);FAR_dat_min=np.min(FAR_dat,axis=0);FAR_dat_max=np.max(FAR_dat,axis=0)\n",
    "    \n",
    "    #     NSE.mean\n",
    "# print(GPR_dat)\n",
    "# print(OPT_dat)\n",
    "# print(FAR_dat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(GPR_dat_min)\n",
    "# print(GPR_dat)\n",
    "\n",
    "print(OPT_dat_mean)\n",
    "# print(OPT_dat)\n",
    "\n",
    "print(FAR_dat_mean)\n",
    "# print(FAR_dat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "OBF =np.array(OBF)\n",
    "OPTq =np.array(OPTq)\n",
    "\n",
    "fig2, ax2 = plt.subplots(1, sharex=True, sharey=True, figsize=(5,5))\n",
    "slope, intercept, r_value, p_value, std_err = stats.linregress(OBF,OPTq)\n",
    "ax2.scatter(OBF, OPTq)\n",
    "\n",
    "ax2.plot(OBF,slope*OBF+intercept, color='k',label='', alpha=a, linewidth=0.8, zorder=3) # linestyle='--'\n",
    "\n",
    "ax2.set(xlabel=('observations'),ylabel=('model'))\n",
    "print('r_value:', r_value, 'p_value:', p_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use the evaluator with the Root Mean Square Error (objective function 3)\n",
    "# def evaluator(func, simulation_s, evaluation, axis=0, transform=None, epsilon=None):\n",
    "my_rmse = evaluator(rmse, OPTq, OBF)\n",
    "my_rmse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "FARq= np.array(FARq)\n",
    "GPRq=np.array(GPRq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GPRq[:-2],OBF[:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EST=[GPRq[:-2],OPTq,FARq] ## must be arrays not lists\n",
    "NSE=[]\n",
    "for e in range(3):\n",
    "    if e==0:\n",
    "        NSE.extend(evaluator(nse, EST[e], OBF[:-2]))\n",
    "    else:\n",
    "        NSE.extend(evaluator(nse, EST[e], OBF))\n",
    "NSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "OPT, z_range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bin_df = pd.DataFrame(list(zip(z_range, OB_F, GPR, OPT, FAR)), columns=['Elev', 'OBS', 'GPR', 'OGGM', 'FARIN']) \n",
    "bin_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bin_df.to_csv(fl_path+'bin_df_2016.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D.to_csv(fl_path+'D_2018.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new.to_csv(fl_path+'new_2018.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# COMP = pd.DataFrame(list(zip(z_range, OBF, GPRq, OPTq, FARq)), columns=['Elev','OBF', 'GPRq', 'OPTq', 'FARq']) \n",
    "COMP = pd.DataFrame(list(zip(z_range_all, obs_all, gpr_all, opt_all, farin_all)), columns=['Elev','OBS', 'GPR', 'OGGM', 'FARIN']) \n",
    "COMP.to_csv(fl_path + 'conrad_balance.csv')\n",
    "# COMP.drop([14,29,41], inplace=True)\n",
    "COMP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "COMPg= COMP.copy()\n",
    "COMPg.dropna(inplace=True)\n",
    "COMPg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cs_G = stats.ks_2samp(COMPg.GPR,COMPg.OBS) # f_obs, f_exp=None, ddof=0, axis=0)[source]\n",
    "cs_O = stats.ks_2samp(COMP.OGGM,COMP.OBS)\n",
    "cs_F = stats.ks_2samp(COMP.FARIN,COMP.OBS)\n",
    "df_G= len(COMPg.GPR)-1\n",
    "df=len(COMP.OGGM)-1\n",
    "print(cs_G,'df gpr:',df_G)\n",
    "print(cs_O, 'df:',df)\n",
    "print(cs_F, 'df:',df)\n",
    "print('For an identical distribution, we cannot reject the null hypothesis since the p-values are high, 79 and 88%:')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cs_G = stats.ttest_rel(COMPg.GPR,COMPg.OBS) # f_obs, f_exp=None, ddof=0, axis=0)[source]\n",
    "cs_O = stats.ttest_rel(COMP.OGGM,COMP.OBS)\n",
    "cs_F = stats.ttest_rel(COMP.FARIN,COMP.OBS)\n",
    "df_G= len(COMPg.GPR)-1\n",
    "df=len(COMP.OGGM)-1\n",
    "print(cs_G,'df gpr:',df_G)\n",
    "print(cs_O, 'df:',df)\n",
    "print(cs_F, 'df:',df)\n",
    "print('We cannot reject the null hypothesis that there is a difference in mass balance between these estimates because the p-value is greater than our chosen alpha value of 0.05')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cs_G = chisquare(COMPg.GPR,COMPg.OBS) # f_obs, f_exp=None, ddof=0, axis=0)[source]\n",
    "cs_O = chisquare(COMP.OGGM,COMP.OBS)\n",
    "cs_F = chisquare(COMP.FARIN,COMP.OBS)\n",
    "df_G= len(COMPg.GPR)-1\n",
    "df=len(COMP.OGGM)-1\n",
    "print(cs_G,'df gpr:',df_G)\n",
    "print(cs_O, 'df:',df)\n",
    "print(cs_F, 'df:',df)\n",
    "print('Our chi-square statistic for each sample is smaller than the critical chi-square level at 0.05, so we cannot reject the null hypothesis that these distributions are different')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gpr_bdiff = pd.Series(gpr_bdiff)\n",
    "gpr_bdiff.dropna(inplace=True)\n",
    "\n",
    "opt_bdiff = pd.Series(opt_bdiff)\n",
    "opt_bdiff.dropna(inplace=True)\n",
    "\n",
    "farin_bdiff =  pd.Series(farin_bdiff)\n",
    "farin_bdiff.dropna(inplace=True)\n",
    "\n",
    "gpr_bdiff_abs = np.abs(gpr_bdiff)\n",
    "opt_bdiff_abs = np.abs(opt_bdiff)\n",
    "farin_bdiff_abs = np.abs(farin_bdiff)\n",
    "m_gpr_bdiff = round(np.mean(gpr_bdiff),2)\n",
    "ma_gpr_bdiff = round(np.mean(gpr_bdiff_abs),2)\n",
    "s_gpr_bdiff = round(np.std(gpr_bdiff),2)\n",
    "sa_gpr_bdiff = round(np.std(gpr_bdiff_abs),2)\n",
    "m_opt_bdiff = round(np.mean(opt_bdiff),2)\n",
    "ma_opt_bdiff = round(np.mean(opt_bdiff_abs),2)\n",
    "s_opt_bdiff = round(np.std(opt_bdiff),2)\n",
    "sa_opt_bdiff = round(np.std(opt_bdiff_abs),2)\n",
    "m_far_bdiff = round(np.mean(farin_bdiff),2)\n",
    "ma_far_bdiff = round(np.mean(farin_bdiff_abs),2)\n",
    "s_far_bdiff = round(np.std(farin_bdiff),2)\n",
    "sa_far_bdiff = round(np.std(farin_bdiff_abs),2)\n",
    "\n",
    "\n",
    "print('mean gpr diff:', m_gpr_bdiff, '+/-',s_gpr_bdiff,', abs. diff mean:', ma_gpr_bdiff,'+/-',sa_gpr_bdiff)\n",
    "print('mean opt diff:', m_opt_bdiff, '+/-',s_opt_bdiff,', abs. diff mean:', ma_opt_bdiff,'+/-',sa_opt_bdiff)\n",
    "print('mean farin diff:', m_far_bdiff, '+/-',s_far_bdiff,', abs. diff mean:', ma_far_bdiff,'+/-',sa_far_bdiff)\n",
    "\n",
    "mean_diff_std = np.round(np.mean([sa_gpr_bdiff, sa_opt_bdiff, sa_far_bdiff]),2) #np.round(np.std([m_gpr_bdiff, m_opt_bdiff, m_far_bdiff]),2)\n",
    "mean_diff =  np.round(np.mean([m_gpr_bdiff, m_opt_bdiff, m_far_bdiff]),2)\n",
    "meanabs_diff_std = np.round(np.mean([s_gpr_bdiff, s_opt_bdiff, s_far_bdiff]),2)#np.round(np.std([ma_gpr_bdiff, ma_opt_bdiff, ma_far_bdiff]),2)\n",
    "meanabs_diff =  np.round(np.mean([ma_gpr_bdiff, ma_opt_bdiff, ma_far_bdiff]),2)\n",
    "\n",
    "print(mean_diff, '+/-', mean_diff_std)\n",
    "print(meanabs_diff, '+/-', meanabs_diff_std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new['FG_opt_m3_we'] = new.b_fg_we * new.dem_count\n",
    "new['FG_gpr_m3_we'] = new.b_fg_we_gpr * new.dem_count\n",
    "\n",
    "B_opt = (new.FG_opt_m3_we.sum()) / (new.dem_count.sum())\n",
    "B_gpr = new.FG_gpr_m3_we.sum() / new.dem_count.sum()\n",
    "print(B_opt)\n",
    "print(B_gpr)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot flux gates as cross-sections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##########just conrad\n",
    "\n",
    "font = {'family' : 'Helvetica', 'weight' : 'normal',  'size'   : 8}\n",
    "plt.rc('font', **font)\n",
    "pylab.rcParams['xtick.major.pad']='1.'\n",
    "pylab.rcParams['ytick.major.pad']='1.'\n",
    "\n",
    "j,k = 0,0\n",
    "n=0\n",
    "# K['area_opt'] = K.thick_opt * 10 \n",
    "a=0.8\n",
    "letter=['A','B','C','D','E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M']\n",
    "div = 1000 # to make y axis km instead of m use 1000, else 1 \n",
    "\n",
    "obs_H = D.copy()\n",
    "obs_H = obs_H.dropna(subset=['gpr'])  #, inplace=True)   \n",
    "\n",
    "fig, ax = plt.subplots(2,6, figsize=(7.08,2.53))\n",
    "for i in range(D.ID.nunique()):\n",
    "    \n",
    "    K=D[D.ID==i].sort_values(by=['distance'])\n",
    "    O=obs_H[obs_H.ID==i].sort_values(by=['distance'])\n",
    "    \n",
    "    \n",
    "    # plot glacier surface\n",
    "    ax[j,k].plot(K[K.ID==i].distance, (K[K.ID==i].dem/div), color='#43a2ca', alpha=a, label='Ice surf.')\n",
    "    \n",
    "    #plot gpr thickness gates\n",
    "    gpr=(O[O.ID==i].dem/div)-(O[O.ID==i].gpr)/div\n",
    "    gpr_mask=np.isfinite(gpr)\n",
    "    ax[j,k].plot(O[O.ID==i].distance, gpr, marker='o'\n",
    "                 , ms=1.5, ls='--', color='k', alpha=a, label='Obs. bed')\n",
    "    \n",
    "#         ax[j,k].set_ylim(((K.elev[K.ID_opt==i])-(K[K.ID_opt==i].thick_opt)+5).max(), -5)\n",
    "    \n",
    "    ##plot optimized thickness gates\n",
    "    \n",
    "    ax[j,k].plot(K[K.ID==i].distance, (K[K.ID==i].dem/div)-(K[K.ID==i].H_opt/div), \n",
    "                 ls='--', c='r', alpha=a, label='Model bed')  #marker='o')\n",
    "    \n",
    "    ##plot Farinotti thickness gates\n",
    "    ax[j,k].plot(K[K.ID==i].distance, (K[K.ID==i].dem/div)-(K[K.ID==i].farin_corr/div), \n",
    "                 ls='--', c='salmon', alpha=a, label='Farinotti bed')  #marker='o')\n",
    "#     ax[1,4].axis('off')\n",
    "    if i == 0 or i==11:\n",
    "        ax[j,k].text(0.9, 0.08, letter[i], transform=ax[j,k].transAxes, fontweight='bold', verticalalignment='center', horizontalalignment='center')\n",
    "    else:\n",
    "        ax[j,k].text(0.1, 0.08, letter[i], transform=ax[j,k].transAxes, fontweight='bold', verticalalignment='center', horizontalalignment='center')\n",
    "    if i == 6 :\n",
    "         ax[j,k].yaxis.set_major_locator(ticker.MultipleLocator(200/div))\n",
    "    else:\n",
    "         ax[j,k].yaxis.set_major_locator(ticker.MultipleLocator(100/div))\n",
    "    ax[j,k].tick_params(which='major', length=2)\n",
    "#     ax[j,k].text(0.05, 0.05, letter[i], transform=ax[j,k].transAxes, fontweight='bold', fontsize=10, verticalalignment='center', horizontalalignment='center',)\n",
    "#     ax[0,0].set_ylim((1.9, 2.01))\n",
    "#     ax[0,1].set_ylim((1.95, 2.11))\n",
    "#     ax[0,4].set_ylim((2.09, 2.31))\n",
    "    ax[0,5].set_xlim((-100, 2250))\n",
    "    ax[1,5].set_xlim((-100, 1100))\n",
    "    n += 1\n",
    "    k += 1\n",
    "    if n == 5: \n",
    "        j += 1\n",
    "        k = 0  \n",
    "    if n== 11:\n",
    "        j += 1\n",
    "        k = 0 \n",
    "#     ax[1,2].legend(loc='best')#,  bbox_to_anchor=(0.45, -0.65),)\n",
    "      \n",
    "# fig.text(0.01, 0.6, 'Altitude (km a.s.l.)', rotation=90)\n",
    "# fig.text(0.5, 0.01, 'Distance (m)')     \n",
    "fig.subplots_adjust(bottom=0.115, top=0.98, left=0.055, right=0.99, wspace=0.25, hspace=0.18) \n",
    "\n",
    "plt.savefig(fl_path + 'products/' + glacier[gl]+'_trial.pdf', dpi=300)\n",
    "plt.show()\n",
    "\n",
    "# for i in range(4):\n",
    "#     area=K[K.ID_opt==i].area_opt\n",
    "#     area_total = area.sum()\n",
    "#     print(area_total)        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "D[D.gpr<1.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_agg.gpr[(df_agg.ID==8)&(df_agg.distance==0.0)]=136.7;df_agg.gpr[(df_agg.ID==8)&(df_agg.distance==1140.0)]=63.4\n",
    "df_agg.gpr[(df_agg.ID==8)&(df_agg.distance==1160.0)]=48.6;df_agg.gpr[(df_agg.ID==8)&(df_agg.distance==1180.0)]=32.2;df_agg.gpr[(df_agg.ID==8)&(df_agg.distance==1210.0)]=0.0\n",
    "df_agg.gpr[(df_agg.ID==2)&(df_agg.distance==50.0)]=53.7;df_agg.gpr[(df_agg.ID==2)&(df_agg.distance==20.0)]=24.2;df_agg.gpr[(df_agg.ID==2)&(df_agg.distance==0.0)]=0.0;\n",
    "df_agg[df_agg.ID==8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_agg.gpr[(df_agg.ID==2)&(df_agg.distance==50.0)]=53.7;df_agg.gpr[(df_agg.ID==2)&(df_agg.distance==20.0)]=24.2;df_agg.gpr[(df_agg.ID==2)&(df_agg.distance==0.0)]=0.0;\n",
    "df_agg[df_agg.ID==2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(df_agg_Illec.id.nunique()):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_H = D.copy()\n",
    "obs_H.gpr[obs_H.len==0.0]=np.nan\n",
    "obs_H = obs_H.dropna(subset=['gpr'])  #, inplace=True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('/home/pelto/Desktop/ice_flux/Illecillewaet/' + glacier[2] +'_df_agg.pkl', 'rb') as f:\n",
    "    df_agg_Illec = pickle.load(f)\n",
    "df_agg_Kok[df_agg_Kok.id==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## ALL glaciers\n",
    "## Conrad 10 gates, 11 bins, Illec. 5 gates 6 bins, Kokanee 5 gates 6 bins\n",
    "\n",
    "Glacier = ['Kokanee', 'Conrad', 'Illecillewaet', 'Nordic','Zillmer']\n",
    "glacier = ['kokanee', 'conrad', 'illecillewaet', 'nordic', 'zillmer']\n",
    "import pickle\n",
    "with open('/home/pelto/Desktop/ice_flux/Illecillewaet/' + glacier[2] +'_df_agg.pkl', 'rb') as f:\n",
    "    df_agg_Illec = pickle.load(f)\n",
    "with open('/home/pelto/Desktop/ice_flux/Kokanee/' + glacier[0] +'_df_agg.pkl', 'rb') as f:\n",
    "    df_agg_Kok = pickle.load(f)\n",
    "with open('/home/pelto/Desktop/ice_flux/Nordic/2016_D.pkl', 'rb') as f:\n",
    "    df_agg_nord = pickle.load(f)\n",
    "with open('/home/pelto/Desktop/ice_flux/Zillmer/zillmer_2016_D.pkl', 'rb') as f:\n",
    "    df_agg_zill = pickle.load(f)\n",
    "\n",
    "font = {'family' : 'Helvetica', 'weight' : 'normal',  'size'   : 8}\n",
    "plt.rc('font', **font)\n",
    "pylab.rcParams['xtick.major.pad']='1.'\n",
    "pylab.rcParams['ytick.major.pad']='1.'\n",
    "\n",
    "j,k = 0,0; n=0; l=1.25\n",
    "# K['area_opt'] = K.thick_opt * 10 \n",
    "a=0.8\n",
    "letter=['A','B','C','D','E', 'F', 'G', 'H', 'I', 'J', ' ',' ','K','L', 'M', 'N', 'O', ' ','P', 'Q', 'R',\n",
    "        'S', 'T', ' ', 'U','V', 'X', 'Y', 'Z',' ','AA','AB','AC','AD',' ']\n",
    "gate=['C0','C1','C2','C3','C4','C5','C6','C7','C8','C9',' ', ' ', 'I0','I1','I2','I3','I4',' ', \n",
    "      'K0', 'K1', 'K2', 'K3', 'K4',' ', 'N0', 'N1', 'N2', 'N3', 'N4', ' ', 'Z0', 'Z1', 'Z2', 'Z3', ' ', ' ',]\n",
    "div = 1000 # to make y axis km instead of m use 1000, else 1 \n",
    "\n",
    "#Conrad data\n",
    "obs_H = D.copy(); obs_H.gpr[obs_H.len==0.0]=np.nan;obs_H = obs_H.dropna(subset=['gpr'])  #, inplace=True)  \n",
    "\n",
    "fig, ax = plt.subplots(6,6, figsize=(cm2inch(18, 15)))\n",
    "\n",
    "for i in range(D.ID.nunique()+8+5+6+6):\n",
    "    \n",
    "    if n<12:\n",
    "        K=D_all[D_all.ID==i].sort_values(by=['distance'])\n",
    "        O=obs_H[obs_H.ID==i].sort_values(by=['distance'])\n",
    "\n",
    "        # plot glacier surface\n",
    "        ax[j,k].tick_params(which='major', length=1.75)\n",
    "        ax[j,k].plot(K[K.ID==i].distance, (K[K.ID==i].dem/div), color='#43a2ca', alpha=a, label='Ice surf.', lw=l)\n",
    "\n",
    "        #plot gpr thickness gates\n",
    "        if n!=6:\n",
    "            gpr=(O[O.ID==i].dem/div)-(O[O.ID==i].gpr)/div\n",
    "            gpr_mask=np.isfinite(gpr)\n",
    "            ax[j,k].plot(O[O.ID==i].distance, gpr, marker='o'\n",
    "                         , ms=1.0, ls='--', color='k', alpha=a, label='Obs. bed', lw=l)\n",
    "\n",
    "        ##plot optimized thickness gates\n",
    "        ax[j,k].plot(K[K.ID==i].distance, (K[K.ID==i].dem/div)-(K[K.ID==i].H_opt/div), \n",
    "                     ls='-.', c='r', alpha=a, label='Model bed', lw=l)  #marker='o')\n",
    "\n",
    "        ##plot Farinotti thickness gates\n",
    "        ax[j,k].plot(K[K.ID==i].distance, (K[K.ID==i].dem/div)-(K[K.ID==i].farin_corr/div), \n",
    "                     ls='--', c='salmon', alpha=a, label='Farinotti bed', lw=l)  #marker='o')\n",
    "             \n",
    "        ax[j,k].text(0.04, 0.09, gate[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='left')\n",
    "            \n",
    "        if i == 10:\n",
    "            ax[j,k].text(0.9, 0.9, letter[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='center')\n",
    "        else:\n",
    "            ax[j,k].text(0.9, 0.09, letter[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='center')\n",
    "        \n",
    "        if i <5 or i==6:\n",
    "             ax[j,k].yaxis.set_major_locator(ticker.MultipleLocator(100/div))\n",
    "        else:\n",
    "             ax[j,k].yaxis.set_major_locator(ticker.MultipleLocator(200/div))\n",
    "       \n",
    "    #     ax[j,k].text(0.04, 0.04, letter[i], transform=ax[j,k].transAxes, fontweight='bold', fontsize=10, verticalalignment='center', horizontalalignment='center',)\n",
    "        ax[0,0].set_ylim((1.965, 2.1)); ax[1,2].set_ylim((2.6, 2.95));  ax[1,3].set_ylim((2.63, 3.02))\n",
    "        ax[2,4].set_ylim((2.25, 2.6)); ax[0,3].set_ylim((2.1, 2.31))\n",
    "#         ax[0,5].set_xlim((-100, 1450));   ax[1,5].set_xlim((-50, 1300)) ; \n",
    "        n += 1;    k += 1\n",
    "        if n == 6: \n",
    "            j += 1; k = 0  \n",
    "        if n== 12:\n",
    "            j += 1; k = 0 \n",
    "    elif n > 11 and n < 18:\n",
    "#         if n==12:\n",
    "#             k += 1 \n",
    "        K=df_agg_Illec[df_agg_Illec.id==i-12].sort_values(by=['distance'])\n",
    "        obs_H = df_agg_Illec.copy();obs_H = obs_H.dropna(subset=['gpr']) \n",
    "        O=obs_H[obs_H.id==i-12].sort_values(by=['distance'])\n",
    "\n",
    "        # plot glacier surface\n",
    "        ax[j,k].tick_params(which='major', length=1.75)\n",
    "        ax[j,k].plot(K.distance, (K.dem/div), color='#43a2ca', alpha=a, label='Ice surface', lw=l,)\n",
    "\n",
    "        #plot gpr thickness gates\n",
    "        gpr=(O.dem/div)-(O.gpr/div)\n",
    "        gpr_mask=np.isfinite(gpr)\n",
    "        ax[j,k].plot(O.distance, gpr, marker='o'\n",
    "                     , ms=1.0, ls='--', color='k', alpha=a, label='Observed bed', lw=l)\n",
    "\n",
    "    #         ax[j,k].set_ylim(((df_agg.elev[df_agg.id_opt==i])-(df_agg[df_agg.id_opt==i].thick_opt)+5).max(), -5)\n",
    "\n",
    "        ##plot optimized thickness gates\n",
    "\n",
    "        ax[j,k].plot(K.distance, (K.dem/div)-(K.H_opt/div), \n",
    "                     ls='-.', c='r', alpha=a, label='OGGM bed', lw=l)  #marker='o')\n",
    "\n",
    "        ##plot Farinotti thickness gates\n",
    "        ax[j,k].plot(K.distance, (K.dem/div)-(K.farin_corr/div), \n",
    "                     ls='--', c='salmon', alpha=a, label='Farinotti et al. (2019) bed', lw=l)  #marker='o')\n",
    "#         ax[2,4].set_ylim(2.1, 2.22)\n",
    "        if i <= 13:\n",
    "            ax[j,k].yaxis.set_major_locator(ticker.MultipleLocator(100/div))\n",
    "        else:\n",
    "            ax[j,k].yaxis.set_major_locator(ticker.MultipleLocator(200/div))\n",
    "        #ax[j,k].set_facecolor('0.92') ## make grey background for Illec.\n",
    "\n",
    "        ax[j,k].text(0.04, 0.09, gate[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='left')\n",
    "        \n",
    "        \n",
    "        if i == 14 or i==15:\n",
    "            ax[j,k].text(0.9, 0.9, letter[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='center')\n",
    "        else:\n",
    "            ax[j,k].text(0.9, 0.09, letter[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='center')\n",
    "          \n",
    "        n += 1;    k += 1\n",
    "        if n == 18: \n",
    "            j += 1; k = 0  \n",
    "    elif n > 17 and n < 24: \n",
    "        K=df_agg_Kok[df_agg_Kok.id==i-18].sort_values(by=['distance'])\n",
    "        obs_H = df_agg_Kok.copy();obs_H = obs_H.dropna(subset=['gpr']) \n",
    "        O=obs_H[obs_H.id==i-18].sort_values(by=['distance'])\n",
    "\n",
    "        # plot glacier surface\n",
    "        ax[j,k].tick_params(which='major', length=1.75)\n",
    "        ax[j,k].plot(K.distance, (K.dem/div), color='#43a2ca', alpha=a, label='Ice surface',lw=l)\n",
    "\n",
    "        #plot gpr thickness gates\n",
    "        gpr=(O.dem/div)-(O.gpr/div)\n",
    "        gpr_mask=np.isfinite(gpr)\n",
    "        ax[j,k].plot(O.distance, gpr, marker='o', ms=1.0, ls='--', color='k', alpha=a, label='Obs. bed', lw=l)\n",
    "\n",
    "        ##plot optimized thickness gates\n",
    "        ax[j,k].plot(K.distance, (K.dem/div)-(K.H_opt/div), ls='-.', c='r', alpha=a, label='OGGM bed',lw=l)  #marker='o')\n",
    "\n",
    "        ##plot Farinotti thickness gates\n",
    "        ax[j,k].plot(K.distance, (K.dem/div)-(K.farin_corr/div), \n",
    "                     ls='--', c='salmon', alpha=a, label='FAR19 bed', lw=l)  #marker='o')\n",
    "\n",
    "        ax[j,k].yaxis.set_major_locator(ticker.MultipleLocator(100/div)) ##\n",
    "       \n",
    "        ax[3,0].set_ylim(2275/div, 2400/div);ax[3,2].set_ylim(2410/div, 2680/div);ax[3,4].set_ylim((2.59, 2.76))\n",
    "#         ax[3,3].set_xlim(1000, 1500);ax[3].set_ylim(2510/div, 2710/div) ax[4].set_ylim(2590/div, 2750/div)\n",
    "\n",
    "        ax[j,k].text(0.9, 0.9, letter[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='left')\n",
    "        if i == 22:\n",
    "            ax[j,k].text(0.04, 0.9, gate[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='left',)\n",
    "        else:\n",
    "            ax[j,k].text(0.04, 0.09, gate[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='left')\n",
    "        n += 1;    k += 1\n",
    "        if n == 24: \n",
    "            j += 1; k = 0 \n",
    "    elif n > 23 and n < 30: \n",
    "        K=df_agg_nord[df_agg_nord.id==i-24].sort_values(by=['distance'])\n",
    "        obs_H = df_agg_nord.copy();obs_H = obs_H.dropna(subset=['gpr']) \n",
    "        O=obs_H[obs_H.id==i-24].sort_values(by=['distance'])\n",
    "\n",
    "        # plot glacier surface\n",
    "        ax[j,k].tick_params(which='major', length=1.75)\n",
    "        ax[j,k].plot(K.distance, (K.dem/div), color='#43a2ca', alpha=a, label='Ice surface',lw=l)\n",
    "\n",
    "        #plot gpr thickness gates\n",
    "        gpr=(O.dem/div)-(O.gpr/div)\n",
    "        gpr_mask=np.isfinite(gpr)\n",
    "        ax[j,k].plot(O.distance, gpr, marker='o', ms=1.0, ls='--', color='k', alpha=a, label='Obs. bed', lw=l)\n",
    "\n",
    "        ##plot optimized thickness gates\n",
    "        ax[j,k].plot(K.distance, (K.dem/div)-(K.H_opt/div), ls='-.', c='r', alpha=a, label='OGGM bed',lw=l)  #marker='o')\n",
    "\n",
    "        ##plot Farinotti thickness gates\n",
    "        ax[j,k].plot(K.distance, (K.dem/div)-(K.farin_corr/div), \n",
    "                     ls='--', c='salmon', alpha=a, label='FAR19 bed', lw=l)  #marker='o')\n",
    "        if n == 27:\n",
    "            ax[j,k].text(0.9, 0.09, letter[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='left')\n",
    "        else:\n",
    "            ax[j,k].text(0.9, 0.9, letter[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='left')\n",
    "        ax[j,k].text(0.04, 0.09, gate[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='left')\n",
    "        ax[4,1].yaxis.set_major_locator(ticker.MultipleLocator(200/div));ax[4,3].yaxis.set_major_locator(ticker.MultipleLocator(100/div))                                            \n",
    "        ax[4,3].set_ylim((2.095, 2.22));\n",
    "        n += 1;    k += 1\n",
    "        if n == 30: \n",
    "            j += 1; k = 0 \n",
    "    elif n > 29 and n < 36: \n",
    "        K=df_agg_zill[df_agg_zill.id==i-30].sort_values(by=['distance'])\n",
    "        obs_H = df_agg_zill.copy();obs_H = obs_H.dropna(subset=['gpr']) \n",
    "        O=obs_H[obs_H.id==i-30].sort_values(by=['distance'])\n",
    "\n",
    "        # plot glacier surface\n",
    "        ax[j,k].tick_params(which='major', length=1.75)\n",
    "        ax[j,k].plot(K.distance, (K.dem/div), color='#43a2ca', alpha=a, label='Ice surface',lw=l)\n",
    "\n",
    "        #plot gpr thickness gates\n",
    "        gpr=(O.dem/div)-(O.gpr/div)\n",
    "        gpr_mask=np.isfinite(gpr)\n",
    "        ax[j,k].plot(O.distance, gpr, marker='o', ms=1.0, ls='--', color='k', alpha=a, label='Obs. bed', lw=l)\n",
    "\n",
    "        ##plot optimized thickness gates\n",
    "        ax[j,k].plot(K.distance, (K.dem/div)-(K.H_opt/div), ls='-.', c='r', alpha=a, label='OGGM bed',lw=l)  #marker='o')\n",
    "\n",
    "        ##plot Farinotti thickness gates\n",
    "        ax[j,k].plot(K.distance, (K.dem/div)-(K.farin_corr/div), \n",
    "                     ls='--', c='salmon', alpha=a, label='FAR19 bed', lw=l)  #marker='o')\n",
    "        ax[j,k].text(0.95, 0.09, letter[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='right')\n",
    "        ax[j,k].text(0.04, 0.09, gate[i], transform=ax[j,k].transAxes, verticalalignment='center', horizontalalignment='left')\n",
    "        ax[5,0].set_ylim((1.97, 2.27));ax[5,1].set_ylim((2.03, 2.47))  \n",
    "        n += 1;    k += 1\n",
    "        \n",
    "        \n",
    "ax[5,4].legend(bbox_to_anchor=(1.07, 0.99))\n",
    "ax[1,5].axis('off');ax[1,4].axis('off');ax[3,5].axis('off');ax[3,5].axis('off');ax[2,5].axis('off');ax[4,5].axis('off')\n",
    "ax[5,4].axis('off');ax[5,5].axis('off')\n",
    "# plt.axhspan(0.75, i+.2, facecolor='0.2', alpha=0.5)\n",
    "fig.text(0.003, 0.6, 'Altitude (km a.s.l.)', rotation=90)\n",
    "fig.text(0.46, 0.009, 'Distance (m)')     \n",
    "fig.subplots_adjust(bottom=0.054, top=0.98, left=0.055, right=0.99, wspace=0.26, hspace=0.19) \n",
    "\n",
    "plt.savefig(fl_path + 'products/' +'All_gates_all_glaciers_5_NEW.pdf', dpi=300)     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_agg_nord"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gates.sort_values(by='ID',ascending=True, inplace=True) # sort by bin\n",
    "\n",
    "WID =[]\n",
    "for i in range(len(gates.ID)):\n",
    "    W1=gates[gates.ID == i].len.to_numpy()\n",
    "    W2=gates[gates.ID == i+1].len.to_numpy()\n",
    "    WID.append(1-(W1/W2))   #,ignore_index=True)\n",
    "gates['p_len_diff']= WID\n",
    "\n",
    "gates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sVSTAKE=1.10; sVOFFice=1.8; sVCoreg=3.0; sVRAND=2.0\n",
    "sVsys=np.sqrt((sVSTAKE**2)+(sVOFFice**2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(df_agg),len(df_agg.gpr.npis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_agg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "year=2017\n",
    "\n",
    "vf_list = ['conrad_2016_vy_25m_pos.tif','conrad_2017_vy_25m_pos.tif','conrad_2018_vy_25m_pos_17mos.tif']\n",
    "vdir = '/home/pelto/Desktop/velocity_mapping/Conrad_DEMs/spm2/3m/'\n",
    "ITS = fl_path + 'ITS_Live/' + str(year) + '_conrad_ITS_LIVE.tif'\n",
    "I = np.abs(year - 2016) \n",
    "### for 2016/7\n",
    "if I == 2:\n",
    "    VX = vdir+ vf_list[I][:-20] + 'vx_25m.tif'\n",
    "    VY = vdir+ vf_list[I]\n",
    "    VM = vdir+ vf_list[I][:-20] + 'vm_25m.tif'\n",
    "else:\n",
    "    VX = vdir+ vf_list[I][:-14] + 'vx_25m.tif' \n",
    "    VY = vdir+ vf_list[I]\n",
    "    VM = vdir+ vf_list[I][:-14] + 'vm_25m.tif'\n",
    "\n",
    "\n",
    "vy = salem.open_xr_dataset(VY);vy = vy.to_array(name='vy')\n",
    "vx = salem.open_xr_dataset(VX);vx = vx.to_array(name='vx')\n",
    "\n",
    "vz = vy\n",
    "vz.data = np.sqrt(vx.data**2 + vz.data**2 )\n",
    "vz.data[vz.data<0.01]=np.nan; #vz.data[vz.data>50.0]=np.nan\n",
    "vz.data[msk_conrad.data!=1.0] = np.nan;\n",
    "\n",
    "font = {'family' : 'Helvetica', 'weight' : 'normal', 'size'   : 8}\n",
    "plt.rc('font', **font)\n",
    "pylab.rcParams['xtick.major.pad']='1'\n",
    "pylab.rcParams['ytick.major.pad']='1'\n",
    "\n",
    "fig, ax = plt.subplots(1, figsize=cm2inch(8.5,10.))\n",
    "topo_big = '/home/pelto/Desktop/lidar_cbt_analysis/conrad/dem_mosaic_conrad.tif'\n",
    "grid1 = mercator_grid(center_ll=(-116.92, 50.802), extent=(4700, 7400)) ##zoomed out view\n",
    "# 487892.000 5509738.000 491232.000 5512358.000\n",
    "# grid1 = vx.salem.grid  ##full view\n",
    "sm1 = Map(grid1, countries=False)\n",
    "sm1.set_lonlat_contours(interval=0)\n",
    "sm1.set_scale_bar(location=(0.13, 0.06),add_bbox=True,bbox_dy=1.5,linewidth=1.0)\n",
    "\n",
    "VZA=xr.DataArray(data=vz, coords=vz.coords, dims=vz.dims, name='VZA', attrs=vz.attrs) #,indexes=vx.indexes fastpath=False)\n",
    "\n",
    "# VZA.data=VZA.data*(msk+1.0)\n",
    "sm1.set_data(vz) \n",
    "\n",
    "sm1.set_cmap(\"Spectral_r\")\n",
    "sm1.set_vmax(val=60.)\n",
    "shape = salem.read_shapefile('/home/pelto/Desktop/lidar_cbt_analysis/conrad/Conrad/conrad_16_extent.shp')\n",
    "#      Change the lon-lat countour setting\n",
    "sm1.set_lonlat_contours(add_ytick_labels=True, interval=0.05, linewidths=0.75, linestyles='--', colors='0.25')\n",
    "sm1.set_topography(topo_big,  relief_factor=0.8)\n",
    "sm1.set_shapefile(shape, lw=1.2, color='k')\n",
    "sm1.set_shapefile(gates, color='w', lw=1.1)\n",
    "\n",
    "obs_shp = '/home/pelto/Desktop/ice_flux/Flux_pts.csv'\n",
    "obs_pts = pd.read_csv(obs_shp)  #salem.read_shapefile(obs_shp)\n",
    "x, y = sm1.grid.transform(obs_pts.lon.values, obs_pts.lat.values)\n",
    "ax.scatter(x, y, color='k', s=8, facecolor='w',zorder=3)\n",
    "\n",
    "\n",
    "sm1.append_colorbar(ax=ax, pad=0.1, label='Ice velocity (m yr$^{-1}$)')#, cbar_title='Ice Velocity (m yr$^-1$)')\n",
    "sm1.plot(ax=ax)\n",
    "\n",
    "u = D.vx.values;v = D.vy.values\n",
    "X, Y = np.meshgrid(D.lon,D.lat)\n",
    "\n",
    "# transform their coordinates to the map reference system and plot the arrows\n",
    "xx, yy = sm1.grid.transform(D.lon, D.lat, crs=salem.wgs84)#sm1.grid.proj\n",
    "\n",
    "# xx, yy = np.meshgrid(xx,yy)\n",
    "\n",
    "# qu = ax.quiver(xx, yy, u, v)\n",
    "\n",
    "###### start:stop:step\n",
    "n=1\n",
    "Q = ax.quiver(xx[::n], yy[::n], u[::n], v[::n], scale=600.)  #, pivot='mid')\n",
    "qk = ax.quiverkey(Q, 0.07, 0.10, 50, r'$40 \\frac{m}{a}$', labelpos='N', coordinates='figure', labelsep=0.025, zorder=1)\n",
    "\n",
    "\n",
    "\n",
    "# Q = ax.quiver(X[::2, ::2], Y[::2, ::2], u[::2, ::2], v[::2, ::2], pivot='mid')\n",
    "#Q= ax2.quiver(X[::3, ::3], Y[::3, ::3], U[::3, ::3], V[::3, ::3],pivot='mid', units='inches')\n",
    "\n",
    "# X, Y = np.meshgrid(D.lon,D.lat)\n",
    "# U = D.vx.values\n",
    "# V = D.vy.values\n",
    "# U,V = np.meshgrid(U, V)\n",
    "\n",
    "# # Q = ax.quiver(X, Y, U, V)#units='width', angles='uv') \n",
    "# Q = ax.quiver(X[::30, ::30], Y[::30, ::30], U[::30, ::30], V[::30, ::30], units='xy')\n",
    "\n",
    "\n",
    "fig.subplots_adjust(bottom=0.05, top=0.99, left=0.14, right=0.88) #, wspace=0.22, hspace=0.15\n",
    "plt.savefig(fl_path+ 'products/conrad_vel_gates_quiver_'+str(year) +'_1.pdf', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D[D.ID==8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1,1,figsize=(10,6))\n",
    "\n",
    "\n",
    "# df = salem.read_shapefile(fl_path + 'conrad_points_17gates_20m_wgs84.shp')\n",
    "\n",
    "# coords = np.array([p.xy for p in df.geometry]).squeeze()\n",
    "# df['lon'] = coords[:, 0]\n",
    "# df['lat'] = coords[:, 1]\n",
    "# # df['lon'] = df[4]\n",
    "# # df['lat'] = df[5]\n",
    "\n",
    "\n",
    "# xx, yy = salem.transform_proj(salem.wgs84, grid1.proj, df['lon'].values, df['lat'].values)\n",
    "# df['x'] = xx\n",
    "# df['y'] = yy\n",
    "\n",
    "# ax.scatter(df.lon, df.lat, s=10, c='r' )#c='depth',cmap='viridis', s=10, ax=ax);\n",
    "\n",
    "\n",
    "X, Y = np.meshgrid(vx.coords['x'],vx.coords['y'])\n",
    "U = vx.data[0]\n",
    "V = vy.data[0]\n",
    "\n",
    "# Q = ax.quiver(X, Y, U, V)#units='width', angles='uv') \n",
    "Q = ax.quiver(X[::30, ::30], Y[::30, ::30], U[::30, ::30], V[::30, ::30], units='xy')\n",
    "# ax.set_xlim(502500, 507500)\n",
    "# ax.set_ylim( 5624000, 5631500)\n",
    "#     plt.quiver(vx.x, vx.y, vx.data ,vy.data)\n",
    "# plt.savefig(fl_path+ 'products/'+ 'conrad_16_17_quiver.pdf', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### number of days average velocity\n",
    "conrad_vel_days = [363,366,399,370,340,352]\n",
    "illec_vel_days = [364,367,399,357,377,370,340,394,339]\n",
    "kok_vel_days = [364,367,399,340,326]\n",
    "np.mean(conrad_vel_days + illec_vel_days + kok_vel_days), np.std((conrad_vel_days + illec_vel_days + kok_vel_days))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### number of cover average velocity\n",
    "conrad_vel_cover = [95,84,98,71,97,96]\n",
    "illec_vel_cover = [80,86,86,79,71,94,97,92,79]\n",
    "kok_vel_cover = [87,87,97,97,85]\n",
    "np.mean(conrad_vel_cover + illec_vel_cover + kok_vel_cover), np.std((conrad_vel_cover + illec_vel_cover + kok_vel_cover))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}