Example #1
0
    def historic(self):
        """Load historic data and calculate histogram"""
        log.info("Processing historic track records")
        config = ConfigParser()
        config.read(self.configFile)
        inputFile = config.get('DataProcess', 'InputFile')
        if len(os.path.dirname(inputFile)) == 0:
            inputFile = pjoin(self.inputPath, inputFile)

        source = config.get('DataProcess', 'Source')

        try:
            tracks = loadTrackFile(self.configFile, inputFile, source)

        except (TypeError, IOError, ValueError):
            log.critical("Cannot load historical track file: {0}".\
                         format(inputFile))
            raise
        else:
            startYr = 9999
            endYr = 0
            for t in tracks:
                startYr = min(startYr, min(t.Year))
                endYr = max(endYr, max(t.Year))
            numYears = endYr - startYr
            log.info("Range of years: %d - %d" % (startYr, endYr))
            try:
                self.hist = self._calculate(tracks)
            #self.hist = self._calculate(tracks) / numYears
            except (ValueError):
                log.critical(
                    "KDE error: The number of observations must be larger than the number of variables"
                )
                raise
Example #2
0
    def historic(self):
        """
        Load historic data and calculate histogram.
        Note that the input historical data is filtered by year
        when it's loaded in `interpolateTracks.parseTracks()`.

        The timestep to interpolate to is set to match that of the
        synthetic event set (normally set to 1 hour).
        """
        config = ConfigParser()
        config.read(self.configFile)
        inputFile = config.get('DataProcess', 'InputFile')
        if len(os.path.dirname(inputFile)) == 0:
            inputFile = pjoin(self.inputPath, inputFile)

        source = config.get('DataProcess', 'Source')

        try:
            tracks = loadTrackFile(self.configFile, inputFile, source)
        except (TypeError, IOError, ValueError):
            log.critical("Cannot load historical track file: {0}".\
                         format(inputFile))
            raise
        else:
            startYr = 9999
            endYr = 0
            for t in tracks:
                startYr = min(startYr, min(t.Year))
                endYr = max(endYr, max(t.Year))
            numYears = endYr - startYr

            self.hist = self.calculate(tracks) / numYears
Example #3
0
    def historic(self):
        """Load historic data and calculate histogram"""
        config = ConfigParser()
        config.read(self.configFile)
        inputFile = config.get('DataProcess', 'InputFile')
        if len(os.path.dirname(inputFile)) == 0:
            inputFile = pjoin(self.inputPath, inputFile)

        source = config.get('DataProcess', 'Source')

        try:
            tracks = loadTrackFile(self.configFile, inputFile,source)

        except (TypeError, IOError, ValueError):
            log.critical("Cannot load historical track file: {0}".format(inputFile))
            raise
        else:
            startYr = 9999
            endYr = 0
            for t in tracks:
                startYr = min(startYr, min(t.Year))
                endYr = max(endYr, max(t.Year))
            numYears = endYr - startYr
            log.info("Range of years: %d - %d" % (startYr, endYr))
            self.hist = self._calculate(tracks) / numYears
Example #4
0
def parseTracks(configFile,
                trackFile,
                source,
                delta,
                outputFile=None,
                interpolation_type=None):
    """
    Load a track dataset, then interpolate to some time delta (given in
    hours). Events with only a single record are not altered.

    :type  configFile: string
    :param configFile: Configuration file containing settings that
                       describe the data source.

    :type  trackFile: string
    :param trackFile: Path to the input data source.

    :type  source: string
    :param source: Name of the data source. `configFile` must have a
                   corresponding section which contains options that
                   describe the data format.

    :type  delta: float
    :param delta: Time difference to interpolate the dataset to. Must be
                  positive.

    :type  outputFile: string
    :param outputFile: Path to the destination of output, if it is to
                       be saved.

    :type  results: `list` of :class:`Track` objects containing the
                    interpolated track data

    """
    LOG.info("Interpolating tracks from {0}".format(trackFile))
    if delta < 0.0:
        raise ValueError("Time step for interpolation must be positive")

    if trackFile.endswith("nc"):
        from Utilities.track import ncReadTrackData
        tracks = ncReadTrackData(trackFile)
    else:
        tracks = loadTrackFile(configFile, trackFile, source)

    results = []

    for track in tracks:
        if len(track.data) == 1:
            results.append(track)
        else:
            newtrack = interpolate(track, delta, interpolation_type)
            results.append(newtrack)

    if outputFile:
        # Save data to file:
        ncSaveTracks(outputFile, results)

    return results
def parseTracks(configFile, trackFile, source, delta, outputFile=None,
                interpolation_type=None):
    """
    Load a track dataset, then interpolate to some time delta (given in
    hours). Events with only a single record are not altered.

    :type  configFile: string
    :param configFile: Configuration file containing settings that
                       describe the data source.

    :type  trackFile: string
    :param trackFile: Path to the input data source.

    :type  source: string
    :param source: Name of the data source. `configFile` must have a
                   corresponding section which contains options that
                   describe the data format.

    :type  delta: float
    :param delta: Time difference to interpolate the dataset to. Must be
                  positive.

    :type  outputFile: string
    :param outputFile: Path to the destination of output, if it is to
                       be saved.

    :type  results: `list` of :class:`Track` objects containing the
                    interpolated track data
                       
    """

    if delta < 0.0:
        raise ValueError("Time step for interpolation must be positive")

    tracks = loadTrackFile(configFile, trackFile, source)

    results = []

    for track in tracks:
        if len(track.data) == 1:
            results.append(track)
        else:
            newtrack = interpolate(track, delta, interpolation_type)
            results.append(newtrack)
  
    if outputFile:
        # Save data to file:
        saveTracks(results, outputFile)

    return results
Example #6
0
def main(configFile):
    from Utilities.loadData import loadTrackFile
    from Utilities.config import ConfigParser
    from os.path import join as pjoin, normpath, dirname
    baseDir = normpath(pjoin(dirname(__file__), '..'))
    inputPath = pjoin(baseDir, 'input')
    config = ConfigParser()
    config.read(configFile)

    inputFile = config.get('DataProcess', 'InputFile')
    source = config.get('DataProcess', 'Source')

    gridLimit = config.geteval('Region', 'gridLimit')

    xx = np.arange(gridLimit['xMin'], gridLimit['xMax'] + .1, 0.1)
    yy = np.arange(gridLimit['yMin'], gridLimit['yMax'] + .1, 0.1)

    xgrid, ygrid = np.meshgrid(xx, yy)

    if len(dirname(inputFile)) == 0:
        inputFile = pjoin(inputPath, inputFile)

    try:
        tracks = loadTrackFile(configFile, inputFile, source)
    except (TypeError, IOError, ValueError):
        log.critical("Cannot load historical track file: {0}".format(inputFile))
        raise

    title = source
    outputPath = config.get('Output', 'Path')
    outputPath = pjoin(outputPath, 'plots', 'stats')
    outputFile = pjoin(outputPath, 'tctracks.png')

    map_kwargs = dict(llcrnrlon=xgrid.min(),
                      llcrnrlat=ygrid.min(),
                      urcrnrlon=xgrid.max(),
                      urcrnrlat=ygrid.max(),
                      projection='merc',
                      resolution='i')

    figure = TrackMapFigure()
    figure.add(tracks, xgrid, ygrid, title, map_kwargs)
    figure.plot()
    saveFigure(figure, outputFile)
Example #7
0
def main(configFile):
    from Utilities.loadData import loadTrackFile
    from Utilities.config import ConfigParser
    from os.path import join as pjoin, normpath, dirname
    baseDir = normpath(pjoin(dirname(__file__), '..'))
    inputPath = pjoin(baseDir, 'input')
    config = ConfigParser()
    config.read(configFile)

    inputFile = config.get('DataProcess', 'InputFile')
    source = config.get('DataProcess', 'Source')

    gridLimit = config.geteval('Region', 'gridLimit')

    xx = np.arange(gridLimit['xMin'], gridLimit['xMax'] + .1, 0.1)
    yy = np.arange(gridLimit['yMin'], gridLimit['yMax'] + .1, 0.1)

    xgrid, ygrid = np.meshgrid(xx, yy)

    if len(dirname(inputFile)) == 0:
        inputFile = pjoin(inputPath, inputFile)

    try:
        tracks = loadTrackFile(configFile, inputFile, source)
    except (TypeError, IOError, ValueError):
        log.critical("Cannot load historical track file: {0}".format(inputFile))
        raise

    title = source
    outputPath = config.get('Output', 'Path')
    outputPath = pjoin(outputPath, 'plots','stats')
    outputFile = pjoin(outputPath, 'tctracks.png')

    map_kwargs = dict(llcrnrlon=xgrid.min(),
                      llcrnrlat=ygrid.min(),
                      urcrnrlon=xgrid.max(),
                      urcrnrlat=ygrid.max(),
                      projection='merc',
                      resolution='i')

    figure = TrackMapFigure()
    figure.add(tracks, xgrid, ygrid, title, map_kwargs)
    figure.plot()
    saveFigure(figure, outputFile)
    def historic(self):
        """Load historic data and calculate histogram"""
        log.info("Processing historical pressure distributions")
        config = ConfigParser()
        config.read(self.configFile)
        inputFile = config.get('DataProcess', 'InputFile')
        source = config.get('DataProcess', 'Source')
        
        if len(os.path.dirname(inputFile)) == 0:
            inputFile = pjoin(self.inputPath, inputFile)
        
        try:
            tracks = loadTrackFile(self.configFile, inputFile, source)
        except (TypeError, IOError, ValueError):
            log.critical("Cannot load historical track file: {0}".format(inputFile))
            raise
        else:
            self.histMean, self.histMin, \
                self.histMax, self.histMed = self.calculate(tracks)

            self.histMinCPDist, self.histMinCP = self.calcMinPressure(tracks)
Example #9
0
    def historic(self):
        """Load historic data and calculate histogram"""
        log.info("Processing historical pressure distributions")
        config = ConfigParser()
        config.read(self.configFile)
        inputFile = config.get('DataProcess', 'InputFile')
        source = config.get('DataProcess', 'Source')

        if len(os.path.dirname(inputFile)) == 0:
            inputFile = pjoin(self.inputPath, inputFile)

        try:
            tracks = loadTrackFile(self.configFile, inputFile, source)
        except (TypeError, IOError, ValueError):
            log.critical(
                "Cannot load historical track file: {0}".format(inputFile))
            raise
        else:
            self.histMean, self.histMin, \
                self.histMax, self.histMed = self.calculate(tracks)

            self.histMinCPDist, self.histMinCP = self.calcMinPressure(tracks)
Example #10
0
    def historic(self):
        """Calculate historical rates of landfall"""

        log.info("Processing landfall rates of historical tracks")
        config = ConfigParser()
        config.read(self.configFile)
        inputFile = config.get('DataProcess', 'InputFile')
        source = config.get('DataProcess', 'Source')
        
        timestep = config.getfloat('TrackGenerator', 'Timestep')

        if len(os.path.dirname(inputFile)) == 0:
            inputFile = pjoin(self.inputPath, inputFile)
        
        try:
            tracks = loadTrackFile(self.configFile, inputFile, source)
        except (TypeError, IOError, ValueError):
            log.critical("Cannot load historical track file: {0}".format(inputFile))
            raise
        else:
            self.historicLandfall, self.historicOffshore = self.processTracks(tracks)

        return
Example #11
0
    def historic(self):
        """Calculate historical rates of landfall"""

        LOG.info("Processing landfall rates of historical tracks")
        config = ConfigParser()
        config.read(self.configFile)
        inputFile = config.get('DataProcess', 'InputFile')
        source = config.get('DataProcess', 'Source')

        if len(os.path.dirname(inputFile)) == 0:
            inputFile = pjoin(self.inputPath, inputFile)

        try:
            tracks = loadTrackFile(self.configFile, inputFile, source)
        except (TypeError, IOError, ValueError):
            LOG.critical("Cannot load historical track file: {0}".\
                         format(inputFile))
            raise
        else:
            self.historicLandfall, self.historicOffshore = \
                                        self.processTracks(tracks)

        return
Example #12
0
                'lon': lambda s: fmtlon(s),
                'vmax': lambda s: float(s.strip()),
                'pcentre': lambda s: float(s.strip()),
                'poci': lambda s: float(s.strip()),
                'rmax': lambda s: float(s.strip()) * 1.852
            },
    "autostrip" : True
    }

source="BDECK"
config_file="B:/CHARS/B_Wind/data/derived/tc/events/bsh132016/TCDebbie.ini"
for f in os.listdir(inputPath):
    inputFile = pjoin(inputPath, f)
    data = np.genfromtxt(inputFile, **bdeck)
    print(inputFile)
    header = 'basin,num,date,lat,lon,vmax,pcentre,poci,rmax,name'
    fmt = '%s,%i,%s,%8.2f,%8.2f,%6.1f,%7.1f,%7.1f,%6.2f,%s'
    outputFile = pjoin(outputPath, f)
    np.savetxt(outputFile, data, fmt=fmt, delimiter=",", header=header)

    fname, ext = splitext(outputFile)
    pt_output_file = fname + '_pt.shp'
    line_output_file = fname + '_line.shp'
    dissolve_output_file = fname + '_dissolve.shp'
    tracks = loadTrackFile(config_file, outputFile, source,
                           calculateWindSpeed=False)

    tracks2point(tracks, pt_output_file)
    tracks2line(tracks, line_output_file)
    tracks2line(tracks, dissolve_output_file, dissolve=True)
Example #13
0
def interpolateTrack(configFile,
                     trackFile,
                     source,
                     delta=0.1,
                     interpolation_type=None):
    """
    Interpolate the data in a track file to the time interval delta hours.

    :param str configFile: Configuration file that contains information on the
                           source format of the track file.
    :param str trackFile: Path to csv format track file.
    :param str source: Name of the data source. There must be a corresponding
                       section in the configuration file that contains the
                       description of the data.
    :param float delta: Time interval in hours to interpolate to. Default is
                        0.1 hours
    :param str interpolation_type: Optionally use Akima or linear
                                   interpolation for the track positions.
                                   Default is linear 1-dimensional spline
                                   interpolation.

    :returns: 10 arrays (id, time, date, lon, lat, bearing, forward speed,
              central pressure, environmental pressure and radius to
              maximum wind) that describe the track at ``delta`` hours
              intervals.

    """
    logger = logging.getLogger()
    indicator, year, month, day, hour, minute, lon, lat, \
        pressure, speed, bearing, windspeed, rmax, penv = \
                    loadTrackFile(configFile, trackFile, source)

    # Time between observations:
    day_ = [
        datetime.datetime(year[i], month[i], day[i], hour[i], minute[i])
        for i in xrange(year.size)
    ]
    time_ = date2num(day_)
    dt_ = 24.0 * numpy.diff(time_)
    dt = numpy.empty(hour.size, 'f')
    dt[1:] = dt_

    # At this stage, convert all times to a time after initial observation:
    timestep = 24.0 * (time_ - time_[0])

    newtime = numpy.arange(timestep[0], timestep[-1] + .01, delta)
    newtime[-1] = timestep[-1]
    _newtime = (newtime / 24.) + time_[0]
    newdates = num2date(_newtime)

    nid = numpy.ones(newtime.size)

    logger.info("Interpolating data...")
    if len(indicator) <= 2:
        # Use linear interpolation only (only a start and end point given):
        nLon = scint.interp1d(timestep, lon, kind='linear')(newtime)
        nLat = scint.interp1d(timestep, lat, kind='linear')(newtime)
        npCentre = scint.interp1d(timestep, pressure, kind='linear')(newtime)
        npEnv = scint.interp1d(timestep, penv, kind='linear')(newtime)
        nrMax = scint.interp1d(timestep, rmax, kind='linear')(newtime)

    else:
        if interpolation_type == 'akima':
            # Use the Akima interpolation method:
            try:
                import _akima
            except ImportError:
                logger.exception(("Akima interpolation module unavailable - "
                                  "default to scipy.interpolate"))
                nLon = scint.splev(newtime,
                                   scint.splrep(timestep, lon, s=0),
                                   der=0)
                nLat = scint.splev(newtime,
                                   scint.splrep(timestep, lat, s=0),
                                   der=0)
            else:
                nLon = _akima.interpolate(timestep, lon, newtime)
                nLat = _akima.interpolate(timestep, lat, newtime)
        elif interpolation_type == 'linear':
            nLon = scint.interp1d(timestep, lon, kind='linear')(newtime)
            nLat = scint.interp1d(timestep, lat, kind='linear')(newtime)
        else:
            nLon = scint.splev(newtime,
                               scint.splrep(timestep, lon, s=0),
                               der=0)
            nLat = scint.splev(newtime,
                               scint.splrep(timestep, lat, s=0),
                               der=0)

        npCentre = scint.interp1d(timestep, pressure, kind='linear')(newtime)
        npEnv = scint.interp1d(timestep, penv, kind='linear')(newtime)
        nrMax = scint.interp1d(timestep, rmax, kind='linear')(newtime)

    bear_, dist_ = maputils.latLon2Azi(nLat, nLon, 1, azimuth=0)
    nthetaFm = numpy.zeros(newtime.size, 'f')
    nthetaFm[:-1] = bear_
    nthetaFm[-1] = bear_[-1]
    dist = numpy.zeros(newtime.size, 'f')
    dist[:-1] = dist_
    dist[-1] = dist_[-1]
    nvFm = dist / delta

    return nid, newtime, newdates, nLon, nLat, nthetaFm, nvFm, npCentre, npEnv, nrMax
Example #14
0
    output_path = dirname(realpath(track_file))
    filename, ext = splitext(track_file)
    pt_output_file = filename + '_pt.shp'
    line_output_file = filename + '_line.shp'
    dissolve_output_file = filename + '_dissolve.shp'

    if track_file.endswith(".nc"):

        from Utilities.track import ncReadTrackData
        tracks = ncReadTrackData(track_file)
        netcdf_format = True

    elif track_file.endswith(".csv"):
        tracks = loadTrackFile(config_file,
                               track_file,
                               source,
                               calculateWindSpeed=True)
        netcdf_format = False

    else:
        raise ValueError("format of {} is not recognizable".format(track_file))

    tracks2point(tracks, pt_output_file, netcdf_format=netcdf_format)
    tracks2line(tracks, line_output_file, netcdf_format=netcdf_format)
    tracks2line(tracks,
                dissolve_output_file,
                dissolve=True,
                netcdf_format=netcdf_format)
    LOG.info("Completed tracks2shp")
Example #15
0
    verbose = config.getboolean('Logging', 'Verbose')
    datestamp = config.getboolean('Logging', 'Datestamp')

    if args.verbose:
        verbose = True

    flStartLog(logfile, logLevel, verbose, datestamp)

    if args.file:
        track_file = args.file
    else:
        track_file = config.get('DataProcess', 'InputFile')

    if args.source:
        source = args.source
    else:
        source = config.get('DataProcess', 'Source')

    output_path = dirname(realpath(track_file))
    filename, ext = splitext(track_file)
    pt_output_file = filename + '_pt.shp'
    line_output_file = filename + '_line.shp'
    dissolve_output_file = filename + '_dissolve.shp'
    tracks = loadTrackFile(config_file, track_file, source)

    tracks2point(tracks, pt_output_file)
    tracks2line(tracks, line_output_file)
    tracks2line(tracks, dissolve_output_file, dissolve=True)
    LOG.info("Completed tracks2shp")