{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reading and using the SLSTR MDB files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By design, the content of SLSTR matchups is very rich and it can be overwhelming. This primer is intended for support you in this (relatively) steep initial learning curve.\n",
    "\n",
    "We will start exploring and understand the content of MDB files with simple netCDF4 and numpy functions which have to be installed in your environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## basics\n",
    "\n",
    "Let's first open a sample file, containing match-ups with CMEMS drifters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import netCDF4 as netcdf\n",
    "\n",
    "# open file\n",
    "mdbfile = netcdf.Dataset('/home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013000000_20161013060000.nc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The file contains a lot of variables! The following examples will help you to understand and analyse the content of the match-up files. Further in this tutorial, more advanced function usage from ``s3mdbpackage`` are provided."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main file dimension is ``time`` : it gives the number of match-ups. Let's get the number of match-ups from our example file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "488\n"
     ]
    }
   ],
   "source": [
    "print len(mdbfile.dimensions['time'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The time, lat and lon variables gives the locations and times of all our match-ups. They correspond to the locations and times of the closest in situ measurement to satellite pixels. These arrays have as many values as the number of match-ups:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "488\n"
     ]
    }
   ],
   "source": [
    "# get latitudes of match-ups\n",
    "lat = mdbfile.variables['lat'][:]\n",
    "\n",
    "# print number of lat values\n",
    "print len(lat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32.207\n"
     ]
    }
   ],
   "source": [
    "# this is the latitude of matchup #3 in the file:\n",
    "print lat[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## understanding the in situ section of the matchups\n",
    "\n",
    "The variables with in situ measurements will be prefixed with ``cmems_drifter__``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cmems_drifter__origin\n",
      "cmems_drifter__dynamic_target_center_index\n",
      "cmems_drifter__lon\n",
      "cmems_drifter__quality_level_4\n",
      "cmems_drifter__rejection_flag_4\n",
      "cmems_drifter__quality_level_1\n",
      "cmems_drifter__rejection_flag_3\n",
      "cmems_drifter__quality_level_3\n",
      "cmems_drifter__quality_level_2\n",
      "cmems_drifter__meas_depth_4\n",
      "cmems_drifter__rejection_flag_2\n",
      "cmems_drifter__time\n",
      "cmems_drifter__meas_depth_0\n",
      "cmems_drifter__meas_depth_1\n",
      "cmems_drifter__meas_depth_2\n",
      "cmems_drifter__meas_depth_3\n",
      "cmems_drifter__rejection_flag_0\n",
      "cmems_drifter__rejection_flag_1\n",
      "cmems_drifter__lat\n",
      "cmems_drifter__water_temperature_3\n",
      "cmems_drifter__water_temperature_2\n",
      "cmems_drifter__water_temperature_1\n",
      "cmems_drifter__water_temperature_0\n",
      "cmems_drifter__water_temperature_4\n",
      "cmems_drifter__quality_level_0\n",
      "cmems_drifter__climatology_water_temperature\n",
      "cmems_drifter__solar_zenith_angle\n"
     ]
    }
   ],
   "source": [
    "for var in mdbfile.variables:\n",
    "    if 'cmems_drifter__' in var:\n",
    "        print var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most in situ variables have two dimensions: ``time`` and ``cmems_drifter___time``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(u'time', u'cmems_drifter___time')\n"
     ]
    }
   ],
   "source": [
    "print mdbfile['cmems_drifter__water_temperature_0'].dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the reason for the the extra dimension ``cmems_drifter___time`` is that we provide the history of the buoy for each match-up in a time window of +/- 6 hours around the match-up time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1129148880 1129151580 1129151940 1129152120 1129154760 1129157460\n",
      " 1129158180 1129160280 1129160580 1129162680 1129163160 1129165920\n",
      " 1129166220 1129168560 1129171980 1129181640 1129187700 1129189380 -- -- --\n",
      " -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n",
      " -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n",
      " -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n",
      " -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n",
      " -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --]\n"
     ]
    }
   ],
   "source": [
    "# get the buoy temperature history of our match-up #3\n",
    "temp = mdbfile['cmems_drifter__water_temperature_0'][3, :]\n",
    "\n",
    "# get the corresponding time of each temperature measurement\n",
    "times = mdbfile['cmems_drifter__time'][3, :]\n",
    "\n",
    "\n",
    "# because all buoys don't have the same sampling rate, the number of measurements in the buoy history\n",
    "# vary from one match-up to another. Therefore, the end of the history array is often trailed with\n",
    "# fill values.\n",
    "print times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmMAAAEyCAYAAAC28teyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzt3Xl4VOX5//H3nY0sQMISloQlQXZlDwqERUGtO1atdUMKWpe6Uayt2n777bftz1qquNRWpSxaRK1FxFoVt1pkEwyLLAZUIEDY952EJM/vjznYFCdkQpYzk3xe15WLyTnnOXOf57L0wznP3GPOOURERETEH1F+FyAiIiJSlymMiYiIiPhIYUxERETERwpjIiIiIj5SGBMRERHxkcKYiIiIiI8UxkRERER8pDAmIiIi4iOFMREREREfxfhdQEU0bdrUZWRk+F2GiIiISLkWL168yzmXWt5xERXGMjIyyMnJ8bsMERERkXKZ2YZQjtNjShEREREfKYyJiIiI+EhhTERERMRHCmMiIiIiPlIYExEREfGRwpiIiIiIjxTGRERERHykMCYiIiLiI4UxERERER9FVAf+6rZ62wGWbtzndxnlyj6jKW2aJPpdhu8Wb9hLZtMkGifF+V2KiIjIaVMYK2Xe17v5zT+/8LuMcvVqk8IbP8r2uwxfbdpzhGufX8CtgzJ56OIufpcjIiJy2hTGSrmub2su7dbS7zJOacbSfMbNWsOyTfvo2TrF73J888L8PIpLHJv2HPG7FBERkUpRGCslqV4MSfXCe0pG9GvLnz9ey5R563nqul5+l+OLg8eO87fPNgGwee9Rn6sRERGpHC3gjzAN4mO5Nqs1by/fyvYDx/wuxxd/+2wThwqKOCu9IZv31c05EBGR2kNhLAL9YEAGxc4xdcEGv0upcUXFJUyZl8fZmY25sGsLdh0q4NjxYr/LEhEROW0KYxGoTZNEhnVuzsuLNta5IPLequ1s3neUWwdmkp6SAMDW/bo7JiIikUthLEKNHpjBnsOF/GPZFr9LqVET564jo0kiw7o0J80LY1v2ad2YiIhELoWxCNW/XRM6t2jA5Hnrcc75XU6NWLxhL0s37mNUdibRUfbNnbHNCmMiIhLBFMYilJkxKjuD1dsOsmDdbr/LqRGT5q6jYXwM1/RpBUCL5HjM9IlKERGJbApjEWx4z3QaJ8UxZV6e36VUu017jjBr5TZuOKftN+1H4mKiaNagnh5TiohIRFMYi2DxsdHccHYbPszdzobdh/0up1q9MD+PKDNGDmj7X9vTUhL0mFJERCKawliEG9G/LdFmvDi/9ra5OOA1eb2se0taJif81770lATdGRMRkYimMBbhmjeM59LuLXktZxMHjx33u5xq8ZrX5PWWge2+tS89JYEt+49RUlI3PsQgIiK1j8JYLTAqO5NDBUVMX5zvdylV7kST13MyG9OtVfK39qc3SqCwqIRdhwt8qE5ERKTyFMZqgZ6tU+jdJoUX5ufVujtEs1ZtCzR5HfTtu2IAackneo2p8auIiEQmhbFaYlR2Jht2H+Ffq3f4XUqVcc7xlznrA01eOzcLeowav4qISKQrN4yZWWsz+9jMcs1slZndV2rfPWa2xts+rozxKWY23cxWe+fo723vaWafmtkyM8sxs7Or7rLqnovOakGLhvFMmb/e71KqzJKNe/l80z5GD8wkKsqCHpPeyGv8ql5jIiISoWJCOKYIuN85t8TMGgCLzewDoDkwHOjunCsws+C3LuApYJZz7hoziwMSve3jgP9zzr1rZpd4v59bmYupy2Kjo7h5QFvGzVrDmm0H6dSigd8lVdrEOetJToj9pslrMA3jY6hfL0btLUREJGKVe2fMObfVObfEe30QyAXSgTuBR51zBd6+bz0fM7OGwGBgkndMoXNu34lTAw2918lA3fqSxWpwfd82xMdGMWVe5N8d27TnCO+t2sYN57QhMa7sfzOYGWkp8XpMKSIiEatCa8bMLAPoBSwEOgKDzGyhmc02s75BhrQDdgJTzGypmU00syRv3xjgD2a2CXgMeKiM97zNe4yZs3PnzoqUW+c0Sorju73SeWPpZvYcLvS7nEqZMs9r8to/o9xj09X4VUREIljIYczM6gOvA2OccwcIPOJsBPQDHgBeM7OTF/bEAL2BZ51zvYDDwIPevjuBHzvnWgM/xrt7djLn3ATnXJZzLis1NTX0K6ujRmVnUlBUwiuLNvpdymkLNHndyOU90miRHF/u8Wlq/CoiIhEspDBmZrEEgtg059wMb3M+MMMFLAJKgKYnDc0H8p1zC73fpxMIZwAjgRPn+jugBfxVoGPzBgxs35SpCzZwvLjE73JOy98WbeJwYTG3DMwM6fj0RgnsPXKcI4VF1VyZiIhI1Qvl05RG4K5VrnNufKldM4Gh3jEdgThgV+mxzrltwCYz6+RtGgZ84b3eAgzxXg8FvjrNa5CTjMrOYNuBY7y7cpvfpVRYoMnres7JbMxZ6d9u8hpMutpbiIhIBAvlzlg2MAIY6rWhWOZ9+nEy0M7MVgKvAiOdc87M0szsnVLj7wGmmdlyoCfwiLf9h8DjZva5t+22KrqmOu+8Ts3IaJIYkQv53125jS37j5XZ5DWYE73GNqvxq4iIRKByW1s45+YCwZs8wU1Bjt8CXFLq92VAVhnn7RNypRKyqCjjBwMy+NVbX7B04156tWnkd0khcc4xcc66UzZ5DebEnTH1GhMRkUikDvy11DVZrWlQL4Yp8/L8LiVkizfs5fP8/dxyiiavwTRrUI/oKNNjShERiUgKY7VU/XoxXNu3Ne+s2Mq2/ZHx+G7S3ECT16tP0eQ1mJjoKFo0VK8xERGJTApjtdjI/hkUO8fUT/P8LqVcG3cHmrzeWE6T17KkpySQrzAmIiIRSGGsFmvTJJHzuzTn5YUbOXa82O9yTmnK/PVERxkjB2Sc1nh14RcRkUilMFbLjc7OZO+R47y5bLPfpZRp/9HjvPbZJi7rnkbzhuU3eQ0mvVEC2/Yfo7jEVXF1IiIi1UthrJbr164xnVs0YPLcPJwLz6Dyt882VqjJazBpKQkUlTh2HIyM9XEiIiInKIzVcmbG6OxM1mw/yIK1u/0u51uOF5fwwrw8+rULvclrMGlq/CoiIhFKYawOuKJnGo2T4pgchm0uvmnyOjD0Jq/BtPLCWL56jYmISIRRGKsD4mOjufGcNny0ejsbdh/2u5xvOOeYNGcdmU2TGFqBJq/BtPzmzpgeU4qISGRRGKsjburXlmgzXpif53cp3zjR5HV0BZu8BlO/XgzJCbF6TCkiIhFHYayOaN4wnsu6t+TvOfkcPHbc73IAmDhnPSmJsVzdO71KzpeeksBmhTEREYkwCmN1yKjsTA4VFPH3nHy/S2HD7sO898XpN3kNJi0lQXfGREQk4iiM1SE9WqfQu00KLy7I870f15R5ecREGTf3z6iyc7ZqlKAvCxcRkYijMFbHjB6YyYbdR/h49Q7fath/9Div5Wzi8ko0eQ0mLSWegwVFHAiTx7AiIiKhUBirY75zZgtaJsczed5632p4ddFGjhQWM7oSTV6DUa8xERGJRApjdUxsdBQj+rdl/trdrN52oMbf/3hxCS/Mz6N/uyaVavIaTLoXxvSoUkREIonCWB10fd82xMdG8YIPTWDfWbGVrfuPceugqr0rBv8JY7ozJiIikURhrA5qlBTHd3u14o2lm9lzuLDG3tc5x6S562nXNInzOlWuyWswTevXIy46is1q/CoiIhFEYayOGpWdQUFRCa8s2lhj75mzYS/Lq6jJazBRUUbLlHj1GhMRkYiiMFZHdWzegEEdmvLXBXkcLy6pkfecOGed1+S1VbW9R1qyeo2JiEhkURirw0ZlZ7D9QAHvrNha7e+1Yfdh3v9iOzee04aEuOhqe5909RoTEZEIozBWh53bsRmZTZOYUgML+aujyWswaSkJbD94rMbu9omIiFSWwlgdFhVl/GBABss27WPJxr3V9j77j3hNXntUbZPXYNJT4nEOtu3XIn4REYkMCmN13NV9WtGgXky13h175bNAk9dbqrjJazDpKYkAWsQvIiIRQ2GsjqtfL4bv923Nuyu2VsvdpOPFJbwwL48BZzThzLSqbfIaTFpK4M6bFvGLiEikUBgTRg7IoMQ5pn6aV+XnfmfFVrYdqJ4mr8HoK5FERCTSKIwJrRsncn6X5ry8cCPHjhdX2Xm/afKamsS5Hau+yWsw8bHRNK0fp8eUIiISMRTGBIDRAzPZe+Q4M5durrJzfpbnNXnNrp4mr2VJS0lQF34REYkYCmMCwDmZjenSsiFT5uXhnKuSc9ZEk9dg0lPU+FVERCJHuWHMzFqb2cdmlmtmq8zsvlL77jGzNd72cWWMTzGz6Wa22jtH/4qMl5phZozKzmDN9oPMX7u70ufL23WYD3K3c9M5bau1yWswaSmBxq9VFSpFRESqU0wIxxQB9zvnlphZA2CxmX0ANAeGA92dcwVmVtaioKeAWc65a8wsDkgEMLPzQhwvNeSKHmn8/t3VTJm3nuz2TSt1rinz1ntNXttWUXWhS0tJ4OjxYvYdOU6jpLgaf38REZGKKPfOmHNuq3Nuiff6IJALpAN3Ao865wq8fTtOHmtmDYHBwCTvmELn3D5vd7njpWbFx0Zz4zlt+Gj1DvJ2HT7t8wSavOZzRY90mlVzk9dg0r1PVGoRv4iIRIIKrRkzswygF7AQ6AgMMrOFZjbbzPoGGdIO2AlMMbOlZjbRzJK8faGMx8xuM7McM8vZuXNnRcqV03BTv7bERBkvzM877XO88tlGjh6vmSavwSiMiYhIJAk5jJlZfeB1YIxz7gCBR5yNgH7AA8BrZnbyR+ZigN7As865XsBh4MFS+8obj3NugnMuyzmXlZqaWqGLk4pr1jCey7qnMX1xPgePHa/w+BNNXrPbN6FrWsNqqLB8avwqIiKRJKQwZmaxBILYNOfcDG9zPjDDBSwCSoCTFxrlA/nOuYXe79MJhLNQx4sPRmVncKigiNdy8is89kSTV7/uigE0ToojPjaKzXsVxkREJPyF8mlKI7DmK9c5N77UrpnAUO+YjkAcsKv0WOfcNmCTmXXyNg0Dvgh1vPije6sU+rRtxIvz8yguCf0Tic45/jJnXY02eQ3GzEhLSWDLfoUxEREJf6HcGcsGRgBDzWyZ93MJMBloZ2YrgVeBkc45Z2ZpZvZOqfH3ANPMbDnQE3jE2x50fBVdl1TS6OxMNu45wr9Wh/65ikXr97By8wFuGVizTV6DSVfjVxERiRDltrZwzs0Fyvp/1puCHL8FuKTU78uArCDHFQYbL+HhO2c2Jy05nslz13NB1+YhjZk4dz2NEmO5qlfNNnkNJj0lgdxcfUBXRETCnzrwS1Ax0VGM6J/BgnW7yd16oNzj1+86zIe527mpX803eQ0mLSWBXYcKqvS7NkVERKqDwpiU6fqzWxMfG8UL8/LKPXbKvPXERkUxwocmr8GcaG+xdb8eVYqISHhTGJMypSTGcVXvVryxbDO7DxWUedz+I8f5e04+V/RMo1mDmm/yGkyaF8bU3kJERMKdwpic0qgBGRQWlfDKoo1lHvPyokCT19HZ/rWzOJkav4qISKRQGJNT6tC8AYM6NGXqpxsoLCr51v7CohJemL/e1yavwbRIjscM9RoTEZGwpzAm5Rqdncn2AwW8u3Lrt/a9s2Ir2w8UcOvAdj5UVra4mCiaNainx5QiIhL2FMakXEM6ptKuaRKTT1rI75xj4tx1nJGaxJCO4fdVVelq/CoiIhFAYUzKFRVl/CA7g8837WPJxr3fbF/4TZPXdr43eQ0mLSVBjylFRCTsKYxJSK7u3YoG8TFMnrv+m20T53hNXnun+1hZ2QJ3xo5RUoGvdBIREalpCmMSkqR6MXw/qzXvrtzG1v1HWb/rMB+t3s6Ifm2Jj/W/yWsw6Y0SKCwqYdfhsttyiIiI+E1hTEI2ckAGzjmmLtjwTZPXm8KkyWswackneo2p8auIiISvcr+bUuSE1o0TuaBrc6Yt3EhhUUlYNXkNpnTj156tU3yuRkREJDiFMamQUdmZvLdqOwC3DAyfJq/BpDcKhLEPvtjO0UJ9R6VEhpho49xOzUhOiPW7FBGpIQpjUiHnZDamZ+sUGifF0aVl+DR5DaZhfAwtk+N5Y+lm3li62e9yRELWtH49/vfyrlzWvSVm4fdJZRGpWuZc5HzSLCsry+Xk5PhdRp137HgxUWbExYT/ksNDBUXsOVTodxkiIdt+8Bi/fusLVmzez7mdUvnN8LNo3TjR77JE5DSY2WLnXFa5xymMiYiEl+ISx4vz83js/TU4Bz++oAOjszOJiQ7/fwCJyH+EGsb0v2wRkTATHWWMHpjJh2OHkN2+KY+8s5rLn5nH55v2+V2aiFQDhTERkTCVlpLAX27uw3M39WbP4QKu/PM8fvWPVRwqKPK7NBGpQgpjIiJhzMy46KyWfDB2CCP6teXFBXmc//hs3lu1ze/SRKSKKIyJiESAhvGx/Hr4Wbx+5wBSEmO5fepibvtrDlv36/tXRSKdwpiISATp3aYRb90zkAcv7swnX+3kgvGf8MK89RTrO1hFIpbCmIhIhImNjuKOIWfw/pgh9G7biF+99QVX/Xkeq7bs97s0ETkNCmMiIhGqTZNEXhzVl6eu68nmfUe54pl5PPJOLkcKtcBfJJIojImIRDAzY3jPdD4cO4Rrs1ox4ZN1XDD+Ez5es8Pv0kQkRApjIiK1QEpiHL+7qjuv3d6fhLhoRk35jLtfXsKOg8f8Lk1EyqEwJiJSi5yd2Zi37x3I2As68v6q7Zz/+GxeXriREi3wFwlbCmMiIrVMvZho7h3WgVljBnFmWjIPv7GCa59fwJfbD/pdmogEoTAmIlJLtUutz8s/PIc/XNOdr3ce4tKn5/DYe2s4drzY79JEpBSFMRGRWszM+F5Waz4aO4TLe6TxzMdfc9GTnzDv611+lyYinnLDmJm1NrOPzSzXzFaZ2X2l9t1jZmu87ePKGJ9iZtPNbLV3jv4n7f+JmTkza1r5yxERkWCa1K/H+Gt7Mu3WcwC4ceJCxr62jN2HCnyuTERiQjimCLjfObfEzBoAi83sA6A5MBzo7pwrMLNmZYx/CpjlnLvGzOKAxBM7zKw1cAGwsVJXISIiIclu35RZYwbzzL++5rnZa/l49Q4evqQL1/RphZn5XZ5InVTunTHn3Fbn3BLv9UEgF0gH7gQedc4VePu+1dTGzBoCg4FJ3jGFzrl9pQ55AvgpoI/5iIjUkPjYaH7ynU68c98g2qXW54Hpy7nhLwtZt/OQ36WJ1EkVWjNmZhlAL2Ah0BEYZGYLzWy2mfUNMqQdsBOYYmZLzWyimSV557oC2Oyc+7yc97zNzHLMLGfnzp0VKVdERE6hY/MG/P32/vy/757Fyi37ueipOTz90VcUFGmBv0hNCjmMmVl94HVgjHPuAIFHnI2AfsADwGv27XvcMUBv4FnnXC/gMPCgmSUCPwd+Wd77OucmOOeynHNZqampoZYrIiIhiIoybjynLR/dP4QLuzZn/AdfcunTc1m0fo/fpYnUGSGFMTOLJRDEpjnnZnib84EZLmARUAKcvAg/H8h3zi30fp9OIJydAWQCn5tZHtAKWGJmLSpzMSIicnqaNYjnmRt6M2VUX44WFnPt8wt48PXl7D9y3O/SRGq9UD5NaQTWfOU658aX2jUTGOod0xGIA/7rs9LOuW3AJjPr5G0aBnzhnFvhnGvmnMtwzmUQCG29veNFRMQn53VqxgdjB3P74Hb8fXE+w8b/mzeXbcY5Le0VqS6h3BnLBkYAQ81smfdzCTAZaGdmK4FXgZHOOWdmaWb2Tqnx9wDTzGw50BN4pIqvQUREqlBiXAwPXdKFf9ydTXpKAve9uoyRUz5j054jfpcmUitZJP1rJysry+Xk5PhdhohInVFc4pi6II8/vLeGYue4b1hHbh2USWy0eoaLlMfMFjvnsso7Tv9rEhGRMkVHGT/IzuTD+4cwuEMqv5+1msv/OJelG/f6XZpIraEwJiIi5WqZnMCEm7N4fkQf9h05zlXPzueXb67k4DEt8BepLIUxEREJ2XfObMEHYwczsn8GUz/dwPnjZzNr5VYt8BepBIUxERGpkAbxsfzqijOZ+aNsGifV446XlvDDvy5my76jfpcmEpEUxkRE5LT0aJ3CW3dn8/AlnZn39S7OHz+bSXPXU1yiu2QiFaEwJiIipy0mOorbBp/B+z8ezNmZjfnNP7/gyj/NY+Xm/X6XJhIxFMZERKTSWjdOZMoP+vLH63uxdf8xrnhmLr/95xccLijyuzSRsKcwJiIiVcLMuLxHGh+NHcJ1Z7dh4tz1XPjEJ/xr9Xa/SxMJawpjIiJSpZITY3nku92Yfkd/EuOiGf1CDndNW8KOA8f8Lk0kLCmMiYhItcjKaMzb9w7iJxd25IPc7Qx7fDZTP91AiRb4i/wXhTEREak2cTFR3D20A++NGUy3Vsn8z8yVXPPcfNZsO+h3aSJhQ2FMRESqXWbTJKbdeg6Pf68H63cd5tKn5zBu1mqOHS/2uzQR3ymMiYhIjTAzru7Tio/uP5cre6Xz53+v5cInPmHOVzv9Lk3EVwpjIiJSoxonxfHY93rw8g/PITrKGDFpEWNeXcquQwV+lybiC4UxERHxxYAzmvLufYO4d2h73l6xlfPHz+a1zzbpey6lzlEYExER38THRjP2wk68c+8gOjSrz09fX851Ez5l7c5DfpcmUmMUxkRExHcdmjfgb7f153dXdSN36wEufnIOT374JQVFWuAvtZ/CmIiIhIWoKOP6s9vw0f3nctFZLXjyw6+4+Kk5fLput9+liVQrhTEREQkrqQ3q8fT1vXhhVF+OF5dw3YRP+en0z9l3pNDv0kSqhcKYiIiEpXM7NeP9MUO4fUg7Xl+ymWGPz2bm0s1a4C+1jsKYiIiErYS4aB66uAtv3T2QVo0TGfO3Zdw8eREbdh/2uzSRKqMwJiIiYa9rWkNm3DmAXw8/k6Ub93HhE5/w539/zfHiEr9LE6k0hTEREYkI0VHGzf0z+HDsEM7r1Ixxs9Zw2dNzWbxhr9+liVSKwpiIiESUFsnxPDeiD3+5OYsDx45zzXPz+cXMFRw4dtzv0kROi8KYiIhEpAu6NueDsUP4wYAMXl64kfMfn807K7Zqgb9EHIUxERGJWPXrxfC/l5/JzLuySW1Qjx9NW8ItL+aQv/eI36WJhExhTEREIl73Vim8eVc2v7i0CwvW7ubCJz5h4px1FGmBv0QAhTEREakVYqKjuHVQOz4YO5h+7Zrw27dzufLP81iRv9/v0kROSWFMRERqlVaNEpk0Mos/3dCb7QcKGP6nufz6rS84XFDkd2kiQZUbxsystZl9bGa5ZrbKzO4rte8eM1vjbR9XxvgUM5tuZqu9c/T3tv/B27bczN4ws5SquywREanLzIxLu7fkw7FDuOGcNkyZv54Lxs/mwy+2+12ayLeEcmesCLjfOdcF6AfcZWZdzew8YDjQ3Tl3JvBYGeOfAmY55zoDPYBcb/sHwFnOue7Al8BDlbgOERGRb0lOiOW3V3Zj+h0DaBAfy61/zeGOqYvZtv+Y36WJfKPcMOac2+qcW+K9PkggTKUDdwKPOucKvH07Th5rZg2BwcAk75hC59w+7/X7zrkT94w/BVpV/nJERES+rU/bRrx1z0Ae+E4nPl6zg/PHz+avC/IoLlEbDPFfhdaMmVkG0AtYCHQEBpnZQjObbWZ9gwxpB+wEppjZUjObaGZJQY4bDbxbxnveZmY5Zpazc+fOipQrIiLyjbiYKO46rz3v/3gwPVun8Ms3V3H1s/PJ3XrA79Kkjgs5jJlZfeB1YIxz7gAQAzQi8OjyAeA1M7OThsUAvYFnnXO9gMPAgyed9+cEHoVOC/a+zrkJzrks51xWampqqOWKiIgE1bZJElNvOZsnv9+TTXuOcPkf5/Lou6s5Wljsd2lSR4UUxswslkAQm+acm+FtzgdmuIBFQAnQ9KSh+UC+c26h9/t0AuHsxHlHApcBNzq1TBYRkRpiZlzZK50Pxw7hqt7pPDd7LRc+OZvZX+oJjNS8UD5NaQTWfOU658aX2jUTGOod0xGIA3aVHuuc2wZsMrNO3qZhwBfemIuAnwFXOOfUKllERGpco6Q4xl3Tg1dv60dsdBQjJy/i3leWsvNggd+lSR1i5d2QMrOBwBxgBYG7XwAPAx8Ck4GeQCHwE+fcv8wsDZjonLvEG98TmEggrK0DRjnn9prZ10A9YLd3zk+dc3ecqpasrCyXk5NT8asUEREpR0FRMX/+eC3P/nstCXHRPHRxZ67Nak1U1MkrcERCY2aLnXNZ5R4XSU8HFcZERKS6fb3jEA+/sYJF6/dwdkZjHrnqLNo3a+B3WRKBQg1j6sAvIiJSSvtm9Xn1h/0Yd3V31mw/yMVPzWH8B19y7LgW+Ev1UBgTERE5SVSUcW3f1nx0/xAu7daSpz/6ikuemsP8tbvKHyxSQQpjIiIiZWhavx5PXteLv44+m6ISxw1/WchP/v45ew8X+l2a1CIKYyIiIuUY3DGV98YM5s5zz2Dm0s0MGz+bGUvyiaR11xK+FMZERERCkBAXzc8u6sw/7x1I2yaJjH3tc26atJC8XYf9Lk0inMKYiIhIBXRu0ZDX7xjAb648i+Wb9nPhk5/wzL++orCopPzBIkEojImIiFRQVJQxol9bPrx/COd3acZj73/JZX+cQ07eHr9LkwikMCYiInKamjeM58839mHSyCwOFxRzzXMLePiNFew/etzv0iSCKIyJiIhU0rAuzXn/x4O5ZWAmry7ayLDHZ/PW51u0wF9CojAmIiJSBZLqxfA/l3XlzbsG0iK5Hve8spTRL3zGpj36+mU5NYUxERGRKtStVTIzf5TN/1zWlYXr93DhE58w4ZO1FBVrgb8EpzAmIiJSxWKio7hlYCYfjB1CdvsmPPLOaq54Zh6fb9rnd2kShhTGREREqkl6SgJ/uTmLZ2/sza5DBXz3z/P41T9WcbRQ33Mp/xHjdwEiIiK1mZlxcbeWZHdoymPvreHFBXnsOHiMP93QGzPzuzwJA7ozJiIiUgMaxsfy6+Fn8dDsO9FUAAATmklEQVTFnXlnxTaenb3W75IkTCiMiYiI1KAfDmrH5T3S+MN7a/j3mh1+lyNhQGFMRESkBpkZv7+6G52aN+DeV5ayYbe+27KuUxgTERGpYYlxMfzl5iyioozb/rqYwwVFfpckPlIYExER8UHrxon88fpefLXjID+dvlzd+uswhTERERGfDOqQys8u6szbK7by3Ox1fpcjPlEYExER8dFtg9txWfeWjHtvNbO/3Ol3OeIDhTEREREfmRnjrumuBf11mMKYiIiIzxLjYnh+RB8Abp+6mCOFWtBflyiMiYiIhIG2TZJ4+vpefLn9IA9oQX+dojAmIiISJoZ0TOWB73Tm7eVbmfCJFvTXFQpjIiIiYeSOIe24tFtLfj9rNXO+0oL+ukBhTEREJIycWNDfoVkD7n55KRt3H/G7JKlmCmMiIiJhJqleDBNu7oNzjtum5mhBfy2nMCYiIhKGTizoX7P9ID97fYUW9Ndi5YYxM2ttZh+bWa6ZrTKz+0rtu8fM1njbx5UxPsXMppvZau8c/b3tjc3sAzP7yvuzUdVdloiISOQ7t1MzfnJhJ976fAsT56z3uxypJqHcGSsC7nfOdQH6AXeZWVczOw8YDnR3zp0JPFbG+KeAWc65zkAPINfb/iDwkXOuA/CR97uIiIiU8qNzz+CSbi343bu5zP1ql9/lSDUoN4w557Y655Z4rw8SCFPpwJ3Ao865Am/fjpPHmllDYDAwyTum0Dm3z9s9HHjRe/0icGXlLkVERKT2MTP+cE0P2jerz92vLGHTHi3or20qtGbMzDKAXsBCoCMwyMwWmtlsM+sbZEg7YCcwxcyWmtlEM0vy9jV3zm2FQOADmpXxnreZWY6Z5ezcqY/4iohI3ZNUL4YJI7IoKXHcPnUxRwuL/S5JqlDIYczM6gOvA2OccweAGKARgUeXDwCvmZmdNCwG6A0865zrBRymgo8jnXMTnHNZzrms1NTUigwVERGpNTKaJvHU9b3I3XaAB2eoQ39tElIYM7NYAkFsmnNuhrc5H5jhAhYBJUDTk4bmA/nOuYXe79MJhDOA7WbW0jt/S+BbjzlFRETkP87zFvS/uWwLk+ZqQX9tEcqnKY3Amq9c59z4UrtmAkO9YzoCccB/rSx0zm0DNplZJ2/TMOAL7/U/gJHe65HAm6d5DSIiInXGj849g4vObMEj7+Qy/2st6K8NQrkzlg2MAIaa2TLv5xJgMtDOzFYCrwIjnXPOzNLM7J1S4+8BppnZcqAn8Ii3/VHgAjP7CrjA+11EREROwcx47NoenJFan7te1oL+2sAi6ZlzVlaWy8nJ8bsMERER363fdZgrnplL60aJvH7nABLiov0uSU5iZoudc1nlHacO/CIiIhEos2kST13Xk9xtB3hIC/ojmsKYiIhIhBrauTljz+/IzGVbmDwvz+9y5DQpjImIiESwu85rz4VdmwcW9K/Vgv5IpDAmIiISwaKijPHf70lm0yTufnkp+Xu1oD/SKIyJiIhEuPr1Ynh+RB+OF5Vwx0uLOXZcHfojicKYiIhILXBGan2evK4nKzcf4OEZK7SgP4IojImIiNQSw7o058fnd2TG0s28MD/P73IkRApjIiIitcg9Q9tzQdfm/PbtXBas3e13ORIChTEREZFaJCrKGH9tD9o2SeTul5ewed9Rv0uSciiMiYiI1DIN4mOZMCKLgqIS7piqBf3hTmFMRESkFmrfrD5PfL8nKzbv5+E3tKA/nCmMiYiI1FIXdG3OfcM6MGPJZl7Ugv6wpTAmIiJSi903rAPnd2nGb97O5dN1WtAfjhTGREREarETHfrbNknkrmlL2KIF/WFHYUxERKSWa1h6Qb869IcdhTEREZE6oH2z+oy/tgfL8/fzi5krtaA/jCiMiYiI1BEXntmCe4d1YPrifKZ+usHvcsSjMCYiIlKHjBnWgWGdm/Hrt75goRb0hwWFMRERkTokKsp44rqetGmcyF0vL2Hrfi3o95vCmIiISB3TMD6W50f04WhhMXe8tEQL+n2mMCYiIlIHdWjegMev7cnnm/bxyze1oN9PCmMiIiJ11EVnteCeoe15LSeflxZu9LucOkthTEREpA4bc35HzuuUyv/9YxWf5e3xu5w6SWFMRESkDouOMp68rhetGiVw50tL2Lb/mN8l1TkKYyIiInVcckIsE27O4mhhEXe8tJiCIi3or0kKYyIiIkLH5g14/NoeLNu0j1/OXKUF/TVIYUxEREQAuOisltx13hn8LWcT07Sgv8YojImIiMg3xl7QiXM7pfJ/b60iRwv6a4TCmIiIiHwjOsp46vu9SEtJ4M5pS9h+QAv6q1u5YczMWpvZx2aWa2arzOy+UvvuMbM13vZxZYzPM7MVZrbMzHJKbe9pZp+e2G5mZ1fNJYmIiEhlJCfGMmFEFocLtKC/JoRyZ6wIuN851wXoB9xlZl3N7DxgONDdOXcm8NgpznGec66ncy6r1LZxwP8553oCv/R+FxERkTDQqUUDHvteD5Zu3Mev/rHK73JqtXLDmHNuq3Nuiff6IJALpAN3Ao865wq8fTsq+N4OaOi9Tga2VHC8iIiIVKNLurXkR+eewSuLNvGyFvRXmwqtGTOzDKAXsBDoCAwys4VmNtvM+pYxzAHvm9liM7ut1PYxwB/MbBOBu2oPlfGet3mPMXN27txZkXJFRESkku6/sBNDOqbyv/9YyeINWtBfHUIOY2ZWH3gdGOOcOwDEAI0IPLp8AHjNzCzI0GznXG/gYgKPOAd72+8Efuycaw38GJgU7H2dcxOcc1nOuazU1NRQyxUREZEqEB1lPH1dL1omJ3DHS1rQXx1CCmNmFksgiE1zzs3wNucDM1zAIqAEaHryWOfcFu/PHcAbwImF+iOBE+f6e6ntIiIiEkaSE2OZcHMfDh0r4s6XFlNYVOJ3SbVKKJ+mNAJ3rXKdc+NL7ZoJDPWO6QjEAbtOGptkZg1OvAYuBFZ6u7cAQ7zXQ4GvTv8yREREpDp1btGQP3yvO0s27uNXb2lBf1WKCeGYbGAEsMLMlnnbHgYmA5PNbCVQCIx0zjkzSwMmOucuAZoDb3hPL2OAl51zs7xz/BB4ysxigGNA6fVkIiIiEmYu657Gys0HeG72WrqlJ3P92W38LqlWsEj67qmsrCyXk5NT/oEiIiJSLYpLHD+YsoiF6/bw6u396N2mkd8lhS0zW3xSW6+g1IFfREREQhYdZfzx+l40T67HHVMXs0ML+itNYUxEREQqJCUxjgkjsjh4rIgfTVuiBf2VpDAmIiIiFdalZUPGXdOdnA17+fU/taC/MkJZwC8iIiLyLZf3SGPl5v08/8k6uqUn8/2+WtB/OnRnTERERE7bTy/qzKAOTfmfmatYunGv3+VEJIUxEREROW0nOvQ3T67HHS8tZsdBLeivKIUxERERqZRGSXE8f1MW+48e5y4t6K8whTERERGptK5pDRl3TQ8+y9vLb/75hd/lRBQt4BcREZEqcYW3oH+Ct6D/2r6t/S4pIujOmIiIiFSZn36nE9ntm/CLmStZtmmf3+VEBIUxERERqTIx0VH88frepDYIdOjfebDA75LCnsKYiIiIVKnGSXFMuLkP+44Wcte0JRwv1oL+U1EYExERkSp3Zloyv7+6O4vy9vBbLeg/JS3gFxERkWoxvGc6K/L3M3Hues5KT+Z7WVrQH4zujImIiEi1efDizgw4owk/n7mSz7WgPyiFMREREak2MdFRPHNDb1LrBzr07zqkBf0nUxgTERGRatU4KY7nR/Rhz+FCfqQF/d+iMCYiIiLV7qz0ZB69uhuL1u/h/72d63c5YUUL+EVERKRGfLdXK1bkH2DyvPV0S0/m6j6t/C4pLOjOmIiIiNSYhy/pTL92jXnojRWsyN/vdzlhQWFMREREakxMdBR/8hb03z41Rwv6URgTERGRGtakfj2eH9GH3YfVoR8UxkRERMQHZ6Un87ururFw/R4eeaduL+jXAn4RERHxxVW9W7E8fz9T5uXRLT2Zq3rXzQX9ujMmIiIivvn5pV04J7MxD81YwcrNdXNBv8KYiIiI+CY2Ooo/3dibJklx3D51Mbvr4IJ+hTERERHxVdP69XhuRB92Hirg7peXUlTHFvQrjImIiIjvurdK4ZHvdmPBut387t3VfpdTo7SAX0RERMLCNX1asXLzfibNDXTov7JXut8l1Yhy74yZWWsz+9jMcs1slZndV2rfPWa2xts+rozxeWa2wsyWmVnOSfvKHS8iIiJ1x88v7cLZmY352evL68yC/lAeUxYB9zvnugD9gLvMrKuZnQcMB7o7584EHjvFOc5zzvV0zmWd2FDB8SIiIlIHxHod+ht7C/r3HC70u6RqV+5jSufcVmCr9/qgmeUC6cAPgUedcwXevh0VfO87KzleREREaqHUBvV47qY+fO/5Bdw1bQmjB2ZW+Xt0S0+mRXJ8lZ/3dJhzLvSDzTKAT4CzvD/fBC4CjgE/cc59FmTMemAv4IDnnXMTvO3LQhx/G3AbQJs2bfps2LAh9KsTERGRiPX3nE08MH15tZz7mRt6cVn3tGo59wlmtrj0U8GyhLyA38zqA68DY5xzB8wsBmhE4NFlX+A1M2vnvp3usp1zW8ysGfCBma12zn3ivXe5473wNgEgKysr9OQoIiIiEe17Wa05J7MJB44dr/Jzt26UWOXnPF0hhTEziyUQxKY552Z4m/OBGV54WmRmJUBTYGfpsc65Ld6fO8zsDeBsAnfVQhovIiIidVebJuETmqpLKJ+mNGASkOucG19q10xgqHdMRyAO2HXS2CQza3DiNXAhsDLU8SIiIiK1XSh3xrKBEcAKb50XwMPAZGCyma0ECoGRzjlnZmnAROfcJUBz4I1AniMGeNk5N8s7R9DxVXVhIiIiIpGgQgv4/ZaVleVycnLKP1BERETEZ6Eu4NfXIYmIiIj4SGFMRERExEcKYyIiIiI+UhgTERER8ZHCmIiIiIiPFMZEREREfKQwJiIiIuKjiOozZmY7gUj/pvCm6JsGaormumZonmuG5rlmaJ5rRl2Z57bOudTyDoqoMFYbmFlOKA3gpPI01zVD81wzNM81Q/NcMzTP/02PKUVERER8pDAmIiIi4iOFsZo3we8C6hDNdc3QPNcMzXPN0DzXDM1zKVozJiIiIuIj3RkTERER8ZHCmIiIiIiPFMZOwcwmm9kOM1t50vbGZvaBmX3l/dmojPF3m9nXZubMrGmp7Tea2XLvZ76Z9QgyNtHM3jaz1Wa2ysweLbVvsJktMbMiM7umKq/ZD2E8z3eY2QozW2Zmc82sa1Ved02rxnke7s3xMjPLMbOBZYy/yMzWeOd4sLzzRrIwnutJZva5d47pZla/qq7ZD2E8zy+Y2Xpv/DIz61lV1+yHMJ7nOaXmeIuZzayqa65xzjn9lPEDDAZ6AytP2j4OeNB7/SDw+zLG9wIygDygaantA4BG3uuLgYVBxiYC53mv44A5wMXe7xlAd+CvwDV+z1MtnueGpY67Apjl91yF6TzX5z/rT7sDq4OMjQbWAu28ef4c6Hqq80byTxjPden/psefqCVSf8J4nl+gFvzdHO7zfNJxrwM3+z1Xp/ujO2On4Jz7BNgTZNdw4EXv9YvAlWWMX+qcywuyfb5zbq/366dAqyDHHHHOfey9LgSWnDjOOZfnnFsOlFTogsJUGM/zgVKHJgER/WmXapznQ87725Cy5+ls4Gvn3Dpvnl/13rfM80ayMJ7rAwBmZkBCGeMjRrjOc20T7vNsZg2AoUDE3hlTGDs9zZ1zWwG8P5tV4ly3AO+e6gAzSwEuBz6qxPtEIt/n2czuMrO1BP4FeG8l3j+cVXqezey7ZrYaeBsYHeSQdGBTqd/zvW11je9zbWZTgG1AZ+CPFX3/COH7PAP/z3sE94SZ1avo+0eIcJhngO8CH530D+iIojDmIzM7j0BI+NkpjokBXgGeds6tq6naapPKzLNz7k/OuTO8sb+o7lojlXPuDedcZwL/Mv5NkEMs2LDqrap2quxcO+dGAWlALvD9aimyFqjkPD9EIOz2BRpzir976roq+rvjegJ/f0cshbHTs93MWgJ4f+7wXr/nLSScWN4JzKw7MBEY7pzbfYpDJwBfOeeerIK6I004zfOrlHELvhao9Dyf4D3OOCPIQvx8oHWp31sBWypXdkQKi7l2zhUDfwOurvglRARf59k5t9UFFABTCDxqq418/+/ZzJoQmN+3T+8SwoPC2On5BzDSez0SeBPAOfcd51xP59ytpxpsZm2AGcAI59yXpzjut0AyMKZKqo48vs6zmXUo9eulwFcVvoLIUNl5bu+tQcLMehNYZHty8P0M6GBmmWYWB1znvW9d49tcW0B7b6wReCS/uoquK9z4+t90qYBiBP4Rt5LaKRz+7vge8E/n3LFKX42fKrrivy79ELjtuRU4TiCd3+Jtb0JgXdFX3p+Nyxh/rzeuiECSn+htnwjsBZZ5PzlBxrYicCs2t9Rxt3r7+nrnPUzgP9xVfs9VLZ3np4BV3raPgTP9nqswneeflZqnBcDAMsZfAnxJ4JNRPy/vvJH8E45zTeAf3/OAFQTCwTRKfboyEn/CcZ697f8qNc8vAfX9nqvaOM/evn8DF/k9R5X90dchiYiIiPhIjylFREREfKQwJiIiIuIjhTERERERHymMiYiIiPhIYUxERETERwpjIiIiIj5SGBMRERHx0f8H4RQdyFipRjMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f4ef2bc8d50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline \n",
    "import numpy \n",
    "\n",
    "# Let's get rid of these trailing file values\n",
    "times = numpy.ma.fix_invalid(times).compressed()\n",
    "temp = numpy.ma.fix_invalid(temp).compressed()\n",
    "\n",
    "# transform these time values in datetime objects\n",
    "times = netcdf.num2date(times, mdbfile['cmems_drifter__time'].units)\n",
    "\n",
    "# display this temperature time series\n",
    "from matplotlib import pyplot\n",
    "\n",
    "fig = pyplot.figure(figsize=(10,5))\n",
    "pyplot.plot(times, temp)\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The closest measurement in time to satellite pixels in this time series, is given by the variable ``cmems_drifter__dynamic_target_center_index``. Here for our match-up #3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "indice = mdbfile['cmems_drifter__dynamic_target_center_index'][3]\n",
    "print indice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26.6499996185\n"
     ]
    }
   ],
   "source": [
    "# the closest temperature value is then:\n",
    "print mdbfile['cmems_drifter__water_temperature_0'][3, indice]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f4ef525f390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# verify on above plot that is at the center of the history\n",
    "fig = pyplot.figure(figsize=(10,5))\n",
    "pyplot.plot(times, temp)\n",
    "pyplot.plot(times[indice], temp[indice], color='r', marker=\"o\")\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some variables have a ``_0``, ``_1``, ``_2``, ``_3``, ``_4`` suffix. They correspond to different depth levels, as the first 5 depth level measurement were retained for any in situ source : this is not the actual depth value, just the rank, 0 being the closest to surface and 4 the deepest.\n",
    "\n",
    "For drifters, there will be most likely only a single value in ``<field>_0`` and fill values in other levels, except for the few who may measure the water temperature at different levels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26.6499996185\n"
     ]
    }
   ],
   "source": [
    "# print closest temperature value to surface for match-up #3\n",
    "print mdbfile.variables['cmems_drifter__water_temperature_0'][3, indice]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--\n"
     ]
    }
   ],
   "source": [
    "# this drifter provides only a single depth measurement\n",
    "print mdbfile.variables['cmems_drifter__water_temperature_1'][3, indice]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "# note that the actual depth (when available at in situ provider) is provided in the corresponding depth field\n",
    "print mdbfile.variables['cmems_drifter__meas_depth_0'][3, indice]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The handy ``read_insitu_field`` function from s3analysis package allow to retrieve a multi-dimensional array instead of reading separately each level field. Just query the name of the field with the ``_<x>`` suffix and set the ``closest_to_surface`` argument to False. See some examples further."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(488, 5)\n"
     ]
    }
   ],
   "source": [
    "# get full profiles in one single array\n",
    "closest_value = read_insitu_field(mdbfile, 'cmems_drifter__water_temperature', closest_to_surface=False)\n",
    "print closest_value.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## understanding the satellite part of the matchups\n",
    "\n",
    "The MDB is a multi-dataset match-up database: for each match-up, a full stack of fields from each of these datasets is provided (filled with fill values when they were not available or not in the match-up window).\n",
    "\n",
    "The fields from each dataset is prefixed with ``<dataset id>__``.\n",
    "\n",
    "For instance, to get the fields from S3A_SL_2_WST product only:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S3A_SL_2_WST__dynamic_target_distance\n",
      "S3A_SL_2_WST__dynamic_target_center_index\n",
      "S3A_SL_2_WST__origin\n",
      "S3A_SL_2_WST__dynamic_target_time_difference\n",
      "S3A_SL_2_WST__time\n",
      "S3A_SL_2_WST__nadir_sst_theoretical_uncertainty\n",
      "S3A_SL_2_WST__sses_standard_deviation\n",
      "S3A_SL_2_WST__wind_speed_dtime_from_sst\n",
      "S3A_SL_2_WST__l2p_flags\n",
      "S3A_SL_2_WST__dt_analysis\n",
      "S3A_SL_2_WST__aerosol_dynamic_indicator\n",
      "S3A_SL_2_WST__dual_nadir_sst_difference\n",
      "S3A_SL_2_WST__lon\n",
      "S3A_SL_2_WST__sst_theoretical_uncertainty\n",
      "S3A_SL_2_WST__miniprod_content_mask\n",
      "S3A_SL_2_WST__lat\n",
      "S3A_SL_2_WST__wind_speed\n",
      "S3A_SL_2_WST__sea_ice_fraction_dtime_from_sst\n",
      "S3A_SL_2_WST__adi_dtime_from_sst\n",
      "S3A_SL_2_WST__brightness_temperature\n",
      "S3A_SL_2_WST__sea_ice_fraction\n",
      "S3A_SL_2_WST__nedt\n",
      "S3A_SL_2_WST__sses_bias\n",
      "S3A_SL_2_WST__quality_level\n",
      "S3A_SL_2_WST__sst_algorithm_type\n",
      "S3A_SL_2_WST__sea_surface_temperature\n",
      "S3A_SL_2_WST__satellite_zenith_angle\n"
     ]
    }
   ],
   "source": [
    "for var in mdbfile.variables:\n",
    "    if 'S3A_SL_2_WST__' in var:\n",
    "        print var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each satellite match-up is provided as box : the match-up pixel and its neighbours within a 21x21 pixel box). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f4ef0ad3250>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# display the content of S3A_SL_2_WST__wind_speed for matchup #3\n",
    "sst = mdbfile.variables['S3A_SL_2_WST__wind_speed'][3, :, :]\n",
    "pyplot.imshow(sst, interpolation='nearest')\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The central pixel of the box is the closest to the in situ measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f4ef0aa8290>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get the lat/lon of the box for S3A_SL_2_WST dataset, for our match-up #3\n",
    "lat = mdbfile.variables['S3A_SL_2_WST__lat'][3, :, :]\n",
    "lon = mdbfile.variables['S3A_SL_2_WST__lon'][3, :, :]\n",
    "\n",
    "# display the location of all pixels from the box\n",
    "fig = pyplot.figure(figsize=(8,8))\n",
    "pyplot.scatter(lat, lon, marker='+', color='b')\n",
    "\n",
    "# highlight the center pixel\n",
    "pyplot.plot(lat[10, 10], lon[10, 10], marker='o', color='r')\n",
    "\n",
    "# overlay the in situ centre pixel and verify it is the closest to the pixel center\n",
    "pyplot.plot(mdbfile.variables['lat'][3], mdbfile.variables['lon'][3], color='g', marker='o')\n",
    "\n",
    "# display\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In some cases, the in situ measuement is not centred on the central pixel, this is because the in situ measurement is out of the footprint of input satellite file (granule). These shifted boxes can be easily spotted by using the distance between the central pixel and the in situ measurement, ``S3A_SL_2_WST__dynamic_target_distance`` : they will have a value greater than 1000m. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "488\n"
     ]
    }
   ],
   "source": [
    "# number of match-ups\n",
    "print len(mdbfile.variables['time'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7635\n"
     ]
    }
   ],
   "source": [
    "# print maximum match-up distance, in meters, found for these match-ups\n",
    "print mdbfile.variables['S3A_SL_2_WST__dynamic_target_distance'][:].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "369\n"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "\n",
    "# mask match-ups where the distance to satellite pixel  is greater than 1km\n",
    "pixel_distance = mdbfile.variables['S3A_SL_2_WST__dynamic_target_distance'][:]\n",
    "\n",
    "times = mdbfile.variables['time'][:]\n",
    "times = numpy.ma.masked_where(pixel_distance > 1000., times)\n",
    "\n",
    "# number of remaining match-ups\n",
    "print times.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, the time difference between the satellite pixels and the closest in situ measurement in time, provided by ``S3A_SL_2_WST__dynamic_target_time_difference`` can be used as a filtering criteria (the colocation window is 2h for drifters and moored buoys, 12h for argo floats):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "375\n"
     ]
    }
   ],
   "source": [
    "time_difference = mdbfile.variables['S3A_SL_2_WST__dynamic_target_time_difference'][:]\n",
    "                                    \n",
    "# select match-ups which time difference is lower than 1h\n",
    "times = mdbfile.variables['time'][:]\n",
    "times = numpy.ma.masked_where(time_difference > 3600, times)\n",
    "\n",
    "# number of remaining match-ups\n",
    "print times.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many satellite match-ups are also actually cloudy and don't have a valid SST value. However there may be some neighbouring pixel in the box with a valid SST value. If it is close enough, you may want to keep it in your analysis. For instance, let's take this cloudy match-up:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f4ef09af750>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Here is an example of cloudy match-up\n",
    "sst = mdbfile.variables['S3A_SL_2_WST__sea_surface_temperature'][15, :, :]\n",
    "\n",
    "#quality = mdbfile.variables['S3A_SL_2_WST__quality_level'][15, :, :]\n",
    "pyplot.imshow(sst, interpolation='nearest')\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--\n"
     ]
    }
   ],
   "source": [
    "# print the central value => it is masked (invalid)\n",
    "print sst[10, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that for all other than SLSTR datasets in the match-ups, resampling on the SLSTR product grid was performed using closest neighbour regridding."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## traceability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All match-ups can be traced back to their original file, using the ``<dataset>__origin`` and ``<dataset>__dynamic_target_center_index`` fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S3A_SL_2_WST____20161013T021744_20161013T022044_20161013T043834_0179_009_360______MAR_O_NR_002.SEN3\n"
     ]
    }
   ],
   "source": [
    "# get the source granule file for our match-up #3\n",
    "print mdbfile.variables['S3A_SL_2_WST__origin'][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1151  257]\n"
     ]
    }
   ],
   "source": [
    "# get the row and column indices of the match-up pixel in this file\n",
    "print mdbfile.variables['S3A_SL_2_WST__dynamic_target_center_index'][3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## some advanced functions with `s3analysis`\n",
    "\n",
    "the `s3analysis` packages provides an abstraction layer of the individual MDB files and some more advanced function to ease the extraction and analysis of information.\n",
    "\n",
    "In additional to helper functions described above, two more functions are provided:\n",
    "  * read_satellite_data\n",
    "  * read_insitu_data\n",
    "\n",
    "The main usage of these function is to loop over the match-up files of time range and return a concatenated result. So you don't have to bother with iterating over files and messing with arrays, these function do that for you!\n",
    "\n",
    "**note: these functions assume you stored the MDB files as they are on Ifremer repository, stored by ``year`` and ``day in year`` folders!**\n",
    "\n",
    "Let's start with ``read_satellite_data`` helper function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading file 4 over 4\n",
      "2113\n",
      "910\n"
     ]
    }
   ],
   "source": [
    "from s3analysis.slstr.mdb.slstrmdb import SLSTRMDB\n",
    "import datetime\n",
    "\n",
    "# instantiate the class to read MDB data\n",
    "mdb = SLSTRMDB(config={\n",
    "    'mdb_output_root': \"/home/cercache/project/s3vt/\",\n",
    "    'reference': 'S3A_SL_2_WST'\n",
    "})\n",
    "\n",
    "# extraction criteria\n",
    "start = datetime.datetime(2016, 10, 13)\n",
    "source = 'cmems_drifter'\n",
    "\n",
    "# fields to read (use the original field names from the source SLSTR products)\n",
    "fields = {\n",
    "    'S3A_SL_2_WST': ['sea_surface_temperature', 'quality_level']\n",
    "}\n",
    "\n",
    "# perform the data selection for day 13 Oct 2016. By default it returns the closest pixel only.\n",
    "res = mdb.read_satellite_data(source, start, dataset_fields=fields, reference='S3A_SL_2_WST')\n",
    "\n",
    "# number or match-ups\n",
    "print res['S3A_SL_2_WST']['sea_surface_temperature'].size\n",
    "\n",
    "# number of valid (unmasked) match-ups\n",
    "print res['S3A_SL_2_WST']['sea_surface_temperature'].count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading file 4 over 4\n",
      "913\n"
     ]
    }
   ],
   "source": [
    "# Among the returned values, we can also filter out those who are two far from the in situ measurement,\n",
    "# using the ``max_distance`` threshold, in meter\n",
    "res = mdb.read_satellite_data(source, start, dataset_fields=fields, max_distance=3000)\n",
    "print res['S3A_SL_2_WST']['sea_surface_temperature'].count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading file 8 over 8\n",
      "1827\n"
     ]
    }
   ],
   "source": [
    "# you can also provide a time range instead of a single day, by specifying the end date\n",
    "# in ``end`` argument\n",
    "end = datetime.datetime(2016, 10, 14)\n",
    "res = mdb.read_satellite_data(source, start,  dataset_fields=fields, end=end)\n",
    "\n",
    "# number or match-ups\n",
    "print res['S3A_SL_2_WST']['sea_surface_temperature'].count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also get instead request the closest *valid* measurement, where the validity is defined by some selection filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading file 4 over 4\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "res = mdb.read_satellite_data(source, start,  dataset_fields=fields, filters={'S3A_SL_2_WST': {'quality_level': [3, 5]}})\n",
    "\n",
    "# number or match-ups\n",
    "print res['S3A_SL_2_WST']['sea_surface_temperature'].count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ``s3analysis`` package provides a handy function to only retrieve the closest in situ value (in time) from each match-up at once : ``read_insitu_data``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013180000_20161014000000.nc\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013120000_20161013180000.nc\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013060000_20161013120000.nc\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013000000_20161013060000.nc\n",
      "(2113,)\n",
      "2113\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013180000_20161014000000.nc\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013120000_20161013180000.nc\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013060000_20161013120000.nc\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013000000_20161013060000.nc\n",
      "(2113, 5)\n"
     ]
    }
   ],
   "source": [
    "# extraction criteria\n",
    "insitu_fields = ['water_temperature']\n",
    "\n",
    "# perform the data selection for day 13 Oct 2016\n",
    "res = mdb.read_insitu_data(source, start, insitu_fields)\n",
    "\n",
    "# this returns by default the closest valid measurement to surface for each match-up\n",
    "# in each profile as seen in the dimensions of the returned result\n",
    "print res['water_temperature'].shape\n",
    "\n",
    "# number or match-ups\n",
    "print res['water_temperature'].count()\n",
    "\n",
    "# alternatively, you can also select the whole profile by deactivating the surface selection\n",
    "res = mdb.read_insitu_data(source, start, insitu_fields, closest_to_surface=False)\n",
    "\n",
    "print res['water_temperature'].shape\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013180000_20161014000000.nc\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013120000_20161013180000.nc\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013060000_20161013120000.nc\n",
      "File: /home/cercache/project/s3vt/2016/287/S3A_SL_2_WCT_cmems_drifter_20161013000000_20161013060000.nc\n",
      "File: /home/cercache/project/s3vt/2016/288/S3A_SL_2_WCT_cmems_drifter_20161014180000_20161015000000.nc\n",
      "File: /home/cercache/project/s3vt/2016/288/S3A_SL_2_WCT_cmems_drifter_20161014120000_20161014180000.nc\n",
      "File: /home/cercache/project/s3vt/2016/288/S3A_SL_2_WCT_cmems_drifter_20161014060000_20161014120000.nc\n",
      "File: /home/cercache/project/s3vt/2016/288/S3A_SL_2_WCT_cmems_drifter_20161014000000_20161014060000.nc\n",
      "4200\n"
     ]
    }
   ],
   "source": [
    "# Similarly you can also provide a time range instead of a single day, by specifying the end date\n",
    "# in ``end`` argument\n",
    "end = datetime.datetime(2016, 10, 14)\n",
    "res = mdb.read_insitu_data(source, start, insitu_fields, end=end)\n",
    "\n",
    "# number or match-ups\n",
    "print res['water_temperature'].count()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}