def getSpeedBearing(index, lon, lat, deltatime, ieast=1,
missingValue=sys.maxint):
"""
.. function:: getSpeedBearing(index, lon, lat, deltatime[, ieast=1, \
missingValue=sys.maxint])
Calculate the speed and bearing of a TC
Parameters
----------
index : :class:`numpy.ndarray`
Array of 0/1 indicating start of new TC (1)
lon : :class:`numpy.ndarray`
Longitudes of TC positions
lat : :class:`numpy.ndarray`
Latitudes of TC positions
deltatime : :class:`numpy.ndarray`
Time difference (hours) between consecutive TC observations
ieast : int, default=1
Indicate which direction has positive longitude.
1 = positive longitude eastwards
-1 = positive longiture westwards
missingValue : int or float, default = `sys.maxint`
Replace questionable values with `missingValue`
Returns
-------
speed : :class:`numpy.ndarray`
bearing : :class:`numpy.ndarray`
"""
bear_, dist_ = maputils.latLon2Azi(lat, lon, ieast, azimuth=0)
assert bear_.size == index.size - 1
assert dist_.size == index.size - 1
bearing = np.zeros(index.size, 'f')
bearing[1:] = bear_
np.putmask(bearing, index, missingValue)
dist = np.zeros(index.size, 'f')
dist[1:] = dist_
speed = dist / deltatime
# Delete speeds less than 0, greated than 200,
# or where indicator == 1.
np.putmask(speed, (speed < 0) | (speed > 200) | index, missingValue)
np.putmask(speed, np.isnan(speed), missingValue)
return speed, bearing
def getSpeedBearing(index,
lon,
lat,
deltatime,
ieast=1,
missingValue=sys.maxint):
"""
Calculate the speed and bearing of a TC.
:param index: Array of 0/1 indicating start of new TC (1)
:type index: :class:`numpy.ndarray`
:param lon: Longitudes of TC positions.
:type lon: :class:`numpy.ndarray`
:param lat: Latitudes of TC positions.
:type lat: :class:`numpy.ndarray`
:param deltatime: Time difference (hours) between
consecutive TC observations.
:type deltatime: :class:`numpy.ndarray`
:param int ieast: Indicate which direction has positive
longitude. 1 = positive longitude eastwards
-1 = positive longiture westwards.
:param missingValue: Replace questionable values with `missingValue`.
:type missingValue: int or float, default = `sys.maxint`
:returns: speed and bearing : :class:`numpy.ndarray`
Example::
>>> speed, bearing = getSpeedBearing(index, lon, lat, deltatime)
"""
bear_, dist_ = maputils.latLon2Azi(lat, lon, ieast, azimuth=0)
assert bear_.size == index.size - 1
assert dist_.size == index.size - 1
bearing = np.zeros(index.size, 'f')
bearing[1:] = bear_
np.putmask(bearing, index, missingValue)
dist = np.zeros(index.size, 'f')
dist[1:] = dist_
speed = dist / deltatime
# Delete speeds less than 0, greated than 200,
# or where indicator == 1.
np.putmask(speed, (speed < 0), missingValue)
np.putmask(speed, (speed > 200), missingValue)
np.putmask(speed, index, missingValue)
np.putmask(speed, np.isnan(speed), missingValue)
return speed, bearing
def getSpeedBearing(index, lon, lat, deltatime, ieast=1,
missingValue=sys.maxint):
"""
Calculate the speed and bearing of a TC.
:param index: Array of 0/1 indicating start of new TC (1)
:type index: :class:`numpy.ndarray`
:param lon: Longitudes of TC positions.
:type lon: :class:`numpy.ndarray`
:param lat: Latitudes of TC positions.
:type lat: :class:`numpy.ndarray`
:param deltatime: Time difference (hours) between
consecutive TC observations.
:type deltatime: :class:`numpy.ndarray`
:param int ieast: Indicate which direction has positive
longitude. 1 = positive longitude eastwards
-1 = positive longiture westwards.
:param missingValue: Replace questionable values with `missingValue`.
:type missingValue: int or float, default = `sys.maxint`
:returns: speed and bearing : :class:`numpy.ndarray`
Example::
>>> speed, bearing = getSpeedBearing(index, lon, lat, deltatime)
"""
bear_, dist_ = maputils.latLon2Azi(lat, lon, ieast, azimuth=0)
assert bear_.size == index.size - 1
assert dist_.size == index.size - 1
bearing = np.zeros(index.size, 'f')
bearing[1:] = bear_
np.putmask(bearing, index, missingValue)
dist = np.zeros(index.size, 'f')
dist[1:] = dist_
speed = dist / deltatime
# Delete speeds less than 0, greated than 200,
# or where indicator == 1.
np.putmask(speed, (speed < 0) | (speed > 200) | index, missingValue)
np.putmask(speed, np.isnan(speed), missingValue)
return speed, bearing
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] + 0.01, delta)
newtime[-1] = timestep[-1]
_newtime = (newtime / 24.0) + 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 = scipy.interpolate.interp1d(timestep, lon, kind="linear")(newtime)
nLat = scipy.interpolate.interp1d(timestep, lat, kind="linear")(newtime)
npCentre = scipy.interpolate.interp1d(timestep, pressure, kind="linear")(newtime)
npEnv = scipy.interpolate.interp1d(timestep, penv, kind="linear")(newtime)
nrMax = scipy.interpolate.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 = scipy.interpolate.splev(newtime, scipy.interpolate.splrep(timestep, lon, s=0), der=0)
nLat = scipy.interpolate.splev(newtime, scipy.interpolate.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 = scipy.interpolate.interp1d(timestep, lon, kind="linear")(newtime)
nLat = scipy.interpolate.interp1d(timestep, lat, kind="linear")(newtime)
else:
nLon = scipy.interpolate.splev(newtime, scipy.interpolate.splrep(timestep, lon, s=0), der=0)
nLat = scipy.interpolate.splev(newtime, scipy.interpolate.splrep(timestep, lat, s=0), der=0)
npCentre = scipy.interpolate.interp1d(timestep, pressure, kind="linear")(newtime)
npEnv = scipy.interpolate.interp1d(timestep, penv, kind="linear")(newtime)
nrMax = scipy.interpolate.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
