root/MGET/Branches/Jason/PythonPackage/src/GeoEco/Datasets/Collections/HYCOM.py @ 534

# Datasets/HYCOM.py - Grids representing HYCOM datasets.
#
# Copyright (C) 2010 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

from GeoEco.Datasets import Dataset, QueryableAttribute, Grid
from GeoEco.Datasets.OPeNDAP import THREDDSCatalog, OPeNDAPURL, OPeNDAPGrid
from GeoEco.Datasets.Virtual import TimeSeriesGridStack, GridSliceCollection, MaskedGrid, ClippedGrid, RotatedGlobalGrid
from GeoEco.DynamicDocString import DynamicDocString
from GeoEco.Internationalization import _
from GeoEco.Types import *


class _HYCOMGridGOMl0043D(OPeNDAPGrid):
    __doc__ = DynamicDocString()

    def __init__(self, url, variableName, timeout, cacheDirectory):
        self._CachedTCenterCoords = None
        super(_HYCOMGridGOMl0043D, self).__init__(OPeNDAPURL(url, timeout=timeout, cacheDirectory=cacheDirectory),
                                                    variableName,
                                                    'Grid',
                                                    lazyPropertyValues={'SpatialReference': Dataset.ConvertSpatialReference('proj4', '+proj=merc +ellps=sphere +a=6371001 +b=6371001', 'obj'),
                                                                        'Dimensions': 'tyx',
                                                                        'CoordDependencies': (None, None, None),
                                                                        'CoordIncrements': (None, 4447.7949713872476, 4447.7949713872476),      # t increment is None because, sadly, HYCOM omits slices when their system occasionally fails to generate data for a day
                                                                        'TCornerCoordType': 'center',
                                                                        'PhysicalDimensions': 'tyx',
                                                                        'PhysicalDimensionsFlipped': (False, False, False),
                                                                        'UnscaledDataType': 'float32',
                                                                        'UnscaledNoDataValue': 1.2676506002282294e+030,
                                                                        'ScalingFunction': None})
        
    def _GetLazyPropertyPhysicalValue(self, name):
        if name == 'CornerCoords':
            return (self._GetCoords('t', 0, [0], [0], -0.5), 2045985.6431758059, -10897097.679898757)       # Center of lower-left cell, in degrees: 98.0 W, 18.091648101806641 N
        return super(_HYCOMGridGOMl0043D, self)._GetLazyPropertyPhysicalValue(name)

    def _GetCoords(self, coord, coordNum, slices, sliceDims, fixedIncrementOffset):
        if coord != 't':
            raise RuntimeError(_('_HYCOMGridGOMl0043D._GetCoords() called with coord == \'%(coord)s\'. This should never happen. Please contact the author of this tool for assistance.') % {u'coord': coord})
        if self._CachedTCenterCoords is None:
            import numpy
            self.ParentCollection._Open()
            self._CachedTCenterCoords = numpy.array(map(lambda days: datetime.timedelta(days) + datetime.datetime(1900, 12, 31), list(self.ParentCollection._PydapDataset['MT'][:])), dtype='object')
        if slices is None:
            result = self._CachedTCenterCoords.copy()
        else:
            result = self._CachedTCenterCoords.__getitem__(*slices)
        if fixedIncrementOffset != 0:
            result += datetime.timedelta(fixedIncrementOffset)
        return result


class HYCOMGOMl0043D(Grid):
    __doc__ = DynamicDocString()

    def _GetVariableName(self):
        return self._VariableName

    VariableName = property(_GetVariableName, doc=DynamicDocString())

    def _GetStartYear(self):
        return self._StartYear

    StartYear = property(_GetStartYear, doc=DynamicDocString())

    def _GetEndYear(self):
        return self._EndYear

    EndYear = property(_GetEndYear, doc=DynamicDocString())

    def __init__(self, variableName, startYear=None, endYear=None, timeout=600, cacheDirectory=None):
        self.__doc__.Obj.ValidateMethodInvocation()

        # Perform additional validation

        if startYear is None:
            startYear = 2003
        elif startYear > (datetime.datetime.now() + datetime.timedelta(5)).year:
            raise ValueError(_(u'The start year must be less than or equal to %(max)i.') % {u'max': (datetime.datetime.now() + datetime.timedelta(5)).year})

        if endYear is not None and endYear < startYear:
            raise ValueError(_(u'The end year must be greater than or equal to the start year. If the start year is not specified, the end year must be greater than or equal to 2003.'))

        # Initialize our properties.

        self._VariableName = variableName
        self._StartYear = startYear
        self._EndYear = endYear
        self._Timeout = timeout
        self._CacheDirectory = cacheDirectory
        self._DisplayName = _(u'%(name)s grid of the HYCOM + NCODA Gulf of Mexico 1/25 degree Analysis (GOMl0.04) aggregated OPeNDAP datasets') % {u'name': variableName}
        self._OpenURL = None
        self._OpenGrid = None

        # Initialize the base class.

        super(HYCOMGOMl0043D, self).__init__(queryableAttributes=(QueryableAttribute(u'VariableName', _(u'Dataset variable'), UnicodeStringTypeMetadata(allowedValues=[u'emp', u'mld', u'mlp', u'qtot', u'ssh', u'surface_salinity_trend', u'surface_temperature_trend'], makeLowercase=True)),),
                                             queryableAttributeValues={u'VariableName': variableName},
                                             lazyPropertyValues={'SpatialReference': Dataset.ConvertSpatialReference('proj4', '+proj=merc +ellps=sphere +a=6371001 +b=6371001', 'obj'),
                                                                 'Dimensions': u'tyx',
                                                                 'CoordDependencies': (None, None, None),
                                                                 'CoordIncrements': (1.0, 4447.7949713872476, 4447.7949713872476),
                                                                 'TIncrementUnit': u'day',
                                                                 'TSemiRegularity': None,
                                                                 'TCountPerSemiRegularPeriod': None,
                                                                 'TCornerCoordType': u'center',
                                                                 'CornerCoords': (datetime.datetime(startYear, 1, 1), 2045985.6431758059, -10897097.679898757),       # Center of lower-left cell, in degrees: 98.0 W, 18.091648101806641 N
                                                                 'PhysicalDimensions': u'tyx',
                                                                 'PhysicalDimensionsFlipped': (False, False, False),
                                                                 'UnscaledDataType': u'float32',
                                                                 'UnscaledNoDataValue': 1.2676506002282294e+030,
                                                                 'ScalingFunction': None})

    def _GetDisplayName(self):
        return self._DisplayName
        
    def _GetLazyPropertyPhysicalValue(self, name):

        # The only property that we can retrieve here is the shape.
        # For the t axis, add the number of days in the years leading
        # up to the final year to the number of days available from
        # HYCOM in the final year. For the x and y axes, just use
        # hardcoded values.

        if name == 'Shape':
            if self._EndYear is not None and self._EndYear < datetime.datetime.now().year:
                return ((datetime.datetime(self._EndYear + 1, 1, 1) - datetime.datetime(self._StartYear, 1, 1)).days, 385, 541)

            endYearGrid = _HYCOMGridGOMl0043D('http://tds.hycom.org/thredds/dodsC/GOMl0.04/expt_30.1/%i' % datetime.datetime.now().year, self._VariableName, self._Timeout, self._CacheDirectory)
            endDay = endYearGrid.CenterCoords['t', -1]
            
            if endDay.month == 12 and endDay.day == 31:
                endYearGrid = _HYCOMGridGOMl0043D('http://tds.hycom.org/thredds/dodsC/GOMl0.04/expt_30.1/%i' % datetime.datetime.now().year + 1, self._VariableName, self._Timeout, self._CacheDirectory)
                endDay = endYearGrid.CenterCoords['t', -1]

            return ((endDay - datetime.datetime(self._StartYear, 1, 1)).days + 1, 385, 541)

        raise AttributeError(_(u'\'%(class)s\' object has no lazy property named \'%(name)s\'') % {u'class': self.__class__.__name__, u'name': name})

    def _ReadNumpyArray(self, sliceList):

        # For many OPeNDAP datasets, we would be able to request the
        # entire 3D slab directly. This won't work for the HYCOM
        # GOMl0.04 dataset, for two reasons: 1) The dataset is split
        # OPeNDAP URLs for each year, and 2) HYCOM omits slices when
        # their system occasionally fails to generate data for a day,
        # so most years do not have a full 365 (or 366) slices. To
        # deal with this, we have to loop over the requested range of
        # time indices and issue OPeNDAP requests to the proper URLs
        # and per-URL time indices.
        #
        # First, allocate the array we will return. We'll populate
        # this as we go along. (I prefer this approach rather than
        # growing an array through concatenation because it avoids
        # repeatedly allocating and copying memory.)

        import numpy
        result = numpy.zeros((sliceList[0].stop - sliceList[0].start, sliceList[1].stop - sliceList[1].start, sliceList[2].stop - sliceList[2].start), dtype=str(self.UnscaledDataType))

        # Loop over the requested t indices, populating the result
        # array.

        i = 0
        tCoords = self.CenterCoords['t', sliceList[0]]
        
        while i < len(tCoords):

            # Open the _HYCOMGridGOMl0043D for the next block of t
            # coordinates. These grids are 1 year long, except in 2010
            # when HYCOM switched to an improved configuration after
            # six months.

            if tCoords[i] < datetime.datetime(2010, 7, 1):
                url = 'http://tds.hycom.org/thredds/dodsC/GOMl0.04/expt_20.1/%i' % tCoords[i].year
            else:
                url = 'http://tds.hycom.org/thredds/dodsC/GOMl0.04/expt_30.1/%i' % tCoords[i].year

            if self._OpenURL != url:
                self._OpenGrid = _HYCOMGridGOMl0043D(url, self._VariableName, self._Timeout, self._CacheDirectory)
                self._OpenURL = url

            if tCoords[i] >= datetime.datetime(2010, 1, 1) and tCoords[i] <= datetime.datetime(2010, 6, 30):
                lastDayOfDataset = datetime.datetime(2010, 6, 30)
            else:
                lastDayOfDataset = datetime.datetime(tCoords[i].year, 12, 31)

            # Read the necessary data from this grid as one 3D slab.

            import bisect

            gridTStart = bisect.bisect_left(self._OpenGrid.CenterCoords['t'].tolist(), tCoords[i])
            gridTStop = bisect.bisect_right(self._OpenGrid.CenterCoords['t'].tolist(), tCoords[-1])
            gridTCoords = self._OpenGrid.CenterCoords['t', gridTStart:gridTStop]
            data = self._OpenGrid.UnscaledData.__getitem__((slice(gridTStart, gridTStop), sliceList[1], sliceList[2]))

            # Iterate through the t indices, copying out time slices
            # when they are available, otherwise setting slices to the
            # UnscaledNoDataValue.

            j = 0

            while i < len(tCoords) and tCoords[i] <= lastDayOfDataset:
                if j < len(gridTCoords) and gridTCoords[j] == tCoords[i]:
                    result[i] = data[j]
                    j += 1
                else:
                    result[i] = self.UnscaledNoDataValue
                i += 1

        # Return successfully.

        return result, self.UnscaledNoDataValue

    @classmethod
    def CreateArcGISRasters(cls, variableName,
                            outputWorkspace, mode=u'add', rasterNameExpressions=['%(VariableName)s', '%%Y', '%(VariableName)s_%%Y%%j.img'],
                            spatialExtent=None, linearUnit=u'Degrees', startDate=None, endDate=None, 
                            timeout=600, cacheDirectory=None,
                            calculateStatistics=True, buildPyramids=False):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Construct a HYCOMGOMl0043D and clip it if requested.

        if startDate is not None:
            startYear = startDate.year
        else:
            startYear = None

        if endDate is not None:
            endYear = endDate.year
        else:
            endYear = None

        grid = HYCOMGOMl0043D(variableName, startYear=startYear, endYear=endYear, timeout=timeout, cacheDirectory=cacheDirectory)

        xMin, yMin, xMax, yMax = None, None, None, None
        if spatialExtent is not None:
            from GeoEco.Types import EnvelopeTypeMetadata
            xMin, yMin, xMax, yMax = EnvelopeTypeMetadata.ParseFromArcGISString(spatialExtent)

            if linearUnit == u'Degrees':
                osr = cls._osr()
                transformer = osr.CoordinateTransformation(Dataset.ConvertSpatialReference('proj4', '+proj=latlong +ellps=sphere +a=6371001 +b=6371001', 'obj'), grid.GetSpatialReference('obj'))
                xMin, yMin = transformer.TransformPoint(xMin, yMin)
                xMax, yMax = transformer.TransformPoint(xMax, yMax)

        cls._LogWarning(_(u'The HYCOM OPeNDAP server often requires five to ten minutes to return the first time slice. Please be patient. This tool cannot be cancelled until the first one is returned. After the first one is returned, the rest will go much faster and you will be able to cancel the tool, if desired. If this tool fails with to a timeout error, increase the timeout value and try again.'))

        if spatialExtent is not None or startDate is not None or endDate is not None:
            grid = ClippedGrid(grid, u'Map coordinates', xMin=xMin, xMax=xMax, yMin=yMin, yMax=yMax, tMin=startDate, tMax=endDate)

        # Construct an ArcGISWorkspace instance and import time slices
        # from the HYCOMGOMl0043D instance.

        from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISRaster

        workspace = ArcGISWorkspace(outputWorkspace,
                                    ArcGISRaster,
                                    pathCreationExpressions=rasterNameExpressions,
                                    cacheTree=True,
                                    queryableAttributes=(QueryableAttribute(u'VariableName', _(u'Variable'), UnicodeStringTypeMetadata(allowedValues=[u'emp', u'mld', u'mlp', u'qtot', u'ssh', u'surface_salinity_trend', u'surface_temperature_trend'], makeLowercase=True)),
                                                         QueryableAttribute(u'DateTime', _(u'Date'), DateTimeTypeMetadata())))

        workspace.ImportDatasets(GridSliceCollection(grid, tQACoordType=u'center').QueryDatasets(), mode, calculateStatistics=calculateStatistics, buildPyramids=buildPyramids)

        # Return successfully.

        return outputWorkspace


class _HYCOMGridGOMl0044D(OPeNDAPGrid):
    __doc__ = DynamicDocString()

    def __init__(self, url, variableName, timeout, cacheDirectory):
        self._CachedTCenterCoords = None
        super(_HYCOMGridGOMl0044D, self).__init__(OPeNDAPURL(url, timeout=timeout, cacheDirectory=cacheDirectory),
                                                    variableName,
                                                    'Grid',
                                                    lazyPropertyValues={'SpatialReference': Dataset.ConvertSpatialReference('proj4', '+proj=merc +ellps=sphere +a=6371001 +b=6371001', 'obj'),
                                                                        'Dimensions': 'tzyx',
                                                                        'CoordDependencies': (None, None, None, None),
                                                                        'CoordIncrements': (None, None, 4447.7949713872476, 4447.7949713872476),        # t increment is None because, sadly, HYCOM omits slices when their system occasionally fails to generate data for a day
                                                                        'TCornerCoordType': 'center',
                                                                        'PhysicalDimensions': 'tzyx',
                                                                        'PhysicalDimensionsFlipped': (False, False, False, False),
                                                                        'UnscaledDataType': 'float32',
                                                                        'UnscaledNoDataValue': 1.2676506002282294e+030,
                                                                        'ScalingFunction': None})
        
    def _GetLazyPropertyPhysicalValue(self, name):
        if name == 'CornerCoords':
            return (self._GetCoords('t', 0, [0], [0], -0.5), 0.0, 2045985.6431758059, -10897097.679898757)       # Center of lower-left cell, in degrees: 98.0 W, 18.091648101806641 N
        return super(_HYCOMGridGOMl0044D, self)._GetLazyPropertyPhysicalValue(name)

    def _GetCoords(self, coord, coordNum, slices, sliceDims, fixedIncrementOffset):
        if coord not in ['t', 'z']:
            raise RuntimeError(_('_HYCOMGridGOMl0044D._GetCoords() called with coord == \'%(coord)s\'. This should never happen. Please contact the author of this tool for assistance.') % {u'coord': coord})

        import numpy

        if coord == 't':
            if self._CachedTCenterCoords is None:
                self.ParentCollection._Open()
                self._CachedTCenterCoords = numpy.array(map(lambda days: datetime.timedelta(days) + datetime.datetime(1900, 12, 31), list(self.ParentCollection._PydapDataset['MT'][:])), dtype='object')
            if slices is None:
                result = self._CachedTCenterCoords.copy()
            else:
                result = self._CachedTCenterCoords.__getitem__(*slices)
            if fixedIncrementOffset != 0:
                result += datetime.timedelta(fixedIncrementOffset)
            return result

        zCoords = [0.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 125.0, 150.0, 200.0, 250.0, 300.0, 400.0, 500.0, 600.0, 700.0, 800.0, 900.0, 1000.0, 1100.0, 1200.0, 1300.0, 1400.0, 1500.0, 1750.0, 2000.0, 2500.0, 3000.0, 3500.0, 4000.0, 4500.0, 5000.0, 5500.0]
        if fixedIncrementOffset == -0.5:
            zCoords = [0.0] + map(lambda a, b: (a+b)/2., zCoords[:-1], zCoords[1:])
        elif fixedIncrementOffset == 0.5:
            zCoords = map(lambda a, b: (a+b)/2., zCoords[:-1], zCoords[1:]) + [11000.0]
        if slices is None:
            return numpy.array(zCoords)
        return numpy.array(zCoords).__getitem__(*slices)


class HYCOMGOMl0044D(Grid):
    __doc__ = DynamicDocString()

    def _GetVariableName(self):
        return self._VariableName

    VariableName = property(_GetVariableName, doc=DynamicDocString())

    def _GetStartYear(self):
        return self._StartYear

    StartYear = property(_GetStartYear, doc=DynamicDocString())

    def _GetEndYear(self):
        return self._EndYear

    EndYear = property(_GetEndYear, doc=DynamicDocString())

    def __init__(self, variableName, startYear=None, endYear=None, timeout=600, cacheDirectory=None):
        self.__doc__.Obj.ValidateMethodInvocation()

        # Perform additional validation

        if startYear is None:
            startYear = 2003
        elif startYear > (datetime.datetime.now() + datetime.timedelta(5)).year:
            raise ValueError(_(u'The start year must be less than or equal to %(max)i.') % {u'max': (datetime.datetime.now() + datetime.timedelta(5)).year})

        if endYear is not None and endYear < startYear:
            raise ValueError(_(u'The end year must be greater than or equal to the start year. If the start year is not specified, the end year must be greater than or equal to 2003.'))

        # Initialize our properties.

        self._VariableName = variableName
        self._StartYear = startYear
        self._EndYear = endYear
        self._Timeout = timeout
        self._CacheDirectory = cacheDirectory
        self._DisplayName = _(u'%(name)s grid of the HYCOM + NCODA Gulf of Mexico 1/25 degree Analysis (GOMl0.04) aggregated OPeNDAP datasets') % {u'name': variableName}
        self._OpenURL = None
        self._OpenGrid = None

        # Initialize the base class.

        super(HYCOMGOMl0044D, self).__init__(queryableAttributes=(QueryableAttribute(u'VariableName', _(u'Dataset variable'), UnicodeStringTypeMetadata(allowedValues=[u'salinity', u'temperature', u'u', u'v', u'w'], makeLowercase=True)),),
                                             queryableAttributeValues={u'VariableName': variableName},
                                             lazyPropertyValues={'SpatialReference': Dataset.ConvertSpatialReference('proj4', '+proj=merc +ellps=sphere +a=6371001 +b=6371001', 'obj'),
                                                                 'Dimensions': u'tzyx',
                                                                 'CoordDependencies': (None, None, None, None),
                                                                 'CoordIncrements': (1.0, None, 4447.7949713872476, 4447.7949713872476),
                                                                 'TIncrementUnit': u'day',
                                                                 'TSemiRegularity': None,
                                                                 'TCountPerSemiRegularPeriod': None,
                                                                 'TCornerCoordType': u'center',
                                                                 'CornerCoords': (datetime.datetime(startYear, 1, 1), 0.0, 2045985.6431758059, -10897097.679898757),       # Center of lower-left cell, in degrees: 98.0 W, 18.091648101806641 N
                                                                 'PhysicalDimensions': u'tzyx',
                                                                 'PhysicalDimensionsFlipped': (False, False, False, False),
                                                                 'UnscaledDataType': u'float32',
                                                                 'UnscaledNoDataValue': 1.2676506002282294e+030,
                                                                 'ScalingFunction': None})

    def _GetDisplayName(self):
        return self._DisplayName
        
    def _GetLazyPropertyPhysicalValue(self, name):

        # The only property that we can retrieve here is the shape.
        # For the t axis, add the number of days in the years leading
        # up to the final year to the number of days available from
        # HYCOM in the final year. For the x and y axes, just use
        # hardcoded values.

        if name == 'Shape':
            if self._EndYear is not None and self._EndYear < datetime.datetime.now().year:
                return ((datetime.datetime(self._EndYear + 1, 1, 1) - datetime.datetime(self._StartYear, 1, 1)).days, 40, 385, 541)

            endYearGrid = _HYCOMGridGOMl0044D('http://tds.hycom.org/thredds/dodsC/GOMl0.04/expt_30.1/%i' % datetime.datetime.now().year, self._VariableName, self._Timeout, self._CacheDirectory)
            endDay = endYearGrid.CenterCoords['t', -1]
            
            if endDay.month == 12 and endDay.day == 31:
                endYearGrid = _HYCOMGridGOMl0044D('http://tds.hycom.org/thredds/dodsC/GOMl0.04/expt_30.1/%i' % datetime.datetime.now().year + 1, self._VariableName, self._Timeout, self._CacheDirectory)
                endDay = endYearGrid.CenterCoords['t', -1]

            return ((endDay - datetime.datetime(self._StartYear, 1, 1)).days + 1, 40, 385, 541)

        raise AttributeError(_(u'\'%(class)s\' object has no lazy property named \'%(name)s\'') % {u'class': self.__class__.__name__, u'name': name})

    def _GetCoords(self, coord, coordNum, slices, sliceDims, fixedIncrementOffset):
        if coord != 'z':
            raise RuntimeError(_('HYCOMGOMl0044D._GetCoords() called with coord == \'%(coord)s\'. This should never happen. Please contact the author of this tool for assistance.') % {u'coord': coord})
        zCoords = [0.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 125.0, 150.0, 200.0, 250.0, 300.0, 400.0, 500.0, 600.0, 700.0, 800.0, 900.0, 1000.0, 1100.0, 1200.0, 1300.0, 1400.0, 1500.0, 1750.0, 2000.0, 2500.0, 3000.0, 3500.0, 4000.0, 4500.0, 5000.0, 5500.0]
        if fixedIncrementOffset == -0.5:
            zCoords = [0.0] + map(lambda a, b: (a+b)/2., zCoords[:-1], zCoords[1:])
        elif fixedIncrementOffset == 0.5:
            zCoords = map(lambda a, b: (a+b)/2., zCoords[:-1], zCoords[1:]) + [11000.0]
        import numpy
        if slices is None:
            return numpy.array(zCoords)
        return numpy.array(zCoords).__getitem__(*slices)

    def _ReadNumpyArray(self, sliceList):

        # For many OPeNDAP datasets, we would be able to request the
        # entire 4D slab directly. This won't work for the HYCOM
        # GOMl0.04 dataset, for two reasons: 1) The dataset is split
        # OPeNDAP URLs for each year, and 2) HYCOM omits slices when
        # their system occasionally fails to generate data for a day,
        # so most years do not have a full 365 (or 366) slices. To
        # deal with this, we have to loop over the requested range of
        # time indices and issue OPeNDAP requests to the proper URLs
        # and per-URL time indices.
        #
        # First, allocate the array we will return. We'll populate
        # this as we go along. (I prefer this approach rather than
        # growing an array through concatenation because it avoids
        # repeatedly allocating and copying memory.)

        import numpy
        result = numpy.zeros((sliceList[0].stop - sliceList[0].start, sliceList[1].stop - sliceList[1].start, sliceList[2].stop - sliceList[2].start, sliceList[3].stop - sliceList[3].start), dtype=str(self.UnscaledDataType))

        # Loop over the requested t indices, populating the result
        # array.

        i = 0
        tCoords = self.CenterCoords['t', sliceList[0]]
        
        while i < len(tCoords):

            # Open the _HYCOMGridGOMl0044D for the next block of t
            # coordinates. These grids are 1 year long, except in 2010
            # when HYCOM switched to an improved configuration after
            # five months.

            if tCoords[i] < datetime.datetime(2010, 7, 1):
                url = 'http://tds.hycom.org/thredds/dodsC/GOMl0.04/expt_20.1/%i' % tCoords[i].year
            else:
                url = 'http://tds.hycom.org/thredds/dodsC/GOMl0.04/expt_30.1/%i' % tCoords[i].year

            if self._OpenURL != url:
                self._OpenGrid = _HYCOMGridGOMl0044D(url, self._VariableName, self._Timeout, self._CacheDirectory)
                self._OpenURL = url

            if tCoords[i] >= datetime.datetime(2010, 1, 1) and tCoords[i] <= datetime.datetime(2010, 6, 30):
                lastDayOfDataset = datetime.datetime(2010, 6, 30)
            else:
                lastDayOfDataset = datetime.datetime(tCoords[i].year, 12, 31)

            # Read the necessary data from this grid as one 4D slab.

            import bisect

            gridTStart = bisect.bisect_left(self._OpenGrid.CenterCoords['t'].tolist(), tCoords[i])
            gridTStop = bisect.bisect_right(self._OpenGrid.CenterCoords['t'].tolist(), tCoords[-1])
            gridTCoords = self._OpenGrid.CenterCoords['t', gridTStart:gridTStop]
            data = self._OpenGrid.UnscaledData.__getitem__((slice(gridTStart, gridTStop), sliceList[1], sliceList[2], sliceList[3]))

            # Iterate through the t indices, copying out time slices
            # when they are available, otherwise setting slices to the
            # UnscaledNoDataValue.

            j = 0

            while i < len(tCoords) and tCoords[i] <= lastDayOfDataset:
                if j < len(gridTCoords) and gridTCoords[j] == tCoords[i]:
                    result[i] = data[j]
                    j += 1
                else:
                    result[i] = self.UnscaledNoDataValue
                i += 1

        # Return successfully.

        return result, self.UnscaledNoDataValue

    @classmethod
    def CreateArcGISRasters(cls, variableName,
                            outputWorkspace, mode=u'add', rasterNameExpressions=['%(VariableName)s', '%%Y', 'Depth_%(Depth)04.0fm', '%(VariableName)s_%%Y%%j_%(Depth)04.0fm.img'],
                            spatialExtent=None, linearUnit=u'Degrees', minDepth=None, maxDepth=None, startDate=None, endDate=None, 
                            timeout=600, cacheDirectory=None,
                            calculateStatistics=True, buildPyramids=False):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Construct a HYCOMGOMl0044D and clip it if requested.

        if startDate is not None:
            startYear = startDate.year
        else:
            startYear = None

        if endDate is not None:
            endYear = endDate.year
        else:
            endYear = None

        grid = HYCOMGOMl0044D(variableName, startYear=startYear, endYear=endYear, timeout=timeout, cacheDirectory=cacheDirectory)

        xMin, yMin, xMax, yMax = None, None, None, None
        if spatialExtent is not None:
            from GeoEco.Types import EnvelopeTypeMetadata
            xMin, yMin, xMax, yMax = EnvelopeTypeMetadata.ParseFromArcGISString(spatialExtent)

            if linearUnit == u'Degrees':
                osr = cls._osr()
                transformer = osr.CoordinateTransformation(Dataset.ConvertSpatialReference('proj4', '+proj=latlong +ellps=sphere +a=6371001 +b=6371001', 'obj'), grid.GetSpatialReference('obj'))
                xMin, yMin = transformer.TransformPoint(xMin, yMin)
                xMax, yMax = transformer.TransformPoint(xMax, yMax)

        cls._LogWarning(_(u'The HYCOM OPeNDAP server often requires five to ten minutes to return the first time slice. Please be patient. This tool cannot be cancelled until the first one is returned. After the first one is returned, the rest will go much faster and you will be able to cancel the tool, if desired. If this tool fails with to a timeout error, increase the timeout value and try again.'))

        if spatialExtent is not None or minDepth is not None or maxDepth is not None or startDate is not None or endDate is not None:
            grid = ClippedGrid(grid, u'Map coordinates', xMin=xMin, xMax=xMax, yMin=yMin, yMax=yMax, zMin=minDepth, zMax=maxDepth, tMin=startDate, tMax=endDate)

        # Construct an ArcGISWorkspace instance and import time slices
        # from the HYCOMGOMl0044D instance.

        from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISRaster

        workspace = ArcGISWorkspace(outputWorkspace,
                                    ArcGISRaster,
                                    pathCreationExpressions=rasterNameExpressions,
                                    cacheTree=True,
                                    queryableAttributes=(QueryableAttribute(u'VariableName', _(u'Variable'), UnicodeStringTypeMetadata(allowedValues=[u'salinity', u'temperature', u'u', u'v', u'w'], makeLowercase=True)),
                                                         QueryableAttribute(u'DateTime', _(u'Date'), DateTimeTypeMetadata()),
                                                         QueryableAttribute(u'Depth', _(u'Depth'), FloatTypeMetadata())))

        workspace.ImportDatasets(GridSliceCollection(grid, tQACoordType=u'center', zQACoordType=u'center').QueryDatasets(), mode, calculateStatistics=calculateStatistics, buildPyramids=buildPyramids)

        # Return successfully.

        return outputWorkspace


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

from GeoEco.ArcGIS import ArcGISDependency
from GeoEco.Dependencies import PythonAggregatedModuleDependency
from GeoEco.Datasets.ArcGIS import _UseUnscaledDataDescription, _CalculateStatisticsDescription, _BuildRATDescription, _BuildPyramidsDescription
from GeoEco.Metadata import *
from GeoEco.Types import *

AddModuleMetadata(shortDescription=_(u'Grids representing HYCOM datasets.'))

###############################################################################
# Metadata: _HYCOMGridGOMl0043D class
###############################################################################

AddClassMetadata(_HYCOMGridGOMl0043D,
    shortDescription=_(u'An OPeNDAPGrid for a 3D variable of a HYCOM GOMl0.04 OPeNDAP URL.')
    longDescription=_(
u"""This class is intended for private use within GeoEco and is not
intended for external callers."""))

###############################################################################
# Metadata: HYCOMGOMl0043D class
###############################################################################

_HYCOMGOMl004_LongDescription = _(
u"""At the time this %(name)s was developed, the
`HYCOM + NCODA Gulf of Mexico 1/25 Degree Analysis (GLMl0.04) <http://www.hycom.org/dataserver/goml0pt04/>`_
consisted of two gridded datasets:

* expt_20.1 - The 20.1 experiment running from 1 January 2003 through
  30 June 2010.

* expt_30.1 - The 30.1 experiment running from 1 July 2010 and running
  to the present day plus five days.

The datasets have identical spatiotemporal extents and resolutions and
the same oceanographic variables. This %(name)s treats them as one
continuous dataset and takes time slices prior to 1 July 2010 from
expt_20.1 and on or after that date from expt_30.1. (On the HYCOM
server, the datasets actually overlap slightly, with expt_20.1 ending
slightly after 30 June 2010 and expt_30.1 starting slightly before 1
July 2010. The %(name)s ignores the overlapping time slices and
switches from expt_20.1 to expt_30.1 on 1 July.)

The grids are in Mercator projection based on a sphere with radius
6371001 m, with square cells approximately 4.5 km on a side. The
geographic extent is approximately 98 to 76 W, 18 to 32 N. The time
step is 1 day, with time slices representing the instantaneous
condition of the ocean estimated at 00:00 UTC on each day.

The HYCOM documentation states that HYCOM provides a five day forecast
and five day hindcast from the current date, although we have
regularly observed netCDF files on their servers that suggested this
window actually extends seven days in both directions. HYCOM revises
the data within this window daily, using the latest ocean observations
assimilated from buoys, satellites, and other sensors. Use caution
when working with time slices close to the current date, as it appears
that time slices continue to be revised until they are 7 days older
than the current date.

Occasionally, HYCOM fails to generate data for a time slice,
presumably due to an outage or other problem in their data processing
infrastructure. For example, in 2004, HYCOM failed to generate data
for three of the 366 time slices of that year. Although HYCOM omits
these time slices from their server, this %(name)s represents them as
grids filled with the No Data value.

The datasets include both 3D variables (dimensions x, y, and time) and
4D variables (dimensions x, y, depth, and time). The 4D variables are
estimated at 40 depth levels: 0, 5, 10, 15, 20, 25, 30, 40, 50, 60,
70, 80, 90, 100, 125, 150, 200, 250, 300, 400, 500, 600, 700, 800,
900, 1000, 1100, 1200, 1300, 1400, 1500, 1750, 2000, 2500, 3000, 3500,
4000, 4500, 5000, and 5500 m.

This %(name)s accesses the HYCOM datasets using the
`OPeNDAP <http://opendap.org/>`_ protocol, allowing slices of data to
be retrieved very efficiently. However, during periods of high load,
the HYCOM OPeNDAP server often requires five to ten minutes to return
the first slice of data. Please be patient; after the first one is
returned, the rest will go much faster. During periods of extreme
load, the tool may fail with a timeout error. If this happens,
increase the timeout value and try again, or wait until later when the
server is less busy."""),

AddClassMetadata(HYCOMGOMl0043D,
    shortDescription=_(u'Represents a HYCOM GOMl0.04 3D variable as a Grid Dataset.'),
    longDescription=_HYCOMGOMl004_LongDescription % {u'name': 'class'})

# Constructor

AddMethodMetadata(HYCOMGOMl0043D.__init__,
    shortDescription=_(u'Constructs a new HYCOMGOMl0043D instance.'),
    isExposedToPythonCallers=True,
    dependencies=[PythonAggregatedModuleDependency('numpy')])

AddArgumentMetadata(HYCOMGOMl0043D.__init__, u'self',
    typeMetadata=ClassInstanceTypeMetadata(cls=HYCOMGOMl0043D),
    description=_(u'HYCOMGOMl0043D instance.'))

AddArgumentMetadata(HYCOMGOMl0043D.__init__, u'variableName',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'emp', u'mld', u'mlp', u'qtot', u'ssh', u'surface_salinity_trend', u'surface_temperature_trend'], makeLowercase=True),
    description=_(
u"""HYCOM GOMl0.04 3D variable (dimensions x, y, and time), one of:

* emp - Water flux into the ocean, in kg/m2/s.

* mld - Mixed layer thickness, in m, defined as the depth at which the
  temperature change from the surface temperature is 0.02 degrees C.

* mlp - Mixed layer thickness, in m, defined as the depth at which the
  pressure change from the surface pressure is 0.03 kg/m3.

* qtot - Surface downward heat flux, in w/m2.

* ssh - Sea surface height, in m, above the HYCOM reference spheroid.

* surface_salinity_trend - Surface salinity trend, in psu/day.

* surface_temperature_trend - Surface temperature trend, in degrees
  C/day.

Please see the HYCOM documentation for more information about these
variables."""),
    arcGISDisplayName=_(u'Dataset variable'))

AddArgumentMetadata(HYCOMGOMl0043D.__init__, u'startYear',
    typeMetadata=IntegerTypeMetadata(canBeNone=True, minValue=2003),
    description=_(
u"""Starting year for this grid. This parameter is optional; if a
value is not specified, 2003 will be used."""))

AddArgumentMetadata(HYCOMGOMl0043D.__init__, u'endYear',
    typeMetadata=IntegerTypeMetadata(canBeNone=True),
u"""Ending year for this grid. This parameter is optional; if a value
is not specified, the grid will extend to the maximum temporal extent
of the HYCOM data. If you do not need data for the current year,
specify an earlier year for this parameter. This will make it
unnecessary to query the HYCOM server to determine the maximum
temporal extent."""))

CopyArgumentMetadata(THREDDSCatalog.__init__, u'timeout', HYCOMGOMl0043D.__init__, u'timeout')

AddArgumentMetadata(HYCOMGOMl0043D.__init__, u'cacheDirectory',
    typeMetadata=DirectoryTypeMetadata(canBeNone=True),
    description=_(
u"""Directory to cache OPeNDAP datasets.

A cache directory can dramatically speed up scenarios that involve
accessing the same subsets the HYCOM data over and over again. When
OPeNDAP data is requested from the HYCOM server, the cache directory
will be checked for data that was downloaded and cached during prior
requests. If cached data exists that can fulfill part of the current
request, the request will be serviced by reading from cache files
rather than the OPeNDAP server. If the entire request can be serviced
from the cache, the OPeNDAP server will not be accessed at all and the
request will be completed extremely quickly. Any parts of the request
that cannot be serviced from the cache will be downloaded from the
OPeNDAP server and added to the cache, speeding up future requests for
the same data.

If you use a cache directory, be aware of these common pitfalls:

* The HYCOM documentation states that HYCOM provides a five day forecast
  and five day hindcast from the current date, although we have
  regularly observed netCDF files on their servers that suggested this
  window actually extends seven days in both directions. HYCOM revises
  the data within this time window daily, using the latest ocean
  observations assimilated from buoys, satellites, and other sensors.
  We recommend you do not cache data in this time window. The caching
  algorithm cannot detect whether cached data should be replaced with
  revised versions available on the server.

* The caching algorithm permits the cache to grow to infinite size and
  never deletes any cached data. If you access a large amount of data
  it will all be added to the cache. Be careful that you do not fill
  up your hard disk. To mitigate this, manually delete the entire
  cache or selected directories or files within it.

* The caching algorithm stores data in uncompressed files, so that
  subsets of those files may be quickly accessed. To save space on
  your hard disk, you can enable compression of the cache directory
  using the operating system. On Windows, right click on the directory
  in Windows Explorer, select Properties, click Advanced, and enable
  "Compress contents to save disk space".
"""),
    arcGISDisplayName=_(u'Cache directory'),
    arcGISCategory=_(u'OPeNDAP options'))

AddResultMetadata(HYCOMGOMl0043D.__init__, u'grid',
    typeMetadata=ClassInstanceTypeMetadata(cls=HYCOMGOMl0043D),
    description=_(u'HYCOMGOMl0043D instance.'))

# Public method: HYCOMGOMl0043D.CreateArcGISRasters

AddMethodMetadata(HYCOMGOMl0043D.CreateArcGISRasters,
    shortDescription=_(u'Downloads a HYCOM GOMl0.04 3D variable and creates ArcGIS rasters.'),
    longDescription=_HYCOMGOMl004_LongDescription % {u'name': 'tool'})
    isExposedByCOM=True,
    isExposedAsArcGISTool=True,
    arcGISDisplayName=_(u'Download HYCOM GOMl0.04 3D Variable to ArcGIS Rasters'),
    arcGISToolCategory=_(u'Data Products\\HYCOM Consortium\\HYCOM + NCODA Gulf of Mexico 1/25 Degree Analysis (GLMl0.04)'),
    dependencies=[ArcGISDependency(9, 1), PythonAggregatedModuleDependency('numpy')])

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

CopyArgumentMetadata(HYCOMGOMl0043D.__init__, u'variableName', HYCOMGOMl0043D.CreateArcGISRasters, u'variableName')

AddArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'outputWorkspace',
    typeMetadata=ArcGISWorkspaceTypeMetadata(createParentDirectories=True),
    description=_(
u"""Directory or geodatabase to receive the rasters.

Unless you have a specific reason to store the rasters in a
geodatabase, we recommend you store them in a directory because it
will be much faster and allows the rasters to be organized in a tree.
If you do store the rasters in a geodatabase, you must change the
Raster Name Expressions parameter; see below for more
information."""),
    arcGISDisplayName=_(u'Output workspace'))

AddArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'mode',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'Add', u'Replace'], makeLowercase=True),
    description=_(
u"""Overwrite mode, one of:

* Add - create rasters that do not exist and skip those that already
  exist. This is the default.

* Replace - create rasters that do not exist and overwrite those that
  already exist.

'Add' is appropriate when working with HYCOM data older than one week
from the current date. When working with newer data, consider using
'Replace'. The HYCOM documentation states that HYCOM provides a five
day forecast and five day hindcast from the current date, although we
have regularly observed netCDF files on their servers that suggested
this window actually extends seven days in both directions. HYCOM
revises the data within this window daily, using the latest ocean
observations assimilated from buoys, satellites, and other sensors.
Therefore, by using 'Replace' when working with data within this
window, you will be sure to overwrite obsolete data with the latest
estimates.

The ArcGIS Overwrite Outputs geoprocessing setting has no effect on
this tool. If 'Replace' is selected the rasters will be overwritten,
regardless of the ArcGIS Overwrite Outputs setting."""),
    arcGISDisplayName=_(u'Overwrite mode'))

AddArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'rasterNameExpressions',
    typeMetadata=ListTypeMetadata(elementType=UnicodeStringTypeMetadata(), minLength=1),
    description=_(
u"""List of expressions specifying how the output rasters should be
named.

The default expression assumes you are storing rasters in a file
system directory and creates them in a tree structure with names that
imitate those used by the original data provider. When storing rasters
in a directory, the final expression specifies the file name of the
raster and any preceding expressions specify subdirectories. The
extension of the final expression determines the output raster format:
.asc for ArcInfo ASCII Grid, .bmp for BMP, .gif for GIF, .img for an
ERDAS IMAGINE file, .jpg for JPEG, .jp2 for JPEG 2000, .png for PNG,
.tif for GeoTIFF, or no extension for ArcInfo Binary Grid. The default
expression uses .img.

When storing rasters in a geodatabase, you should provide only one
expression. That expression specifies the raster's name.

Each expression may contain any sequence of characters permitted by
the output workspace. Each expression may optionally contain one or
more of the following case-sensitive codes. The tool replaces the
codes with appropriate values when creating each raster:

* %(VariableName)s - dataset variable represented in the output
  raster.

* %%Y - four-digit year of the raster.

* %%m - two-digit month of the first day of the raster.

* %%d - two-digit day of the month of the first day of the raster.

* %%j - three-digit day of the year of the first day of the raster.
"""),
    arcGISDisplayName=_(u'Raster name expressions'))

AddArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'spatialExtent',
    typeMetadata=EnvelopeTypeMetadata(canBeNone=True),
    description=_(
u"""Spatial extent of the output rasters, in the units specified by
the Linear Units parameter.

If you do not specify a spatial extent, it will default to
approximately 98 to 76 W, 18 to 32 N. The rasters can only be clipped
in whole grid cells. The values you provide will be rounded off to the
closest cell."""),
    arcGISDisplayName=_(u'Spatial extent'),
    arcGISCategory=_(u'Spatiotemporal extent'))

AddArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'linearUnit',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'Degrees', u'Meters'], makeLowercase=True),
    description=_(
u"""Specifies the unit of the Spatial Extent parameter, one of:

* Degrees - Decimal degrees.

* Meters - Meters, in the coordinate system of the output rasters.
"""),
    arcGISDisplayName=_(u'Linear unit'),
    arcGISCategory=_(u'Spatiotemporal extent'))

AddArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'startDate',
    typeMetadata=DateTimeTypeMetadata(canBeNone=True),
    description=_(
u"""Start date for the rasters to create.

Rasters will be created for images that occur on or after the start
date and on or before the end date. The HYCOM GOMl0.04 dataset
provides a five-day forecast; its temporal extent ranges from 1
January 2003 to today's date plus five days. If you do not specify a
start date, 1 January 2003 will be used."""),
    arcGISDisplayName=_(u'Start date'),
    arcGISCategory=_(u'Spatiotemporal extent'))

AddArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'endDate',
    typeMetadata=DateTimeTypeMetadata(canBeNone=True),
    description=_(
u"""End date for the rasters to create.

Rasters will be created for images that occur on or after the start
date and on or before the end date. The HYCOM GOMl0.04 dataset
provides a five-day forecast; its temporal extent ranges from 1
January 2003 to today's date plus five days. If you do not specify an
end date, the most recent day available will be used (typically
today's date plus five days)."""),
    arcGISDisplayName=_(u'End date'),
    arcGISCategory=_(u'Spatiotemporal extent'))

CopyArgumentMetadata(HYCOMGOMl0043D.__init__, u'timeout', HYCOMGOMl0043D.CreateArcGISRasters, u'timeout')
CopyArgumentMetadata(HYCOMGOMl0043D.__init__, u'cacheDirectory', HYCOMGOMl0043D.CreateArcGISRasters, u'cacheDirectory')

AddArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'calculateStatistics',
    typeMetadata=BooleanTypeMetadata(),
    description=_CalculateStatisticsDescription,
    arcGISDisplayName=_(u'Calculate statistics'),
    arcGISCategory=_(u'Additional raster processing options'))

AddArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'buildPyramids',
    typeMetadata=BooleanTypeMetadata(),
    description=_BuildPyramidsDescription,
    arcGISDisplayName=_(u'Build pyramids'),
    arcGISCategory=_(u'Additional raster processing options'))

AddResultMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'updatedOutputWorkspace',
    typeMetadata=ArcGISWorkspaceTypeMetadata(),
    description=_(u'Updated output workspace.'),
    arcGISDisplayName=_(u'Updated output workspace'),
    arcGISParameterDependencies=[u'outputWorkspace'])

###############################################################################
# Metadata: _HYCOMGridGOMl0044D class
###############################################################################

AddClassMetadata(_HYCOMGridGOMl0044D,
    shortDescription=_(u'An OPeNDAPGrid for a 4D variable of a HYCOM GOMl0.04 OPeNDAP URL.')
    longDescription=_(
u"""This class is intended for private use within GeoEco and is not
intended for external callers."""))

###############################################################################
# Metadata: HYCOMGOMl0044D class
###############################################################################

AddClassMetadata(HYCOMGOMl0044D,
    shortDescription=_(u'Represents a HYCOM GOMl0.04 3D variable as a Grid Dataset.'),
    longDescription=_HYCOMGOMl004_LongDescription % {u'name': 'class'})

# Constructor

AddMethodMetadata(HYCOMGOMl0044D.__init__,
    shortDescription=_(u'Constructs a new HYCOMGOMl0044D instance.'),
    isExposedToPythonCallers=True,
    dependencies=[PythonAggregatedModuleDependency('numpy')])

AddArgumentMetadata(HYCOMGOMl0044D.__init__, u'self',
    typeMetadata=ClassInstanceTypeMetadata(cls=HYCOMGOMl0044D),
    description=_(u'HYCOMGOMl0044D instance.'))

AddArgumentMetadata(HYCOMGOMl0044D.__init__, u'variableName',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'salinity', u'temperature', u'u', u'v', u'w'], makeLowercase=True),
    description=_(
u"""HYCOM GOMl0.04 4D variable (dimensions x, y, depth, and time), one
of:

* salinity - Sea water salinity, in psu.

* temperature - Sea water potential temperature, in degrees C.

* u - Eastward sea water velocity, in m/s.

* v - Northward sea water velocity, in m/s.

* w - Upward sea water velocity, in m/s.

Please see the HYCOM documentation for more information about these
variables."""),
    arcGISDisplayName=_(u'Dataset variable'))

CopyArgumentMetadata(HYCOMGOMl0043D.__init__, u'startYear', HYCOMGOMl0044D.__init__, u'startYear')
CopyArgumentMetadata(HYCOMGOMl0043D.__init__, u'endYear', HYCOMGOMl0044D.__init__, u'endYear')
CopyArgumentMetadata(HYCOMGOMl0043D.__init__, u'timeout', HYCOMGOMl0044D.__init__, u'timeout')
CopyArgumentMetadata(HYCOMGOMl0043D.__init__, u'cacheDirectory', HYCOMGOMl0044D.__init__, u'cacheDirectory')

CopyResultMetadata(HYCOMGOMl0043D.__init__, u'grid', HYCOMGOMl0044D.__init__, u'grid')

# Public method: HYCOMGOMl0044D.CreateArcGISRasters

AddMethodMetadata(HYCOMGOMl0044D.CreateArcGISRasters,
    shortDescription=_(u'Downloads a HYCOM GOMl0.04 4D variable and creates ArcGIS rasters.'),
    longDescription=_HYCOMGOMl004_LongDescription % {u'name': 'class'})
    isExposedByCOM=True,
    isExposedAsArcGISTool=True,
    arcGISDisplayName=_(u'Download HYCOM GOMl0.04 4D Variable to ArcGIS Rasters'),
    arcGISToolCategory=_(u'Data Products\\HYCOM Consortium\\HYCOM + NCODA Gulf of Mexico 1/25 Degree Analysis (GLMl0.04)'),
    dependencies=[ArcGISDependency(9, 1), PythonAggregatedModuleDependency('numpy')])

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

CopyArgumentMetadata(HYCOMGOMl0044D.__init__, u'variableName', HYCOMGOMl0044D.CreateArcGISRasters, u'variableName')
CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'outputWorkspace', HYCOMGOMl0044D.CreateArcGISRasters, u'outputWorkspace')
CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'mode', HYCOMGOMl0044D.CreateArcGISRasters, u'mode')

AddArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'rasterNameExpressions',
    typeMetadata=ListTypeMetadata(elementType=UnicodeStringTypeMetadata(), minLength=1),
    description=_(
u"""List of expressions specifying how the output rasters should be
named.

The default expression assumes you are storing rasters in a file
system directory and creates them in a tree structure with names that
imitate those used by the original data provider. When storing rasters
in a directory, the final expression specifies the file name of the
raster and any preceding expressions specify subdirectories. The
extension of the final expression determines the output raster format:
.asc for ArcInfo ASCII Grid, .bmp for BMP, .gif for GIF, .img for an
ERDAS IMAGINE file, .jpg for JPEG, .jp2 for JPEG 2000, .png for PNG,
.tif for GeoTIFF, or no extension for ArcInfo Binary Grid. The default
expression uses .img.

When storing rasters in a geodatabase, you should provide only one
expression. That expression specifies the raster's name.

Each expression may contain any sequence of characters permitted by
the output workspace. Each expression may optionally contain one or
more of the following case-sensitive codes. The tool replaces the
codes with appropriate values when creating each raster:

* %(VariableName)s - dataset variable represented in the output
  raster.

* %(Depth)f - depth of the output raster. The f may be preceded by
  Python's string formatting codes. Please see the Python
  documentation for more information.

* %%Y - four-digit year of the raster.

* %%m - two-digit month of the first day of the raster.

* %%d - two-digit day of the month of the first day of the raster.

* %%j - three-digit day of the year of the first day of the raster.
"""),
    arcGISDisplayName=_(u'Raster name expressions'))

CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'spatialExtent', HYCOMGOMl0044D.CreateArcGISRasters, u'spatialExtent')
CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'linearUnit', HYCOMGOMl0044D.CreateArcGISRasters, u'linearUnit')

AddArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'minDepth',
    typeMetadata=FloatTypeMetadata(minValue=0.0, maxValue=5500.0, canBeNone=True),
    description=_(
u"""Minimum depth, in meters, for the rasters to create.

The value must be between 0 and 5500, inclusive. Rasters will be
created for images with depths that are greater than or equal to the
minimum depth and less than or equal to the maximum depth. If you do
not specify a minimum depth, 0 will be used."""),
    arcGISDisplayName=_(u'Minimum depth'),
    arcGISCategory=_(u'Spatiotemporal extent'))

AddArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'maxDepth',
    typeMetadata=FloatTypeMetadata(minValue=0.0, maxValue=5500.0, canBeNone=True),
    description=_(
u"""Maximum depth, in meters, for the rasters to create.

The value must be between 0 and 5500, inclusive. Rasters will be
created for images with depths that are greater than or equal to the
minimum depth and less than or equal to the maximum depth. If you do
not specify a maximum depth, 5500 will be used. This depth encompasses
the deepest HYCOM layer."""),
    arcGISDisplayName=_(u'Maximum depth'),
    arcGISCategory=_(u'Spatiotemporal extent'))

CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'startDate', HYCOMGOMl0044D.CreateArcGISRasters, u'startDate')
CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'endDate', HYCOMGOMl0044D.CreateArcGISRasters, u'endDate')
CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'timeout', HYCOMGOMl0044D.CreateArcGISRasters, u'timeout')
CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'cacheDirectory', HYCOMGOMl0044D.CreateArcGISRasters, u'cacheDirectory')
CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'calculateStatistics', HYCOMGOMl0044D.CreateArcGISRasters, u'calculateStatistics')
CopyArgumentMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'buildPyramids', HYCOMGOMl0044D.CreateArcGISRasters, u'buildPyramids')

CopyResultMetadata(HYCOMGOMl0043D.CreateArcGISRasters, u'updatedOutputWorkspace', HYCOMGOMl0044D.CreateArcGISRasters, u'updatedOutputWorkspace')

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

__all__ = ['HYCOMGOMl0043D', 'HYCOMGOMl0044D']