root/sodar/trunk/sodar/processedData.py

#!/usr/bin/python
"""
Classes to handle processed sodar data samples.

A list of sample data.

A list of dictionaries, each with an item for header and body data.

A list of dictionaries of sample data, each with a two items:
    a header dictionary, and
    a body list of alitude dictionaries.
"""

__author__ = 'Chris Calloway'
__email__ = 'cbc@unc.edu'
__copyright__ = 'Copyright 2007 UNC-CH Department of Marine Science'
__license__ = 'GPL2'

import rawData
import numpy as n
import datetime

class ProcessedData(list):
    
    """Processed daily sodar file data.
    
       A list of rawData.Sample deep copies.
    """
    
    def __init__(self, data):
        """Prepare raw sodar daily data for analysis."""
        super(ProcessedData, self).__init__()
        self.extend([sample.data() for sample in data])
        self._normalize()

    def _normalize(self):
        """Clean up data for analysis."""
        self._convert()
        self._stamp()
        self._sampleInterval()
        # correct for missing times
        self._minimumAltitude()
        self._maximumAltitude()
        # compute number of altitudes
        # compute altitude interval
        # correct for missing altitudes
        # mark maximum altitude with good values for each sample
        # mark minimum altitude with invalid values for each sample
        # convert direction to radians
        # compute u,v,c components
        # compute colorspecs
        # compute plotting parameters
    
    def _convert(self):
        """Convert data to numbers and correct for invalid values."""
        INVALID = "-9999"
        for sample in self:
            # convert header data to integers
            for key,value in sample['header'].items():
                try:
                    if value == INVALID:
                        raise ValueError
                    sample['header'][key] = int(value)
                except (ValueError, TypeError):
                    sample['header'][key] = n.NaN
            # convert body data to floats
            for altitude in sample['body']:
                for key,value in altitude.items():
                    try:
                        if value == INVALID:
                            raise ValueError
                        altitude[key] = float(value)
                    except (ValueError, TypeError):
                        altitude[key] = n.NaN
    
    def _stamp(self):
        """Add a datetime stamp item to each sample."""
        for sample in self:
            try:
                header = sample['header']
                sample['stamp'] = datetime.datetime(header['YEAR'],
                                                    header['MONTH'],
                                                    header['DAY'],
                                                    header['HOUR'],
                                                    header['MIN'])
            except (KeyError, TypeError):
                sample['stamp'] = datetime.datetime.min
    
    def _sampleInterval(self):
        """Add a sample interval attribute."""
        intervals = zip([sample['stamp'] for sample in self[:-1]],
                        [sample['stamp'] for sample in self[1:]])
        intervals = [interval[1] - interval[0] for interval in intervals]
        intervals = [interval for interval in intervals if interval]
        intervals = [interval for interval in intervals
                     if interval != datetime.datetime.min]
        try:
            self.interval = min(intervals)
        except ValueError:
            self.interval = datetime.datetime.min
    
    def _minimumAltitude(self):
        """Add an overall minimum altitude attribute."""
        accumulator = {}
        for sample in self:
            minalt = sample['body'][0]['ALT']
            sample['header']['minalt'] = minalt
            if minalt is not n.NaN:
                if minalt in accumulator:
                    accumulator[minalt] += 1
                else:
                    accumulator[minalt] = 1
        maxVotes = max(accumulator.values())
        for key,value in accumulator.items():
            if value == maxVotes:
                self.minimumAltitude = key
                break
        self.minimumAltitude = getattr(self,
                                       'minimumAltitude',
                                       n.NaN)

    
    def _maximumAltitude(self):
        """Add an overall maximum altitude attribute."""
        accumulator = {}
        for sample in self:
            maxalt = sample['body'][-1]['ALT']
            sample['header']['maxalt'] = maxalt
            if maxalt is not n.NaN:
                if maxalt in accumulator:
                    accumulator[maxalt] += 1
                else:
                    accumulator[maxalt] = 1
        maxVotes = max(accumulator.values())
        for key,value in accumulator.items():
            if value == maxVotes:
                self.maximumAltitude = key
                break
        self.maximumAltitude = getattr(self,
                                       'maximumAltitude',
                                       n.NaN)
def _main():
    """Process as script from command line."""
    import urllib2
    try:
        rawDataHandle = urllib2.urlopen('http://nemo.isis.unc.edu/'\
                                        'data/nccoos/level0/dukeforest/sodar/'\
                                        'store/2007-06/20070601.dat')
        rawDataString = rawDataHandle.read()
    except:
        raise IOError("Failure to read raw test data")
    rawDataObject = rawData.RawData(rawDataString)
    processedDataObject = ProcessedData(rawDataObject)

if __name__ == "__main__":
    _main()