apply_ML_IRAC.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example of how to apply a ML model to IRAC data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### This code applies a model for removing systematics to exoplanet light curve data from the Spitzer IRAC archive and plots some results. \n",
    "\n",
    "The method to make the model is described in detail in Krick et al. 2020. Briefly, we used scikitlearn xgboost to learn a model using features based on past experience with systematics removal.  We used a calibration dataset from a star which is known to not vary astrophysically.  The science data is 10 observations of eclipses of XO3b taken from the Spitzer archive and also discussed in Wong et al. 2015 and Ingalls et al. 2016.  \n",
    "\n",
    "We generated the XO3 photometry csv file using the idl code phot_exoplanet_csv.pro.  It is important that the data features be generated in the same way for the science data as was done when generating the model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import batman\n",
    "import exoparams\n",
    "import numpy as np\n",
    "import statistics\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from batman             import TransitParams, TransitModel\n",
    "from functools          import partial\n",
    "from lmfit              import Minimizer, Parameters, report_errors\n",
    "from pylab              import *;ion()\n",
    "from scipy              import stats\n",
    "from sklearn.externals import joblib\n",
    "from astropy.stats      import sigma_clip\n",
    "\n",
    "dirname = '/Users/jkrick/Library/Mobile Documents/com~apple~CloudDocs/XO3/'\n",
    "\n",
    "#Here are the names of the 10 observations of XO3b\n",
    "aorname = ['r46468096','r46468352','r46468608','r46469120','r46469632','r46470400',\n",
    "           'r46470656','r46470912','r46471168','r46471424']\n",
    "n_aor = 10 \n",
    "#data\n",
    "e_depth = np.zeros(n_aor)  #waiting for eclipse depths\n",
    "deptherr = np.zeros(n_aor)  #waiting for uncertainties on eclipse depths\n",
    "\n",
    "#model to be used to correct the data\n",
    "model_name='xgboost_PLD_sumnorm_mse_ch2.pkl'\n",
    "\n",
    "\n",
    "#set the planetname for finding initial guesses of planet parameters\n",
    "planetname = 'XO-3 b'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#These functions set up transit fitting with Batman\n",
    "def deltaphase_eclipse(ecc, omega, omegatype = 'RV'):\n",
    "    from numpy import cos, pi, abs\n",
    "    return 0.5*( 1 + (4. / pi) * ecc * cos(omega))\n",
    "\n",
    "def batman_lmfit_model(period, tCenter, inc, aprs, edepth, tdepth, ecc, omega, times,u1=None, u2=None,\n",
    "                       ldtype = 'uniform', transittype=\"secondary\", bm_params=None):\n",
    "    if tdepth is not 0.0 or edepth is not 0.0:\n",
    "        if bm_params is None:\n",
    "            bm_params = TransitParams() # object to store transit parameters\n",
    "        \n",
    "        bm_params.per       = period  # orbital period\n",
    "        bm_params.t0        = tCenter # time of inferior conjunction\n",
    "        bm_params.a         = aprs    # semi-major axis (in units of stellar radii)\n",
    "        bm_params.fp        = edepth  # f\n",
    "        bm_params.tdepth    = tdepth  # from Fraine et al. 2014s\n",
    "        bm_params.rp        = math.sqrt(tdepth) # planet radius (in units of stellar radii)\n",
    "        bm_params.ecc       = ecc     # eccentricity\n",
    "        bm_params.w         = omega   # longitude of periastron (in degrees)\n",
    "        bm_params.inc       = inc     # orbital inclination (in degrees)\n",
    "        bm_params.limb_dark = ldtype  # limb darkening model # NEED TO FIX THIS\n",
    "        bm_params.u         = []      # limb darkening coefficients # NEED TO FIX THIS\n",
    "        \n",
    "        \n",
    "        if u1 is not None and ldtype is not 'uniform':\n",
    "            bm_params.u.append(u1)\n",
    "        elif u1 is not None and ldtype is 'uniform':\n",
    "            raise ValueError('If you set `u1`, you must also set `ldtype` to either linear or quadratic')\n",
    "        if u2 is not None and ldtype is 'quadratic':\n",
    "            bm_params.u.append(u2)\n",
    "        elif u2 is not None and ldtype is not 'quadratic':\n",
    "            raise ValueError('If you set `u2`, you must also set `ldtype` quadratic')\n",
    "        \n",
    "        if transittype==\"secondary\" and edepth != 0.0:\n",
    "            bm_params.delta_phase = deltaphase_eclipse(bm_params.ecc, bm_params.w) if bm_params.ecc is not 0.0 else 0.5\n",
    "            bm_params.t_secondary = bm_params.t0 + bm_params.per*bm_params.delta_phase\n",
    "\n",
    "        m_eclipse = TransitModel(bm_params, times, transittype=transittype).light_curve(bm_params)\n",
    "    else:\n",
    "        return ones(times.size)\n",
    "    \n",
    "    return m_eclipse\n",
    "\n",
    "def residuals_func(model_params, times, data, data_err, ldtype='uniform'):\n",
    "\n",
    "    \"\"\"Returns residuals of current model estimate with input `data`\n",
    "    \n",
    "    Args:\n",
    "        model_params    : set of model parmaeters  -- named to avoid global / local confusion\n",
    "        data            : data to be fit\n",
    "        times           : temporal array to use with model\n",
    "        input_features  : basis vectors for linear fitting to noise array\n",
    "        in_eclipse      : boolean array to identify the eclipse location from initial guess\n",
    "        method          : string to identify if residuals should be taken over \n",
    "                            `fourier` or `spiderman` phase curve models\n",
    "    \n",
    "    Returns:\n",
    "        Returns the array of residuals, that is the data - model\n",
    "    \"\"\"\n",
    "    # Return residuals between this model and the `data` allocated above\n",
    "    period  = model_params['period']\n",
    "    tCenter = model_params['tCenter']\n",
    "    inc     = model_params['inc']\n",
    "    aprs    = model_params['aprs']\n",
    "    edepth  = model_params['edepth']\n",
    "    tdepth  = model_params['tdepth']\n",
    "    ecc     = model_params['ecc']\n",
    "    omega   = model_params['omega']\n",
    "#    u1      = model_params['u1']\n",
    "#    u2      = model_params['u2']\n",
    "    intcpt  = model_params['intcpt']\n",
    "    slope   = model_params['slope']\n",
    "    crvtur  = model_params['crvtur']\n",
    "   \n",
    "    model_now = batman_lmfit_model(period, tCenter, inc, aprs, edepth, tdepth, ecc, omega, times,\n",
    "                                    ldtype=ldtype)#u1=u1, u2=u2,\n",
    "    \n",
    "    line_model  = intcpt\n",
    "    if slope != 0:\n",
    "        line_model += slope*(times - times.mean())\n",
    "    if crvtur != 0:\n",
    "        line_model += crvtur*(times - times.mean())**2\n",
    "    \n",
    "    model_total = model_now*line_model\n",
    "    \n",
    "    return ((model_total - data) / data_err)**2\n",
    "\n",
    "def exoparams_to_lmfit_params(planet_name):\n",
    "    ep_params   = exoparams.PlanetParams(planet_name)\n",
    "    iApRs       = ep_params.ar.value\n",
    "    iEcc        = ep_params.ecc.value\n",
    "    iInc        = ep_params.i.value\n",
    "    iPeriod     = ep_params.per.value\n",
    "    iTCenter    = ep_params.tt.value\n",
    "    iTdepth     = ep_params.depth.value\n",
    "    iOmega      = ep_params.om.value\n",
    "    \n",
    "    return iApRs, iEcc, iInc, iPeriod, iTCenter, iTdepth, iOmega\n",
    "\n",
    "def exoparams_to_batman_model(planet_name, times=None, u1=None, u2=None):\n",
    "    ep_params           = exoparams.PlanetParams(planet_name)\n",
    "    bm_params           = TransitParams()\n",
    "\n",
    "    bm_params.a         = ep_params.ar.value\n",
    "    bm_params.ecc       = ep_params.ecc.value\n",
    "    bm_params.inc       = ep_params.i.value\n",
    "    bm_params.limb_dark = 'uniform'\n",
    "    bm_params.per       = ep_params.per.value\n",
    "    bm_params.t0        = ep_params.tt.value\n",
    "    bm_params.rp        = math.sqrt(ep_params.depth.value)\n",
    "    bm_params.w         = ep_params.om.value\n",
    "    \n",
    "    ldcs  = []\n",
    "    if u1 is not None:\n",
    "        bm_params.limb_dark = 'linear'\n",
    "        ldcs.append(u1)\n",
    "        if u2 is not None:\n",
    "            bm_params.limb_dark = 'quadratic'\n",
    "            ldcs.append(u2)    \n",
    "    \n",
    "    bm_params.u         = ldcs\n",
    "    if times is not None:\n",
    "        times = times.copy()\n",
    "        if len(str(times[0]).split('.')[0]) == 5:\n",
    "            times += 2400000\n",
    "        if len(str(times[0]).split('.')[0]) == 4:\n",
    "            times += 2450000\n",
    "        \n",
    "        lc_model  = TransitModel(bm_params, times).light_curve(bm_params)\n",
    "        \n",
    "        return lc_model, bm_params, ep_params\n",
    "    else:\n",
    "        return bm_params, ep_params\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define my own scoring function based on accuracy of measuring transit depths\n",
    "#this was used in generating the pkl model and so is needed here.\n",
    "def inject_accuracy_score(estimator, X, y):\n",
    "\n",
    "    #split up the test arrays into simulated 'AORs'\n",
    "    n = 50\n",
    "\n",
    "    #maybe don't need to inject and fit all of them\n",
    "    n_aor = 31\n",
    "\n",
    "    nr = X.shape[0]\n",
    "    ns = nr/n\n",
    "    dfs_X = np.array_split(X,50 , axis = 0)\n",
    "    dfs_y = np.array_split(y,50 , axis = 0)\n",
    "    t_depth = np.zeros(n_aor)  #waiting for transit depths\n",
    "    inject_depth = np.zeros(n_aor)\n",
    "    for counter in range(0, n_aor ): \n",
    "    \n",
    "        #seperate pmap dataframe into a shorter df with a single AOR in it.\n",
    "        df_AOR_X = dfs_X[counter]\n",
    "        df_AOR_y = dfs_y[counter]\n",
    "        \n",
    "        #makeup a time array here\n",
    "        #want it to have equally spaced times from 0 to 0.6\n",
    "        pmap_time = np.linspace(0.1, 0.7, df_AOR_X.shape[0])\n",
    "    \n",
    "        #inject transits in that single AOR pmap data\n",
    "        planet_period = 0.6   #in days .02 if pnap_time in days\n",
    "        planet_sma = 0.1\n",
    "        #make this a random number between 0.05 and 0.1\n",
    "        rp_rs = np.random.uniform(0.03, 0.1)\n",
    "        df_AOR_X_transit, inject_depth[counter] = inject_transit(rp_rs, df_AOR_X, df_AOR_y, \n",
    "                                                                 pmap_time, planet_period, planet_sma, verbose=True)\n",
    "\n",
    "        #apply ML correction to injected data\n",
    "        y_data_predict = apply_ML(df_AOR_X_transit, estimator)\n",
    "\n",
    "\n",
    "        #measure the depth of the transit injected in previous step\n",
    "        t_depth[counter], fitresults_lmfit = measure_transit_depth(y_data_predict, pmap_time,planet_period, rp_rs )       \n",
    "    \n",
    "    #calcaulate accuracy on ensemble of AORs\n",
    "    a = accuracy(t_depth, inject_depth, np.median(df['flux']))\n",
    "    \n",
    "    return a\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## set up parameters for fitting the XO3 data\n",
    "#get initial guesses at planet parameters from exoplanet.org\n",
    "iApRs, iEcc, iInc, iPeriod, iTCenter, iTdepth, iOmega = exoparams_to_lmfit_params(planetname)\n",
    "\n",
    "#make an educated guess for the initial and minimum eclipse depth and argument of periastron\n",
    "iEdepth = 0.0015 \n",
    "iEdepth_min = 0.0011 \n",
    "iOmega = 346\n",
    "#do not fit limb darkening parameters\n",
    "u1 = None\n",
    "u2 = None\n",
    "\n",
    "#only fitting eclipse depth and out of transit intercept, slope and curvature\n",
    "init_params_lmfit = Parameters()\n",
    "init_params_lmfit.add_many(\n",
    "    # Planetary Parameters\n",
    "    ('period' , iPeriod , False),\n",
    "    ('tCenter', iTCenter, False , iTCenter-1.5, iTCenter+1.5), # +\\- 1.2 hours\n",
    "    ('inc'    , iInc    , False, 75.0 ,  90.), # Physically down to 0.0, but 80.0 is already an 'extreme' value\n",
    "    ('aprs'   , iApRs   , False,  0.0 , 100.), # 100.0 is considered \"very large\" for transiting exoplanets; but could go up to np.inf\n",
    "    ('edepth' , iEdepth , True,  iEdepth_min , 0.005 ), # 1.0   is considered \"very large\" for transiting exoplanets -- could go down to 0.1\n",
    "    ('tdepth' , iTdepth , False,  0.0 , 0.01 ), # 1.0   is considered \"very large\" for transiting exoplanets -- could go down to 0.25 \n",
    "    ('ecc'    , iEcc    , False,  0.1 , 0.5 ), # 1.0   is considered \"very large\" for transiting exoplanets -- could go down to 0.5\n",
    "    ('omega'  , iOmega  , False,  345 , 347), # Could be any number around a circle; but prescribing to \"near RV results\" is probably best\n",
    "    ('u1'     , u1      , False,  0.0 , 1.0 ), # could go up to 1; but physically, u1 + u2 < 1.0; so u1 and u2 cannot both be 1.0\n",
    "    ('u2'     , u2      , False,  0.0 , 1.0 ), # could go up to 1; but physically, u1 + u2 < 1.0; so u1 and u2 cannot both be 1.0\n",
    "\n",
    "    # Out of transit linear baselines\n",
    "    ('intcpt' , 1.0 , True, 0.95, 1.05 ),  # If the 'linear model' is centered around the median(time), then 1.0 should be a useful initial condition\n",
    "    ('slope'  , 0.0 , True, -0.009, 0.015),   # If the 'linear model' is centered around the median(time), then 0.0 should be a useful initial condition\n",
    "    ('crvtur' , -0.03 , True, -0.08, 0.00))  # If the 'linear model' is centered around the median(time), then 0.0 should be a useful initial condition\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For each of the observations, read in the features, do some feature engineering in the same way as was done to generate the model, then use the model to predict fluxes, and correct the data with those fluxes.  Lastly, make a plot with raw and corrected fluxes for visual comparison\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/sklearn/base.py:251: UserWarning: Trying to unpickle estimator RandomizedSearchCV from version 0.20rc1 when using version 0.20.1. This might lead to breaking code or invalid results. Use at your own risk.\n",
      "  UserWarning)\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur    -0.0102    -0.08        0 0.004298     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth   0.001607   0.0011    0.005 9.103e-05     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt     0.9991     0.95     1.05 5.338e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    0.0008103   -0.009    0.015 0.0002892     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1607ppm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur   -0.01476    -0.08        0 0.004521     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth   0.001447   0.0011    0.005 9.389e-05     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt     0.9991     0.95     1.05 5.308e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    0.001441   -0.009    0.015 0.0002958     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1447ppm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur   -0.002828    -0.08        0 0.004431     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth     0.0011   0.0011    0.005  0.00339     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt     0.9992     0.95     1.05 5.381e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    0.004737   -0.009    0.015 0.0002932     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1100ppm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur   -8.52e-06    -0.08        0 0.004428     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth   0.001323   0.0011    0.005 9.227e-05     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt      0.999     0.95     1.05 5.245e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    0.0004175   -0.009    0.015 0.0002906     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1323ppm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur   -0.00945    -0.08        0 0.004493     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth    0.00161   0.0011    0.005 9.337e-05     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt      0.999     0.95     1.05 5.166e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    0.002253   -0.009    0.015 0.0002843     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1610ppm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur   -5.354e-09    -0.08        0 0.0002802     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth   0.001418   0.0011    0.005 9.43e-05     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt      0.999     0.95     1.05 5.239e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    -0.0003896   -0.009    0.015  0.00029     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1418ppm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur   -1.181e-05    -0.08        0 0.004211     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth     0.0011   0.0011    0.005 0.0001583     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt     0.9992     0.95     1.05 5.158e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    0.001217   -0.009    0.015 0.0002838     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1100ppm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur   -0.002256    -0.08        0 0.004335     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth     0.0015   0.0011    0.005 9.148e-05     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt      0.999     0.95     1.05 5.308e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    0.002919   -0.009    0.015 0.0002914     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1500ppm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur   -0.01745    -0.08        0 0.004605     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth   0.001764   0.0011    0.005 9.416e-05     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt      0.999     0.95     1.05 5.163e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    -0.0009145   -0.009    0.015 0.0002827     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1764ppm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n",
      "/Users/jkrick/anaconda/lib/python3.5/site-packages/scipy/stats/_binned_statistic.py:607: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  result = result[core]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name        Value      Min      Max   Stderr     Vary     Expr Brute_Step\n",
      "aprs        4.946        0      100        0    False     None     None\n",
      "crvtur   -0.009482    -0.08        0 0.004325     True     None     None\n",
      "ecc        0.2884      0.1      0.5        0    False     None     None\n",
      "edepth   0.001613   0.0011    0.005 9.138e-05     True     None     None\n",
      "inc         79.32       75       90        0    False     None     None\n",
      "intcpt      0.999     0.95     1.05 5.359e-05     True     None     None\n",
      "omega         346      345      347        0    False     None     None\n",
      "period      3.192     -inf      inf        0    False     None     None\n",
      "slope    0.001407   -0.009    0.015 0.0002989     True     None     None\n",
      "tCenter  2.454e+06 2.454e+06 2.454e+06        0    False     None     None\n",
      "tdepth   0.008943        0     0.01        0    False     None     None\n",
      "u1              0        0        1        0    False     None     None\n",
      "u2              0        0        1        0    False     None     None\n",
      "depth name 1613ppm\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-ca176ea19a96>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    176\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    177\u001b[0m \u001b[0;31m#save\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 178\u001b[0;31m \u001b[0msavename\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdirname\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'XO3_summary_'\u001b[0m  \u001b[0;34m+\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m+\u001b[0m \u001b[0;34m'.png'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    179\u001b[0m \u001b[0;31m#plt.savefig(savename)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    180\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x1440 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#load the previously trained model\n",
    "xgbr = joblib.load(model_name)\n",
    "\n",
    "\n",
    "\n",
    "#Make one big master plot with all 10 light curves on it\n",
    "figfull, axfull = plt.subplots( nrows = 10, ncols = 2, sharex = True,  sharey = True, \n",
    "                               figsize = (10,20))\n",
    "\n",
    "\n",
    "for counter in range(0,n_aor): #for each observation\n",
    "    #load data\n",
    "    csv_name = dirname + 'XO3_' + aorname[counter] + '.csv'\n",
    "    XO3 = pd.read_csv(csv_name)\n",
    "\n",
    "    #remove any row which has a nan anywhere\n",
    "    XO3.dropna(inplace = True)\n",
    "\n",
    " \n",
    "    #adjust the pixel values to be normalized by the mean of the sum of all pixel values\n",
    "    XO3['pixsum'] = XO3['pix1'] + XO3['pix2'] + XO3['pix3'] + XO3['pix4'] + XO3['pix5'] + XO3['pix6']+XO3['pix7'] + XO3['pix8']+ XO3['pix9']\n",
    "    medflux_XO3 = statistics.median(XO3['pixsum'])\n",
    "    meanflux_XO3 = statistics.mean(XO3['pixsum'])\n",
    "\n",
    "    XO3['pix1']/= XO3['pixsum']#meanflux_XO3#\n",
    "    XO3['pix2']/= XO3['pixsum']#meanflux_XO3#\n",
    "    XO3['pix3']/= XO3['pixsum']#meanflux_XO3#\n",
    "    XO3['pix4']/= XO3['pixsum']#meanflux_XO3#\n",
    "    XO3['pix5']/= XO3['pixsum']#meanflux_XO3#\n",
    "    XO3['pix6']/= XO3['pixsum']#meanflux_XO3#\n",
    "    XO3['pix7']/= XO3['pixsum']#meanflux_XO3#\n",
    "    XO3['pix8']/= XO3['pixsum']#meanflux_XO3#\n",
    "    XO3['pix9']/= XO3['pixsum']#meanflux_XO3#\n",
    "\n",
    "\n",
    "    #normalize bg_flux in some way as well.\n",
    "    meanbgflux_XO3 = statistics.mean(XO3['bg_flux'])\n",
    "    XO3['bg_flux'] /= meanbgflux_XO3\n",
    "\n",
    "\n",
    "    #also need to do the background errors and flux error\n",
    "    meanfluxerr=statistics.mean(XO3['fluxerr'])\n",
    "    meansigmabgflux = statistics.mean(XO3['sigma_bg_flux'])\n",
    "    XO3['fluxerr']/= meanfluxerr\n",
    "    XO3['sigma_bg_flux'] /= meansigmabgflux\n",
    "\n",
    "\n",
    "    #choose feature set \n",
    "    #16 feature feature set\n",
    "    #X_data = XO3[['xpos','ypos',  'fluxerr','xfwhm','yfwhm','bg_flux', 'sigma_bg_flux','pix1','pix2', 'pix3','pix4','pix5','pix6','pix7','pix8','pix9']]\n",
    "\n",
    "    #PLD emulator - 9 feature set\n",
    "    X_data = XO3[['pix1','pix2', 'pix3','pix4','pix5','pix6','pix7','pix8','pix9']]\n",
    "\n",
    "    y_data = XO3['flux']\n",
    " \n",
    "    #normalize y\n",
    "    #my = statistics.median(y_data)\n",
    "    #y_data = y_data / my\n",
    "\n",
    "    time_bmjd = XO3['bmjd']\n",
    "    time_0 = time_bmjd - time_bmjd[0]\n",
    "    time_jd = time_bmjd + 2400000.5\n",
    "\n",
    "    #use the trained xgboost model to correct the data (predict fluxes)\n",
    "    y_data_predict = xgbr.predict(X_data)\n",
    "\n",
    "    #predicted values are actually predicted gain so need to multiply those \n",
    "    #by the y_data to get y_predict\n",
    "    y_data_predict = y_data / y_data_predict\n",
    "\n",
    "    #do sigma clipping on flux\n",
    "    filtered_data = sigma_clip(y_data_predict, sigma=3.0) \n",
    "    y_data_filtered = y_data_predict[~filtered_data.mask]\n",
    "    time_jd_filtered = time_jd[~filtered_data.mask]\n",
    "\n",
    "    #binning to get ready for plotting\n",
    "    raw_means, raw_edges, raw_number = stats.binned_statistic(time_jd, y_data, statistic = 'mean', \n",
    "                                                            bins = (len(time_jd) / 63))\n",
    "\n",
    "    #figure out what the center of the bins in time is:\n",
    "    raw_time_bins = (raw_edges[:-1]+raw_edges[1:])/2\n",
    "    \n",
    "    #stddev in the bin\n",
    "    raw_s_bins,raw_s_edges, raw_misc = stats.binned_statistic(time_jd_filtered,y_data_filtered,\n",
    "                                                            statistic=np.std, bins=(len(time_jd) / 63))\n",
    "\n",
    "\n",
    "    #need to bin both fluxes and time\n",
    "    corr_means, corr_edges, corr_number = stats.binned_statistic(time_jd_filtered, y_data_filtered, \n",
    "                                                            statistic = 'mean', bins = (len(time_jd) / 63))\n",
    "\n",
    "    #figure out what the center of the bins in time is:\n",
    "    corr_time_bins = (corr_edges[:-1]+corr_edges[1:])/2\n",
    "\n",
    "    #stddev in the bin\n",
    "    corr_s_bins,corr_s_edges, corr_misc = stats.binned_statistic(time_jd_filtered,y_data_filtered,\n",
    "                                                            statistic=np.std, bins=(len(time_jd) / 63))\n",
    "\n",
    "    #normalize\n",
    "    med_corr = statistics.median(corr_means)\n",
    "    med_raw = statistics.median(raw_means)\n",
    "\n",
    "    #run LM fitting\n",
    "    partial_residuals = partial(residuals_func, data = y_data_filtered.values/median(y_data_filtered), \n",
    "                                data_err = sqrt(y_data_filtered.values / median(y_data_filtered)), times = time_jd_filtered.values)\n",
    "\n",
    "    mean_time = mean(time_jd_filtered)\n",
    "\n",
    "    mini = Minimizer(partial_residuals, init_params_lmfit)\n",
    "\n",
    "    fitResults_lmfit = mini.leastsq()\n",
    "    \n",
    "    fitResults_lmfit.params.pretty_print()\n",
    "    fitResults_lmfit.message\n",
    "    \n",
    "    #overplotting the results on the data\n",
    "    #convert lmfit params to batman params\n",
    "    lm_paramsdict = fitResults_lmfit.params.valuesdict()\n",
    "    bm_lmfit_params           = TransitParams()\n",
    "\n",
    "    bm_lmfit_params.a         = lm_paramsdict['aprs']\n",
    "    bm_lmfit_params.ecc       = lm_paramsdict['ecc']\n",
    "    bm_lmfit_params.inc       = lm_paramsdict['inc']\n",
    "    bm_lmfit_params.limb_dark = 'uniform'\n",
    "    bm_lmfit_params.per       = lm_paramsdict['period']\n",
    "    bm_lmfit_params.t0        = lm_paramsdict['tCenter']\n",
    "    bm_lmfit_params.rp        = sqrt(lm_paramsdict['edepth'])\n",
    "    bm_lmfit_params.w         = lm_paramsdict['omega']\n",
    "    bm_lmfit_params.u       = []  #right now using uniform limb darkening\n",
    "    bm_lmfit_params.fp        =lm_paramsdict['edepth']\n",
    "\n",
    "    #make the batman model with the fitted parameters\n",
    "    lm_model_flux = batman_lmfit_model(lm_paramsdict['period'], lm_paramsdict['tCenter'], \n",
    "                                lm_paramsdict['inc'], lm_paramsdict['aprs'], \n",
    "                                lm_paramsdict['edepth'], lm_paramsdict['tdepth'],\n",
    "                                lm_paramsdict['ecc'], lm_paramsdict['omega'], \n",
    "                                time_jd_filtered.values, ldtype='uniform')\n",
    "    line_model  = lm_paramsdict['intcpt']\n",
    "    if lm_paramsdict['slope'] != 0:\n",
    "        line_model += lm_paramsdict['slope']*(time_jd_filtered.values - time_jd_filtered.values.mean())\n",
    "    if lm_paramsdict['crvtur'] != 0:\n",
    "        line_model += lm_paramsdict['crvtur']*(time_jd_filtered.values - time_jd_filtered.values.mean())**2\n",
    "    \n",
    "    model_total = lm_model_flux*line_model\n",
    "\n",
    "\n",
    "\n",
    "    #plot the models\n",
    "    d = max(lm_model_flux) - min(lm_model_flux)\n",
    "    d = lm_paramsdict['edepth']*1E6\n",
    "    depth =  \"{0:.0f}\".format(d) \n",
    "    depth_name = depth + 'ppm'\n",
    "    print('depth name', depth_name)\n",
    "\n",
    "    #Fill the big figure\n",
    "    axfull[counter,0].scatter(raw_time_bins - raw_time_bins[-1], raw_means/med_raw, color = 'red', s = 8, label = aorname[counter] )\n",
    "    axfull[counter,1].scatter(corr_time_bins - corr_time_bins[-1], corr_means/med_corr, color = 'black', s = 8)\n",
    "    axfull[counter,1].plot(time_jd_filtered - time_jd_filtered.iloc[-1], model_total, color = 'blue', label = depth_name) #lm_paramsdict['edepth']\n",
    "    axfull[counter,0].legend(fontsize='large')\n",
    "    axfull[counter,1].legend(fontsize='large')\n",
    "\n",
    "    #and make it look good\n",
    "    axfull[counter, 0].set_ylim((0.996,1.006))\n",
    "    axfull[counter, 1].set_ylim((0.996,1.006))\n",
    "    figfull.subplots_adjust(hspace=0.00)\n",
    "    axfull[counter, 0].axis(\"off\")\n",
    "    axfull[counter, 1].axis(\"off\")\n",
    "\n",
    "    #store eclipse depth for summary plot later\n",
    "    e_depth[counter] = d\n",
    "    deptherr[counter] = fitResults_lmfit.params['edepth'].stderr *1E6\n",
    "\n",
    "        \n",
    "plt.tight_layout()\n",
    "\n",
    "#save\n",
    "savename = dirname + 'XO3_summary_'  + model[0:-8]+ '.png'\n",
    "#plt.savefig(savename)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XGBoost mean and std 1448.146038221669 209.81570198888275\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the eclipse depths as a function of AOR\n",
    "fig, ax = plt.subplots(nrows = 1, ncols = 1,figsize = (10,6))\n",
    "ax.set_title(\"XO3 ch2\")\n",
    "     \n",
    "#compare to the literature\n",
    "BLISS = [1850.00, 1670.00, 1570.00, 1410.00, 1520.00, 1390.00, 1480.00, 1570.00, 1500.00, 1520.00 ,1543]\n",
    "GP  =[1763.00, 1652.00, 1570.00, 1336.00, 1497.00 ,1522.00, 1441.00, 1217.00, 1415.00, 1459.00 ,1513]\n",
    "ICA  =[1720.00, 1540.00, 1560.00, 1520.00, 1560.00, 1640.00, 1570.00, 1520.00, 1500.00, 1480.00 ,1560]\n",
    "KR_Data  =[1732.00, 1653.00, 1561.00, 1467.00, 1614.00, 1587.00, 1533.00, 1578.00, 1565.00, 1468.00,1570 ]\n",
    "KR_Pmap  =[1460.00, 1572.00, 1420.40, 1470.00, 1514.00, 1483.00, 1402.00, 1455.00, 1459.00, 1260.00,1460 ]\n",
    "PLD  =[1729.00, 1608.00, 1574.00, 1500.00, 1547.00, 1723.00, 1339.00, 1592.00, 1588.00, 1525.00 ,1573]\n",
    "SP_K2  =[1653.70, 1214.60, 1578.80, 1370.90, 1363.30, 1377.80, 1287.70, 1525.50, 1522.30, 1382.20,1421 ]\n",
    "\n",
    "BLISS_unc = [   90.00,   90.00,   90.00,   80.00,   90.00 ,  90.00 ,  80.00,   90.00 ,  80.00,   80.00 ,85]\n",
    "GP_unc_neg = [  169.00,   92.00,  143.00,  133.00 ,  98.00,  181.00 , 169.00,  279.00 , 142.00 ,  86.00 ,152]\n",
    "GP_unc_pos = [  164.00,   93.00,  143.00,  133.00,  101.00 , 178.00 , 174.00 , 293.00 , 146.00 ,  88.00,152 ]\n",
    "ICA_unc = [  110.00,  100.00,  100.00,  100.00,  130.00 , 110.00,  120.00 , 100.00 , 120.00,  120.00 ,111]\n",
    "KR_Data_unc_neg = [ 84.00,   83.00,   84.00,   80.00,   91.00,  120.00 ,  83.00 ,  61.00 ,  81.00 ,  82.00,94 ]\n",
    "KR_Data_unc_pos = [  85.00,   84.00,   85.00,   80.00,  111.00,   88.00 ,  80.00,  130.00 ,  81.00 ,  80.00,94 ]\n",
    "KR_Pmap_unc = [  110.00,  121.70,  120.90,  109.00 , 108.00,  102.00 , 120.40 , 104.00,  132.00,  149.00 ,117]\n",
    "PLD_unc = [  123.00,   91.00,   87.00,  102.00 , 121.00,  111.00,  121.00 , 111.00,  111.00,  100.00 ,107]\n",
    "SP_K2_unc = [   52.22,   45.43,   50.38,   47.38 ,  48.37,   48.32,   47.78,   49.34 ,  49.42 ,  49.76,48 ]\n",
    "\n",
    "\n",
    "ax.errorbar(np.arange(len(BLISS)) + 0.2, BLISS, yerr = BLISS_unc, fmt = 'o',  markersize = 10, color=\"black\", marker = '>')\n",
    "ax.errorbar(np.arange(len(BLISS))+0.1, GP, yerr = [GP_unc_neg, GP_unc_pos], fmt='o', markersize='10', color=\"black\")\n",
    "ax.errorbar(np.arange(len(BLISS)), ICA, yerr = ICA_unc, fmt='o', markersize='10', color=\"black\", marker = 'v')\n",
    "ax.errorbar(np.arange(len(BLISS))-.1, KR_Data, yerr = [KR_Data_unc_neg,KR_Data_unc_pos] , fmt='o', markersize='10', color=\"black\", marker = '<')\n",
    "ax.errorbar(np.arange(len(BLISS))-0.2, KR_Pmap, yerr = KR_Pmap_unc, fmt='o', markersize='10', color=\"black\", marker = '^')\n",
    "ax.errorbar(np.arange(len(BLISS))+0.05, PLD, yerr = PLD_unc, fmt='o', markersize='10', color=\"black\", marker = 's')\n",
    "ax.errorbar(np.arange(len(BLISS))-0.05, SP_K2, yerr = SP_K2_unc, fmt='o', markersize='10', color=\"black\", marker = '*')\n",
    "\n",
    "#xgboost results\n",
    "ax.errorbar(range(len(BLISS)), np.append(e_depth, e_depth.mean()), \n",
    "            yerr = np.append(deptherr, e_depth.std()), fmt='o', \n",
    "            markersize='10', color=\"blue\", label = 'xgboost_mse')\n",
    "\n",
    "\n",
    "\n",
    "ax.set_xticks(range(len(BLISS)))\n",
    "ax.set_xticklabels(np.append(aorname,'average'), fontsize = 15, rotation=55)\n",
    "\n",
    "\n",
    "#add average of all other methods\n",
    "average = np.zeros(len(BLISS)) + 1520.\n",
    "ax.plot(range(len(BLISS)), average, color = 'black')\n",
    "print('XGBoost mean and std', e_depth.mean(), e_depth.std())\n",
    "\n",
    "\n",
    "ax.set_ylabel('Eclipse Depth in PPM', fontsize = 'large')\n",
    "ax.set_ylim(1000, 2100)\n",
    "\n",
    "plt.tight_layout()\n",
    "#save\n",
    "savename = dirname + 'XO3_ML_xgboost.png'\n",
    "#plt.savefig(savename, edgecolor = 'white')\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}