root/MGET/Branches/Jason/PythonPackage/src/GeoEco/SpatialAnalysis/Temporal.py @ 974

# SpatialAnalysis/Temporal.py - Classes for temporal analysis.
#
# Copyright (C) 2012 Jason J. Roberts
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License (available in the file LICENSE.TXT)
# for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

import datetime
import itertools
import math

from GeoEco.DynamicDocString import DynamicDocString
from GeoEco.Internationalization import _
from GeoEco.Logging import Logger


class Periodicity(object):
    __doc__ = DynamicDocString()

    @classmethod
    def AnalyzeTable(cls, table, dateField, valueField=None, normalizationField=None, aggregationMethod=u'Mean', where=None, binWidth=None, timeUnits=None, yAxisLabel=None, scaleFactor=None, samplingPeriod=None, maxPeriod=400., periodogramMethod=u'Lomb-Scargle', oversamplingFactor=4., outputFile=None, title=None, width=4., dpi=300., dayOfYearPlot=u'Automatic', moonPhasePlot=u'Automatic', timeOfDayPlot=u'Automatic', overwriteExisting=False):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Perform additional validation.

        if valueField is None:
            normalizationField = None

        if normalizationField is not None and aggregationMethod == u'sum':
            raise ValueError(_(u'A normalization field was specified and "sum" aggregation was requested. This is not allowed. "Sum" aggregation may only be requested if a normalization field is not specified.'))

        if binWidth is not None and timeUnits == u'automatic':
            raise ValueError(_(u'A bin width was specified but the time units were not. This is not allowed. If a bin width is specified, the time units must also be specified.'))

        # Read the data from the table into a dictionary that maps
        # dates to values for those dates. If the caller's data have
        # high temporal precision then each date will usually have
        # just one value. But many datasets are not that precise--they
        # may have a date with no time component, for example. These
        # may have more than one value per date. Later, we may need
        # to average or sum them together, as requested by the caller.

        import numpy

        Logger.Info(_(u'Retrieving records to analyze from %(table)s.') % {u'table': table.DisplayName})

        countsForDates = {}
        valuesForDates = {}
        normalizeByForDates = {}
        minDate = None
        maxDate = None

        if where is None:
            cursor = table.OpenSelectCursor(rowCount=table.GetRowCount())     # Provide a value for rowCount, so the ArcGIS progressor will be used.
        else:
            cursor = table.OpenSelectCursor(where=where)
        try:
            while cursor.NextRow():
                date = cursor.GetValue(dateField)
                if date is None:
                    continue

                if valueField is not None:
                    value = cursor.GetValue(valueField)
                    if value is None:
                        continue
                    value = float(value)
                
                if normalizationField is not None:
                    normalizeBy = cursor.GetValue(normalizationField)
                    if normalizeBy is None or normalizeBy == 0:
                        continue
                    normalizeBy = float(normalizeBy)

                if date not in countsForDates:
                    countsForDates[date] = 1
                    if valueField is not None:
                        valuesForDates[date] = [value]
                    if normalizationField is not None:
                        normalizeByForDates[date] = [normalizeBy]
                else:
                    countsForDates[date] += 1
                    if valueField is not None:
                        valuesForDates[date].append(value)
                    if normalizationField is not None:
                        normalizeByForDates[date].append(normalizeBy)

                if minDate is None or date < minDate:
                    minDate = date
                if maxDate is None or date > maxDate:
                    maxDate = date
        finally:
            del cursor

        # Validate that we got some data to analyze.

        if len(countsForDates) <= 0:
            if where is None:
                raise ValueError(_(u'There are no records in %(table)s to analyze.') % {u'table': table.DisplayName})
            raise ValueError(_(u'There were no records in %(table)s selected by the where clause %(where)s') % {u'table': table.DisplayName, u'where': where})

        # Build an ascending list of dates.

        dates = sorted(countsForDates.keys())

        # Determine if the dates have time components.

        datesHaveTimes = False
        for i in range(1, len(dates)):
            if dates[i].hour != dates[i-1].hour or dates[i].minute != dates[i-1].minute or dates[i].second != dates[i-1].second or dates[i].microsecond != dates[i-1].microsecond:
                datesHaveTimes = True
                break

        # If the caller did not specify a sampling period, choose 1
        # hour or 1 day, depending on whether or not the dates have
        # time components.

        if samplingPeriod is None:
            if datesHaveTimes:
                samplingPeriod = 1./24
            else:
                samplingPeriod = 1.

        # Otherwise (the caller did not specify a sampling period) and
        # the caller specified a sampling period of less than 1 day
        # but the dates do not include time components, set the
        # sampling period to 1 day. (Daily periodicity cannot be
        # detected without time components, so there is no use
        # checking for it. Doing so will just produce big spectral
        # power spikes at 1 day and its harmonics, which will be
        # confusing to interpret.)

        elif samplingPeriod < 1. and not datesHaveTimes:
            samplingPeriod = 1.
            Logger.Warning(_(u'A sampling period of less than 1 day was specified but the dates in %(dn)s do not have time components. Without times, it is not possible to detect daily periodicity and therefore there is no reason to use such a small sampling period. A sampling period of 1 day will be used instead.') % {u'dn': table.DisplayName})

        # Validate that the duration of the data is long enough.

        if minDate == maxDate:
            raise ValueError(_(u'All of the records have the same date (%(date)s). To analyze temporal periodicity, the records must have some variation in their dates.') % {u'date': minDate.strftime('%c')})

        dataDuration = maxDate - minDate
        dataDuration = float(dataDuration.days) + dataDuration.seconds/86400. + dataDuration.microseconds/(86400.*1000000.)
        if dataDuration <= samplingPeriod * 2:
            raise ValueError(_(u'The sampling period (%(sp)g days) is greater than one-half of the duration of the records (%(dur)g days). In order for a signal to be detected, the duration of the records must be at least twice as long as the sampling period. Please decrease the sampling period or select records that cover a longer duration.') % {u'sp': samplingPeriod, u'dur': dataDuration})

        # If the caller requested the Lomb-Scargle method, calculate
        # the periodogram using lomb_scargle.py.

        if periodogramMethod.lower() == u'lomb-scargle':

            # Build a list of values for the dates. If the caller did
            # not provide a value field, then we use the count of
            # records for the dates. If the caller did provide a value
            # field then we must aggregate the values that occur on
            # the same date as requested. Note that, unlike the FFT
            # method, we do not have to aggregate values from
            # *different* dates together in order to provide values at
            # a constant time increment.

            if valueField is None:
                values = [float(countsForDates[d]) for d in dates]
            elif aggregationMethod == u'sum':
                if normalizationField is None:
                    values = [sum(valuesForDates[d]) for d in dates]
                else:
                    raise ValueError(_(u'A normalization field was specified and "sum" aggregation was requested. This is not allowed. "Sum" aggregation may only be requested if a normalization field is not specified.'))
            elif normalizationField is None:
                values = [sum(valuesForDates[d]) / countsForDates[d] if countsForDates[d] > 0 else 0. for d in dates]
            else:
                values = [sum(valuesForDates[d]) / sum(normalizeByForDates[d]) if sum(normalizeByForDates[d]) != 0. else 0. for d in dates]

            # Convert the datetime values to the number of days
            # elapsed since minDate.

            elapsed = [float((d - minDate).days) + (d - minDate).seconds/86400. + (d - minDate).microseconds/(86400.*1000000.) for d in dates]

            # Calculate the periodogram.

            from GeoEco.AssimilatedModules.lomb_scargle import fasper

            frequencies, powers, Nout, Jmax, Prob = fasper(numpy.array(elapsed), numpy.array(values), oversamplingFactor, 1./samplingPeriod)
            periods = 1/frequencies

##        # If the caller requested the fast fourier transform method,
##        # calculate the periodgram using numpy.
##
##        elif periodogramMethod.lower() == u'fft':
##
##            # TODO: REWRITE THIS CODE. FOR NOW, I'M LEAVING FFT OUT.
##
##            # Allocate a list for holding the data at the requested
##            # sampling frequency, sort the data into these buckets, and
##            # perform the requested aggregation.
##
##            n = int(math.ceil(dataDuration / samplingPeriod))
##            valueTimeSeries = [[] for i in range(n)]
##
##            for i in range(len(dates)):
##                elapsed = dates[i] - minDate
##                elapsed = float(elapsed.days) + elapsed.seconds/86400. + elapsed.microseconds/(86400.*1000000.)
##                valueTimeSeries[int(math.floor(elapsed / samplingPeriod))].append(values[i])
##
##            del values, dates
##            
##            if aggregationMethod == u'mean':
##                valueTimeSeries = [v[0] / max(1, v[1]) for v in zip([sum(v) for v in valueTimeSeries], [len(v) for v in valueTimeSeries])]
##            else:
##                valueTimeSeries = [sum(v) for v in valueTimeSeries]
##
##            # Compute a descrete Fourier Transform for the time series of
##            # values.
##
##            dft = numpy.fft.rfft(valueTimeSeries)[1:]       # Discard the zero-frequency term at index 0
##
##            if transform is None:
##                powers = abs(dft)
##            elif transform == u'square':
##                powers = abs(dft)**2
##            elif transform == u'log':
##                powers = math.log(abs(dft))
##            elif transform == u'log10':
##                powers = math.log10(abs(dft))
##            else:
##                raise ValueError(_(u'Unknown transform value.'))
##
##            periods = 1. / (numpy.arange(1, len(powers) + 1, dtype='float64')  )

        else:
            raise NotImplementedError(_(u'"%(method)s" is not a supported method for computing the periodogram.') % {u'method': periodogramMethod})

        # If the caller specified 'Automatic' for any of the radial
        # plots, determine whether we should plot them, based on the
        # temporal range and other characteristics of the data.

        if timeOfDayPlot == u'automatic':
            datesHaveTimes = False
            for i in range(1, len(dates)):
                if dates[i].hour != dates[i-1].hour or dates[i].minute != dates[i-1].minute or dates[i].second != dates[i-1].second or dates[i].microsecond != dates[i-1].microsecond:
                    datesHaveTimes = True
                    break

        dayOfYearPlot = dayOfYearPlot == u'yes' or dayOfYearPlot == u'automatic' and maxDate - minDate >= datetime.timedelta(335)
        moonPhasePlot = moonPhasePlot == u'yes' or moonPhasePlot == u'automatic' and maxDate - minDate >= datetime.timedelta(28)
        timeOfDayPlot = timeOfDayPlot == u'yes' or timeOfDayPlot == u'automatic' and maxDate - minDate >= datetime.timedelta(23./24.) and datesHaveTimes

        # Create the figure. Compute the height from the width and the
        # number of subplots.

        import matplotlib
        import matplotlib.pyplot as plt
        import matplotlib.gridspec as gridspec
        import matplotlib.lines as lines

        numRows = 2 + int(dayOfYearPlot or moonPhasePlot or timeOfDayPlot)
        numCols = max(1, int(dayOfYearPlot) + int(moonPhasePlot) + int(timeOfDayPlot))

        if outputFile is None:
            figsize = (max(6, 3 * numCols), 3 * numRows)
            dpi = 80
        else:
            figsize = (width, width * (float(numRows)/float(numCols)))
        
        fig = plt.figure(figsize=figsize, dpi=dpi)
        try:
            gs = gridspec.GridSpec(numRows, numCols)
            
            # Subplot 1: bar plot of values for dates.
            # ========================================

            # If the caller did not specify a bin width, select one
            # automatically. Our goal is to show fine resolution, so
            # we try to have 400 or 600 bins (we use 600 if the figure
            # has 3 columns) using a bin width that would be naturally
            # chosen by a person (e.g. "1 week", "30 days", etc).

            TotalSeconds = lambda dt: dt.days*86400. + dt.seconds + dt.microseconds*0.000001

            if binWidth is None:
                binWidthNames = [_(u'Hour'),
                                 _(u'4 Hours'),
                                 _(u'6 Hours'),
                                 _(u'12 Hours'),
                                 _(u'Day'),
                                 _(u'3 Days'),
                                 _(u'Week'),
                                 _(u'14 Days'),
                                 _(u'30 Days'),
                                 _(u'90 Days'),
                                 _(u'Year')]

                binWidthDeltas = [datetime.timedelta(seconds=3600),
                                  datetime.timedelta(seconds=3600*4),
                                  datetime.timedelta(seconds=3600*6),
                                  datetime.timedelta(seconds=3600*12),
                                  datetime.timedelta(days=1),
                                  datetime.timedelta(days=3),
                                  datetime.timedelta(days=7),
                                  datetime.timedelta(days=14),
                                  datetime.timedelta(days=30),
                                  datetime.timedelta(days=90),
                                  datetime.timedelta(days=365)]

                if numCols <= 2:
                    desiredBins = 400
                else:
                    desiredBins = 600

                numBinsForDeltas = [TotalSeconds(maxDate - minDate) / TotalSeconds(delta) < desiredBins for delta in binWidthDeltas]

                if True not in numBinsForDeltas:
                    binWidthInSeconds = TotalSeconds(binWidthDeltas[-1])
                    binWidthName = binWidthNames[-1]
                else:
                    binWidthInSeconds = TotalSeconds(binWidthDeltas[numBinsForDeltas.index(True)])
                    binWidthName = binWidthNames[numBinsForDeltas.index(True)]

            # Otherwise (the caller did specify a bin width), create a
            # display name for it and compute its width in seconds.

            else:
                if timeUnits == u'hours':
                    binWidthInSeconds = TotalSeconds(datetime.timedelta(hours=binWidth))
                    if binWidthInSeconds == 3600:
                        binWidthName = 'Hour'
                    elif binWidthInSeconds > 3600:
                        binWidthName = '%r Hours' % round((binWidthInSeconds / 3600), 1)
                    else:
                        binWidthName = '%r Hour' % round((binWidthInSeconds / 3600), 2)
                        
                elif timeUnits == u'days':
                    binWidthInSeconds = TotalSeconds(datetime.timedelta(binWidth))
                    if binWidthInSeconds == 86400*365:
                        binWidthName = 'Year'
                    elif binWidthInSeconds == 86400*7:
                        binWidthName = 'Week'
                    elif binWidthInSeconds == 86400:
                        binWidthName = 'Day'
                    elif binWidthInSeconds > 86400:
                        binWidthName = '%r Days' % round((binWidthInSeconds / 3600), 1)
                    else:
                        binWidthName = '%r Day' % round((binWidthInSeconds / 3600), 2)

                else:
                    raise ValueError(_(u'Programming error in this tool: Unknown timeUnits %r. Please contact the author of this tool for assistance.') % timeUnits)

            # Determine the start date for the first bin. For display
            # purposes, we want this to be rounded to a whole hour,
            # day, or year.

            if binWidthName.endswith('Hour') or binWidthName.endswith('Hours'):
                firstBinStartDate = datetime.datetime(minDate.year, minDate.month, minDate.day, minDate.hour)
            elif binWidthName.endswith('Year'):
                firstBinStartDate = datetime.datetime(minDate.year, 1, 1)
            else:
                firstBinStartDate = datetime.datetime(minDate.year, minDate.month, minDate.day)

            # Define a function that returns the start date of the bin
            # that a given date falls within.

            BinStartDate = lambda d: firstBinStartDate + datetime.timedelta(seconds=math.floor(TotalSeconds(d - firstBinStartDate) / binWidthInSeconds) * binWidthInSeconds)

            # Calculate the values of the bins.

            binStartDates = []
            binValues = []

            for binStartDate, datesInBin in itertools.groupby(dates, BinStartDate):
                binStartDates.append(binStartDate)

                if valueField is None:
                    binValues.append(sum([countsForDates[d] for d in datesInBin]))

                elif aggregationMethod == u'sum':
                    if normalizationField is None:
                        binValues.append(sum([sum(valuesForDates[d]) for d in datesInBin]))
                    else:
                        raise ValueError(_(u'A normalization field was specified and "sum" aggregation was requested. This is not allowed. "Sum" aggregation may only be requested if a normalization field is not specified.'))

                else:
                    datesInBinList = list(datesInBin)                                           # This is necessary because datesInBin is an iterator and we need to access it multiple times
                    sumOfValues = float(sum([sum(valuesForDates[d]) for d in datesInBinList]))

                    if normalizationField is None:
                        count = sum([countsForDates[d] for d in datesInBinList])
                        if count > 0:
                            binValues.append(sumOfValues / count)
                        else:
                            binValues.append(0.)

                    else:
                        sumOfNormalizeBy = float(sum([sum(normalizeByForDates[d]) for d in datesInBinList]))
                        if sumOfNormalizeBy > 0:
                            binValues.append(sumOfValues / sumOfNormalizeBy)
                        else:
                            binValues.append(0.)

            # If the caller provided a scale factor, apply it.

            if scaleFactor is not None:
                binValues = [value * scaleFactor for value in binValues]
                scaleFactorLabel = u' \xd7 %g' % scaleFactor
            else:
                scaleFactorLabel = u''

            # Now create the plot

            matplotlib.rc('xtick', direction='out')
            matplotlib.rc('ytick', direction='out')

            ax1 = plt.subplot(gs[0, :])
            ax1.bar(binStartDates, binValues, width=binWidthInSeconds / 86400., color='black', linewidth=0)     # Convert seconds to days, which matplotlib uses as width of bars when x axis uses datetimes

            if yAxisLabel is not None:
                ax1.set_ylabel(yAxisLabel)
            elif valueField is None:
                ax1.set_ylabel(u'Count / ' + binWidthName + scaleFactorLabel)
            elif aggregationMethod == u'sum':
                if normalizationField is None:
                    ax1.set_ylabel(valueField + u' / ' + binWidthName + scaleFactorLabel)
                else:
                    raise ValueError(_(u'A normalization field was specified and "sum" aggregation was requested. This is not allowed. "Sum" aggregation may only be requested if a normalization field is not specified.'))
            elif normalizationField is None:
                ax1.set_ylabel(u'Mean ' + valueField + scaleFactorLabel)
            else:
                ax1.set_ylabel(valueField + u' / ' + normalizationField + scaleFactorLabel)

            # Rotate the dates on the x axis to make them easier to
            # read. This code was adapted from matplotlib's
            # autofmt_xdate().
            
            for label in ax1.get_xticklabels():
                label.set_ha('right')
                label.set_rotation(30)

            # Subplot 2: the periodogram.
            # ===========================

            periodsToPlot = numpy.logical_and(periods >= samplingPeriod * 2, periods <= min(maxPeriod, max(periods)))

            ax2 = plt.subplot(gs[1, :])
            plt.plot(periods[periodsToPlot], powers[periodsToPlot], 'k')
            ax2.set_xlabel('Period (days)')
            ax2.set_ylabel('Spectral Power')
            #ax2.set_xlim(right=min(maxPeriod, max(periods)))

            matplotlib.rc('xtick', direction='in')
            matplotlib.rc('ytick', direction='in')

            # Subplot 3: day-of-year radial bar plot.
            # =======================================

            if dayOfYearPlot:

                # Calculate the 0-indexed day of the year as 0 to 364
                # (Jan 1 to Dec 31). On leap years, treat both Dec 30
                # and 31 as day 364.

                daysOfYear = [min(364, int(d.strftime('%j')) - 1) for d in dates]

                # Classify the moon phase values into 73 bins, each 5
                # days long.

                binForDOY = [int(math.floor(doy / 5.)) for doy in daysOfYear]

                # Compute the mean value for each bin.

                binCount = numpy.zeros(73, int)
                binSum = numpy.zeros(len(binCount))
                
                for i in range(len(values)):
                    binCount[binForDOY[i]] += 1
                    binSum[binForDOY[i]] += values[i]

                binMean = numpy.zeros(len(binCount))
                binMean[binCount > 0] = binSum[binCount > 0] / binCount[binCount > 0]

                # Normalize the means.

                binMean /= binSum.sum()

                # Create a polar bar plot.

                ax3 = plt.subplot(gs[2, 0], polar=True)
                ax3.bar([float(i)/len(binCount) * 2 * math.pi for i in range(len(binCount))], binMean, 1./len(binCount) * 2 * math.pi, color='gray')
                ax3.set_yticklabels([])

                # Label the first days of the months.

                ax3.set_theta_zero_location('S')
                ax3.set_theta_direction(-1)

                ax3.set_thetagrids([(int(datetime.datetime(2001, month, 1).strftime('%j')) - 1)/365. * 360. for month in range(1, 13)],
                                   ['Jan 1', 'Feb 1', 'Mar 1', 'Apr 1', 'May 1', 'Jun 1', 'Jul 1', 'Aug 1', 'Sep 1', 'Oct 1', 'Nov 1', 'Dec 1']);

                for label in ax3.get_xticklabels():
                    if label.get_text() == 'Jan 1':
                        label.set_va('top')
                    elif label.get_text() in ['Feb 1', 'Mar 1', 'Apr 1', 'May 1', 'Jun 1']:
                        label.set_ha('right')
                    elif label.get_text() == 'Jul 1':
                        label.set_va('bottom')
                    else:
                        label.set_ha('left')

            # Subplot 4: moon-phase radial bar plot.
            # ======================================

            if moonPhasePlot:

                # Calculate the moon phase as a number ranging from 0
                # to 1, where 0 and 1 are new moon and 0.5 is full.

                from GeoEco.AssimilatedModules.moon import MoonPhase

                mp = [MoonPhase(d).phase for d in dates]

                # Classify the moon phase values into 30 bins, each
                # just under 1 day long.

                binForMP = [int(math.floor(p * 30.)) for p in mp]

                # Compute the mean value for each bin.

                binCount = numpy.zeros(30, int)
                binSum = numpy.zeros(len(binCount))
                
                for i in range(len(values)):
                    binCount[binForMP[i]] += 1
                    binSum[binForMP[i]] += values[i]

                binMean = numpy.zeros(len(binCount))
                binMean[binCount > 0] = binSum[binCount > 0] / binCount[binCount > 0]

                # Normalize the means.

                binMean /= binSum.sum()

                # Create a polar bar plot.

                ax4 = plt.subplot(gs[2, 0 + int(dayOfYearPlot)], polar=True)
                ax4.bar([float(i)/len(binCount) * 2 * math.pi for i in range(len(binCount))], binMean, 1./len(binCount) * 2 * math.pi, color='gray')
                ax4.set_yticklabels([])

                # Label the quadrants with moon phase names.

                ax4.set_theta_zero_location('W')
                ax4.set_theta_direction(-1)
                
                ax4.set_thetagrids([0, 90, 180, 270], ['New\nMoon', 'First Quarter', 'Full\nMoon', 'Last Quarter']);

                for label in ax4.get_xticklabels():
                    if label.get_text() == 'New\nMoon':
                        label.set_ha('right')
                    elif label.get_text() == 'First Quarter':
                        label.set_va('bottom')
                    elif label.get_text() == 'Full\nMoon':
                        label.set_ha('left')
                    else:
                        label.set_va('top')

            # Subplot 5: day-of-year radial bar plot.
            # =======================================

            if timeOfDayPlot:

                # Extract the hours from the datetime instances.

                hours = [d.hour for d in dates]

                # Compute the mean value for each bin.

                binCount = numpy.zeros(24, int)
                binSum = numpy.zeros(len(binCount))
                
                for i in range(len(values)):
                    binCount[hours[i]] += 1
                    binSum[hours[i]] += values[i]

                binMean = numpy.zeros(len(binCount))
                binMean[binCount > 0] = binSum[binCount > 0] / binCount[binCount > 0]

                # Normalize the means.

                binMean /= binSum.sum()

                # Create a polar bar plot.

                ax5 = plt.subplot(gs[2, -1], polar=True)
                ax5.bar([float(i)/len(binCount) * 2 * math.pi for i in range(len(binCount))], binMean, 1./len(binCount) * 2 * math.pi, color='gray')
                ax5.set_yticklabels([])

                # Label the first days of the months.

                ax5.set_theta_zero_location('S')
                ax5.set_theta_direction(-1)

                ax5.set_thetagrids([360 * hour/24. for hour in range(0, 24, 3)],
                                   ['%02i:00' % hour for hour in range(0, 24, 3)]);

                for label in ax5.get_xticklabels():
                    if label.get_text() == '00:00':
                        label.set_va('top')
                    elif label.get_text() in ['03:00', '06:00', '09:00']:
                        label.set_ha('right')
                    elif label.get_text() == '12:00':
                        label.set_va('bottom')
                    else:
                        label.set_ha('left')

            # Use tight layout to allow dates to display properly.

            plt.tight_layout()

            # If the caller provided a plot title, add it. This must
            # be done after calling plt.tight_layout().
            
            if title is not None:
                plt.subplots_adjust(top=0.93)
                fig.suptitle(title)

            # If the caller provided an outputFile, save the figure to
            # it. If not, display the figure interactively.

            if outputFile is not None:
                plt.savefig(outputFile)
            else:
                Logger.Info(_(u'Waiting for the interactive plot window to be closed...'))
                plt.show()
                
        finally:
            plt.close(fig)

    @classmethod
    def AnalyzeArcGISTable(cls, table, dateField, valueField=None, normalizationField=None, aggregationMethod=u'Mean', where=None, binWidth=None, timeUnits=None, yAxisLabel=None, scaleFactor=None, samplingPeriod=None, maxPeriod=400., periodogramMethod=u'Lomb-Scargle', oversamplingFactor=4., outputFile=None, title=None, width=4., dpi=300., dayOfYearPlot=u'Automatic', moonPhasePlot=u'Automatic', timeOfDayPlot=u'Automatic', overwriteExisting=False):
        cls.__doc__.Obj.ValidateMethodInvocation()
        from GeoEco.Datasets.ArcGIS import ArcGISTable
        cls.AnalyzeTable(ArcGISTable(table), dateField, valueField, normalizationField, aggregationMethod, where, binWidth, timeUnits, yAxisLabel, scaleFactor, samplingPeriod, maxPeriod, periodogramMethod, oversamplingFactor, outputFile, title, width, dpi, dayOfYearPlot, moonPhasePlot, timeOfDayPlot, overwriteExisting)
        

###############################################################################
# Metadata: module
###############################################################################

from GeoEco.ArcGIS import ArcGISDependency
from GeoEco.Datasets import Table
from GeoEco.Dependencies import MatplotlibDependency
from GeoEco.Metadata import *
from GeoEco.Types import *

AddModuleMetadata(shortDescription=_(u'Classes for temporal analysis.'))

###############################################################################
# Metadata: Periodicity class
###############################################################################

AddClassMetadata(Periodicity,
    shortDescription=_(u'Methods for analyzing temporal perodicity in time-series data.'),
    isExposedAsCOMServer=True,
    comIID=u'{CABE75DC-A0A4-410D-8698-9FEF7085232A}',
    comCLSID=u'{8D268D4D-320B-4E07-8948-954D90F87544}')

# Public method: Periodicity.AnalyzeTable

AddMethodMetadata(Periodicity.AnalyzeTable,
    shortDescription=_(u'Creates several plots that show the temporal periodicity of the records in a Table.'),
    longDescription=_(
u"""This tool creates several plots that show whether or not the
records or the value of some field of them exhibit any temporal
periodicity (i.e., patterns that repeat in time). What is analyzed and
presented in the plots depends on what fields you select, if any, for
analysis.

The first plot is a bar plot showing values at different times over
the temporal extent of the data. If you do not select a Value Field
for analysis, then this plot will be a simple histogram showing the
counts of records in a series of equal-duration time bins. If you do
select a Value Field, then the plot will show the sum or mean of that
field for each bin (the Aggregation Method parameter specifies whether
the sum or mean is used). Finally, if you also specify a Normalization
Field, the plot will show the sum of the Value Field divided by the
sum of the Normalization Field, for each bin (the Aggregation Method
parameter is ignored in this case).

The second plot is a periodogram that indicates whether or not a
repeating signal exists in the data at various temporal periods. The
second plot is produced by conducting Fourier analysis on the data
plotted in the first plot. In Fourier analysis, the overall pattern in
the data is decomposed into a series of sine waves having different
periods (or frequencies), which accurately reconstruct the overall
pattern when summed together. The periodogram summarizes the
collection of sine waves by plotting a point for each one; the x axis
is the period of the sine wave (the inverse of its frequency) and the
y axis is its amplitude.

Sine waves with high amplitudes represent strong cyclic patterns
present in the overall pattern. These appear as peaks in the
periodogram. In marine ecological data, patterns are often observed in
relation to solar, lunar, or tidal cycles. In the periodogram, solar
cycles are indicated by peaks at 365 days (an annual cycle) and at 24
hours (a diurnal cycle). Lunar cycles are indicated by a peak at 29.5
days. Tidal cycles are more complicated to observe, and depend on
tidal patterns in the region of interest.

To interpret this periodogram, look for high spikes at 365 days, 29.5
days, 1 day, with very low values elsewhere. If you see high spikes at
one or more of those locations, a solar or lunar cycle is indicated.
But if those spikes are not very high relative to other periods--if
the periodogram displays a generally jittery or noisy pattern--then
solar and lunar cycles may not exist.

In order for Fourier analysis to detect such patterns, the data must
span at least two cycles. For example, to detect an annual pattern,
the data must span at least two years. The results will be much more
reliable if many years of data are available.

To better determine whether annual, lunar, or diurnal patterns exist,
up to three optional plots will be created. Each of these is a radial
bar plot, similar to the first bar plot but binning the data according
to day of the year, phase of the lunar cycle, or hour of the day. If
temporal cycles exist, the radial plots will show high values at some
times and low values at others.

By default, all three radial plots will be produced if there are
sufficient data available, but you can manually enable or disable each
one."""),
    isExposedToPythonCallers=True,
    dependencies=[MatplotlibDependency()])

AddArgumentMetadata(Periodicity.AnalyzeTable, u'cls',
    typeMetadata=ClassOrClassInstanceTypeMetadata(cls=Periodicity),
    description=_(u'Periodicity class or instance.'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'table',
    typeMetadata=ClassInstanceTypeMetadata(cls=Table),
    description=_(
u"""Table to analyze.

The table must contain, at minimum, a date field. It may optionally
contain an integer or floating point field of values to analyze, and
another integer or floating point field used to normalize the
values."""))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'dateField',
    typeMetadata=TableFieldTypeMetadata(u'table', allowedFieldTypes=[u'date', u'datetime']),
    description=_(
u"""Field containing the dates of the records."""))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'valueField',
    typeMetadata=TableFieldTypeMetadata(u'table', allowedFieldTypes=[u'int8', u'uint8', u'int16', u'uint16', u'int32', u'uint32', u'int64', u'uint64', u'float32', u'float64'], canBeNone=True),
    description=_(
u"""Field containing the values to analyze.

If this field is not provided, the temporal analysis will be conducted
only on the dates of the records. The first plot will be a simple
histogram showing the counts of records for a series of equal-duration
time bins. The periodogram will be based on a Fourier analysis of the
counts.

If this field is provided and the Normalization Field is not provided,
the temporal analysis will be conducted on the values of this field
for the dates they occur. The first plot will show the sum or mean of
the values for each time bin (the Aggregation Method parameter
specifies whether the sum or mean is used). The periodogram will be
based on a Fourier analysis of the values.

If this field is provided and the Normalization Field is also
provided, the first plot will show the sum of values of this field
divided by the sum of the values of the Normalization Field, for each
time bin (the Aggregation Method parameter is ignored in this case).
The periodogram will be based on a Fourier analysis of the normalized
values."""))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'normalizationField',
    typeMetadata=TableFieldTypeMetadata(u'table', allowedFieldTypes=[u'int8', u'uint8', u'int16', u'uint16', u'int32', u'uint32', u'int64', u'uint64', u'float32', u'float64'], mustBeDifferentThanArguments=[u'valueField'], canBeNone=True),
    description=_(
u"""Field for normalizing the Value Field. Please see the
documentation for that parameter for more information.

The Normalization Field is ignored if the Value Field is not
provided."""))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'aggregationMethod',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'Mean', u'Sum'], makeLowercase=True),
    description=_(
u"""Specifies whether the analysis should use the mean or the sum of
the Value Field. Please see the documentation for that parameter for
more information.

If a Value Field is not specified, this parameter is ignored. If a
Value Field and Normalization Field both are provided, then this
parameter must be set to Mean."""),
    arcGISDisplayName=_(u'Aggregation method'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'where',
    typeMetadata=UnicodeStringTypeMetadata(canBeNone=True),
    description=_(
u"""SQL WHERE clause expression that specifies the subset of points to
use. If this parameter is not provided, all of the points will be
used. The exact syntax of this expression depends on the underlying
storage format of the input Table."""))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'binWidth',
    typeMetadata=FloatTypeMetadata(mustBeGreaterThan=0., canBeNone=True),
    description=_(
u"""Width, in time units, of the bins used to produce the first plot.
If you provide a value for this parmaeter, you must also specify the
value for the Time Units parameter.

If this parameter is omitted, a value that allows a large number of
bins will be automatically selected, with the hope that fine temporal
dynamics may be observable."""),
    arcGISDisplayName=_(u'Bar plot bin width'),
    arcGISCategory=_(u'Bar plot options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'timeUnits',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'Days', u'Hours'], makeLowercase=True, canBeNone=True),
    description=_(
u"""Specifies the time units of the Bar Plot Bin Width parameter. If
you specify a Bar Plot Bin Width, you must also specify the time
units."""),
    arcGISDisplayName=_(u'Time units'),
    arcGISCategory=_(u'Bar plot options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'yAxisLabel',
    typeMetadata=UnicodeStringTypeMetadata(canBeNone=True),
    description=_(
u"""Label for the y axis of the bar plot. If you do not provide a
label, a generic label will be created for you."""),
    arcGISDisplayName=_(u'Bar plot y axis label'),
    arcGISCategory=_(u'Bar plot options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'scaleFactor',
    typeMetadata=FloatTypeMetadata(mustBeGreaterThan=0., canBeNone=True),
    description=_(
u"""Scale factor. If provided, the values will be multiplied by this
value prior to plotting.

Use this value to scale the y axis values to a preferred range. For
example, which calculating catch per unit effort (CPUE) for longline
fishing gear, it is traditional to present catch per 1000 hooks. But
your Value Field contains the amount of catch and your Normalization
Field contains the number of hooks, the unscaled result will be catch
per 1 hook. To plot catch per 1000 hooks, provide 1000 for the Scale
Factor parameter."""),
    arcGISDisplayName=_(u'Scale factor'),
    arcGISCategory=_(u'Bar plot options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'samplingPeriod',
    typeMetadata=FloatTypeMetadata(mustBeGreaterThan=0., canBeNone=True),
    description=_(
u"""Sampling period, in days, for the Fourier analysis used to produce
the periodogram.

If you do not supply a value, one will be selected for you. If the
dates in your table include time components, 1 hour will be used. If
they do not, 1 day will be used.

The sampling period determines the period of cycles that can be
detected. The shorter the sampling period (i.e. the higher the
sampling frequency), the shorter the cycles that can be detected, with
the shortest detectable cycle equal to twice the sampling period.

If you specify a sampling period of less than 1 day but the dates in
your table do not include time components, or all of the time values
are the same, a sampling period of 1 day will be used. This is
because, when all the times are the same, strong periodicity will be
detected the period of 1 day (because no records will occur at
fractional days) and the harmonics of 1 day (e.g. 1/2 day, 1/3 day,
1/4 day, and so on). These strong but spurious cycles will produce
spikes in the periodogram at those periods, obscuring the cycles of
true interest that occur at higher periods."""),
    arcGISDisplayName=_(u'Sampling period'),
    arcGISCategory=_(u'Periodogram options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'maxPeriod',
    typeMetadata=FloatTypeMetadata(mustBeGreaterThan=0., canBeNone=True),
    description=_(
u"""Maximum period, in days, to plot on the periodogram.

By default, this parameter is set to 400 days, under the observation
that natural ecological phenomena frequenty exhibit annual periodicity
(which results in a spike in the periodogram at 365 days) but that
most users of this tool will either not be interested in or have the
data to detect cycles having longer periods. If you have sufficient
data and wish to check for longer cycles (e.g. decadal oscillations),
increase this parameter."""),
    arcGISDisplayName=_(u'Maximum period to plot'),
    arcGISCategory=_(u'Periodogram options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'periodogramMethod',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'Lomb-Scargle'], makeLowercase=True),
    description=_(
u"""Method to use for computing the periodogram. Currently only one
method is available:

* Lomb-Scargle - the Lomb (1976) and Scargle (1976) method is designed
  to perform spectral analysis on unevenly sampled data, making it
  more suitable for analysis of ecological data than the most common
  method for spectral analysis, the Fast Fourier transform (FFT). This
  tool uses a Python implementation of Press and Rybicki's (1989)
  algorithm for the Lomb-Scargle method.

References

Lomb, N (1976). Least-Squares Frequency Analysis of Unequally Spaced
Data. Astrophysics and Space Science 39: 447-462.

Press, WH and GB Rybicki (1989). Fast algorithm for spectral analysis
of unevenly sampled data. Astrophysical Journal, Part 1, vol. 338, p. 277-280.

Scargle, J. (1982). Studies in Astronomical Time Series Analysis II.
Statistical Aspects of Spectral Analysis of Unevenly Spaced Data.
Astrophysical Journal, Part 1, vol. 263, p. 835-853."""),
    arcGISDisplayName=_(u'Periodogram method'),
    arcGISCategory=_(u'Periodogram options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'oversamplingFactor',
    typeMetadata=FloatTypeMetadata(minValue=1., canBeNone=True),
    description=_(
u"""Oversampling factor for the Lomb-Scargle method.

In order to produce accurate values for the peaks in the peridogram,
it is necessary to sample the input data at a higher frequency than is
necessary to merely detect a short-period cycle. This is called
oversampling. In practice, an oversampling factor of 4 or higher is
recommended for the Lomb-Scargle method. (The effective sampling
period is the Sampling Period parameter divided by the Oversampling
Factor parameter.)"""),
    arcGISDisplayName=_(u'Oversampling factor'),
    arcGISCategory=_(u'Periodogram options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'outputFile',
    typeMetadata=FileTypeMetadata(deleteIfParameterIsTrue=u'overwriteExisting', createParentDirectories=True, canBeNone=True),
    description=_(
u"""Output plot file.

If this parameter is not provided (the default), a plot will be
created in an interactive window.

If this parameter is provided, a plot will be written to the file and
an interactive window will not be created. The extension of the file
determines its format and may be:

* .emf - Enhanced Metafile
* .eps - Encapsulated Postscript
* .pdf - Portable Document Format
* .png - Portable Network Graphics
* .ps - Postscript
* .raw - Raw RGBA bitmap
* .rgba - Raw RGBA bitmap
* .svg - Scalable Vector Graphics
* .svgz - Scalable Vector Graphics
"""),
    direction=u'Output',
    arcGISDisplayName=_(u'Output plot file'),
    arcGISCategory=_(u'Other plotting options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'title',
    typeMetadata=UnicodeStringTypeMetadata(canBeNone=True),
    description=_(
u"""Title of the plot, to appear at the very top."""),
    arcGISDisplayName=_(u'Plot title'),
    arcGISCategory=_(u'Other plotting options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'width',
    typeMetadata=FloatTypeMetadata(mustBeGreaterThan=0.),
    description=_(
u"""Width of the output plot file, in inches. This parameter is
ignored if the plot is not written to an output file."""),
    arcGISDisplayName=_(u'Plot width'),
    arcGISCategory=_(u'Other plotting options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'dpi',
    typeMetadata=FloatTypeMetadata(mustBeGreaterThan=0.),
    description=_(
u"""Dots per inch (DPI) of the output plot file. This parameter is
ignored if the plot is not written to an output file, and may not
apply for vector-based output formats."""),
    arcGISDisplayName=_(u'Plot DPI'),
    arcGISCategory=_(u'Other plotting options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'dayOfYearPlot',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'Automatic', u'No', u'Yes'], makeLowercase=True),
    description=_(
u"""Specifies whether or not a radial bar plot should be generated
showing the distribution of values according day of the year. If
'Automatic' is specified, a plot will be generated if the data span
335 days or more.

Each bar of the plot encompasses 5 days (the first bin is January 1-5,
the second is January 6-10, and so on). On leap years, the last bar
encompasses 6 days.

The values of the bars are calculated similar to the main bar plot: if
a Value Field is not specified, each 5-day bar shows the count of
records for those days. If a Value Field is specified but a
Normalization Field is not, each bar shows the sum or mean of the
values for those days (the Aggregation Method parameter specifies
whether the sum or mean is used). If both a Value Field and
Normalization Field are specified, each bar shows the sum of the Value
Field divided by the sum of the Normalization Field for those
days."""),
    arcGISDisplayName=_(u'Create day of year plot'),
    arcGISCategory=_(u'Other plotting options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'moonPhasePlot',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'Automatic', u'No', u'Yes'], makeLowercase=True),
    description=_(
u"""Specifies whether or not a radial bar plot should be generated
showing the distribution of values according to the phase of the moon
calculated from the records' dates. If 'Automatic' is specified, a
plot will be generated if the data span 28 days or more.

The plot has 30 equal-width bars, each corresponding to about 1 day
(the moon phase is actually about 29.53 days long, so each bar is
about 29.53/30 days long).

The values of the bars are calculated similar to the main bar plot: if
a Value Field is not specified, each bar shows the count of records
for that fraction of the moon phase. If a Value Field is specified but
a Normalization Field is not, each bar shows the sum or mean of the
values for that fraction (the Aggregation Method parameter specifies
whether the sum or mean is used). If both a Value Field and
Normalization Field are specified, each bar shows the sum of the Value
Field divided by the sum of the Normalization Field for that
fraction."""),
    arcGISDisplayName=_(u'Create moon phase plot'),
    arcGISCategory=_(u'Other plotting options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'timeOfDayPlot',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'Automatic', u'No', u'Yes'], makeLowercase=True),
    description=_(
u"""Specifies whether or not a radial bar plot should be generated
showing the distribution of values according to the time of the day.
If 'Automatic' is specified, a plot will be generated if the data span
23 hours or more.

The plot has 24 hour-long bars.

The values of the bars are calculated similar to the main bar plot: if
a Value Field is not specified, each bar shows the count of records
for that hour of the day. If a Value Field is specified but a
Normalization Field is not, each bar shows the sum or mean of the
values for that hour (the Aggregation Method parameter specifies
whether the sum or mean is used). If both a Value Field and
Normalization Field are specified, each bar shows the sum of the Value
Field divided by the sum of the Normalization Field for that
hour."""),
    arcGISDisplayName=_(u'Create time of day plot'),
    arcGISCategory=_(u'Other plotting options'))

AddArgumentMetadata(Periodicity.AnalyzeTable, u'overwriteExisting',
    typeMetadata=BooleanTypeMetadata(),
    description=_(
u"""If True, the output plot file will be overwritten, if it exists.
If False, a ValueError will be raised if the output plot file
exists."""))

# Public method: Periodicity.AnalyzeArcGISTable

AddMethodMetadata(Periodicity.AnalyzeArcGISTable,
    shortDescription=_(u'Creates several plots that show the temporal periodicity of the records in a table.'),
    longDescription=Periodicity.AnalyzeTable.__doc__.Obj.LongDescription,
    isExposedToPythonCallers=True,
    dependencies=[ArcGISDependency(9, 1), MatplotlibDependency()])

CopyArgumentMetadata(Periodicity.AnalyzeTable, u'cls', Periodicity.AnalyzeArcGISTable, u'cls')

AddArgumentMetadata(Periodicity.AnalyzeArcGISTable, u'table',
    typeMetadata=ArcGISTableViewTypeMetadata(mustExist=True),
    description=Periodicity.AnalyzeTable.__doc__.Obj.Arguments[1].Description,
    arcGISDisplayName=_(u'Table'))

AddArgumentMetadata(Periodicity.AnalyzeArcGISTable, u'dateField',
    typeMetadata=ArcGISFieldTypeMetadata(mustExist=True, allowedFieldTypes=[u'date']),
    description=Periodicity.AnalyzeTable.__doc__.Obj.Arguments[2].Description,
    arcGISDisplayName=_(u'Date field'),
    arcGISParameterDependencies=[u'table'])

AddArgumentMetadata(Periodicity.AnalyzeArcGISTable, u'valueField',
    typeMetadata=ArcGISFieldTypeMetadata(mustExist=True, allowedFieldTypes=[u'SHORT', u'LONG', u'FLOAT', u'DOUBLE'], canBeNone=True),
    description=Periodicity.AnalyzeTable.__doc__.Obj.Arguments[3].Description,
    arcGISDisplayName=_(u'Value field'),
    arcGISParameterDependencies=[u'table'])

AddArgumentMetadata(Periodicity.AnalyzeArcGISTable, u'normalizationField',
    typeMetadata=ArcGISFieldTypeMetadata(mustExist=True, allowedFieldTypes=[u'SHORT', u'LONG', u'FLOAT', u'DOUBLE'], canBeNone=True),
    description=Periodicity.AnalyzeTable.__doc__.Obj.Arguments[4].Description,
    arcGISDisplayName=_(u'Normalization field'),
    arcGISParameterDependencies=[u'table'])

CopyArgumentMetadata(Periodicity.AnalyzeTable, u'aggregationMethod', Periodicity.AnalyzeArcGISTable, u'aggregationMethod')

AddArgumentMetadata(Periodicity.AnalyzeArcGISTable, u'where',
    typeMetadata=SQLWhereClauseTypeMetadata(canBeNone=True),
    description=_(
u"""SQL WHERE clause expression that specifies the subset of rows to
use. If this parameter is not provided, all of the rows will be used.

The exact syntax of this expression depends on the type of feature
class you're using. ESRI recommends you reference fields using the
following syntax:

* For shapefiles, ArcInfo coverages, or feature classes stored in file
  geodatabases, ArcSDE geodatabases, or ArcIMS, enclose field names in
  double quotes: "MY_FIELD"

* For feature classes stored in personal geodatabases, enclose field
  names in square brackets: [MY_FIELD].
"""),
    arcGISDisplayName=_(u'Where clause'),
    arcGISParameterDependencies=[u'table'])

CopyArgumentMetadata(Periodicity.AnalyzeTable, u'binWidth', Periodicity.AnalyzeArcGISTable, u'binWidth')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'timeUnits', Periodicity.AnalyzeArcGISTable, u'timeUnits')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'yAxisLabel', Periodicity.AnalyzeArcGISTable, u'yAxisLabel')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'scaleFactor', Periodicity.AnalyzeArcGISTable, u'scaleFactor')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'samplingPeriod', Periodicity.AnalyzeArcGISTable, u'samplingPeriod')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'maxPeriod', Periodicity.AnalyzeArcGISTable, u'maxPeriod')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'periodogramMethod', Periodicity.AnalyzeArcGISTable, u'periodogramMethod')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'oversamplingFactor', Periodicity.AnalyzeArcGISTable, u'oversamplingFactor')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'outputFile', Periodicity.AnalyzeArcGISTable, u'outputFile')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'title', Periodicity.AnalyzeArcGISTable, u'title')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'width', Periodicity.AnalyzeArcGISTable, u'width')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'dpi', Periodicity.AnalyzeArcGISTable, u'dpi')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'dayOfYearPlot', Periodicity.AnalyzeArcGISTable, u'dayOfYearPlot')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'moonPhasePlot', Periodicity.AnalyzeArcGISTable, u'moonPhasePlot')
CopyArgumentMetadata(Periodicity.AnalyzeTable, u'timeOfDayPlot', Periodicity.AnalyzeArcGISTable, u'timeOfDayPlot')

AddArgumentMetadata(Periodicity.AnalyzeArcGISTable, u'overwriteExisting',
    typeMetadata=BooleanTypeMetadata(),
    description=_(
u"""If True, the output plot file will be overwritten, if it exists.
If False, a ValueError will be raised if the output plot file
exists."""),
    initializeToArcGISGeoprocessorVariable=u'OverwriteOutput')

###############################################################################
# Names exported by this module
###############################################################################

__all__ = ['Periodicity']