{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Parse Logger Files\n",
    "Parse raw logger data and utility to handle raw data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "is_executing": true,
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [],
   "source": [
    "#|hide\n",
    "#|default_exp logger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:23.382489600Z",
     "start_time": "2023-08-31T12:54:15.661534300Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#|export\n",
    "from numpy.typing import NDArray,ArrayLike\n",
    "import re\n",
    "import gzip\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.stats import linregress\n",
    "import logging\n",
    "\n",
    "from pyrnet import utils\n",
    "\n",
    "# logging setup\n",
    "logging.basicConfig(\n",
    "    filename='pyrnet.log',\n",
    "    encoding='utf-8',\n",
    "    level=logging.DEBUG,\n",
    "    format='%(asctime)s %(name)s %(levelname)s:%(message)s'\n",
    ")\n",
    "logger = logging.getLogger(__name__)\n",
    "\n",
    "\n",
    "# Local variables\n",
    "_nat      = np.datetime64('NaT','ms')\n",
    "_re_gprmc = re.compile('^(\\d+,\\d+ \\d) \\$GPRMC,(.*)(\\*\\w{2})$')\n",
    "_re_adc   = re.compile('^(\\d+)(\\s\\d+)+$')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:24.858973200Z",
     "start_time": "2023-08-31T12:54:23.394459500Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Operations on the raw logger file\n",
    "Open and read the binary files from the logger. These files have a header of 8 lines.\n",
    "\n",
    "If the Logger receives power, it immediately starts to write data to the file. The first voltage measurements are good, but the GPS signal needs some time to establish.\n",
    "\n",
    "If Logger writes data item per item, so if turned off, the file ends in an incomplete line most of the time. Sometimes, the last information is a GPS line. These events have to be handled.\n",
    "\n",
    "### Reading the raw logger file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:24.888059800Z",
     "start_time": "2023-08-31T12:54:24.869559700Z"
    },
    "collapsed": false,
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=====Header and Start of Data=====:\n",
      "# - TROPOS - Pyranometer Network BOX 9\n",
      "#FIRMWARE: Logomatic Kwan v1.1 (modified Witthuhn 201803) Aug 23 2018 10:43:35\n",
      "#    MAM setup: MAMCR=2, MAMTIM=4\n",
      "#    SD Card Setup: result=3,   MID=3,   OID='SD',   PNM='SU02G',   PRV=128,   PSN=321248437\n",
      "#    IDs: TROPOS_ID: A201300109 ; BOX: 9 ; WTS: 9\n",
      "#        Pyr9 - serial:S12128.009 ; Pyr62 - serial:S12137.012\n",
      "#    Calibration: Pyr9: 7.460000 (201504) ; Pyr62: 7.590000 (201504)\n",
      "# time [ms] , [counts]...\n",
      "891 836 322 484 194 1000 180\n",
      "991 836 322 484 194 998 180\n",
      "91 836 322 484 194 999 180\n",
      "20800108,112102 0 $GPRMC,112102.067,V,,,,,0.00,0.00,080180,,,N*4C\n",
      "191 836 322 485 194 1000 180\n",
      "291 837 324 485 194 998 181\n",
      "391 836 324 485 194 998 180\n",
      "\n",
      "...\n",
      "\n",
      "==========End of Data=============:\n",
      "791 834 322 488 194 1000 180\n",
      "891 835 323 488 194 998 180\n",
      "991 834 322 486 194 998 180\n",
      "91 835 322 486 194 997 180\n",
      "191 838 322 486 194 1000 180\n",
      "20030114,112109 0 $GPRMC,112109.000,A,5123.4125,N,01153.1148,E,0.21,0.00,140103,,,A*6D\n",
      "291 836 322 487 194 1002 180\n",
      "391 837 323 488 194 1002 181\n",
      "491 838 324 488 194 1000 180\n",
      "591 838 324\n"
     ]
    }
   ],
   "source": [
    "#|dropout\n",
    "fname = \"../../example_data/Pyr9_000.bin\"\n",
    "if fname[-3:]=='.gz':\n",
    "    f = gzip.open(fname,'rt',errors='ignore') # open in text mode, ignore non UTF8 characters\n",
    "else:\n",
    "    f = open(fname,'r',errors='ignore')\n",
    "lines =[l.rstrip() for l in f.readlines()]\n",
    "f.close()\n",
    "\n",
    "print(\"=====Header and Start of Data=====:\")\n",
    "print(*lines[:15], sep='\\n')\n",
    "print('\\n...\\n')\n",
    "print(\"==========End of Data=============:\")\n",
    "print(*lines[-10:], sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### Cleanup\n",
    "*  Skip almost empty files (data lines <20)\n",
    "*  remove the last line as it is probably incomplete\n",
    "*  check again if now a GPS line is the last line and remove it if so"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.012212500Z",
     "start_time": "2023-08-31T12:54:24.891022Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# remove last line -> mostly damaged or empty\n",
    "lines=lines[:-1]\n",
    "# remove gps line at the end -> else processing issues\n",
    "if _re_gprmc.match(lines[-1]):\n",
    "    lines=lines[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### Divide GPS and ADC records\n",
    "GPS and ADC lines have to be parsed separately"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.049520300Z",
     "start_time": "2023-08-31T12:54:24.914375700Z"
    },
    "collapsed": false,
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPS lines:\n",
      "20800108,112102 0 $GPRMC,112102.067,V,,,,,0.00,0.00,080180,,,N*4C\n",
      "20800108,112103 0 $GPRMC,112103.067,V,,,,,0.00,0.00,080180,,,N*4D\n",
      "20030114,112104 0 $GPRMC,112104.065,A,5123.4127,N,01153.1153,E,0.06,0.00,140103,,,A*6E\n",
      "20030114,112105 0 $GPRMC,112105.065,A,5123.4127,N,01153.1154,E,0.05,0.00,140103,,,A*6B\n",
      "20030114,112107 0 $GPRMC,112107.000,A,5123.4126,N,01153.1151,E,0.14,0.00,140103,,,A*6E\n",
      "20030114,112108 0 $GPRMC,112108.000,A,5123.4126,N,01153.1150,E,0.20,0.00,140103,,,A*67\n",
      "20030114,112109 0 $GPRMC,112109.000,A,5123.4125,N,01153.1148,E,0.21,0.00,140103,,,A*6D\n",
      "\n",
      "ADC lines:\n",
      "891 836 322 484 194 1000 180\n",
      "991 836 322 484 194 998 180\n",
      "91 836 322 484 194 999 180\n",
      "191 836 322 485 194 1000 180\n",
      "291 837 324 485 194 998 181\n",
      "391 836 324 485 194 998 180\n",
      "491 836 322 484 194 1000 181\n",
      "591 836 322 484 194 999 180\n",
      "691 837 322 484 194 998 180\n",
      "791 829 322 484 194 1000 180\n",
      "...\n"
     ]
    }
   ],
   "source": [
    "#|dropout\n",
    "gpslines = []\n",
    "adclines = []\n",
    "for i,l in enumerate(lines):\n",
    "    m = _re_gprmc.match(l)\n",
    "    if m:\n",
    "        gpslines.append(l)\n",
    "        # -> send to parse_gps function\n",
    "    elif _re_adc.match(l):\n",
    "        adclines.append(l)\n",
    "        # -> send to parse_adc function\n",
    "    else:\n",
    "        # unhandled record...\n",
    "        pass\n",
    "\n",
    "print(\"GPS lines:\")\n",
    "print(*gpslines, sep=\"\\n\")\n",
    "print()\n",
    "print(\"ADC lines:\")\n",
    "print(*adclines[:10], sep=\"\\n\")\n",
    "print(\"...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### Parsing GPS\n",
    "Workflow:\n",
    "1. Look if GPS is available (Status:*A*) if not return nan\n",
    "2. Read lat,lon and time information\n",
    "3. Account for GPS rollover\n",
    "\n",
    "The GPS chip in use has no automatic patch to account for GPS week integer rollover, which happend at 2019-04-06. Measurements taken after this date, have to add 1024 weeks to the date the GPS provides. Therefore this parsing function requires the measurement date (to process older campaigns)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.051522300Z",
     "start_time": "2023-08-31T12:54:24.940817300Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#|export\n",
    "def parse_gprmc(s, date_of_measure=np.datetime64('now')):\n",
    "    '''\n",
    "    Parse a string with a GPRMC GPS record\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    s: string\n",
    "        A GPRMC record\n",
    "    date_of_measure: datetime or datetime64\n",
    "        A rough time, when the measurements happen to account for GPS rollover.\n",
    "        Precise datetime is only necessary for the period of 2019-05-06 to 2019-08-17.\n",
    "        Otherwise, providing a year is sufficient.\n",
    "        The default is np.datetime64(\"now\"), which is sufficient for all measurements conducted later than 2019-08-17.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    gprmc : tuple\n",
    "        A tuple with datetime64,status,lat,lon\n",
    "    '''\n",
    "    date_of_measure = utils.to_datetime64(date_of_measure)\n",
    "    # split fields of GPRMC record\n",
    "    f = s.split(',')\n",
    "    status = f[1]\n",
    "    if status=='A':\n",
    "        try:\n",
    "            # parse latitude\n",
    "            lat = float(f[2][:2])+float(f[2][2:])/60\n",
    "            if f[3]=='S':\n",
    "                lat *= -1.0\n",
    "            # parse longitude\n",
    "            lon = float(f[4][:3])+float(f[4][3:])/60\n",
    "            if f[5]=='W':\n",
    "                lon *= -1.0\n",
    "            if date_of_measure>np.datetime64(\"2019-04-06\") and date_of_measure<np.datetime64(\"2019-08-17\"): #account for gps week rollover\n",
    "                YY = '19'+f[8][4:6]\n",
    "            else:\n",
    "                YY = \"20\"+f[8][4:6]\n",
    "            mm = f[8][2:4]\n",
    "            dd = f[8][0:2]\n",
    "            HH = f[0][0:2]\n",
    "            MM = f[0][2:4]\n",
    "            SS = f[0][4:]\n",
    "            dt = np.datetime64(YY+'-'+mm+'-'+dd+'T'+HH+':'+MM+':'+SS,'ms')\n",
    "            if date_of_measure>np.datetime64(\"2019-04-06\"): #account for gps week rollover -> date jump 1024 weeks back at 2019-04-06\n",
    "                dt= dt+np.timedelta64(1024,'W')\n",
    "            r = (dt,status,lat,lon)\n",
    "        except:\n",
    "            return (_nat,'V',np.nan,np.nan)\n",
    "    else:\n",
    "        r = (_nat,'V',np.nan,np.nan)\n",
    "    return r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### Parse ADC\n",
    "The ADC output are simple tab separated voltage values of the 5 analog input pins of the Logger.\n",
    "#### ADC (3.3V, 10bit) Analog In Pins:\n",
    "* [0] Internal Battery measure\n",
    "* [1] Temperature sensor (0-5V, measured with voltage split)\n",
    "* [2] Humidity sensor (0-5V, measured with voltage split)\n",
    "* [3] Pyranometer main (0  -$\\mathrm{gain}*\\mathrm{F}*\\mathrm{C}$ V)\n",
    "* [4] Battery (0-6V, measured with voltage split (same resistors))\n",
    "* [5] None\n",
    "* [6] Pyranometer secondary platform (0 - $\\mathrm{gain}*\\mathrm{F}*\\mathrm{C}$ V)\n",
    "* [7] None\n",
    "* [8] None\n",
    "\n",
    "with $\\mathrm{gain}=300$, surface irradiance $\\mathrm{F}$ of 0-1500 Wm-2, and calibration factor $\\mathrm{C} < 8e-6 V\\,Wm-2$, the voltage range of the pyranometer sensors spans the full available range (0-3.3V) depending on the calibration factor.\n",
    "\n",
    "> *None* column won't appear in raw output file\n",
    "\n",
    "> The first column is always milliseconds of processor runtime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.051522300Z",
     "start_time": "2023-08-31T12:54:24.957713300Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#|export\n",
    "def parse_adc(s):\n",
    "    '''\n",
    "    Parse an ADC record\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    s: string\n",
    "        The ADC record\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    t: tuple\n",
    "       A tuple of digital counts of the ADC\n",
    "    '''\n",
    "    return tuple(map(int,s.split()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### Putt all together\n",
    "This function reads the logger file, separates GPS and ADC records, wich will be parsed by the functions introduced above. Then the data is collected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.052970Z",
     "start_time": "2023-08-31T12:54:24.969512600Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#|export\n",
    "dtype_gprmc = [\n",
    "    ( 'time',   'datetime64[ms]' ),\n",
    "    ( 'status', 'S1' ),\n",
    "    ( 'lat',    'f8' ),\n",
    "    ( 'lon',    'f8' ),\n",
    "    ( 'iadc',   'u4' )\n",
    "]\n",
    "\n",
    "def read_records(fname: str,\n",
    "                 date_of_measure: np.datetime64 = np.datetime64('now')) -> (NDArray, NDArray):\n",
    "    '''\n",
    "    Read the GPRMC and ADC records from the pyranometer logger files\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    fname: string\n",
    "        The filename of the logger file\n",
    "    date_of_measure: numpy.datetime64\n",
    "        Date of measurement to account for gps rollover\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    rec_adc: ndarray\n",
    "        The 10bit ADC readings\n",
    "    rec_gprmc: recarray\n",
    "        The GPRMC GPS records\n",
    "    '''\n",
    "    logger.info(f\"Start reading records from file: {fname}\")\n",
    "    date_of_measure = utils.to_datetime64(date_of_measure)\n",
    "    # Read file, use errors='ignore' to skip non UTF-8 characters\n",
    "    # non UTF-8 characters may arise in broken GPS strings from time to time\n",
    "    if fname[-3:]=='.gz':\n",
    "        f = gzip.open(fname,'rt',errors='ignore') # open in text mode, ignore non UTF8 characters\n",
    "    else:\n",
    "        f = open(fname,'r',errors='ignore')\n",
    "    lines =[l.rstrip() for l in f.readlines()]\n",
    "    f.close()\n",
    "\n",
    "    ##- skip almost empty files\n",
    "    if len(lines)<20:\n",
    "        logger.info(\"Skip file, as number of records is < 20.\")\n",
    "        return False,False\n",
    "\n",
    "    # remove last line -> mostly damaged or empty\n",
    "    lines=lines[:-1]\n",
    "    # remove gps line at the end -> else processing issues\n",
    "    if _re_gprmc.match(lines[-1]):\n",
    "        lines=lines[:-1]\n",
    "\n",
    "    rec_gprmc = []\n",
    "    rec_adc = []\n",
    "    iadc = 0\n",
    "    for i,l in enumerate(lines):\n",
    "        m = _re_gprmc.match(l)\n",
    "        if m:\n",
    "            r = parse_gprmc(m.group(2), date_of_measure)\n",
    "            if not np.isnat(r[0]):\n",
    "                # add number of adc values before GPS line\n",
    "                rec_gprmc.append(r+(iadc,))\n",
    "        elif _re_adc.match(l):\n",
    "            r = parse_adc(l)\n",
    "            if iadc==0:\n",
    "                adc_len=len(r)\n",
    "            # if record line is incomplete (due to power cut off)\n",
    "            # the line is dropped\n",
    "            if len(r)==adc_len:\n",
    "                rec_adc.append(r)\n",
    "                iadc += 1\n",
    "        else:\n",
    "            # unhandled record...\n",
    "            pass\n",
    "    rec_adc   = np.array(rec_adc,dtype=np.uint16)\n",
    "    rec_gprmc = np.array(rec_gprmc,dtype=dtype_gprmc).view(np.recarray)\n",
    "    logger.info(\"Done reading records from raw file.\")\n",
    "    return rec_adc, rec_gprmc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.066867400Z",
     "start_time": "2023-08-31T12:54:25.012212500Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "rec_adc, rec_gprmc = read_records(fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.200822200Z",
     "start_time": "2023-08-31T12:54:25.031273100Z"
    },
    "collapsed": false,
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec.array([('2022-08-30T11:21:04.065', b'A', 51.39021167, 11.885255  , 26),\n",
       "           ('2022-08-30T11:21:05.065', b'A', 51.39021167, 11.88525667, 35),\n",
       "           ('2022-08-30T11:21:07.000', b'A', 51.39021   , 11.88525167, 54),\n",
       "           ('2022-08-30T11:21:08.000', b'A', 51.39021   , 11.88525   , 64),\n",
       "           ('2022-08-30T11:21:09.000', b'A', 51.39020833, 11.88524667, 74)],\n",
       "          dtype=[('time', '<M8[ms]'), ('status', 'S1'), ('lat', '<f8'), ('lon', '<f8'), ('iadc', '<u4')])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#|dropout\n",
    "rec_gprmc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.293335Z",
     "start_time": "2023-08-31T12:54:25.056005800Z"
    },
    "collapsed": false,
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 891,  836,  322,  484,  194, 1000,  180],\n",
       "       [ 991,  836,  322,  484,  194,  998,  180],\n",
       "       [  91,  836,  322,  484,  194,  999,  180],\n",
       "       [ 191,  836,  322,  485,  194, 1000,  180],\n",
       "       [ 291,  837,  324,  485,  194,  998,  181],\n",
       "       [ 391,  836,  324,  485,  194,  998,  180],\n",
       "       [ 491,  836,  322,  484,  194, 1000,  181],\n",
       "       [ 591,  836,  322,  484,  194,  999,  180],\n",
       "       [ 691,  837,  322,  484,  194,  998,  180],\n",
       "       [ 791,  829,  322,  484,  194, 1000,  180],\n",
       "       [ 891,  834,  322,  485,  194,  999,  180],\n",
       "       [ 991,  836,  323,  486,  194, 1000,  181],\n",
       "       [  91,  836,  324,  484,  194,  998,  180],\n",
       "       [ 191,  836,  322,  483,  194,  998,  180],\n",
       "       [ 291,  836,  322,  484,  194,  998,  180],\n",
       "       [ 391,  835,  322,  484,  194, 1000,  180],\n",
       "       [ 491,  836,  323,  484,  194,  998,  180],\n",
       "       [ 591,  836,  322,  485,  194,  999,  180],\n",
       "       [ 691,  836,  323,  486,  194,  999,  180],\n",
       "       [ 791,  836,  322,  484,  194,  998,  180],\n",
       "       [ 891,  835,  322,  484,  194, 1000,  180],\n",
       "       [ 991,  835,  322,  485,  194, 1000,  180],\n",
       "       [  91,  835,  322,  486,  194,  998,  180],\n",
       "       [ 191,  834,  323,  486,  194,  999,  180],\n",
       "       [ 291,  834,  324,  486,  194,  998,  180],\n",
       "       [ 391,  835,  323,  486,  194,  998,  180],\n",
       "       [ 491,  836,  322,  484,  194,  998,  180],\n",
       "       [ 591,  836,  322,  486,  194,  999,  180],\n",
       "       [ 691,  835,  322,  486,  194,  999,  180],\n",
       "       [ 791,  836,  322,  486,  194,  998,  180],\n",
       "       [ 891,  837,  323,  486,  194, 1000,  181],\n",
       "       [ 991,  838,  324,  487,  193, 1000,  180],\n",
       "       [  91,  837,  322,  485,  194, 1000,  180],\n",
       "       [ 191,  838,  322,  485,  194,  999,  179],\n",
       "       [ 291,  837,  322,  485,  194, 1000,  180],\n",
       "       [ 391,  836,  322,  486,  194, 1002,  179],\n",
       "       [ 491,  834,  323,  486,  194,  998,  180],\n",
       "       [ 591,  836,  324,  486,  194,  998,  180],\n",
       "       [ 691,  835,  323,  486,  194,  999,  180],\n",
       "       [ 791,  834,  322,  485,  194,  999,  180],\n",
       "       [ 891,  835,  322,  486,  194,  999,  181],\n",
       "       [ 991,  837,  322,  486,  194, 1002,  180],\n",
       "       [  91,  838,  323,  486,  194, 1000,  180],\n",
       "       [ 191,  837,  323,  486,  194, 1000,  181],\n",
       "       [ 291,  836,  323,  487,  194, 1000,  180],\n",
       "       [ 391,  837,  322,  486,  194, 1000,  180],\n",
       "       [ 491,  837,  322,  485,  194, 1002,  180],\n",
       "       [ 591,  836,  322,  486,  194,  999,  180],\n",
       "       [ 691,  836,  322,  486,  194,  997,  180],\n",
       "       [ 791,  836,  322,  487,  194,  999,  180],\n",
       "       [ 891,  836,  324,  486,  194,  997,  180],\n",
       "       [ 991,  834,  324,  487,  194,  999,  180],\n",
       "       [  91,  836,  322,  485,  194,  999,  180],\n",
       "       [ 191,  830,  322,  486,  194, 1000,  180],\n",
       "       [ 291,  836,  322,  486,  194, 1002,  180],\n",
       "       [ 391,  837,  323,  487,  194, 1000,  180],\n",
       "       [ 491,  836,  323,  488,  194, 1002,  180],\n",
       "       [ 591,  838,  323,  488,  193, 1001,  180],\n",
       "       [ 691,  835,  324,  487,  194,  998,  180],\n",
       "       [ 791,  834,  322,  486,  194,  998,  180],\n",
       "       [ 891,  834,  322,  486,  194,  999,  180],\n",
       "       [ 991,  834,  323,  486,  194,  997,  180],\n",
       "       [  91,  834,  322,  488,  194,  998,  180],\n",
       "       [ 191,  837,  323,  488,  194,  999,  179],\n",
       "       [ 291,  837,  324,  488,  194, 1000,  179],\n",
       "       [ 391,  834,  322,  486,  194, 1002,  180],\n",
       "       [ 491,  836,  322,  486,  194, 1000,  180],\n",
       "       [ 591,  837,  322,  487,  194, 1002,  180],\n",
       "       [ 691,  837,  323,  487,  194, 1000,  180],\n",
       "       [ 791,  834,  322,  488,  194, 1000,  180],\n",
       "       [ 891,  835,  323,  488,  194,  998,  180],\n",
       "       [ 991,  834,  322,  486,  194,  998,  180],\n",
       "       [  91,  835,  322,  486,  194,  997,  180],\n",
       "       [ 191,  838,  322,  486,  194, 1000,  180],\n",
       "       [ 291,  836,  322,  487,  194, 1002,  180],\n",
       "       [ 391,  837,  323,  488,  194, 1002,  181],\n",
       "       [ 491,  838,  324,  488,  194, 1000,  180]], dtype=uint16)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#|dropout\n",
    "rec_adc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## ADC time to milliseconds from start\n",
    "The logger stores internally counted milliseconds from power up. The values are stored as the milliseconds from the last second only, we need a function to add up the seconds for a continuous time stamp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.302726600Z",
     "start_time": "2023-08-31T12:54:25.075281800Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#|export\n",
    "def get_adc_time(rec_adc):\n",
    "    \"\"\"\n",
    "    Get Milliseconds from Start of ADC measurement.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    rec_adc: ndarray\n",
    "        The digital counts of the ADC from the logger file.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    ndarray\n",
    "        Milliseconds from start of the measurement.\n",
    "    \"\"\"\n",
    "    # get millisecond part\n",
    "    ta = rec_adc[:,0].astype('timedelta64[ms]')\n",
    "    # get time difference between records\n",
    "    dt = np.diff(ta)\n",
    "    dt[dt<np.timedelta64(-850,'ms')] += 1000\n",
    "    # get cummulative time offset rel. to first ADC record\n",
    "    ta[0] = 0\n",
    "    ta[1:] = np.cumsum(dt)\n",
    "    return ta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.322748Z",
     "start_time": "2023-08-31T12:54:25.088720300Z"
    },
    "collapsed": false,
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,  100,  200,  300,  400,  500,  600,  700,  800,  900, 1000,\n",
       "       1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000, 2100,\n",
       "       2200, 2300, 2400, 2500, 2600, 2700, 2800, 2900, 3000, 3100, 3200,\n",
       "       3300, 3400, 3500, 3600, 3700, 3800, 3900, 4000, 4100, 4200, 4300,\n",
       "       4400, 4500, 4600, 4700, 4800, 4900, 5000, 5100, 5200, 5300, 5400,\n",
       "       5500, 5600, 5700, 5800, 5900, 6000, 6100, 6200, 6300, 6400, 6500,\n",
       "       6600, 6700, 6800, 6900, 7000, 7100, 7200, 7300, 7400, 7500, 7600],\n",
       "      dtype='timedelta64[ms]')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#|hideout\n",
    "get_adc_time(rec_adc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Sync GPS time to ADC records\n",
    "The ADC is timed internally by the processor clock. This is prone to be not accurate. The following function attaches the GPS time to ADC samples in between two GPS lines by linear regression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:25.908369100Z",
     "start_time": "2023-08-31T12:54:25.108139700Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get millisecond part\n",
    "ta = get_adc_time(rec_adc)\n",
    "### 2. Get logger clock for GPRMC records\n",
    "# get time of previous ADC record\n",
    "t1 = ta[rec_gprmc.iadc]/np.timedelta64(1,'ms')\n",
    "# time of GPS records from GPRMC record\n",
    "t2 = (rec_gprmc.time-rec_gprmc.time[0])/np.timedelta64(1,'ms')\n",
    "a,b = linregress(t1,t2)[:2]\n",
    "t = rec_gprmc.time[0]+ta*a+b.astype('timedelta64[ms]')\n",
    "\n",
    "fig,ax = plt.subplots(1,1)\n",
    "_ = ax.plot(ta/np.timedelta64(1,'ms'),\n",
    "            a*ta/np.timedelta64(1,'ms')+b,\n",
    "            'r.', label='ADC records')\n",
    "_ = ax.plot(t1,t2,'k.', label='GPS records')\n",
    "_ = ax.grid(True)\n",
    "_ = ax.legend()\n",
    "_ = ax.set_ylabel(\"GPS milliseconds from first GPS record\")\n",
    "_ = ax.set_xlabel(\"ADC milliseconds from first GPS record\")\n",
    "fig.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.076441400Z",
     "start_time": "2023-08-31T12:54:25.898233400Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#|export\n",
    "def sync_adc_time(adctime, gpstime, iadc, check_results=True):\n",
    "    '''\n",
    "    Synchronize the ADC time to the GPS records\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    adctime: ndarray\n",
    "        Milliseconds from start of the ADC measurement.\n",
    "    gpstime: ndarray\n",
    "        GPS time\n",
    "    iadc: ndarray of int\n",
    "        Index of the last ADC sample before a GPS record has been stored.\n",
    "    check_results: bool\n",
    "        If True, check plausibility of fitted slope and offset (abs(slope)<10s/day; abs(offset)<2s).\n",
    "        The default is True\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    time: ndarray(datetime64[ms])\n",
    "        The time of the ADC records\n",
    "    '''\n",
    "    # assure milliseconds\n",
    "    ta = adctime.astype('timedelta64[ms]')\n",
    "    # assure int type\n",
    "    iadc = np.array(iadc).astype(int)\n",
    "    # get GPStime of the previous ADC record\n",
    "    # here we assume, that the last ADC sample stored before a GPS record\n",
    "    # has the same time as the GPS timestamp\n",
    "    t1 = ta[iadc]/np.timedelta64(1,'ms')\n",
    "    # time of GPS records from GPRMC record\n",
    "    t2 = (gpstime-gpstime[0])/np.timedelta64(1,'ms')\n",
    "    a,b = linregress(t1,t2)[:2]\n",
    "    t = gpstime[0]+ta*a+b.astype('timedelta64[ms]')\n",
    "\n",
    "    drift = (1/a-1)*86400\n",
    "    logger.info('Sync ADC time to GPS Fit Summary:')\n",
    "    logger.info('|-- Drift  : {0:7.2f} [s/day]'.format(drift))\n",
    "    logger.info('|-- Slope  : {0:13.8f}'.format(a))\n",
    "    logger.info('|-- Offset : {0:7.2f} [s]'.format(b/1000))\n",
    "    logger.info('|-- Jitter : {0:7.2f} [ms]'.format(np.std(t2-(a*t1+b))))\n",
    "    \n",
    "    if check_results:\n",
    "        if np.abs(drift)>10:\n",
    "            logger.warning(\"Absolute ADC drift larger than 10 s/day.\")\n",
    "            return None\n",
    "    return t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.078646800Z",
     "start_time": "2023-08-31T12:54:25.928316200Z"
    },
    "collapsed": false,
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2022-08-30T11:21:01.443', '2022-08-30T11:21:01.545',\n",
       "       '2022-08-30T11:21:01.647', '2022-08-30T11:21:01.750',\n",
       "       '2022-08-30T11:21:01.852', '2022-08-30T11:21:01.955',\n",
       "       '2022-08-30T11:21:02.057', '2022-08-30T11:21:02.160',\n",
       "       '2022-08-30T11:21:02.262', '2022-08-30T11:21:02.364',\n",
       "       '2022-08-30T11:21:02.467', '2022-08-30T11:21:02.569',\n",
       "       '2022-08-30T11:21:02.672', '2022-08-30T11:21:02.774',\n",
       "       '2022-08-30T11:21:02.877', '2022-08-30T11:21:02.979',\n",
       "       '2022-08-30T11:21:03.081', '2022-08-30T11:21:03.184',\n",
       "       '2022-08-30T11:21:03.286', '2022-08-30T11:21:03.389',\n",
       "       '2022-08-30T11:21:03.491', '2022-08-30T11:21:03.594',\n",
       "       '2022-08-30T11:21:03.696', '2022-08-30T11:21:03.799',\n",
       "       '2022-08-30T11:21:03.901', '2022-08-30T11:21:04.003',\n",
       "       '2022-08-30T11:21:04.106', '2022-08-30T11:21:04.208',\n",
       "       '2022-08-30T11:21:04.311', '2022-08-30T11:21:04.413',\n",
       "       '2022-08-30T11:21:04.516', '2022-08-30T11:21:04.618',\n",
       "       '2022-08-30T11:21:04.720', '2022-08-30T11:21:04.823',\n",
       "       '2022-08-30T11:21:04.925', '2022-08-30T11:21:05.028',\n",
       "       '2022-08-30T11:21:05.130', '2022-08-30T11:21:05.233',\n",
       "       '2022-08-30T11:21:05.335', '2022-08-30T11:21:05.438',\n",
       "       '2022-08-30T11:21:05.540', '2022-08-30T11:21:05.642',\n",
       "       '2022-08-30T11:21:05.745', '2022-08-30T11:21:05.847',\n",
       "       '2022-08-30T11:21:05.950', '2022-08-30T11:21:06.052',\n",
       "       '2022-08-30T11:21:06.155', '2022-08-30T11:21:06.257',\n",
       "       '2022-08-30T11:21:06.359', '2022-08-30T11:21:06.462',\n",
       "       '2022-08-30T11:21:06.564', '2022-08-30T11:21:06.667',\n",
       "       '2022-08-30T11:21:06.769', '2022-08-30T11:21:06.872',\n",
       "       '2022-08-30T11:21:06.974', '2022-08-30T11:21:07.077',\n",
       "       '2022-08-30T11:21:07.179', '2022-08-30T11:21:07.281',\n",
       "       '2022-08-30T11:21:07.384', '2022-08-30T11:21:07.486',\n",
       "       '2022-08-30T11:21:07.589', '2022-08-30T11:21:07.691',\n",
       "       '2022-08-30T11:21:07.794', '2022-08-30T11:21:07.896',\n",
       "       '2022-08-30T11:21:07.998', '2022-08-30T11:21:08.101',\n",
       "       '2022-08-30T11:21:08.203', '2022-08-30T11:21:08.306',\n",
       "       '2022-08-30T11:21:08.408', '2022-08-30T11:21:08.511',\n",
       "       '2022-08-30T11:21:08.613', '2022-08-30T11:21:08.715',\n",
       "       '2022-08-30T11:21:08.818', '2022-08-30T11:21:08.920',\n",
       "       '2022-08-30T11:21:09.023', '2022-08-30T11:21:09.125',\n",
       "       '2022-08-30T11:21:09.228'], dtype='datetime64[ms]')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#|dropout\n",
    "adctime = get_adc_time(rec_adc)\n",
    "time = sync_adc_time(\n",
    "    adctime=adctime,\n",
    "    gpstime=rec_gprmc.time,\n",
    "    iadc=rec_gprmc.iadc,\n",
    "    check_results=False\n",
    ")\n",
    "time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Binning of ADC values\n",
    "The original time resolution is about 10Hz. Here we apply binning of ADC samples to a regular spaced time grid.\n",
    "\n",
    "We declare *bins* as the desired number of bins per day, e.g. ```bins = 86400``` one bin every second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.117219300Z",
     "start_time": "2023-08-31T12:54:25.968026700Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Desired bins per day\n",
    "bins = 86400"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Now we can calculate the bin number each sample is assigned to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.118487800Z",
     "start_time": "2023-08-31T12:54:26.002083900Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([40861, 40861, 40861, 40861, 40861, 40861, 40862, 40862, 40862,\n",
       "       40862, 40862, 40862, 40862, 40862, 40862, 40862, 40863, 40863,\n",
       "       40863, 40863, 40863, 40863, 40863, 40863, 40863, 40864, 40864,\n",
       "       40864, 40864, 40864, 40864, 40864, 40864, 40864, 40864, 40865,\n",
       "       40865, 40865, 40865, 40865, 40865, 40865, 40865, 40865, 40865,\n",
       "       40866, 40866, 40866, 40866, 40866, 40866, 40866, 40866, 40866,\n",
       "       40866, 40867, 40867, 40867, 40867, 40867, 40867, 40867, 40867,\n",
       "       40867, 40867, 40868, 40868, 40868, 40868, 40868, 40868, 40868,\n",
       "       40868, 40868, 40869, 40869, 40869])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# starting day\n",
    "t0 = time[0].astype('datetime64[D]')\n",
    "# convert time to 'days from t0'\n",
    "dday = (time-t0)/np.timedelta64(1,'D')\n",
    "# calculate the bin number assigned to every sample\n",
    "it = np.int64(dday*bins)\n",
    "it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Calculate number of samples per bins (*cnt*) and a bin index starting with the first bin (*inv_idx*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.119495700Z",
     "start_time": "2023-08-31T12:54:26.050743200Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([40861, 40862, 40863, 40864, 40865, 40866, 40867, 40868, 40869]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,\n",
       "        2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n",
       "        4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7,\n",
       "        7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8]),\n",
       " array([ 6, 10,  9, 10, 10, 10, 10,  9,  3]))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "uval,inv_idx,cnt = np.unique(it,return_inverse=True,return_counts=True)\n",
    "uval,inv_idx,cnt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Now [np.bincount](https://numpy.org/doc/stable/reference/generated/numpy.bincount.html) can be used to calculate the average value of the samples in every bin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.151571Z",
     "start_time": "2023-08-31T12:54:26.074518600Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rec_adc values of the fist bin, 3rd column\n",
      "[322 322 322 322 324 324]\n",
      "Average calculated with bincount:\n",
      "322.6666666666667\n"
     ]
    }
   ],
   "source": [
    "binvalues = np.bincount(inv_idx,weights=rec_adc[:,2])/cnt\n",
    "print('rec_adc values of the fist bin, 3rd column')\n",
    "print(rec_adc[inv_idx==0,2])\n",
    "print(\"Average calculated with bincount:\")\n",
    "print(binvalues[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Time values for each bin are assigned as the starting boundary of the sample times within the bin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.172619700Z",
     "start_time": "2023-08-31T12:54:26.094134200Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sample time for the fist bin:\n",
      "['2022-08-30T11:21:01.443' '2022-08-30T11:21:01.545'\n",
      " '2022-08-30T11:21:01.647' '2022-08-30T11:21:01.750'\n",
      " '2022-08-30T11:21:01.852' '2022-08-30T11:21:01.955']\n",
      "Assigned bin time:\n",
      "2022-08-30T11:21:01.000\n"
     ]
    }
   ],
   "source": [
    "# assign bin time\n",
    "bintime = t0+ np.timedelta64(86400000,'ms')*uval.astype(np.float64)/bins\n",
    "print('sample time for the fist bin:')\n",
    "print(time[inv_idx==0])\n",
    "print(\"Assigned bin time:\")\n",
    "print(bintime[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.394789500Z",
     "start_time": "2023-08-31T12:54:26.113015800Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#|export\n",
    "def adc_binning(rec_adc, time, bins=86400):\n",
    "    \"\"\"\n",
    "    Binning and averaging of ADC samples\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    rec_adc: ndarray\n",
    "        The ADC records parsed from the logger.\n",
    "    time: ndarray of time objects\n",
    "        Sample time of ADC records.\n",
    "    bins: int\n",
    "        Number of desired bins per day. The default is 86400, which result in\n",
    "        mean values of 1 second steps per day. Maximum resolution is 86400000.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    ndarray, ndarray(datetime64)\n",
    "        Binned ADC records and corresponding time.\n",
    "    \"\"\"\n",
    "    time = utils.to_datetime64(time)\n",
    "    # starting day\n",
    "    t0 = time[0].astype('datetime64[D]')\n",
    "    # convert time to 'days from t0'\n",
    "    dday = (time-t0)/np.timedelta64(1,'D')\n",
    "    # calculate time bins of output dataset\n",
    "    it = np.int64(dday*bins)\n",
    "    # index for unique bins (inv_idx) and count of samples per bin (cnt)\n",
    "    uval, inv_idx, cnt = np.unique(it,\n",
    "                                   return_inverse=True,\n",
    "                                   return_counts=True)\n",
    "    logger.info(f\"ADC records fill {len(uval)} bins of data.\")\n",
    "    # Calculate average of sample values per bin\n",
    "    # The first two columns of rec_adc will be omitted as they store the\n",
    "    # internal measures for timing and battery (first two columns)\n",
    "    V = np.zeros((len(uval),rec_adc.shape[1]-2))\n",
    "    for i in range(V.shape[1]):\n",
    "        V[:,i] = np.bincount(inv_idx,weights=rec_adc[:,i+2])/cnt\n",
    "    bintime = t0+ np.timedelta64(86400000,'ms')*uval.astype(np.float64)/bins\n",
    "    logger.info(f\"ADC records span a time period from {bintime[0]} to {bintime[-1]}.\")\n",
    "    return V, bintime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    " In a similar way we can do it for a dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.396783100Z",
     "start_time": "2023-08-31T12:54:26.133238600Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#|export\n",
    "def resample_mean(ds,freq='1s'):\n",
    "\n",
    "    # start and end bin time\n",
    "    start_time = np.datetime64(\n",
    "       pd.to_datetime(ds.time.values[0]).floor(freq)\n",
    "    )\n",
    "    end_time = np.datetime64(\n",
    "        pd.to_datetime(ds.time.values[-1]).floor(freq)\n",
    "    )\n",
    "\n",
    "    # bin time\n",
    "    bintime = pd.date_range(\n",
    "        start_time,\n",
    "        end_time,\n",
    "        freq=freq\n",
    "    ).floor(freq)\n",
    "\n",
    "    ds_r = ds.assign_coords(\n",
    "        {\n",
    "            \"time_resampled\": (\"time_resampled\", bintime)\n",
    "        }\n",
    "    )\n",
    "\n",
    "    # calculate bin index of output dataset\n",
    "    it = np.int64(\n",
    "        (ds.time.values - start_time)/pd.Timedelta(freq)\n",
    "    )\n",
    "\n",
    "    # index for unique bins (inv_idx) and count of samples per bin (cnt)\n",
    "    uval, inv_idx, cnt = np.unique(it,\n",
    "                                   return_inverse=True,\n",
    "                                   return_counts=True)\n",
    "\n",
    "    # apply to all time dependent variables\n",
    "    for var in ds:\n",
    "        if 'time' in ds[var].dims:\n",
    "            # replace time dimension with time_resampled\n",
    "            vardims = ds[var].dims\n",
    "            newdims = [d if d!='time' else 'time_resampled' for d in vardims]\n",
    "            # if only time dimension, take the shortcut\n",
    "            if len(vardims)==1:\n",
    "                newval = np.bincount(inv_idx,weights=ds[var].values)/cnt\n",
    "                ds_r = ds_r.assign( {var: (newdims, newval)})\n",
    "            elif len(vardims)==2: # more than the time dimension, assume 2\n",
    "                N = ds[var].shape[1]\n",
    "                newval = np.zeros((bintime.size,N))\n",
    "                for i in range(N):\n",
    "                    newval[:,i] = np.bincount(inv_idx,weights=ds[var].values[:,i])/cnt\n",
    "                ds_r = ds_r.assign( {var: (newdims, newval)})\n",
    "            else:\n",
    "                raise ValueError(\"logger.resample is implemented for 2dims only.\")\n",
    "        # add attributes again\n",
    "        ds_r[var].attrs.update(ds[var].attrs)\n",
    "        ds_r[var].encoding.update(ds[var].encoding)\n",
    "\n",
    "    # drop original time and rename\n",
    "    ds_r = ds_r.drop_dims(\"time\").rename({\"time_resampled\":\"time\"})\n",
    "    # add time encoding\n",
    "    ds_r.time.encoding.update({\n",
    "        \"units\": f\"seconds since {np.datetime_as_string(ds_r.time.data[0], unit='D')}T00:00Z\",\n",
    "    })\n",
    "\n",
    "    return ds_r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Interpolate GPS coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:26.427699700Z",
     "start_time": "2023-08-31T12:54:26.146843900Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#|export\n",
    "def interpolate_coords(rec_gprmc, time):\n",
    "    \"\"\"\n",
    "    Interpolate lat and lon from gps records\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    rec_gprmc: recarray\n",
    "        The GPRMC records from the logger file\n",
    "    time: list or array of time objects\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    ndarray, ndarray\n",
    "        lat and lon interpolated from GPS records to `time`\n",
    "    \"\"\"\n",
    "    time = utils.to_datetime64(time)\n",
    "    t0 = time[0].astype('datetime64[D]')\n",
    "    # coordinate variables\n",
    "    x1 = (time-t0)/np.timedelta64(1,'ms')\n",
    "    x2 = (rec_gprmc.time-t0)/np.timedelta64(1,'ms')\n",
    "    lat = np.interp(x1,x2,rec_gprmc.lat)\n",
    "    lon = np.interp(x1,x2,rec_gprmc.lon)\n",
    "    return lat, lon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-31T12:54:29.060939800Z",
     "start_time": "2023-08-31T12:54:26.162882100Z"
    },
    "collapsed": false,
    "tags": [
     "remove-cell",
     "hide-input",
     "hide-output"
    ]
   },
   "outputs": [],
   "source": [
    "#|hide\n",
    "# Export module\n",
    "# Requires *nbdev* to export and update the *../lib/logger.py* module\n",
    "import nbdev.export\n",
    "import nbformat as nbf\n",
    "name = \"logger\"\n",
    "\n",
    "# Export python module\n",
    "nbdev.export.nb_export( f\"{name}.ipynb\" ,f\"../../src/pyrnet\")\n",
    "\n",
    "# Export to docs\n",
    "ntbk = nbf.read(f\"{name}.ipynb\", nbf.NO_CONVERT)\n",
    "\n",
    "text_search_dict = {\n",
    "    \"#|hide\": \"remove-cell\",  # Remove the whole cell\n",
    "    \"#|dropcode\": \"hide-input\",  # Hide the input w/ a button to show\n",
    "    \"#|dropout\": \"hide-output\"  # Hide the output w/ a button to show\n",
    "}\n",
    "for cell in ntbk.cells:\n",
    "    cell_tags = cell.get('metadata', {}).get('tags', [])\n",
    "    for key, val in text_search_dict.items():\n",
    "            if key in cell['source']:\n",
    "                if val not in cell_tags:\n",
    "                    cell_tags.append(val)\n",
    "    if len(cell_tags) > 0:\n",
    "        cell['metadata']['tags'] = cell_tags\n",
    "    nbf.write(ntbk, f\"../../docs/source/nbs/{name}.ipynb\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}