root/track/trunk/track.py

#!/usr/bin/env python

"""
Parse glider surface positions from glider logs.

Usage:

   python track.py [positions [start_date [end_date]]]

   where (optional) positions are the number of positions to report, and

   where (optional) start_date and end_date are of the form: YYYYMMDD.

       start_date is inclusive; stop_date is exclusive.

   An exception is raised if start_date > stop_date.
"""

import sys
import os
import re
from datetime import datetime, timedelta
from glob import glob

glider_dir = '/var/opt/gmc/gliders'
gliders = ['pelagia', 'ramses']
comms = ['freewave', 'network', ]
positions = 10  # report most recent number of positions
tomorrow = datetime.now() + timedelta(1)
start_date = '20120125'                       # inclusive
stop_date = '%04d%02d%02d' % (tomorrow.year,  # exclusive
                              tomorrow.month,
                              tomorrow.day)
file_pattern_template = "%s_%s_%04d%02d%02dT*.log"
p_pattern = re.compile(r"^GPS Location:\s+(\S+)\s+\S\s+(\S+)"
                       r"\s+\S\s+\S+\s+(\S+)\s+")
c_pattern = re.compile(r"^Curr Time:\s+(\S+)\s+(\S+)\s+(\S+)"
                       r"\s+(\S+)\s+(\S+)\s+")
bad_coordinate = "69696969.000"
bad_freshness = "1e+308"
stale = 120.0  # position must not be older than this many seconds
delta = timedelta(seconds=600)  # positions must be this many seconds apart
months = {'Jan': 1,
          'Feb': 2,
          'Mar': 3,
          'Apr': 4,
          'May': 5,
          'Jun': 6,
          'Jul': 7,
          'Aug': 8,
          'Sep': 9,
          'Oct': 10,
          'Nov': 11,
          'Dec': 12}
shtnom = {}
for month in months:
    shtnom[months[month]] = month
weekdays = {0: 'Mon',
            1: 'Tue',
            2: 'Wed',
            3: 'Thu',
            4: 'Fri',
            5: 'Sat',
            6: 'Sun'}


def find(gliders=gliders,
         start_date=start_date,
         stop_date=stop_date):
    start_datetime = datetime(int(start_date[:4]),
                              int(start_date[4:6]),
                              int(start_date[6:]))
    stop_datetime = datetime(int(stop_date[:4]),
                             int(stop_date[4:6]),
                             int(stop_date[6:]))
    try:
        assert start_datetime < stop_datetime
    except AssertionError:
        print >> sys.stderr, "Start date is not less than stop date."
        print __doc__
        sys.exit(2)

    date = start_datetime
    date_range = []
    while date < stop_datetime:
        date_range.append(date)
        date += timedelta(1)

    file_patterns = {}
    for glider in gliders:
        file_patterns[glider] = [file_pattern_template % (glider,
                                                          comm,
                                                          date.year,
                                                          date.month,
                                                          date.day,)
                                 for comm in comms
                                 for date in date_range]

    log_dirs = {}
    for glider in gliders:
        log_dirs[glider] = os.path.join(glider_dir, glider, 'logs')

    file_paths = {}
    for glider in gliders:
        file_paths[glider] = []
        for file_pattern in file_patterns[glider]:
            file_paths[glider].extend(glob(os.path.join(log_dirs[glider],
                                                        file_pattern)))
    return file_paths


def parse(gliders=gliders,
          start_date=start_date,
          stop_date=stop_date):
    file_paths = find(gliders, start_date, stop_date)
    points = {}
    for glider in gliders:
        points[glider] = []
        for file_path in file_paths[glider]:
            handle = open(file_path)
            contents = handle.readlines()
            handle.close()
            protents = contents[4:]
            xref = zip(protents, contents)
            for pline, cline in xref:
                match = p_pattern.search(pline)
                if match:
                    lat, lon, fresh = match.groups()
                    if lat == bad_coordinate:
                        continue
                    if lon == bad_coordinate:
                        continue
                    if fresh == bad_freshness:
                        continue
                    # if float(fresh) >= stale:
                    #     continue
                    match = c_pattern.search(cline)
                    if match:
                        weekday, month, day, time, year = match.groups()
                        year = int(year)
                        month = months[month]
                        day = int(day)
                        hour = int(time[0:2])
                        minute = int(time[3:5])
                        second = int(time[6:8])
                        stamp = datetime(year, month, day,
                                         hour, minute, second)
                        stamp = stamp - timedelta(seconds=float(fresh))
                        points[glider].append({'lat': lat,
                                               'lon': lon,
                                               'fresh': fresh,
                                               'stamp': stamp, }),
                        break

        points[glider].sort(cmp=lambda x, y: cmp(x['stamp'], y['stamp']))
        # If two adjacent positions differ in time by less than delta,
        # then remove the earlier position from the report.
        # This effect is cumulative for a string of adjacent positions.
        for pointa, pointb in zip(points[glider][:-1], points[glider][1:]):
            if pointb['stamp'] - pointa['stamp'] < delta:
                points[glider].remove(pointa)

    return points

if __name__ == '__main__':
    if not (len(sys.argv) < 5):
        sys.exit(__doc__)

    try:
        positions = int(sys.argv[1])
    except:
        pass

    try:
        start_date = sys.argv[2]
        int(start_date)
    except:
        pass

    try:
        stop_date = sys.argv[3]
        int(stop_date)
    except:
        pass

    points = parse(gliders, start_date, stop_date)
    spec = "Glider: %s, Lat: %s, Lon: %s on %s %s %02d, " \
           "%04d at %02d:%02d:%02d UTC\n"
    for glider in gliders:
        for point in points[glider][-positions:]:
            print spec % (glider,
                          point['lat'],
                          point['lon'],
                          weekdays[point['stamp'].weekday()],
                          shtnom[point['stamp'].month],
                          point['stamp'].day,
                          point['stamp'].year,
                          point['stamp'].hour,
                          point['stamp'].minute,
                          point['stamp'].second)