root/MGET/Branches/Jason/PythonPackage/src/GeoEco/Connectivity/CoralReefConnectivity.py @ 885

# CoralReefConnectivity.py - Implements Eric Treml's coral reef
# connectivity analysis.
#
# Copyright (C) 2008 Jason J. Roberts and Eric A. Treml
#
# 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 os

from GeoEco.DataProducts.Aviso import AvisoGriddedGeostrophicCurrents, _AvisoGriddedProduct, _AvisoGriddedProduct_LongDescription
from GeoEco.DataProducts.HYCOM import HYCOMGOMl0044D, _HYCOMGOMl004_LongDescription, HYCOMGLBa008Equatorial4D, _HYCOMGLBa008Equatorial_LongDescription
from GeoEco.DataProducts.NOAA.OSCAR import OSCAR5DayThirdDegreeCurrents, _OSCAR_LongDescription
from GeoEco.DataProducts.UMaineOMG import ROMSCoSiNE4D, _ROMS_CoSiNE_LongDescription
from GeoEco.DynamicDocString import DynamicDocString
from GeoEco.Internationalization import _
from GeoEco.Logging import Logger, ProgressReporter
from GeoEco.Types import EnvelopeTypeMetadata

class CoralReefConnectivity(object):
    __doc__ = DynamicDocString()

    @classmethod
    def CreateSimulationFromArcGISRasters(cls, simulationDirectory, reefIDsRaster, reefCoverRaster, waterMaskRaster, crosses180=False, overwriteExisting=False):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Validate the coordinate systems, extents, and cell sizes of
        # the input rasters.

        from GeoEco.ArcGIS import GeoprocessorManager
        gp = GeoprocessorManager.GetWrappedGeoprocessor()

        describeReefIDsRaster = gp.Describe(reefIDsRaster)
        describereefCoverRaster = gp.Describe(reefCoverRaster)
        describeWaterMaskRaster = gp.Describe(waterMaskRaster)

        if describeReefIDsRaster.SpatialReference.Type.lower() != u'projected':
            Logger.RaiseException(ValueError(_(u'ArcGIS reports that the reef IDs raster %(raster)s uses a %(type)s coordinate system. It must use a projected coordinate system. Please project it and try again.') % {u'raster': reefIDsRaster, u'type': describeReefIDsRaster.SpatialReference.Type.lower()}))
        if describeReefIDsRaster.SpatialReference.LinearUnitName.lower() != u'meter':
            Logger.RaiseException(ValueError(_(u'ArcGIS reports that the reef IDs raster %(raster)s uses the linear unit "%(unit)s". It must use a coordinate system that has meters as its linear unit.  Please project it to a coordinate system that uses meters and try again.') % {u'raster': reefIDsRaster, u'unit': describeReefIDsRaster.SpatialReference.LinearUnitName.lower()}))

        reefIDsRasterCS = gp.CreateSpatialReference(describeReefIDsRaster.SpatialReference).split(';')[0]
        reefCoverRasterCS = gp.CreateSpatialReference(describereefCoverRaster.SpatialReference).split(';')[0]
        waterMaskRasterCS = gp.CreateSpatialReference(describeWaterMaskRaster.SpatialReference).split(';')[0]

        if reefCoverRasterCS.lower() != reefIDsRasterCS.lower():
            Logger.RaiseException(ValueError(_(u'The reef cover raster %(raster1)s uses a different coordinate system than the reef IDs raster, %(raster2)s. Please project the reef cover raster to the reef IDs raster\'s coordinate system and try again.') % {u'raster1': reefCoverRaster, u'raster2': reefIDsRaster}))
        if waterMaskRasterCS.lower() != reefIDsRasterCS.lower():
            Logger.RaiseException(ValueError(_(u'The water mask raster %(raster1)s uses a different coordinate system than the reef IDs raster, %(raster2)s. Please project the water mask raster to the reef IDs raster\'s coordinate system and try again.') % {u'raster1': waterMaskRaster, u'raster2': reefIDsRaster}))

        reefIDsRasterLeft, reefIDsRasterBottom, reefIDsRasterRight, reefIDsRasterTop = EnvelopeTypeMetadata.ParseFromArcGISString(describeReefIDsRaster.Extent)
        reefCoverRasterLeft, reefCoverRasterBottom, reefCoverRasterRight, reefCoverRasterTop = EnvelopeTypeMetadata.ParseFromArcGISString(describereefCoverRaster.Extent)
        waterMaskRasterLeft, waterMaskRasterBottom, waterMaskRasterRight, waterMaskRasterTop = EnvelopeTypeMetadata.ParseFromArcGISString(describeWaterMaskRaster.Extent)

        if abs(reefCoverRasterLeft - reefIDsRasterLeft) > 0.001 or abs(reefCoverRasterBottom - reefIDsRasterBottom) > 0.001 or abs(reefCoverRasterRight - reefIDsRasterRight) > 0.001 or abs(reefCoverRasterTop - reefIDsRasterTop) > 0.001 or abs(describereefCoverRaster.MeanCellWidth - describeReefIDsRaster.MeanCellWidth) > 0.001 or abs(describereefCoverRaster.MeanCellHeight - describeReefIDsRaster.MeanCellHeight) > 0.001:
            Logger.RaiseException(ValueError(_(u'The reef cover raster %(raster1)s has a different extent or cell size than the reef IDs raster, %(raster2)s. Please prepare a reef cover raster that has the same extent and cell size as the reef IDs raster and try again.') % {u'raster1': reefCoverRaster, u'raster2': reefIDsRaster}))
        if abs(waterMaskRasterLeft - reefIDsRasterLeft) > 0.001 or abs(waterMaskRasterBottom - reefIDsRasterBottom) > 0.001 or abs(waterMaskRasterRight - reefIDsRasterRight) > 0.001 or abs(waterMaskRasterTop - reefIDsRasterTop) > 0.001 or abs(describeWaterMaskRaster.MeanCellWidth - describeReefIDsRaster.MeanCellWidth) > 0.001 or abs(describeWaterMaskRaster.MeanCellHeight - describeReefIDsRaster.MeanCellHeight) > 0.001:
            Logger.RaiseException(ValueError(_(u'The water mask raster %(raster1)s has a different extent or cell size than the reef IDs raster, %(raster2)s. Please prepare a water mask raster that has the same extent and cell size as the reef IDs raster and try again.') % {u'raster1': reefCoverRaster, u'raster2': waterMaskRaster}))

        # Validate that 0 is not used as a reef ID. The MATLAB code
        # uses 0 to represent cells where no reefs are present.

        from GeoEco.DataManagement.ArcGISRasters import ArcGISRaster
        from GeoEco.DataManagement.Directories import Directory, TemporaryDirectory
        import numpy

        tempDir = TemporaryDirectory()
        reefIDsImage, reefIDsNoDataValue = ArcGISRaster.ToNumpyArray(reefIDsRaster, tempRasterPath=os.path.join(tempDir.Path, u'reef_ids'))
        if numpy.any(reefIDsImage == 0) and reefIDsNoDataValue != 0:
            Logger.RaiseException(ValueError(_(u'The reef IDs raster %(raster)s uses 0 as a reef ID. This is not allowed.  Please remove the value 0 from the reef IDs raster and try again.')  % {u'raster': reefIDsRaster}))

        # Validate that reef cover raster ranges between 0.0 and 1.0.

        reefCoverImage, noDataValue = ArcGISRaster.ToNumpyArray(reefCoverRaster, tempRasterPath=os.path.join(tempDir.Path, u'reef_areas'))
        if noDataValue is not None:
            reefCoverImage[reefCoverImage == noDataValue] = 0
        if numpy.any(reefCoverImage < 0) or numpy.any(reefCoverImage > 1):
            Logger.RaiseException(ValueError(_(u'The reef cover raster %(raster)s includes values that are less than 0 or are greater than 1. The values of a cell of this raster is supposed to represent the proportion of the cell\'s area that is occupied by reef, thus the value is supposed to be between 0 and 1. Please prepare a raster that has the correct values and try again.')  % {u'raster': reefCoverRaster}))

        # Create the simulation directory and the ReefData
        # subdirectory.

        oldLogInfoAsDebug = Logger.LogInfoAndSetInfoToDebug(_(u'Creating and initializing the simulation directory %(dir)s...') % {u'dir': simulationDirectory})
        Logger.SetLogInfoAsDebug(True)
        try:
            from GeoEco.DataManagement.Directories import Directory, TemporaryDirectory

            Directory.Create(simulationDirectory)
            Directory.Create(os.path.join(simulationDirectory, u'ReefData'))

            # Copy the reef IDs raster into the ReefData directory.

            ArcGISRaster.Copy(reefIDsRaster, os.path.join(simulationDirectory, u'ReefData', u'reef_ids'))

            # Copy the reef cover raster into the ReefData directory,
            # setting the NoData values and non-reef cells to 0 in the process.

            if GeoprocessorManager.GetArcGISMajorVersion() >= 10:
                mapAlgebraExpression = u'float(con(isnull( [%(raster1)s] ) == 1 || isnull( [%(raster2)s] ) == 1, 0.0, [%(raster1)s] ))' % {u'raster1': reefCoverRaster, u'raster2': reefIDsRaster}
            else:
                mapAlgebraExpression = u'float(con(isnull( %(raster1)s ) == 1 || isnull( %(raster2)s ) == 1, 0.0, %(raster1)s ))' % {u'raster1': reefCoverRaster, u'raster2': reefIDsRaster}
            gp.SingleOutputMapAlgebra_sa(mapAlgebraExpression, os.path.join(tempDir.Path, u'reef_areas2'))
            ArcGISRaster.Copy(os.path.join(tempDir.Path, u'reef_areas2'), os.path.join(simulationDirectory, u'ReefData', u'reef_areas'))

            # Copy the water mask raster into the ReefData directory,
            # normalizing it to integer values where 1 is water, 0 is
            # land.

            if GeoprocessorManager.GetArcGISMajorVersion() >= 10:
                mapAlgebraExpression = u'con(isnull( [%(raster)s] ) || [%(raster)s] == 0, 0, 1)' % {u'raster': waterMaskRaster}
            else:
                mapAlgebraExpression = u'con(isnull( %(raster)s ) || %(raster)s == 0, 0, 1)' % {u'raster': waterMaskRaster}
            gp.SingleOutputMapAlgebra_sa(mapAlgebraExpression, os.path.join(tempDir.Path, u'water_mask'))
            ArcGISRaster.Copy(os.path.join(tempDir.Path, u'water_mask'), os.path.join(simulationDirectory, u'ReefData', u'water_mask'))

            # Create the reef_geometry file by calling Spatial
            # Analyst's Zonal Geometry As Table tool. (Note that this
            # tool will create a .dbf file no matter what, even if we
            # give it a .csv or .txt extension. This is very annoying,
            # because we can't read it easily without going through a
            # database API, which is slow.)

            gp.ZonalGeometryAsTable_sa(os.path.join(simulationDirectory, u'ReefData', u'reef_ids'), u'Value', os.path.join(simulationDirectory, u'ReefData', u'reef_geometry.dbf'), describeReefIDsRaster.MeanCellWidth)

            # Create the directories that will hold the currents
            # rasters.

            Directory.Create(os.path.join(simulationDirectory, u'Currents'))
            Directory.Create(os.path.join(simulationDirectory, u'Currents', u'u'))
            Directory.Create(os.path.join(simulationDirectory, u'Currents', u'v'))

            # Create the config file that stores properties of the
            # simulation.

            from ConfigParser import SafeConfigParser

            scp = SafeConfigParser()
            scp.add_section(u'Simulation')
            scp.set(u'Simulation', u'Crosses180', unicode(crosses180))
            scp.set(u'Simulation', u'CurrentsLoaded', unicode(False))
            scp.set(u'Simulation', u'CurrentsProduct', u'')
            f = file(os.path.join(simulationDirectory, u'Simulation.ini'), 'w')
            try:
                scp.write(f)
            finally:
                try:
                    f.close()
                except:
                    pass

        finally:
            Logger.SetLogInfoAsDebug(oldLogInfoAsDebug)

    @classmethod
    def LoadAvisoGeostrophicCurrentsIntoSimulation(cls, simulationDirectory, username, password, product, startDate, endDate, resamplingTechnique=u'CUBIC', interpolationMethod=None, timeout=60, maxRetryTime=120, cacheDirectory=None):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Parse and validate the Simulation.ini file.

        scp, crosses180, currentsLoaded, currentsProduct = cls._ReadCurrentsInfoFromSimulationINI(simulationDirectory)

        # If the simulation already has currents loaded in it from a
        # different product, report an error.

        thisCurrentsProduct = u'Aviso %s (resampling=%s, interpolation=%s)' % (product, resamplingTechnique.lower(), str(interpolationMethod).lower())

        if currentsLoaded and currentsProduct != thisCurrentsProduct:
            Logger.RaiseException(ValueError(_(u'Cannot load %(prod1)s currents data into the simulation in directory %(dir)s because that simulation already has %(prod2)s currents data loaded into it. You can load additional %(prod2)s data, if you like, but to use Aviso %(prod1)s data, you must create a new simulation.') % {u'dir': simulationDirectory, u'prod1': thisCurrentsProduct, u'prod2': currentsProduct}))

        # First, download and create Aviso current rasters in an
        # Aviso-specific directory. These will have the Aviso
        # projection, extent, and cell size. We still need to project
        # them to the simulation's projection, extent, and cell size.
        #
        # TODO: Need to handle rotation?

        avisoCurrentsDirectory = os.path.join(simulationDirectory, 'OriginalAvisoCurrents')
        _AvisoCurrentsInMetersPerSecond.CreateArcGISRasters(username, password, product, u'u', avisoCurrentsDirectory, rasterNameExpressions=['u', '%%Y', 'u%%Y%%j0000.img'], startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)
        _AvisoCurrentsInMetersPerSecond.CreateArcGISRasters(username, password, product, u'v', avisoCurrentsDirectory, rasterNameExpressions=['v', '%%Y', 'v%%Y%%j0000.img'], startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)

        # Record in the Simulation.ini file that we downloaded some
        # currents and then project, snap, and clip them to the
        # projection, extent, and cell size of the reef IDs raster.

        grid = AvisoGriddedGeostrophicCurrents(product, u'u', username, password, timeout=timeout, maxRetryTime=maxRetryTime)
        timeStep = grid.CenterCoords['t', 1] - grid.CenterCoords['t', 0]

        cls._FinishLoadingCurrents(simulationDirectory, scp, thisCurrentsProduct, u'Center', timeStep.days * 86400 + timeStep.seconds, avisoCurrentsDirectory, resamplingTechnique, interpolationMethod)

        # Return successfully.

        return simulationDirectory

    @classmethod
    def LoadOSCARCurrentsIntoSimulation(cls, simulationDirectory, startDate, endDate, resamplingTechnique=u'CUBIC', interpolationMethod=None, timeout=60, maxRetryTime=120, cacheDirectory=None):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Parse and validate the Simulation.ini file.

        scp, crosses180, currentsLoaded, currentsProduct = cls._ReadCurrentsInfoFromSimulationINI(simulationDirectory)

        # If the simulation already has currents loaded in it from a
        # different product, report an error.

        thisCurrentsProduct = u'OSCAR (resampling=%s, interpolation=%s)' % (resamplingTechnique.lower(), str(interpolationMethod).lower())

        if currentsLoaded and currentsProduct != thisCurrentsProduct:
            Logger.RaiseException(ValueError(_(u'Cannot load %(prod1)s currents data into the simulation in directory %(dir)s because that simulation already has %(prod2)s currents data loaded into it. You can load additional %(prod2)s data, if you like, but to use Aviso %(prod1)s data, you must create a new simulation.') % {u'dir': simulationDirectory, u'prod1': thisCurrentsProduct, u'prod2': currentsProduct}))

        # First, download and create OSCAR current rasters in an
        # OSCAR-specific directory. These will have the OSCAR
        # projection, extent, and cell size. We still need to project
        # them to the simulation's projection, extent, and cell size.
        #
        # TODO: Need to handle rotation?

        oscarCurrentsDirectory = os.path.join(simulationDirectory, 'OriginalOSCARCurrents')
        OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters(u'u', oscarCurrentsDirectory, rasterNameExpressions=['u', '%%Y', 'u%%Y%%j0000.img'], rotationOffset=-20., startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)
        OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters(u'v', oscarCurrentsDirectory, rasterNameExpressions=['v', '%%Y', 'v%%Y%%j0000.img'], rotationOffset=-20., startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)

        # Record in the Simulation.ini file that we downloaded some
        # currents and then project, snap, and clip them to the
        # projection, extent, and cell size of the reef IDs raster.

        cls._FinishLoadingCurrents(simulationDirectory, scp, thisCurrentsProduct, u'Center', 6*86400, oscarCurrentsDirectory, resamplingTechnique, interpolationMethod)

        # Return successfully.

        return simulationDirectory

    @classmethod
    def LoadHYCOMGOMl0044DCurrentsIntoSimulation(cls, simulationDirectory, startDate, endDate, depth=0., resamplingTechnique=u'CUBIC', interpolationMethod=None, timeout=600, maxRetryTime=None, cacheDirectory=None):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Parse and validate the Simulation.ini file.

        scp, crosses180, currentsLoaded, currentsProduct = cls._ReadCurrentsInfoFromSimulationINI(simulationDirectory)

        # If the simulation already has currents loaded in it from a
        # different product, report an error.

        thisCurrentsProduct = u'HYCOM GOMl0.04 %i m (resampling=%s, interpolation=%s)' % (int(depth), resamplingTechnique.lower(), str(interpolationMethod).lower())

        if currentsLoaded and currentsProduct != thisCurrentsProduct:
            Logger.RaiseException(ValueError(_(u'Cannot load %(prod1)s currents data into the simulation in directory %(dir)s because that simulation already has %(prod2)s currents data loaded into it. You can load additional %(prod2)s data, if you like, but to use Aviso %(prod1)s data, you must create a new simulation.') % {u'dir': simulationDirectory, u'prod1': thisCurrentsProduct, u'prod2': currentsProduct}))

        # First, download and create HYCOM current rasters in a
        # HYCOM-specific directory. These will have the HYCOM
        # projection, extent, and cell size. We still need to project
        # them to the simulation's projection, extent, and cell size.

        hycomCurrentsDirectory = os.path.join(simulationDirectory, 'OriginalHYCOMCurrents')
        HYCOMGOMl0044D.CreateArcGISRasters(u'u', hycomCurrentsDirectory, rasterNameExpressions=['%(VariableName)s', '%%Y', '%(VariableName)s%%Y%%j0000.img'], minDepth=depth, maxDepth=depth, startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)
        HYCOMGOMl0044D.CreateArcGISRasters(u'v', hycomCurrentsDirectory, rasterNameExpressions=['%(VariableName)s', '%%Y', '%(VariableName)s%%Y%%j0000.img'], minDepth=depth, maxDepth=depth, startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)

        # Record in the Simulation.ini file that we downloaded some
        # currents and then project, snap, and clip them to the
        # projection, extent, and cell size of the reef IDs raster.

        cls._FinishLoadingCurrents(simulationDirectory, scp, thisCurrentsProduct, u'Center', 86400, hycomCurrentsDirectory, resamplingTechnique, interpolationMethod)

        # Return successfully.

        return simulationDirectory

    @classmethod
    def LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation(cls, simulationDirectory, startDate, endDate, depth=0., extendYExtent=False, resamplingTechnique=u'CUBIC', interpolationMethod=None, timeout=60, maxRetryTime=120, cacheDirectory=None):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Parse and validate the Simulation.ini file.

        scp, crosses180, currentsLoaded, currentsProduct = cls._ReadCurrentsInfoFromSimulationINI(simulationDirectory)

        # If the simulation already has currents loaded in it from a
        # different product, report an error.

        thisCurrentsProduct = u'HYCOM GLBa0.08 Equatorial %i m (resampling=%s, interpolation=%s)' % (int(depth), resamplingTechnique.lower(), str(interpolationMethod).lower())

        if currentsLoaded and currentsProduct != thisCurrentsProduct:
            Logger.RaiseException(ValueError(_(u'Cannot load %(prod1)s currents data into the simulation in directory %(dir)s because that simulation already has %(prod2)s currents data loaded into it. You can load additional %(prod2)s data, if you like, but to use Aviso %(prod1)s data, you must create a new simulation.') % {u'dir': simulationDirectory, u'prod1': thisCurrentsProduct, u'prod2': currentsProduct}))

        # First, download and create HYCOM current rasters in a
        # HYCOM-specific directory. These will have the HYCOM
        # projection, extent, and cell size. We still need to project
        # them to the simulation's projection, extent, and cell size.

        hycomCurrentsDirectory = os.path.join(simulationDirectory, 'OriginalHYCOMCurrents')
        HYCOMGLBa008Equatorial4D.CreateArcGISRasters(u'u', hycomCurrentsDirectory, rasterNameExpressions=['%(VariableName)s', '%%Y', '%(VariableName)s%%Y%%j0000.img'], extendYExtent=extendYExtent, minDepth=depth, maxDepth=depth, startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)
        HYCOMGLBa008Equatorial4D.CreateArcGISRasters(u'v', hycomCurrentsDirectory, rasterNameExpressions=['%(VariableName)s', '%%Y', '%(VariableName)s%%Y%%j0000.img'], extendYExtent=extendYExtent, minDepth=depth, maxDepth=depth, startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)

        # Record in the Simulation.ini file that we downloaded some
        # currents and then project, snap, and clip them to the
        # projection, extent, and cell size of the reef IDs raster.

        cls._FinishLoadingCurrents(simulationDirectory, scp, thisCurrentsProduct, u'Center', 86400, hycomCurrentsDirectory, resamplingTechnique, interpolationMethod)

        # Return successfully.

        return simulationDirectory

    @classmethod
    def LoadROMSCoSiNE4DCurrentsIntoSimulation(cls, simulationDirectory, startDate, endDate, depth=0., resamplingTechnique=u'CUBIC', interpolationMethod=None, url=u'http://viz.clusters.umaine.edu:8080/thredds/dodsC/pacific/1991-2008', timeout=60, maxRetryTime=120, cacheDirectory=None):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Parse and validate the Simulation.ini file.

        scp, crosses180, currentsLoaded, currentsProduct = cls._ReadCurrentsInfoFromSimulationINI(simulationDirectory)

        # If the simulation already has currents loaded in it from a
        # different product, report an error.

        thisCurrentsProduct = u'ROMS-CoSiNE %i m (resampling=%s, interpolation=%s)' % (int(depth), resamplingTechnique.lower(), str(interpolationMethod).lower())

        if currentsLoaded and currentsProduct != thisCurrentsProduct:
            Logger.RaiseException(ValueError(_(u'Cannot load %(prod1)s currents data into the simulation in directory %(dir)s because that simulation already has %(prod2)s currents data loaded into it. You can load additional %(prod2)s data, if you like, but to use Aviso %(prod1)s data, you must create a new simulation.') % {u'dir': simulationDirectory, u'prod1': thisCurrentsProduct, u'prod2': currentsProduct}))

        # First, download and create ROMS-CoSiNE current rasters in a
        # ROMS-CoSiNE-specific directory. These will have the
        # ROMS-CoSiNE projection, extent, and cell size. We still need
        # to project them to the simulation's projection, extent, and
        # cell size.

        romsCurrentsDirectory = os.path.join(simulationDirectory, 'OriginalROMSCurrents')
        ROMSCoSiNE4D.CreateArcGISRasters(u'u', [depth], romsCurrentsDirectory, rasterNameExpressions=['%(VariableName)s', '%%Y', '%(VariableName)s%%Y%%j0000.img'], startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)
        ROMSCoSiNE4D.CreateArcGISRasters(u'v', [depth], romsCurrentsDirectory, rasterNameExpressions=['%(VariableName)s', '%%Y', '%(VariableName)s%%Y%%j0000.img'], startDate=startDate, endDate=endDate, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)

        # Record in the Simulation.ini file that we downloaded some
        # currents and then project, snap, and clip them to the
        # projection, extent, and cell size of the reef IDs raster.

        cls._FinishLoadingCurrents(simulationDirectory, scp, thisCurrentsProduct, u'Center', 73*3600, romsCurrentsDirectory, resamplingTechnique, interpolationMethod)

        # Return successfully.

        return simulationDirectory

    @classmethod
    def _FinishLoadingCurrents(cls, simulationDirectory, scp, currentsProduct, currentsDateType, maxSecondsBetweenCurrentsImages, originalCurrentsDirectory, resamplingTechnique, interpolationMethod):

        # Write the Simulation.ini file, so that any new rasters
        # loaded into the simulation must be from the same product and
        # depth.
            
        scp.set(u'Simulation', u'CurrentsLoaded', unicode(True))
        scp.set(u'Simulation', u'CurrentsProduct', currentsProduct)
        scp.set(u'Simulation', u'CurrentsDateType', currentsDateType)
        scp.set(u'Simulation', u'MaxSecondsBetweenCurrentsImages', unicode(maxSecondsBetweenCurrentsImages))
        f = file(os.path.join(simulationDirectory, u'Simulation.ini'), 'w')
        try:
            scp.write(f)
        finally:
            try:
                f.close()
            except:
                pass

        # Create a temporary copy of the water mask with land set to
        # No Data.

        from GeoEco.DataManagement.Directories import TemporaryDirectory
        tempDir = TemporaryDirectory()

        from GeoEco.ArcGIS import GeoprocessorManager
        gp = GeoprocessorManager.GetWrappedGeoprocessor()

        waterMask = os.path.join(simulationDirectory, u'ReefData', u'water_mask')
        newWaterMask = os.path.join(tempDir.Path, u'water_mask')
        gp.SingleOutputMapAlgebra_sa('setnull(%s == 0, %s)' % (waterMask, waterMask), newWaterMask)

        # Using the new water mask as a template, project and clip the
        # current rasters to the reef rasters' coordinate system, cell
        # size, and extent.

        from GeoEco.DataManagement.ArcGISRasters import ArcGISRaster

        ArcGISRaster.FindAndProjectRastersToTemplate(originalCurrentsDirectory,
                                                     os.path.join(simulationDirectory, u'Currents'),
                                                     newWaterMask,
                                                     resamplingTechnique,
                                                     wildcard=u'*.img',
                                                     searchTree=True,
                                                     interpolationMethod=interpolationMethod,
                                                     mask=True,
                                                     outputRasterPythonExpression=u'os.path.join(outputWorkspace, os.path.splitext(inputRaster[len(workspaceToSearch)+1:])[0])',
                                                     modulesToImport=[u'os'],
                                                     skipExisting=True)

    @classmethod
    def _ReadCurrentsInfoFromSimulationINI(cls, simulationDirectory):
        if not os.path.isfile(os.path.join(simulationDirectory, u'Simulation.ini')):
            Logger.RaiseException(ValueError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: it does not contain a file called Simulation.ini. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool and try again.') % {u'dir': simulationDirectory}))

        from ConfigParser import SafeConfigParser

        scp = SafeConfigParser()
        f = file(os.path.join(simulationDirectory, u'Simulation.ini'), 'r')
        try:
            try: 
                scp.readfp(f, os.path.join(simulationDirectory, u'Simulation.ini'))
            except:
                Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: the file Simulation.ini in that directory could not be parsed. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool and try again.') % {u'dir': simulationDirectory})
                raise
        finally:
            try:
                f.close()
            except:
                pass

        try:
            crosses180 = scp.getboolean(u'Simulation', u'Crosses180')
        except:
            Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: failed to parse a boolean option named Crosses180 from the file Simulation.ini in that directory. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool and try again.') % {u'dir': simulationDirectory})
            raise

        try:
            currentsLoaded = scp.getboolean(u'Simulation', u'CurrentsLoaded')
        except:
            Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: failed to parse a boolean option named CurrentsLoaded from the file Simulation.ini in that directory. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool and try again.') % {u'dir': simulationDirectory})
            raise

        try:
            currentsProduct = unicode(scp.get(u'Simulation', u'CurrentsProduct'))
        except:
            Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: failed to parse a string option named CurrentsProduct from the file Simulation.ini in that directory. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool and try again.') % {u'dir': simulationDirectory})
            raise

        return scp, crosses180, currentsLoaded, currentsProduct

    @classmethod
    def RunSimulation(cls, simulationDirectory, outputDirectory, startDate, duration=30.0, simulationTimeStep=2.4, summarizationPeriod=10, initialLarvaeDensity=10000.0, densityRasterCutoff=0.1, diffusivity=25.0, includeReefIDs=None, excludeReefIDs=None, overwriteExisting=False):
        cls.__doc__.Obj.ValidateMethodInvocation()

        # Parse and validate the Simulation.ini file.

        if not os.path.isfile(os.path.join(simulationDirectory, u'Simulation.ini')):
            Logger.RaiseException(ValueError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: it does not contain a file called Simulation.ini. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool and try again.') % {u'dir': simulationDirectory}))

        from ConfigParser import SafeConfigParser

        scp = SafeConfigParser()
        f = file(os.path.join(simulationDirectory, u'Simulation.ini'), 'r')
        try:
            try: 
                scp.readfp(f, os.path.join(simulationDirectory, u'Simulation.ini'))
            except:
                Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: the file Simulation.ini in that directory could not be parsed. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool and try again.') % {u'dir': simulationDirectory})
                raise
        finally:
            try:
                f.close()
            except:
                pass

        try:
            crosses180 = scp.getboolean(u'Simulation', u'Crosses180')
        except:
            Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: failed to parse a boolean option named Crosses180 from the file Simulation.ini in that directory. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool and try again.') % {u'dir': simulationDirectory})
            raise

        try:
            currentsLoaded = scp.getboolean(u'Simulation', u'CurrentsLoaded')
        except:
            Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: failed to parse a boolean option named CurrentsLoaded from the file Simulation.ini in that directory. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool and try again.') % {u'dir': simulationDirectory})
            raise
        if not currentsLoaded:
            Logger.RaiseException(ValueError(_(u'The coral reef connectivity simulation in directory %(dir)s does not contain any ocean currents data. Please load ocean currents into it using a tool designed for this purpose, and try again.') % {u'dir': simulationDirectory}))

        try:
            currentsProduct = unicode(scp.get(u'Simulation', u'CurrentsProduct'))
        except:
            Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: failed to parse a string option named CurrentsProduct from the file Simulation.ini in that directory. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool, load ocean currents into it using a tool designed for this purpose, and try again.') % {u'dir': simulationDirectory})
            raise

        try:
            currentsDateType = unicode(scp.get(u'Simulation', u'CurrentsDateType'))
        except:
            Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: failed to parse a string option named CurrentsProduct from the file Simulation.ini in that directory. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool, load ocean currents into it using a tool designed for this purpose, and try again.') % {u'dir': simulationDirectory})
            raise
        if currentsDateType.lower() not in [u'center']:
            Logger.RaiseException(ValueError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: the CurrentsDataType option in the Simulation.ini file has the unknown value %(val)s. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool, load ocean currents into it using a tool designed for this purpose, and try again.') % {u'dir': simulationDirectory, u'val': currentsDateType}))

        try:
            maxSecondsBetweenCurrentsImages = scp.getint(u'Simulation', u'MaxSecondsBetweenCurrentsImages')
        except:
            Logger.LogExceptionAsError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: failed to parse an integer option named MaxSecondsBetweenCurrentsImages from the file Simulation.ini in that directory. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool, load ocean currents into it using a tool designed for this purpose, and try again.') % {u'dir': simulationDirectory})
            raise
        if maxSecondsBetweenCurrentsImages <= 0:
            Logger.RaiseException(ValueError(_(u'The directory %(dir)s does not appear to be a properly-initialized coral reef connectivity simulation directory: the MaxSecondsBetweenCurrentsImages option in the Simulation.ini file is less than or equal to zero. It must be greater than zero. Please create a simulation directory using the Create Coral Reef Connectivity Simulation tool, load ocean currents into it using a tool designed for this purpose, and try again.') % {u'dir': simulationDirectory}))

        # Validate other input parameters.

        if duration <= 0:
            Logger.RaiseException(ValueError(_(u'The simulation duration must be greater than zero.')))

        if duration - simulationTimeStep/24 <= 0:
            Logger.RaiseException(ValueError(_(u'The time step must be shorter than or equal to the simulation duration. For accurate results, the time step should be significantly shorter than the simulation duration. For example, if the simulation duration is 60 days, a time step of 1 hour would be appropriate.')))

        if includeReefIDs is not None and excludeReefIDs is not None:
            Logger.RaiseException(ValueError(_(u'You cannot specify both a list of reefs to include and a list of reefs to exclude. You must specify one, or the other, or neither.')))

        # Build lists of the currents rasters that are loaded into the
        # simulation, and validate that we have currents for the start
        # date and duration specified by the caller.

        import datetime
        import glob

        uRasters = glob.glob(os.path.join(simulationDirectory, u'Currents', u'u', u'*', u'u[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]'))
        uRasters.sort()
        vRasters = glob.glob(os.path.join(simulationDirectory, u'Currents', u'v', u'*', u'v[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]'))
        vRasters.sort()

        if len(uRasters) <= 0:
            Logger.RaiseException(ValueError(_(u'The coral reef connectivity simulation in directory %(dir)s does not contain any ocean currents data. Please load ocean currents into it using a tool designed for this purpose, and try again.') % {u'dir': simulationDirectory}))
        if len(uRasters) != len(vRasters):
            Logger.RaiseException(ValueError(_(u'The ocean currents data in the coral reef connectivity simulation in directory %(dir)s appears to be incompletely loaded. The number of "u" rasters does not equal the number of "v" rasters, indicating that the load operation did not complete successfully. Please try loading ocean currents again, and then try to run the simulation.') % {u'dir': simulationDirectory}))

        rasterDates = []

        for i in range(len(uRasters)):
            uRasterName = os.path.basename(uRasters[i])
            if uRasterName[1:] != os.path.basename(vRasters[i])[1:]:
                Logger.RaiseException(ValueError(_(u'The ocean currents data in the coral reef connectivity simulation in directory %(dir)s appears to be incompletely loaded. The "u" raster %(r1)s could not be matched up with a "v" raster with the same date (the next available "v" raster is %(r2)s). Please try loading ocean currents again, and then try to run the simulation.') % {u'dir': simulationDirectory, u'r1': uRasters[i], u'r2': vRasters[i]}))
            rasterDates.append(datetime.datetime(int(uRasterName[1:5]), 1, 1) + datetime.timedelta(days=int(uRasterName[5:8]) - 1, hours=int(uRasterName[8:10]), minutes=int(uRasterName[10:12])))

        if currentsDateType.lower() == u'center':
            currentsDateStartDelta = datetime.timedelta(seconds=maxSecondsBetweenCurrentsImages / 2)
            currentsDateEndDelta = datetime.timedelta(seconds=maxSecondsBetweenCurrentsImages / 2)
        else:
            Logger.RaiseException(NotImplementedError(_(u'This tool does not currently support a CurrentsDateType of "%(type)s". Please contact the author of this tool for assistance.') % {u'type': currentsDateType}))

        if startDate < rasterDates[0] - currentsDateStartDelta:
            Logger.RaiseException(ValueError(_(u'The start date of the simulation (%(start)s) occurs too far before the date of the first ocean currents image (%(date)s) that is loaded in the coral reef connectivity simulation in directory %(dir)s. To fix this problem, either move the start date forward or load some older ocean currents data into the simulation, so that the start date matches up with the currents data.') % {u'dir': simulationDirectory, u'start': str(startDate), u'date': str(rasterDates[0])}))

        if startDate > rasterDates[-1] + currentsDateEndDelta:
            Logger.RaiseException(ValueError(_(u'The start date of the simulation (%(start)s) occurs too far after the date of the last ocean currents image (%(date)s) that is loaded in the coral reef connectivity simulation in directory %(dir)s. To fix this problem, either move the start date backward or load some more recent ocean currents data into the simulation, so that the start date matches up with the currents data.') % {u'dir': simulationDirectory, u'start': str(startDate), u'date': str(rasterDates[-1])}))

        endDate = startDate + datetime.timedelta(days=duration)

        if endDate > rasterDates[-1] + currentsDateEndDelta:
            Logger.RaiseException(ValueError(_(u'The end date of the simulation (%(end)s) occurs too far after the date of the last ocean currents image (%(date)s) that is loaded in the coral reef connectivity simulation in directory %(dir)s. To fix this problem, either move the start date backward, reduce the duration of the simulation, or load some more recent ocean currents data into the simulation, so that the end date matches up with the currents data.') % {u'dir': simulationDirectory, u'end': str(endDate), u'date': str(rasterDates[-1])}))

        startRasterIndex = 0
        while startDate > rasterDates[startRasterIndex] + currentsDateEndDelta:
            startRasterIndex += 1

        endRasterIndex = startRasterIndex
        while endDate > rasterDates[endRasterIndex] + currentsDateEndDelta:
            endRasterIndex += 1
            if rasterDates[endRasterIndex] - rasterDates[endRasterIndex-1] > datetime.timedelta(seconds=maxSecondsBetweenCurrentsImages):
                Logger.RaiseException(ValueError(_(u'The ocean currents data that is loaded in the coral reef connectivity simulation in directory %(dir)s has a data gap in the range of dates between the simulation start date (%(start)s) and end date (%(end)s). A gap of %(gap)s occurs between %(d1)s and %(d2)s, which is larger than the maximum time permitted between images (%(max)s) for %(prod)s data. To fix this problem, either adjust the start date or duration, or load ocean currents data into the simulation that fills the gap.') % {u'dir': simulationDirectory, u'start': str(startDate), u'end': str(endDate), u'gap': str(rasterDates[endRasterIndex] - rasterDates[endRasterIndex-1]), u'd1': rasterDates[endRasterIndex-1], u'd2': rasterDates[endRasterIndex], u'max': datetime.timedelta(seconds=maxSecondsBetweenCurrentsImages), u'prod': currentsProduct}))

        # Read the reef rasters and geometry table into 2D numpy
        # arrays.

        Logger.Info(_(u'Reading coral reef data...'))

        from GeoEco.DataManagement.ArcGISRasters import ArcGISRaster

        reefIDsImage, reefIDsNoDataValue = ArcGISRaster.ToNumpyArray(os.path.join(simulationDirectory, u'ReefData', u'reef_ids'))
        reefIDsNoDataValue = int(reefIDsNoDataValue)
        reefCoverImage = ArcGISRaster.ToNumpyArray(os.path.join(simulationDirectory, u'ReefData', u'reef_areas'))[0]
        waterMaskImage = ArcGISRaster.ToNumpyArray(os.path.join(simulationDirectory, u'ReefData', u'water_mask'))[0]

        from GeoEco.DatabaseAccess.ArcGIS import ArcGIS91DatabaseConnection
        from GeoEco.DatabaseAccess.InMemory import InMemoryDatabaseConnection

        arcGISConn = ArcGIS91DatabaseConnection()
        inMemoryConn = InMemoryDatabaseConnection()
        
        if includeReefIDs is not None:
            inMemoryConn.ImportTable(arcGISConn, os.path.join(simulationDirectory, u'ReefData', u'reef_geometry.dbf'), u'reef_geometry', [u'VALUE', u'XCENTROID', u'YCENTROID'], where=u'"VALUE" IN (%s)' % u', '.join(map(unicode, includeReefIDs)), orderBy=[u'VALUE'], directions=[u'Ascending'])
            if inMemoryConn.GetRowCount(u'reef_geometry') <= 0:
                Logger.RaiseException(ValueError(_(u'The list of reefs IDs to include in the simulation does contain any IDs that also exist in the simulation directory %(dir)s. Please specify at least one existing reef ID.') % {u'dir': simulationDirectory}))
                
        elif excludeReefIDs is not None:
            inMemoryConn.ImportTable(arcGISConn, os.path.join(simulationDirectory, u'ReefData', u'reef_geometry.dbf'), u'reef_geometry', [u'VALUE', u'XCENTROID', u'YCENTROID'], where=u'"VALUE" NOT IN (%s)' % u', '.join(map(unicode, excludeReefIDs)), orderBy=[u'VALUE'], directions=[u'Ascending'])
            if inMemoryConn.GetRowCount(u'reef_geometry') <= 0:
                Logger.RaiseException(ValueError(_(u'The list of reefs IDs to exclude from the simulation excluded all of the reefs in the simulation directory %(dir)s. Please remove some IDs from this list so that at least one reef will be included in the simulation.') % {u'dir': simulationDirectory}))

        else:
            inMemoryConn.ImportTable(arcGISConn, os.path.join(simulationDirectory, u'ReefData', u'reef_geometry.dbf'), u'reef_geometry', [u'VALUE', u'XCENTROID', u'YCENTROID'], orderBy=[u'VALUE'], directions=[u'Ascending'])
            if inMemoryConn.GetRowCount(u'reef_geometry') <= 0:
                Logger.RaiseException(ValueError(_(u'The reef data in simulation directory %(dir)s does not contain any reefs. Please recreate the simulation using input rasters that contain at least one reef.') % {u'dir': simulationDirectory}))

        # Read the ocean currents into parallel lists of 2D numpy
        # arrays.

        import numpy

        imagesToRead = (endRasterIndex - startRasterIndex + 1) * 2
        Logger.Info(_(u'Reading %i ocean currents images...') % imagesToRead)
        progressReporter = ProgressReporter(progressMessage1=_(u'Still reading: %(elapsed)s elapsed, %(opsCompleted)i images read, %(perOp)s per image, %(opsRemaining)i remaining, estimated completion time: %(etc)s.'),
                                            completionMessage=_(u'Finished reading: %(elapsed)s elapsed, %(opsCompleted)i images read, %(perOp)s per image.'))
        progressReporter.Start(imagesToRead)

        uImageList = []
        vImageList = []
        uvDateList = []

        i = startRasterIndex
        while i >= startRasterIndex and i <= endRasterIndex:
            imageDate = rasterDates[i]
            uvDateList.append(imageDate)
            
            image, noDataValue = ArcGISRaster.ToNumpyArray(os.path.join(simulationDirectory, u'Currents', u'u', unicode(imageDate.year), imageDate.strftime('u%Y%j%H%M')))
            image[image == noDataValue] = numpy.nan
            uImageList.append(image)
            progressReporter.ReportProgress()
            
            image, noDataValue = ArcGISRaster.ToNumpyArray(os.path.join(simulationDirectory, u'Currents', u'v', unicode(imageDate.year), imageDate.strftime('v%Y%j%H%M')))
            image[image == noDataValue] = numpy.nan
            vImageList.append(image)
            progressReporter.ReportProgress()
            
            i += 1

        # Stack the numpy arrays into two 3D arrays that we will pass
        # to the MATLAB function.
        #
        # Note that with numpy, it appears that 2D arrays are
        # traditionally indexed [y,x] but that 3D arrays are [y,x,t].
        # This is what is output by numpy's dstack function. This is
        # kind of screwy, because when you print a 3D numpy array, it
        # looks much better if ordered [t,y,x] than [y,x,t]. But
        # MATLAB was the inspiration for numpy and [y,x,t] is
        # traditional in MATLAB as well. Finally, Eric Treml's
        # original MATLAB code used [y,x,z].

        uImages = numpy.dstack(tuple(uImageList))
        del uImageList
        
        vImages = numpy.dstack(tuple(vImageList))
        del vImageList

        # Build a list that specifies the t index into the 3D arrays
        # for each time step. Note that when we pass this list to
        # MATLAB, we must increment all of the indices by 1, because
        # MATLAB uses 1-based indexing (Python uses 0-based).

        import math        

        numTimeSteps = int(math.ceil(duration / (simulationTimeStep/24)))
        uvIndexForTimestep = [0]
        for i in range(1, numTimeSteps):
            if startDate + datetime.timedelta(hours=simulationTimeStep*i) <= uvDateList[uvIndexForTimestep[-1]] + currentsDateEndDelta:
                uvIndexForTimestep.append(uvIndexForTimestep[-1])
            else:
                uvIndexForTimestep.append(uvIndexForTimestep[-1] + 1)

        # Look up the cell size of the rasters.

        from GeoEco.ArcGIS import GeoprocessorManager
        gp = GeoprocessorManager.GetWrappedGeoprocessor()
        describeReefIDsRaster = gp.Describe(os.path.join(simulationDirectory, u'ReefData', u'reef_ids'))
        cellSize = describeReefIDsRaster.MeanCellWidth

        # Calculate and report the maximum Courant number. Issue a
        # warning if it is greater than or equal to 1.0 because the
        # simulation is likely to be unstable. Provide an estimate of
        # the largest time step that would allow the Courant number to
        # be less than 1.0.

        hasData = numpy.logical_and(numpy.logical_not(numpy.isnan(uImages)), numpy.logical_not(numpy.isnan(vImages)))
        maxVelocity = max(numpy.max(uImages[hasData]), numpy.max(vImages[hasData]))
        maxCourant = maxVelocity * (simulationTimeStep*3600) / cellSize

        if maxCourant <= 0.25:
            Logger.Info(_(u'The maximum Courant number is %(mc)f, which is less than or equal to 0.25. The simulation is likely to be numerically stable.') % {u'mc': maxCourant})
        else:
            maxTimeStep = cellSize / maxVelocity / 3600 * 0.25
            if maxCourant <= 0.5:
                Logger.Warning(_(u'The maximum Courant number is %(mc)f, which is greater than 0.25 and less than or equal to 0.5. The simulation may exhibit some instability. Please review the results carefully. To improve the chance that the simulation will be stable, we recommend you reduce the time step to %(mts)g or less, so that the maximum Courant number is less than or equal to 0.25.') % {u'mc': maxCourant, u'mts': maxTimeStep})
            else:
                Logger.Warning(_(u'The maximum Courant number is %(mc)f, which is greater than 0.5. The simulation is likely to be unstable. Please review the results carefully. To improve the chance that the simulation will be stable, we recommend you reduce the time step to %(mts)g or less, so that the maximum Courant number is less than or equal to 0.25.') % {u'mc': maxCourant, u'mts': maxTimeStep})

        # Create a temporary directory and write the arrays to it in
        # binary format.

        reefIDs = inMemoryConn.GetFieldValues(u'reef_geometry', u'VALUE')

        from GeoEco.DataManagement.Directories import TemporaryDirectory
        tempDir = TemporaryDirectory()

        try:
            reefIDsArray = numpy.array(reefIDs)
            reefIDsDataType = reefIDsArray.dtype.name
            reefIDsFile = os.path.join(tempDir.Path, 'ReefIDs.bin')
            reefIDsArray.tofile(reefIDsFile)

            reefIDsImageDataType = reefIDsImage.dtype.name
            reefIDsImageFile = os.path.join(tempDir.Path, 'ReefIDsImage.bin')
            reefIDsImage.tofile(reefIDsImageFile)

            reefCoverImageDataType = reefCoverImage.dtype.name
            reefCoverImageFile = os.path.join(tempDir.Path, 'ReefCoverImage.bin')
            reefCoverImage.tofile(reefCoverImageFile)

            waterMaskImageDataType = waterMaskImage.dtype.name
            waterMaskImageFile = os.path.join(tempDir.Path, 'waterMaskImage.bin')
            waterMaskImage.tofile(waterMaskImageFile)

            uImagesDataType = uImages.dtype.name
            uImagesFile = os.path.join(tempDir.Path, 'uImages.bin')
            uImages.tofile(uImagesFile)

            vImagesDataType = vImages.dtype.name
            vImagesFile = os.path.join(tempDir.Path, 'vImages.bin')
            vImages.tofile(vImagesFile)

            uvIndexForTimestepArray = numpy.array(uvIndexForTimestep) + 1
            uvIndexForTimestepDataType = uvIndexForTimestepArray.dtype.name
            uvIndexForTimestepFile = os.path.join(tempDir.Path, 'UVIndexForTimestep.bin')
            uvIndexForTimestepArray.tofile(uvIndexForTimestepFile)

            # Execute RunLarvalDispersal.py to run the simulation.
            # This script calls MATLAB functions. We prefer to call
            # those functions directly right here but there is a
            # continuing incompatibility between MATLAB DLLs and
            # ArcGIS DLLs (they both try to load their own
            # incompatible versions of xerces-c_2_7.dll) so we have to
            # do it in a separate process.

            dispersalMatrixFile = os.path.join(tempDir.Path, u'DispersalMatrix.bin')
            densityImagesFile = os.path.join(tempDir.Path, u'DensityImages.bin')

            from GeoEco.DataManagement.Processes import ChildProcess
            import win32api

            ChildProcess.ExecuteProgram(win32api.FindExecutable(os.path.join(os.path.dirname(__file__), 'RunLarvalDispersal.py'), os.path.dirname(__file__))[1],
                                        arguments=[os.path.join(os.path.dirname(__file__), 'RunLarvalDispersal.py'),
                                                   repr(uImages.shape[2]),      # t
                                                   repr(uImages.shape[0]),      # y
                                                   repr(uImages.shape[1]),      # x
                                                   reefIDsFile,
                                                   reefIDsDataType,
                                                   reefIDsImageFile,
                                                   reefIDsImageDataType,
                                                   reefCoverImageFile,
                                                   reefCoverImageDataType,
                                                   waterMaskImageFile,
                                                   waterMaskImageDataType,
                                                   uImagesFile,
                                                   uImagesDataType,
                                                   vImagesFile,
                                                   vImagesDataType,
                                                   repr(cellSize),
                                                   repr(simulationTimeStep * 3600.0),
                                                   repr(initialLarvaeDensity / 1000000.0),
                                                   repr(summarizationPeriod),
                                                   repr(diffusivity),
                                                   uvIndexForTimestepFile,
                                                   uvIndexForTimestepDataType,
                                                   dispersalMatrixFile,
                                                   densityImagesFile],
                                        stdoutLogLevel=u'Info',
                                        windowState=u'invisible',
                                        maxRunTime=None)

            del uImages, vImages

            # Read the output files.

            dispersalMatrix = numpy.fromfile(dispersalMatrixFile, 'float32')
            dispersalMatrix = dispersalMatrix.reshape(len(reefIDs), len(reefIDs), len(dispersalMatrix) / len(reefIDs) / len(reefIDs))

            densityImages = numpy.fromfile(densityImagesFile, 'float32')
            densityImages = densityImages.reshape(reefIDsImage.shape[0], reefIDsImage.shape[1], len(densityImages) / reefIDsImage.shape[0] / reefIDsImage.shape[1])

        finally:
            del tempDir

        # The DisperseLarvae function returns densities in particles
        # per square meter. Convert to particles per square km.

        densityImages *= 1000000.0

        # Mask cells that are land and that have a density that is
        # below the threshold.

        densityImages[waterMaskImage == 0, :] = 0
        if densityRasterCutoff is not None:
            densityImages[densityImages < initialLarvaeDensity * densityRasterCutoff / 100.0] = 0

        # Create the output personal geodatabase in the output
        # directory.

        outputGDB = os.path.join(outputDirectory, u'ConnectivityGeodatabase.mdb')
        if gp.Exists(outputGDB):
            if not overwriteExisting:
                Logger.RaiseException(ValueError(_(u'The output geodatabase %s already exists. Please delete it or specify that existing outputs should be overwritten and try again.') % outputGDB))
            gp.Delete_management(outputGDB)

        gp.CreatePersonalGDB_management(outputDirectory, u'ConnectivityGeodatabase.mdb')

        # Create the edge list feature class.

        gp.CreateFeatureClass_management(outputGDB, u'Edges', u'POLYLINE', None, u'DISABLED', u'DISABLED', gp.CreateSpatialReference(describeReefIDsRaster.SpatialReference).split(';')[0])
        gp.AddField_management(os.path.join(outputGDB, u'Edges'), u'FromReefID', u'LONG')
        gp.AddField_management(os.path.join(outputGDB, u'Edges'), u'ToReefID', u'LONG')
        gp.AddField_management(os.path.join(outputGDB, u'Edges'), u'MaxDispersal', u'FLOAT')

        # Populate the edge list feature class.

        maxDispersal = dispersalMatrix[:,:,1:].max(2)
        for fromReef in range(len(reefIDs)):
            for toReef in range(len(reefIDs)):
                if fromReef != toReef:
                    maxDispersal[fromReef, toReef] /= dispersalMatrix[fromReef, fromReef, 0]
                else:
                    maxDispersal[fromReef, toReef] = 0

        nonZeroEdges = sum(sum(maxDispersal > 0.0001))
        xCentroids = inMemoryConn.GetFieldValues(u'reef_geometry', u'XCENTROID')
        yCentroids = inMemoryConn.GetFieldValues(u'reef_geometry', u'YCENTROID')
        shapeFieldName = gp.Describe(os.path.join(outputGDB, u'Edges')).ShapeFieldName

        if nonZeroEdges > 0:
            Logger.Info(_(u'Writing %i edges to the edge list in the output geodatabase...') % nonZeroEdges)
            cur = arcGISConn.OpenInsertCursor(os.path.join(outputGDB, u'Edges'), rowCount=nonZeroEdges)
            for fromReef in range(len(reefIDs)):
                for toReef in range(len(reefIDs)):
                    if maxDispersal[fromReef, toReef] > 0.0001:
                        point = gp.CreateObject(u'Point')
                        line = gp.CreateObject(u'Array')
                        point.X = xCentroids[fromReef]
                        point.Y = yCentroids[fromReef]
                        line.Add(point)
                        point.X = xCentroids[toReef]
                        point.Y = yCentroids[toReef]
                        line.Add(point)
                        cur.SetValue(shapeFieldName, line)
                        cur.SetValue(u'FromReefID', reefIDs[fromReef])
                        cur.SetValue(u'ToReefID', reefIDs[toReef])
                        cur.SetValue(u'MaxDispersal', float(maxDispersal[fromReef, toReef]))        # Must convert from numpy float to Python float
                        cur.InsertRow()
        else:
            Logger.Warning(_(u'The edge list in the output geodatabase will be empty because none of the reefs are connected.'))

        # Create the DensityRasters subdirectory, if it does not
        # already exist.
        
        from GeoEco.DataManagement.Directories import Directory
        from GeoEco.DataManagement.ArcGISRasters import ArcGISRaster
             
        if not Directory.Exists(os.path.join(outputDirectory, u'DensityRasters'))[0]:
            Directory.Create(os.path.join(outputDirectory, u'DensityRasters'))

        # If the directory already exists and the caller requested
        # that we overwrite existing outputs, delete any existing
        # density rasters.

        elif overwriteExisting:
            oldLogInfoAsDebug = Logger.GetLogInfoAsDebug()
            Logger.SetLogInfoAsDebug(True)
            try:
                ArcGISRaster.FindAndDelete(os.path.join(outputDirectory, u'DensityRasters'), u'*')
            finally:
                Logger.SetLogInfoAsDebug(oldLogInfoAsDebug)

        # Create the density rasters in the subdirectory.

        coordinateSystem = gp.CreateSpatialReference(describeReefIDsRaster.SpatialReference).split(';')[0]

        Logger.Info(_(u'Writing %i density rasters to the output directory...') % densityImages.shape[2])
        progressReporter = ProgressReporter(progressMessage1=_(u'Still writing density rasters: %(elapsed)s elapsed, %(opsCompleted)i rasters written, %(perOp)s per raster, %(opsRemaining)i remaining, estimated completion time: %(etc)s.'),
                                            completionMessage=_(u'Finished writing density rasters: %(elapsed)s elapsed, %(opsCompleted)i rasters written, %(perOp)s per raster.'))
        progressReporter.Start(densityImages.shape[2])

        for i in range(densityImages.shape[2]):
            oldLogInfoAsDebug = Logger.GetLogInfoAsDebug()
            Logger.SetLogInfoAsDebug(True)
            try:
                ArcGISRaster.FromNumpyArray(densityImages[:,:,i].copy(),    # Copy is currently needed because the current implementation of ArcGISRaster.FromNumpyArray requires the array to be in C order.
                                            os.path.join(outputDirectory, u'DensityRasters', (startDate + datetime.timedelta(seconds=simulationTimeStep*3600.0*summarizationPeriod*i)).strftime('d%Y%j%H%M')),
                                            EnvelopeTypeMetadata.ParseFromArcGISString(describeReefIDsRaster.Extent)[0],
                                            EnvelopeTypeMetadata.ParseFromArcGISString(describeReefIDsRaster.Extent)[1],
                                            cellSize,
                                            nodataValue=0,
                                            coordinateSystem=coordinateSystem,
                                            buildPyramids=True,
                                            overwriteExisting=overwriteExisting)
            finally:
                Logger.SetLogInfoAsDebug(oldLogInfoAsDebug)

            progressReporter.ReportProgress()

        # Create a raster catalog in the output geodatabase for
        # the density rasters, so they can be easily animated. Add
        # and populate StartTime and EndTime fields, which define
        # the period for which the raster applies, as recommended
        # by the ArcGIS documentation.

        Logger.Info(_(u'Creating a raster catalog for the density rasters...'))

        gp.CreateRasterCatalog_management(outputGDB, u'DensityRasters', coordinateSystem, coordinateSystem, None, None, None, None, u'Unmanaged')
        gp.AddField_management(os.path.join(outputGDB, u'DensityRasters'), u'StartTime', u'DATE')
        gp.AddField_management(os.path.join(outputGDB, u'DensityRasters'), u'EndTime', u'DATE')
        gp.WorkspaceToRasterCatalog(os.path.join(outputDirectory, u'DensityRasters'), os.path.join(outputGDB, u'DensityRasters'))

        # Populate the StartTime and EndTime fields of the raster
        # catalog. Originally, I implemented this using the ArcGIS
        # Calculate Fields tool, but it kept crashing in 9.3,
        # regardless of whether I used Python or VB, and regardless of
        # whether I created the geoprocessor using
        # arcgisscripting.create or win32com.client.Dispatch. To work
        # around this ArcGIS bug, I'm using the MGET Calculate Fields
        # tool instead. It is slower (due to slow ArcGIS cursors) but
        # does not crash.

        from GeoEco.DataManagement.Fields import Field
        Field.CalculateFields(arcGISConn, os.path.join(outputGDB, u'DensityRasters'), [u'StartTime', u'EndTime'], [u"(datetime.datetime(int(row.Name[1:5]), 1, 1, int(row.Name[8:10]), int(row.Name[10:12])) + datetime.timedelta(days=int(row.Name[5:8])-1)).strftime('%Y-%m-%d %H:%M:%S')", u"(datetime.datetime(int(row.Name[1:5]), 1, 1, int(row.Name[8:10]), int(row.Name[10:12])) + datetime.timedelta(days=int(row.Name[5:8])-1) + datetime.timedelta(seconds=" + unicode(simulationTimeStep*3600.0*summarizationPeriod) + u")).strftime('%Y-%m-%d %H:%M:%S')"], modulesToImport=[u'datetime']) 

        # Return successfully.

        return outputDirectory


class _AvisoCurrentsInMetersPerSecond(AvisoGriddedGeostrophicCurrents):
    __doc__ = DynamicDocString()

    def _ReadNumpyArray(self, sliceList):

        # Aviso provides geostrophic currents in cm/s but we require
        # them to be in m/s. Convert them.

        data, noDataValue = super(_AvisoCurrentsInMetersPerSecond, self)._ReadNumpyArray(sliceList)
        data[data != noDataValue] /= 100.
        return data, noDataValue

    @classmethod
    def CreateArcGISRasters(cls, username, password, productName, vectorComponent,
                            outputWorkspace, mode=u'add', rasterNameExpressions=['%(Region)s', '%(DataSeries)s', '%(Satellites)s', '%(Variable)s', '%%Y', '%(DataSeries)s_%(Satellites)s_%(Variable)s_%%Y%%j.img'],
                            rotationOffset=None, spatialExtent=None, linearUnit=u'Degrees', startDate=None, endDate=None,
                            timeout=60, maxRetryTime=120, cacheDirectory=None,
                            calculateStatistics=True, buildPyramids=False):
        grid = _AvisoCurrentsInMetersPerSecond(productName, vectorComponent, username, password, timeout, maxRetryTime, cacheDirectory)
        _AvisoGriddedProduct.CreateArcGISRasters(grid, outputWorkspace, mode, rasterNameExpressions, rotationOffset, spatialExtent, linearUnit, startDate, endDate, calculateStatistics, buildPyramids)
        return outputWorkspace


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

from GeoEco.ArcGIS import ArcGISDependency, ArcGISExtensionDependency
from GeoEco.Dependencies import PythonAggregatedModuleDependency
from GeoEco.Matlab import MatlabDependency
from GeoEco.Metadata import *
from GeoEco.Types import *

AddModuleMetadata(shortDescription=_(u'Implements Eric Treml\'s coral reef connectivity analysis.'))

###############################################################################
# Metadata: CoralReefConnectivity class
###############################################################################

AddClassMetadata(CoralReefConnectivity,
    shortDescription=_(u'Implements Eric Treml\'s coral reef connectivity analysis.'),
    isExposedAsCOMServer=True,
    comIID=u'{1B3A8B7F-8921-4A69-AF39-D209FAA0D588}',
    comCLSID=u'{BAD2EBA8-1077-4A5B-B737-D4906466B60A}')

# Public method: CoralReefConnectivity.CreateSimulationFromArcGISRasters

AddMethodMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters,
    shortDescription=_(u'Creates a coral reef connectivity simulation and initializes it with reef data in ArcGIS rasters.'),
    isExposedToPythonCallers=True,
    isExposedByCOM=True,
    isExposedAsArcGISTool=True,
    arcGISDisplayName=_(u'Create Coral Reef Connectivity Simulation From ArcGIS Rasters'),
    arcGISToolCategory=_(u'Connectivity Analysis\\Coral Reef Larval Connectivity'),
    dependencies=[ArcGISDependency(9, 2), ArcGISExtensionDependency(u'spatial'), PythonAggregatedModuleDependency('numpy')])

AddArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'cls',
    typeMetadata=ClassOrClassInstanceTypeMetadata(cls=CoralReefConnectivity),
    description=_(u'%s class or an instance of it.') % CoralReefConnectivity.__name__)

AddArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'simulationDirectory',
    typeMetadata=DirectoryTypeMetadata(deleteIfParameterIsTrue=u'overwriteExisting', createParentDirectories=True),
    description=_(
u"""Output directory to create to contain the simulation's data.

After creating the simulation directory, you must load ocean currents
data into it using other tools before you can run the simulation. Use
the MGET tools designed for this purpose. Unless you know what you are
doing, do not modify the contents of the simulation directory
yourself."""),
    direction=u'Output',
    arcGISDisplayName=_(u'Simulation directory to create'))

AddArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'reefIDsRaster',
    typeMetadata=ArcGISRasterLayerTypeMetadata(mustExist=True, allowedPixelTypes=[u'S8', u'U8', u'S16', u'U16', u'S32', u'U32', u'S64', u'U64']),
    description=_(
u"""Integer raster specifying the locations and IDs of reefs.

The raster value specifies the ID of the reef contained by that cell.
NoData indicates that the cell does not contain a reef. The value 0
may not be used as a reef ID.

The raster also defines the coordinate system, extent, and cell size
for the analysis. The raster must use a projected coordinate system,
with meters as the linear unit. The reef cover and water mask rasters
must have the same coordinate system, extent, and cell size. When
ocean currents data are loaded into the simulation, they will be
automatically projected and clipped as needed into this coordinate
system, extent, and cell size."""),
    arcGISDisplayName=_(u'Reef IDs raster'))

AddArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'reefCoverRaster',
    typeMetadata=ArcGISRasterLayerTypeMetadata(mustExist=True),
    description=_(
u"""Floating-point raster specifying the proportion of each cell's
area that is occupied by reef.

This raster determines the density of coral larvae released into the
cell at the start of the simulation. The density for a cell is
determined by multiplying this raster's value by the larvae density
parameter you specify when you run the simulation.

This raster must have the same coordinate system, extent, and cell
size as the reef IDs raster.

The raster values must be greater than or equal to 0 and less than or
equal to 1. The value 1 indicates that the entire cell is occupied by
reef, while 0.5 indicates that only half of it is. If the cell size
was 25 km by 25 km, this would mean the cell contained either 625 or
312.5 square km of reef, respectively.

If the value is 0 or NoData, it is assumed that the cell does not
contain any reef, even if the reef IDs raster indicates that a reef is
there. If the value is greater than 0 but the corresponding reef IDs
raster contains NoData, it is assumed that the cell does not contain
any reef."""),
    arcGISDisplayName=_(u'Reef cover raster'))

AddArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'waterMaskRaster',
    typeMetadata=ArcGISRasterLayerTypeMetadata(mustExist=True),
    description=_(
u"""Raster specifying the locations of land and water. 0 or NoData
indicates land; any other value indicates water.

This raster must have the same coordinate system, dimensions, and cell
size as the reef IDs raster."""),
    arcGISDisplayName=_(u'Water mask raster'))

AddArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'crosses180',
    typeMetadata=BooleanTypeMetadata(),
    description=_(
u"""Set this option to True if your study area crosses the 180th
meridian (i.e. 180 W / 180 E). This will happen if you are studying
reefs in the tropical Pacific, for example."""),
    arcGISDisplayName=_(u'Study area crosses the 180th meridian'))

AddArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'overwriteExisting',
    typeMetadata=BooleanTypeMetadata(),
    description=_(
u"""If True, the simulation directory will be deleted and recreated,
if it exists. If False, a ValueError will be raised if the simulation
directory exists."""),
    initializeToArcGISGeoprocessorVariable=u'OverwriteOutput')

# Public method: CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation

AddMethodMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation,
    shortDescription=_(u'Downloads Aviso geostrophic currents into a coral reef connectivity simulation.'),
    longDescription=_AvisoGriddedProduct_LongDescription % {u'name': 'tool'},
    isExposedToPythonCallers=True,
    isExposedByCOM=True,
    isExposedAsArcGISTool=True,
    arcGISDisplayName=_(u'Load Aviso Geostrophic Currents Into Coral Reef Connectivity Simulation'),
    arcGISToolCategory=_(u'Connectivity Analysis\\Coral Reef Larval Connectivity'),
    dependencies=[ArcGISDependency(9, 2), ArcGISExtensionDependency(u'spatial'), PythonAggregatedModuleDependency('numpy')])

CopyArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'cls', CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'cls')

AddArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'simulationDirectory',
    typeMetadata=DirectoryTypeMetadata(mustExist=True),
    description=_(
u"""Existing coral reef connectivity simulation directory that should
recieve the geostrophic currents data.

The directory must have been created using the Create Coral Reef
Connectivity Simulation tool.

If you have already loaded geostrophic currents data into the
simulation, you can use this tool to add data for an additional range
of dates so long as the data is from the same Aviso product. If you
try to add a different product to existing data, this tool will report
an error.

If you try to load data for a range of dates that have been already
loaded into the simulation, the downloads for those dates will be
skipped. There is no way to delete or overwrite the data that has
already been loaded into the simulation. If you want to overwrite your
existing data (e.g. you want to switch to using a different Aviso
product), you must create a new simulation."""),
    arcGISDisplayName=_(u'Simulation directory to recieve geostrophic currents data'))

CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'username', CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'username')
CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'password', CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'password')

AddArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'product',
    typeMetadata=UnicodeStringTypeMetadata(allowedValues=filter(lambda s: s.find(u'MADT') >= 0, AvisoGriddedGeostrophicCurrents.Products)),
    description=_(
u"""Aviso geostrophic currents product to load into the simulation.
Please see the Aviso web site (http://www.aviso.oceanobs.com) for
descriptions of the products.

At the time of this writing, this tool supported all of the
geostrophic currents products that Aviso made available for download
over OPeNDAP. If you find that Aviso publishes a new product that is
not available using this tool, please contact the author of this tool
to have support for it added.

The product name that you must pass for this parameter is case
sensitive. If you invoke this tool programmatically, be sure to
specify the product name using the proper case."""),
    arcGISDisplayName=_(u'Aviso geostrophic currents product to download'))

AddArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'startDate',
    typeMetadata=DateTimeTypeMetadata(),
    description=_(
u"""Start date for the data to load into the simulation. Data that
occurs on or after the start date and on or before the end date will
be loaded into the simulation."""),
    arcGISDisplayName=_(u'Start date'))

AddArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'endDate',
    typeMetadata=DateTimeTypeMetadata(),
    description=_(
u"""End date for the data to load into the simulation. Data that
occurs on or after the start date and on or before the end date will
be loaded into the simulation."""),
    arcGISDisplayName=_(u'End date'))

AddArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'resamplingTechnique',
    typeMetadata=UnicodeStringTypeMetadata(makeLowercase=True, allowedValues=[u'BILINEAR', u'CUBIC']),
    description=_(
u"""Resampling algorithm to be used when projecting the ocean currents
data to the coordinate system and cell size of the simulation. One of:

* BILINEAR - `Bilinear interpolation
  <http://en.wikipedia.org/wiki/Bilinear_interpolation>`_.

* CUBIC - Cubic convolution, also known as `bicubic interpolation
  <http://en.wikipedia.org/wiki/Bicubic_interpolation>`_. This method
  is slower but we believe it produces more accurate values.

The projection is accomplished with the ArcGIS Project Raster tool.
Please see the documentation for that tool for more information."""),
    arcGISDisplayName=_(u'Resampling technique'))

AddArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'interpolationMethod',
    typeMetadata=UnicodeStringTypeMetadata(makeLowercase=True, allowedValues=[u'Del2a', u'Del2b', u'Del2c', u'Del4', u'Spring'], canBeNone=True),
    description=_(
u"""Method to use to guess ocean current values for cells marked as
water by the simulation's water mask but for which no estimate is
available in the currents data.

By default, this option is disabled and cells marked as water that do
not have any currents data are assumed to have a current velocity of
zero. Larvae within these cells cannot exit by advection, only by
diffusion. Because diffusion typically disperses larvae much more
slowly than advection, these zero-velocity cells will act as larvae
sinks that appear to trap most larvae that enter them.

That situation is usually urealistic and undesirable, and when it
happens the simulator will issue a warning describing the problem. If
you experience this problem you can instruct the tool to guess current
values using one of the following algorithms:

* Del2a - Laplacian interpolation and linear extrapolation. We
  recommend you use this method unless you have a specific reason to
  select one of the others.

* Del2b - Same as Del2a but does not build as large a linear system of
  equations. May be faster than Del2a at the cost of some accuracy.

* Del2c - Same as Del2a but solves a direct linear system of equations
  for the No Data values. Faster than both Del2a and Del2b but is the
  least robust to noise on the boundaries of No Data cells and least
  able to interpolate accurately for smooth surfaces.

* Del4 - Same as Del2a but instead of the Laplace operator (also
  called the del^2 operator) it uses the biharmonic operator (also
  called the del^4 operator). May result in more accurate
  interpolations, at some cost in speed.

* Spring - Uses a spring metaphor. Assumes springs (with a nominal
  length of zero) connect each cell with every neighbor (horizontally,
  vertically and diagonally). Since each cell tries to be like its
  neighbors, extrapolation is as a constant function where this is
  consistent with the neighboring nodes.

Be advised that this option should be considered a last resort. When
ocean current values are missing for a region, it is because the
original data provider does not know how to estimate or model the
currents in that region. If it was simply a matter of using one of the
methods above, they would have already done so. These methods produce
estimates that are likely to be inaccurate and should only be used
when you are willing to accept those inaccuracies because there is no
other way to proceed.

Thanks to John D'Errico for providing the code that implements the
mathematical algorithms described here (click `here
<http://www.mathworks.com/matlabcentral/fileexchange/4551>`_ for more
information)."""),
    arcGISDisplayName=_(u'Method for estimating missing currents values'))

CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'timeout', CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'timeout')
CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'maxRetryTime', CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'maxRetryTime')
CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'cacheDirectory', CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'cacheDirectory')

AddResultMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'updatedSimulationDirectory',
    typeMetadata=DirectoryTypeMetadata(),
    description=_(u'Updated simulation directory.'),
    arcGISDisplayName=_(u'Updated simulation directory'))

# Public method: CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation

AddMethodMetadata(CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation,
    shortDescription=_(u'Downloads NOAA OSCAR 5-day unfiltered 1/3 degree ocean surface currents into a coral reef connectivity simulation.'),
    longDescription=_OSCAR_LongDescription % {u'name': 'tool'},
    isExposedToPythonCallers=True,
    isExposedByCOM=True,
    isExposedAsArcGISTool=True,
    arcGISDisplayName=_(u'Load OSCAR Currents Into Coral Reef Connectivity Simulation'),
    arcGISToolCategory=_(u'Connectivity Analysis\\Coral Reef Larval Connectivity'),
    dependencies=[ArcGISDependency(9, 2), ArcGISExtensionDependency(u'spatial'), PythonAggregatedModuleDependency('numpy')])

CopyArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'cls', CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'cls')

AddArgumentMetadata(CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'simulationDirectory',
    typeMetadata=DirectoryTypeMetadata(mustExist=True),
    description=_(
u"""Existing coral reef connectivity simulation directory that should
recieve the OSCAR currents data.

The directory must have been created using the Create Coral Reef
Connectivity Simulation tool.

If you have already loaded OSCAR currents data into the simulation,
you can use this tool to add data for an additional range of dates. If
you try to load data for a range of dates that have been already
loaded into the simulation, the downloads for those dates will be
skipped."""),
    arcGISDisplayName=_(u'Simulation directory to recieve OSCAR currents data'))

CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'startDate', CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'startDate')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'endDate', CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'endDate')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'resamplingTechnique', CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'resamplingTechnique')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'interpolationMethod', CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'interpolationMethod')
CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'timeout', CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'timeout')
CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'maxRetryTime', CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'maxRetryTime')
CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'cacheDirectory', CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'cacheDirectory')

CopyResultMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'updatedSimulationDirectory', CoralReefConnectivity.LoadOSCARCurrentsIntoSimulation, u'updatedSimulationDirectory')

# Public method: CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation

AddMethodMetadata(CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation,
    shortDescription=_(u'Downloads HYCOM GOMl0.04 ocean currents into a coral reef connectivity simulation.'),
    longDescription=_HYCOMGOMl004_LongDescription % {u'name': 'tool'},
    isExposedToPythonCallers=True,
    isExposedByCOM=True,
    isExposedAsArcGISTool=True,
    arcGISDisplayName=_(u'Load HYCOM GOMl0.04 Currents Into Coral Reef Connectivity Simulation'),
    arcGISToolCategory=_(u'Connectivity Analysis\\Coral Reef Larval Connectivity'),
    dependencies=[ArcGISDependency(9, 2), ArcGISExtensionDependency(u'spatial'), PythonAggregatedModuleDependency('numpy')])

CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'cls', CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'cls')

AddArgumentMetadata(CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'simulationDirectory',
    typeMetadata=DirectoryTypeMetadata(mustExist=True),
    description=_(
u"""Existing coral reef connectivity simulation directory that should
recieve the currents.

The directory must have been created using the Create Coral Reef
Connectivity Simulation tool.

If you have already loaded HYCOM GOMl0.04 currents into the
simulation, you can use this tool to add currents for an additional
range of dates so long as they are for the same depth as the original
currents. If you try to add a different currents product to the
simulation (e.g. geostrophic currents from Aviso), or for a different
depth, this tool will report an error.

If you try to load data for a range of dates that have been already
loaded into the simulation, the downloads for those dates will be
skipped. There is no way to delete or overwrite the data that has
already been loaded into the simulation. If you want to overwrite your
existing data (e.g. you want to switch to using a different depth),
you must create a new simulation."""),
    arcGISDisplayName=_(u'Simulation directory to recieve HYCOM currents'))

CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'startDate', CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'startDate')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'endDate', CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'endDate')

AddArgumentMetadata(CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'depth',
    typeMetadata=FloatTypeMetadata(allowedValues=[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., 5500.]),
    description=_(
u"""HYCOM depth layer to download currents from.

This tool was designed primarily to study larvae that float at or near
the surface. The default depth is 0. If you are studying larvae that
stay submerged, you can choose a deeper depth, but be aware of two
important points:

* This tool assumes the larvae remain at that depth for the entire
  simulation. It does not implement vertical migration or other
  behaviors that might be appropriate for your species. A newer
  version of this tool, to be released in 2012, will support vertical
  migration.

* Be aware that the spatial extent of available currents data will
  shrink as depth increases. For example, if you choose a deep depth
  such as 250 m, there will be no data available for regions close to
  shore because the ocean is typically shallower than 250 m in those
  regions. Data for very deep depths will only be available near the
  center of the Gulf of Mexico.
"""),
    arcGISDisplayName=_(u'Depth'))

CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'resamplingTechnique', CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'resamplingTechnique')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'interpolationMethod', CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'interpolationMethod')
CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'timeout', CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'timeout')
CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'maxRetryTime', CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'maxRetryTime')
CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'cacheDirectory', CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'cacheDirectory')

CopyResultMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'updatedSimulationDirectory', CoralReefConnectivity.LoadHYCOMGOMl0044DCurrentsIntoSimulation, u'updatedSimulationDirectory')

# Public method: CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation

AddMethodMetadata(CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation,
    shortDescription=_(u'Downloads HYCOM GLBa0.08 ocean currents into a coral reef connectivity simulation.'),
    longDescription=_HYCOMGLBa008Equatorial_LongDescription % {u'name': 'tool'},
    isExposedToPythonCallers=True,
    isExposedByCOM=True,
    isExposedAsArcGISTool=True,
    arcGISDisplayName=_(u'Load HYCOM GLBa0.08 Currents Into Coral Reef Connectivity Simulation'),
    arcGISToolCategory=_(u'Connectivity Analysis\\Coral Reef Larval Connectivity'),
    dependencies=[ArcGISDependency(9, 2), ArcGISExtensionDependency(u'spatial'), PythonAggregatedModuleDependency('numpy')])

CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'cls', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'cls')

AddArgumentMetadata(CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'simulationDirectory',
    typeMetadata=DirectoryTypeMetadata(mustExist=True),
    description=_(
u"""Existing coral reef connectivity simulation directory that should
recieve the currents.

The directory must have been created using the Create Coral Reef
Connectivity Simulation tool.

If you have already loaded HYCOM GLBa0.08 currents into the
simulation, you can use this tool to add currents for an additional
range of dates so long as they are for the same depth as the original
currents. If you try to add a different currents product to the
simulation (e.g. geostrophic currents from Aviso), or for a different
depth, this tool will report an error.

If you try to load data for a range of dates that have been already
loaded into the simulation, the downloads for those dates will be
skipped. There is no way to delete or overwrite the data that has
already been loaded into the simulation. If you want to overwrite your
existing data (e.g. you want to switch to using a different depth),
you must create a new simulation."""),
    arcGISDisplayName=_(u'Simulation directory to recieve HYCOM currents'))

CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'startDate', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'startDate')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'endDate', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'endDate')

AddArgumentMetadata(CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'depth',
    typeMetadata=FloatTypeMetadata(allowedValues=[0., 10., 20., 30., 50., 75., 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., 5500.]),
    description=_(
u"""HYCOM depth layer to download currents from.

This tool was designed primarily to study larvae that float at or near
the surface. The default depth is 0. If you are studying larvae that
stay submerged, you can choose a deeper depth, but be aware of two
important points:

* This tool assumes the larvae remain at that depth for the entire
  simulation. It does not implement vertical migration or other
  behaviors that might be appropriate for your species. A newer
  version of this tool, to be released in 2012, will support vertical
  migration.

* Be aware that the spatial extent of available currents data will
  shrink as depth increases. For example, if you choose a deep depth
  such as 250 m, there will be no data available for regions close to
  shore because the ocean is typically shallower than 250 m in those
  regions.
"""),
    arcGISDisplayName=_(u'Depth'))

CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'extendYExtent', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'extendYExtent')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'resamplingTechnique', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'resamplingTechnique')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'interpolationMethod', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'interpolationMethod')
CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'timeout', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'timeout')
CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'maxRetryTime', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'maxRetryTime')
CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'cacheDirectory', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'cacheDirectory')

CopyResultMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'updatedSimulationDirectory', CoralReefConnectivity.LoadHYCOMGLBa0084DEquatorialCurrentsIntoSimulation, u'updatedSimulationDirectory')

# Public method: CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation

AddMethodMetadata(CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation,
    shortDescription=_(u'Downloads Pacific ROMS-CoSiNE ocean currents into a coral reef connectivity simulation.'),
    longDescription=_ROMS_CoSiNE_LongDescription % {u'name': 'tool'},
    isExposedToPythonCallers=True,
    isExposedByCOM=True,
    isExposedAsArcGISTool=True,
    arcGISDisplayName=_(u'Load Pacific ROMS-CoSiNE Currents Into Coral Reef Connectivity Simulation'),
    arcGISToolCategory=_(u'Connectivity Analysis\\Coral Reef Larval Connectivity'),
    dependencies=[ArcGISDependency(9, 2), ArcGISExtensionDependency(u'spatial'), PythonAggregatedModuleDependency('numpy')])

CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'cls', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'cls')

AddArgumentMetadata(CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'simulationDirectory',
    typeMetadata=DirectoryTypeMetadata(mustExist=True),
    description=_(
u"""Existing coral reef connectivity simulation directory that should
recieve the currents.

The directory must have been created using the Create Coral Reef
Connectivity Simulation tool.

If you have already loaded Pacific ROMS-CoSiNE currents into the
simulation, you can use this tool to add currents for an additional
range of dates so long as they are for the same depth as the original
currents. If you try to add a different currents product to the
simulation (e.g. geostrophic currents from Aviso), or for a different
depth, this tool will report an error.

If you try to load data for a range of dates that have been already
loaded into the simulation, the downloads for those dates will be
skipped. There is no way to delete or overwrite the data that has
already been loaded into the simulation. If you want to overwrite your
existing data (e.g. you want to switch to using a different depth),
you must create a new simulation."""),
    arcGISDisplayName=_(u'Simulation directory to recieve ROMS-CoSiNE currents'))

CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'startDate', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'startDate')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'endDate', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'endDate')

AddArgumentMetadata(CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'depth',
    typeMetadata=FloatTypeMetadata(),
    description=_(
u"""Depth of currents layer to download.

ROMS-CoSiNE uses a terrain-following vertical coordinate system
designed to maximize the accuracy of the simulation in coastal areas
and the open ocean simultaneously. There are 30 depth layers but their
depths vary on a per-cell basis with latitude, longitude, and time.
For example, coastal cells of the 10th depth layer might represent a
depth of 10 meters, while cells in the open ocean might represent a
depth of 200 meters. This tool interpolates a constant-depth layer
from ROMS-CoSiNE's varying-depth layers using a linear interpolation
algorithm.

The depth 0 represents the surface. The sign of the depth coordinate
is ignored (e.g. the values 10 and -10 are both interpreted as 10 m
below the surface).

This tool was designed primarily to study larvae that float at or near
the surface. The default depth is 0. If you are studying larvae that
stay submerged, you can choose a deeper depth, but be aware of two
important points:

* This tool assumes the larvae remain at that depth for the entire
  simulation. It does not implement vertical migration or other
  behaviors that might be appropriate for your species. A newer
  version of this tool, to be released in 2012, will support vertical
  migration.

* Be aware that the spatial extent of available currents data will
  shrink as depth increases. For example, if you choose a deep depth
  such as 250 m, there will be no data available for regions close to
  shore because the ocean is typically shallower than 250 m in those
  regions.
"""),
    arcGISDisplayName=_(u'Depth'))

CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'resamplingTechnique', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'resamplingTechnique')
CopyArgumentMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'interpolationMethod', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'interpolationMethod')
CopyArgumentMetadata(ROMSCoSiNE4D.CreateArcGISRasters, u'url', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'url')
CopyArgumentMetadata(ROMSCoSiNE4D.CreateArcGISRasters, u'timeout', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'timeout')
CopyArgumentMetadata(ROMSCoSiNE4D.CreateArcGISRasters, u'maxRetryTime', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'maxRetryTime')
CopyArgumentMetadata(ROMSCoSiNE4D.CreateArcGISRasters, u'cacheDirectory', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'cacheDirectory')

CopyResultMetadata(CoralReefConnectivity.LoadAvisoGeostrophicCurrentsIntoSimulation, u'updatedSimulationDirectory', CoralReefConnectivity.LoadROMSCoSiNE4DCurrentsIntoSimulation, u'updatedSimulationDirectory')

# Public method: CoralReefConnectivity.RunSimulation

AddMethodMetadata(CoralReefConnectivity.RunSimulation,
    shortDescription=_(u'Executes a coral coral reef connectivity simulation.'),
    isExposedToPythonCallers=True,
    isExposedByCOM=True,
    isExposedAsArcGISTool=True,
    arcGISDisplayName=_(u'Run Coral Reef Connectivity Simulation'),
    arcGISToolCategory=_(u'Connectivity Analysis\\Coral Reef Larval Connectivity'),
    dependencies=[ArcGISDependency(9, 2), ArcGISExtensionDependency(u'spatial'), PythonAggregatedModuleDependency('numpy')])

CopyArgumentMetadata(CoralReefConnectivity.CreateSimulationFromArcGISRasters, u'cls', CoralReefConnectivity.RunSimulation, u'cls')

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'simulationDirectory',
    typeMetadata=DirectoryTypeMetadata(mustExist=True),
    description=_(
u"""Existing coral reef connectivity simulation directory that has
been loaded with ocean currents data.

The directory must have been created using the Create Coral Reef
Connectivity Simulation tool and then loaded with ocean currents data
using one of the tools provided for this purpose.

The simulation may take hours to complete, due to the complex
mathematics involved. The run time is goverened by the size of your
study area, the number of reefs include in the simulation, and the
duration and time step of the simulation."""),
    arcGISDisplayName=_(u'Simulation directory'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'outputDirectory',
    typeMetadata=DirectoryTypeMetadata(mustExist=True),
    description=_(
u"""Output directory to receive the results of the simulation.

The directory must already exist. Within it, the simulator creates:

* DensityRasters - this subdirectory will contain a time series of
  rasters that represent snapshots of the larvae density throughout
  the study area, in particles per square km. A raster will be created
  each time the simulation is summarized; the summarization frequency
  is controlled by the Simulation Summarization Period parameter. The
  rasters' names will be of the form dYYYYDDDHHMM, where YYYY is the
  year, DDD is the day of the year (e.g. February 1 is day 032), HH is
  the hour, and MM is the minute.

* DensityRasters raster catalog in ConnectivityGeodatabase.mdb - this
  catalog references the rasters created in the DensityRasters
  subdirectory. The StartDate and EndDate columns of the catalog
  specify the applicable timeframe for each raster, and may be used to
  animate the raster time series using the Animation toolbar available
  in ArcMap and other ArcGIS applications.

* Edges feature class in ConnectivityGeodatabase.mdb - this line
  feature class shows which reefs are connected by larval dispersal.
  Each line represents a direction link between two reefs. The
  FromReefID and ToReefID fields specify the IDs of the source reef
  and sink reef, respectively. The MaxDispersal field shows the
  maximum quantity of larvae from the source reef found over the sink
  reef during the series of simulation summaries. The quantity is
  expressed as the fraction of larvae initially released from the
  source reef that are over the sink reef, and ranges from 0.0 to 1.0.
  For example, the value 0.01 means that 1% of the larvae initially
  released by the source reef were found over the sink reef, when
  dispersal from the source to the sink peaked.
"""),
    arcGISDisplayName=_(u'Output directory'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'startDate',
    typeMetadata=DateTimeTypeMetadata(),
    description=_(
u"""Start date of the simulation.

The larvae are released from the reefs on this date. Selecting an
appropriate value requires knowledge of the reproductive biology of
the species you are studying."""),
    arcGISDisplayName=_(u'Start date'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'duration',
    typeMetadata=FloatTypeMetadata(minValue=0.0),
    description=_(
u"""Duration of the simulation, in days.

Larger values require more computer memory and require more processing
time. To avoid extreme scenarios, this parameter can be no larger that
365 days."""),
    arcGISDisplayName=_(u'Duration'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'simulationTimeStep',
    typeMetadata=FloatTypeMetadata(minValue=0.0),
    description=_(
u"""Time step of the simulation, in hours.

The time step defines the simulated time period at which larvae
density is recalculated using a Eulerian advection/diffusion model.
Smaller time steps increase the stability of the model and accuracy of
the results but also the run time and computer memory requirements of
the simulation. The original study from which this tool was developed
(Treml et al. 2008) used a time step of 2.4 hours.

To check the model stability, this tool reports the effective Courant
number for the model, calculated from the simulation time step, grid
cell size, and average current velocity. The Courant number reflects
the portion of a cell that the larvae will traverse by advection in
one time step. If the Courant number is greater than 1, the model is
likely to be unstable and inaccurate. If it is significantly less than
1 (e.g. 0.1), it is likely to be stable and accurate."""),
    arcGISDisplayName=_(u'Temp step'),
    arcGISCategory=_(u'Simulation options'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'summarizationPeriod',
    typeMetadata=IntegerTypeMetadata(minValue=1),
    description=_(
u"""Period, expressed as a number of simulation time steps, at which
the simulation should be summarized.

The period specifies how frequently summarization should occur. The
first summarization will occur at the start of the simulation, and
subsequent summarizations will occur every time the period elapses.
For example, if the time step is 1 hour and the summarization period
is 24, summarizations will occur every 24 hours.

The summarization procedure governs the production of simulation
outputs. Please see the documentation of the Output Directory
parameter for more information."""),
    arcGISDisplayName=_(u'Sumulation summarization period'),
    arcGISCategory=_(u'Simulation options'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'initialLarvaeDensity',
    typeMetadata=FloatTypeMetadata(minValue=1.0),
    description=_(
u"""Density of larvae, in particles per square km, released at the
start of the simulation. 

The original study from which this tool was developed (Treml et al.
2008) used 10,000 particles per square km. This is consistent with
previous studies (Cowen et al. 2000; James et al. 2002; Largier 2003)
and was selected based on exploratory modeling efforts using densities
ranging from 1,000 to 100,000 particles per square km. For particular
taxa, these initial densities may need to be larger or smaller, based
on the specific fecundity and density characteristics of that species
of interest (Richmond 1987; Largier 2003)."""),
    arcGISDisplayName=_(u'Initial larvae density'),
    arcGISCategory=_(u'Simulation options'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'densityRasterCutoff',
    typeMetadata=FloatTypeMetadata(minValue=0.0, maxValue=100.0, canBeNone=True),
    description=_(
u"""Minimum larvae density, expressed as a percentage of the initial
larvae density, that a larvae density raster cell must be to not be
masked.

This parameter is a percent of the initial larvae density. For
example, if the initial larvae density is 10000 particles per km and
this parameter is 1, a density of 100 particles per km will be used as
the cutoff. Larvae density cells that are less than this value will
set to NoData.

This parameter does not affect the computations performed during the
simulation. It only affects the production of density rasters after
the simulation is complete, and is provided as a convenience for
visualization.

If you set this parameter to 0, the density rasters will be produced
with no masking. The results may seem surprising. For most
simulations, larvae will have spread throughout the entire study area,
albeit in very small quantities for most cells. This is a surprising
effect of the diffusion component of the Eularian hydrodynamic
calculations. Diffiusion occurs equally in all directions at the rate
specified by the Diffusivity parameter. Given enough time, an
infinitesimal fraction of larvae from any given reef can theoretically
spread throughout the entire ocean simply by diffusion. To avoid a
confusing visualization, use this parameter to mask the extremely
density values that result from diffiusion."""),
    arcGISDisplayName=_(u'Cutoff percentage for larvae density rasters'),
    arcGISCategory=_(u'Simulation options'))

##AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'deathRate',
##    typeMetadata=FloatTypeMetadata(minValue=0.0, maxValue=1.0, canBeNone=True),
##    description=_(
##u"""Death rate of the larvae, as proportion of the population that
##dies per day.
##
##Reliable mortality estimates for invertebrate larvae are rare due to
##the difficulty in sampling and identifying the same larval cohort in
##the plankton through time (Rumrill 1990; Morgan 1995). In a review of
##larval mortality rates, Rumrill (1990) showed that this parameter
##varied greatly between invertebrate species, from 0.016 to .357 per
##day, with an average of .223 per day. A recent study on several
##Pacific corals measuring larval survival, recruitment rates, and gene
##flow, reports the mortality of a broadcast-spawning coral to be around
##4 - 6% per day (Nishikawa et al. 2003; Nishikawa and Sakai 2005).  For
##this reason, the study from which this tool was developed (Treml et
##al. 2008) used a constant mortality of 6% per day. Although this rate
##is lower than the 18% per day reported for reef fish (Cowen et al.
##2000; James et al. 2002), it may be more representative of
##invertebrate taxa (Rumrill 1990, Ellien et al. 2004)."""),
##    arcGISDisplayName=_(u'Larvae death rate'),
##    arcGISCategory=_(u'Simulation options'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'diffusivity',
    typeMetadata=FloatTypeMetadata(minValue=0.0),
    description=_(
u"""The diffusion coefficent, in meters squared per second, to use in
the simulation.

It is recommended that you consult an oceanographer to determine this
value. The original study from which this tool was developed (Treml et
al. 2008) used the value 25."""),
    arcGISDisplayName=_(u'Diffusivity'),
    arcGISCategory=_(u'Simulation options'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'includeReefIDs',
    typeMetadata=ListTypeMetadata(elementType=IntegerTypeMetadata(), canBeNone=True, minLength=1),
    description=_(
u"""List of IDs of the reefs to include in the simulation. If the list
is empty, all of the reefs will be included, unless some reefs are
listed in the "exclude reefs" parameter."""),
    arcGISDisplayName=_(u'IDs of reefs to include in the simulation'),
    arcGISCategory=_(u'Simulation options'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'excludeReefIDs',
    typeMetadata=ListTypeMetadata(elementType=IntegerTypeMetadata(), canBeNone=True, minLength=1),
    description=_(
u"""List of IDs of the reefs to exclude from the simulation. This list
may only be provided if the "include reefs" list is omitted (an error
will be reported if both lists are provided). If this list is
provided, all of the reefs will be included in the simulation except
those in this list."""),
    arcGISDisplayName=_(u'IDs of reefs to exclude from the simulation'),
    arcGISCategory=_(u'Simulation options'))

AddArgumentMetadata(CoralReefConnectivity.RunSimulation, u'overwriteExisting',
    typeMetadata=BooleanTypeMetadata(),
    description=_(
u"""If True, the outputs will be overwritten, if it exists. If False,
a ValueError will be raised if the outputs exist."""),
    initializeToArcGISGeoprocessorVariable=u'OverwriteOutput')

AddResultMetadata(CoralReefConnectivity.RunSimulation, u'updatedOutputDirectory',
    typeMetadata=DirectoryTypeMetadata(),
    description=_(u'Updated output directory.'),
    arcGISDisplayName=_(u'Updated output directory'))

###############################################################################
# Metadata: _AvisoCurrentsInMetersPerSecond class
###############################################################################

AddClassMetadata(_AvisoCurrentsInMetersPerSecond,
    shortDescription=_(u'A version of AvisoGriddedGeostrophicCurrents that gives current velocity in m/s rather than cm/s.'),
    longDescription=_(
u"""This class is intended for private use within GeoEco and is not
intended for external callers."""))

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

__all__ = ['CoralReefConnectivity']