def __init__(self):
self.tau = 60
self.width = 10
self.y = np.zeros((2,self.tau))
self.y[0] = self.y[1] = np.linspace(self.width/2+5, settings["size_y"] - self.width/2-5, self.tau)
self.x = np.zeros((2,self.tau))
self.x[0] = self.x[1] = np.linspace(self.width/2+5, settings["size_x"] - self.width/2-5, self.tau)
mod_y0 = np.concatenate((self.y[0], np.random.uniform(self.width/2, settings["size_y"] - self.width/2, 1)))
mod_y1 = np.concatenate((self.y[1], np.random.uniform(self.width/2, settings["size_y"] - self.width/2, 1)))
mod_x0 = np.concatenate((self.x[0], np.random.uniform(self.width/2, settings["size_x"] - self.width/2, 1)))
mod_x1 = np.concatenate((self.x[1], np.random.uniform(self.width/2, settings["size_x"] - self.width/2, 1)))
x = np.concatenate((np.arange(self.tau), np.array([2*self.tau])))
new_y0 = interpolate(x, mod_y0, np.arange(2*self.tau))
new_y1 = interpolate(x, mod_y1, np.arange(2*self.tau))
new_x0 = interpolate(x, mod_x0, np.arange(2*self.tau))
new_x1 = interpolate(x, mod_x1, np.arange(2*self.tau))
self.y = np.vstack((new_y0, new_y1))
self.x = np.vstack((new_x0, new_x1))
self.pointer = 0
def get(self):
if self.pointer >=self.tau:
self.y = self.y[self.tau-1:-1]
self.x = self.x[self.tau-1:-1]
mod_y = np.concatenate((self.y, np.random.uniform(self.a_max/2, self.a_max, 1)))
mod_x = np.concatenate((self.x, np.random.uniform(self.a_max/2, self.size_x, 1)))
x = np.concatenate((np.arange(self.tau), np.array([2*self.tau])))
self.y = interpolate(x, mod_y, np.arange(2*self.tau))
self.x = interpolate(x, mod_x, np.arange(2*self.tau))
self.pointer = 0
#left,right, top, bottom
a = self.y[self.pointer]
xk = self.x[self.pointer]
Ul = t = self.a_max*(np.exp(-((np.arange(self.size_x) - xk)**2)/(2*self.sigma)) -0.1)
for i in range(self.size_y-1): Ul = np.vstack((Ul, t))
Vl = Wl = t = np.random.uniform(-1,1,(self.size_x, self.size_y))
self.pointer = self.pointer + 1
return (Ul.transpose(),Vl,Wl)
def shift_freq(self, deltaf):
if deltaf == 0: return
if deltaf > 0:
newFreq = self.ctrF + deltaf
newSize = self.samples.size * newFreq / self.ctrF
newSR = self.sampleRate * newSize / self.samples.size
T = 1 / newSR
x = np.linspace(0, 1, self.samples.size)
new_x = np.linspace(0, 1, newSize)
interp_r = interpolate(x, self.samples.real, new_x)
interp_i = interpolate(x, self.samples.imag, new_x)
out = (interp_r + i * interp_i) * np.exp(-i * T * deltaf * np.arange(interp_i.size))
s = Signal(newFreq, newSR, out)
return s
if deltaf < 0:
newFreq = self.ctrF + deltaf
T = 1 / self.sampleRate
newSize = self.samples.size * newFreq / self.ctrF
newSR = self.sampleRate * newFreq / self.ctrF
k = (np.arange(newSize) * self.ctrF / newFreq).astype(np.int)
out = np.take(self.samples, k) * np.exp(-i * deltaf * T * np.arange(newSize))
s = Signal(newFreq, newSR, out)
def freqShift(self, newFreq):
if newFreq <0: return
if newFreq == self.ctrF: return
if newFreq > self.ctrF:
f2 = newFreq - self.ctrF
newSize = self.samples.size *newFreq/self.ctrF
newSR = self.sampleRate*newSize/self.samples.size
T = 1/newSR
x = np.linspace(0, 1, self.samples.size)
new_x = np.linspace(0, 1, newSize)
interp_r = interpolate(x, self.samples.real, new_x)
interp_i = interpolate(x, self.samples.imag, new_x)
out = (interp_r + i*interp_i)*np.exp(-i*T*f2*np.arange(interp_i.size))
self.ctrF = newFreq
self.sampleRate = newSR
self.samples = out
return out
if newFreq < self.ctrF:
f2 = self.ctrF - newFreq
T = 1/self.sampleRate
newSize = self.samples.size*newFreq/self.ctrF
newSR = self.sampleRate*newFreq/self.ctrF
k = (np.arange(newSize)*self.ctrF/newFreq).astype(np.int)
out = np.take(self.samples, k)*np.exp(i*f2*T*np.arange(newSize))
self.samples = out
self.sampleRate = newSR
self.ctrF = newFreq
return out
def __init__(self, size_x,size_y, a_max, sigma):
self.tau = 60
self.size_x = size_x
self.size_y = size_y
self.a_max = a_max
self.sigma = sigma
self.y = self.a_max*np.sin(np.linspace(-np.pi/2,np.pi/2,self.tau))
self.x = np.linspace(0, self.size_x, self.tau)
mod_y = np.concatenate((self.y, np.random.uniform(self.a_max/2, self.a_max, 1)))
mod_x = np.concatenate((self.x, np.random.uniform(self.a_max/2, self.size_x, 1)))
x = np.concatenate((np.arange(self.tau), np.array([2*self.tau])))
self.y = interpolate(x, mod_y, np.arange(2*self.tau))
self.x = interpolate(x, mod_x, np.arange(2*self.tau))
self.pointer = 0
def interpolate(track, delta, interpolation_type=None):
"""
Interpolate the records in time to have a uniform time difference between
records. Each of the input arrays represent the values for a single TC
event.
:param track: :class:`Track` object containing all data for the track.
:param delta: `float` time difference to interpolate the dataset to. Must be
positive.
:param interpolation_type: Optional ['linear', 'akima'], specify the type
of interpolation used for the locations (i.e.
longitude and latitude) of the records.
# FIXME: Need to address masking values - scipy.interpolate.interp1d
handles numpy.ma masked arrays.
"""
day_ = [datetime(*x) for x in zip(track.Year, track.Month,
track.Day, track.Hour,
track.Minute)]
timestep = timedelta(delta/24.)
time_ = np.array([d.toordinal() + d.hour/24.0 for d in day_], dtype=float)
dt_ = 24.0 * np.diff(time_)
dt = np.empty(track.Hour.size, dtype=float)
dt[1:] = dt_
# Convert all times to a time after initial observation:
timestep = 24.0*(time_ - time_[0])
newtime = np.arange(timestep[0], timestep[-1] + .01, delta)
newtime[-1] = timestep[-1]
_newtime = (newtime / 24.) + time_[0]
newdates = num2date(_newtime)
newdates = np.array([n.replace(tzinfo=None) for n in newdates])
nid = track.trackId[0] * np.ones(newtime.size)
# Find the indices of valid pressure observations:
validIdx = np.where(track.CentralPressure < sys.maxint)[0]
# FIXME: Need to address the issue when the time between obs is less
# than delta (e.g. only two obs 5 hrs apart, but delta = 6 hrs).
if len(track.data) <= 2:
# Use linear interpolation only (only a start and end point given):
nLon = interp1d(timestep, track.Longitude, kind='linear')(newtime)
nLat = interp1d(timestep, track.Latitude, kind='linear')(newtime)
if len(validIdx) == 2:
npCentre = interp1d(timestep,
track.CentralPressure,
kind='linear')(newtime)
nwSpd = interp1d(timestep,
track.WindSpeed,
kind='linear')(newtime)
elif len(validIdx) == 1:
# If one valid observation, assume no change and
# apply value to all times
npCentre = np.ones(len(newtime)) * track.CentralPressure[validIdx]
nwSpd = np.ones(len(newtime)) * track.WindSpeed[validIdx]
else:
npCentre = np.zeros(len(newtime))
nwSpd = np.zeros(len(newtime))
npEnv = interp1d(timestep, track.EnvPressure, kind='linear')(newtime)
nrMax = interp1d(timestep, track.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 = splev(newtime, splrep(timestep, track.Longitude, s=0), der=0)
nLat = splev(newtime, splrep(timestep, track.Latitude, s=0), der=0)
else:
nLon = akima.interpolate(timestep, track.Longitude, newtime)
nLat = akima.interpolate(timestep, track.Latitude, newtime)
elif interpolation_type=='linear':
nLon = interp1d(timestep, track.Longitude, kind='linear')(newtime)
nLat = interp1d(timestep, track.Latitude, kind='linear')(newtime)
else:
nLon = splev(newtime, splrep(timestep, track.Longitude, s=0), der=0)
nLat = splev(newtime, splrep(timestep, track.Latitude, s=0), der=0)
if len(validIdx) >= 2:
# No valid data at the final new time,
# would require extrapolation:
firsttime = np.where(newtime >= timestep[validIdx[0]])[0][0]
lasttime = np.where(newtime <= timestep[validIdx[-1]])[0][-1]
if firsttime == lasttime:
# only one valid observation:
npCentre = np.zeros(len(newtime))
nwSpd = np.zeros(len(newtime))
npCentre[firsttime] = track.CentralPressure[validIdx[0]]
nwSpd[firsttime] = track.WindSpeed[validIdx[0]]
else:
npCentre = np.zeros(len(newtime))
nwSpd = np.zeros(len(newtime))
_npCentre = interp1d(timestep[validIdx],
track.CentralPressure[validIdx],
kind='linear')(newtime[firsttime:lasttime])
_nwSpd = interp1d(timestep[validIdx],
track.WindSpeed[validIdx],
kind='linear')(newtime[firsttime:lasttime])
npCentre[firsttime:lasttime] = _npCentre
nwSpd[firsttime:lasttime] = _nwSpd
npCentre[lasttime] = _npCentre[-1]
nwSpd[lasttime] = _nwSpd[-1]
elif len(validIdx) == 1:
npCentre = np.ones(len(newtime)) * track.CentralPressure[validIdx]
nwSpd = np.ones(len(newtime)) * track.WindSpeed[validIdx]
else:
npCentre = np.zeros(len(newtime))
nwSpd = np.zeros(len(newtime))
npEnv = interp1d(timestep, track.EnvPressure, kind='linear')(newtime)
nrMax = interp1d(timestep, track.rMax, kind='linear')(newtime)
if len(nLat) >= 2:
bear_, dist_ = latLon2Azi(nLat, nLon, 1, azimuth=0)
nthetaFm = np.zeros(newtime.size, dtype=float)
nthetaFm[:-1] = bear_
nthetaFm[-1] = bear_[-1]
dist = np.zeros(newtime.size, dtype=float)
dist[:-1] = dist_
dist[-1] = dist_[-1]
nvFm = dist / delta
else:
nvFm = track.Speed[-1]
nthetaFm = track.Bearing[-1]
nYear = [date.year for date in newdates]
nMonth = [date.month for date in newdates]
nDay = [date.day for date in newdates]
nHour = [date.hour for date in newdates]
nMin = [date.minute for date in newdates]
np.putmask(npCentre, npCentre > 10e+6, sys.maxint)
np.putmask(npCentre, npCentre < 700, sys.maxint)
newindex = np.zeros(len(newtime))
newindex[0] = 1
newTCID = np.ones(len(newtime)) * track.trackId[0]
newdata = np.empty(len(newtime),
dtype={
'names': TRACKFILE_COLS,
'formats': TRACKFILE_FMTS
} )
for key, val in zip(TRACKFILE_COLS,
[newindex, newTCID, nYear, nMonth, nDay, nHour, nMin,
newtime, newdates, nLon, nLat, nvFm, nthetaFm,
npCentre, nwSpd, nrMax, npEnv]):
newdata[key] = val
newtrack = Track(newdata)
newtrack.trackId = track.trackId
newtrack.trackfile = track.trackfile
return newtrack
def get(self):
if self.pointer >=self.tau:
self.y = self.y[:,self.tau-1:-1]
self.x = self.x[:,self.tau-1:-1]
mod_y0 = np.concatenate((self.y[0], np.random.uniform(self.width/2+5, settings["size_y"] -self.width/2-5, 1)))
mod_y1 = np.concatenate((self.y[1], np.random.uniform(self.width/2+5, settings["size_y"] -self.width/2-5, 1)))
mod_x0 = np.concatenate((self.x[0], np.random.uniform(self.width/2+5, settings["size_x"] - self.width/2-5, 1)))
mod_x1 = np.concatenate((self.x[1], np.random.uniform(self.width/2+5, settings["size_x"] - self.width/2-5, 1)))
x = np.concatenate((np.arange(self.tau), np.array([2*self.tau])))
new_y0 = interpolate(x, mod_y0, np.arange(2*self.tau))
new_y1 = interpolate(x, mod_y1, np.arange(2*self.tau))
new_x0 = interpolate(x, mod_x0, np.arange(2*self.tau))
new_x1 = interpolate(x, mod_x1, np.arange(2*self.tau))
self.y = np.vstack((new_y0, new_y1))
self.x = np.vstack((new_x0, new_x1))
print("hi")
#self.y = self.y[self.tau-1:-1]
#self.x = self.x[self.tau-1:-1]
self.pointer = 0
#left,right, top, bottom
Ul = Ur = np.random.uniform(-10, -5, (settings["size_y"],settings["size_z"]))
Vl = Wl = Vr = Wr = np.random.uniform(-3, 3, (settings["size_y"],settings["size_z"]))
#Ur = np.random.uniform(-15, -10, (settings["size_y"],settings["size_z"]))
#Vr = Wr = np.random.uniform(-3, 3, (settings["size_y"],settings["size_z"]))
Vt = Vb = np.random.uniform(-10, -5, (settings["size_x"],settings["size_z"]))
Ut = Wt = Ub = Wb = np.random.uniform(-3, 3, (settings["size_x"],settings["size_z"]))
#left
a= self.y[0, self.pointer]
print(a)
w = int(a + self.width/2) - int(a - self.width/2)
Ul[int(a - self.width/2):int(a + self.width/2), :] = np.full((w, settings["size_z"]), 15)
Vl[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(-3,3,(w, settings["size_z"]))
Wl[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(-3,3,(w, settings["size_z"]))
#right
a= self.y[1, self.pointer]
w = int(a + self.width/2) - int(a - self.width/2)
Ur[int(a - self.width/2):int(a + self.width/2), :] = np.full((w, settings["size_z"]), 15)
Vr[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(-3,3,(w, settings["size_z"]))
Wr[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(-3,3,(w, settings["size_z"]))
#top
a= self.x[0, self.pointer]
w = int(a + self.width/2) - int(a - self.width/2)
Ut[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(-3,3,(w, settings["size_z"]))
Vt[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(10,15,(w, settings["size_z"]))
Wt[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(-3,3,(w, settings["size_z"]))
#bottom
a= self.x[1, self.pointer]
w = int(a + self.width/2) - int(a - self.width/2)
Ub[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(-3,3,(w, settings["size_z"]))
Vb[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(10,15,(w, settings["size_z"]))
Wb[int(a - self.width/2):int(a + self.width/2), :] = np.random.uniform(-3,3,(w, settings["size_z"]))
self.pointer = self.pointer + 1
return ((Ul,Vl,Wl),(Ur,Vr,Wr),(Ut,Vt,Wt),(Ub,Vb,Wb))
def interpolate(track, delta, interpolation_type=None):
"""
Interpolate the records in time to have a uniform time difference between
records. Each of the input arrays represent the values for a single TC
event.
:param track: :class:`Track` object containing all data for the track.
:param delta: `float` time difference to interpolate the dataset to. Must be
positive.
:param interpolation_type: Optional ['linear', 'akima'], specify the type
of interpolation used for the locations (i.e.
longitude and latitude) of the records.
# FIXME: Need to address masking values - scipy.interpolate.interp1d
handles numpy.ma masked arrays.
"""
LOG.debug("Performing interpolation of TC track")
if not hasattr(track, 'Datetime'):
day_ = [
datetime(*x) for x in zip(track.Year, track.Month, track.Day,
track.Hour, track.Minute)
]
else:
day_ = track.Datetime
timestep = timedelta(delta / 24.)
try:
time_ = np.array(
[d.toordinal() + (d.hour + d.minute / 60.) / 24.0 for d in day_],
dtype=float)
except AttributeError:
import cftime
if isinstance(day_[0], cftime.DatetimeJulian):
day__ = [d._to_real_datetime() for d in day_]
time_ = np.array([
d.toordinal() + (d.hour + d.minute / 60.) / 24. for d in day__
],
dtype=float)
else:
raise
dt_ = 24.0 * np.diff(time_)
dt = np.zeros(len(track.data), dtype=float)
dt[1:] = dt_
# Convert all times to a time after initial observation:
timestep = 24.0 * (time_ - time_[0])
newtime = np.arange(timestep[0], timestep[-1] + .01, delta)
newtime[-1] = timestep[-1]
_newtime = (newtime / 24.) + time_[0]
newdates = num2date(_newtime)
newdates = np.array([n.replace(tzinfo=None) for n in newdates])
if not hasattr(track, 'Speed'):
idx = np.zeros(len(track.data))
idx[0] = 1
# TODO: Possibly could change `np.mean(dt)` to `dt`?
track.WindSpeed = maxWindSpeed(idx, np.mean(dt), track.Longitude,
track.Latitude, track.CentralPressure,
track.EnvPressure)
# Find the indices of valid pressure observations:
validIdx = np.where(track.CentralPressure < sys.maxsize)[0]
# FIXME: Need to address the issue when the time between obs is less
# than delta (e.g. only two obs 5 hrs apart, but delta = 6 hrs).
if len(track.data) <= 3:
# Use linear interpolation only (only a start and end point given):
nLon = interp1d(timestep, track.Longitude, kind='linear')(newtime)
nLat = interp1d(timestep, track.Latitude, kind='linear')(newtime)
if len(validIdx) >= 2:
npCentre = interp1d(timestep, track.CentralPressure,
kind='linear')(newtime)
nwSpd = interp1d(timestep, track.WindSpeed, kind='linear')(newtime)
elif len(validIdx) == 1:
# If one valid observation, assume no change and
# apply value to all times
npCentre = np.ones(len(newtime)) * track.CentralPressure[validIdx]
nwSpd = np.ones(len(newtime)) * track.WindSpeed[validIdx]
else:
npCentre = np.zeros(len(newtime))
nwSpd = np.zeros(len(newtime))
npEnv = interp1d(timestep, track.EnvPressure, kind='linear')(newtime)
nrMax = interp1d(timestep, track.rMax, kind='linear')(newtime)
else:
if interpolation_type == 'akima':
# Use the Akima interpolation method:
try:
import akima
except ImportError:
LOG.exception(("Akima interpolation module unavailable "
" - default to scipy.interpolate"))
nLon = splev(newtime,
splrep(timestep, track.Longitude, s=0),
der=0)
nLat = splev(newtime,
splrep(timestep, track.Latitude, s=0),
der=0)
else:
nLon = akima.interpolate(timestep, track.Longitude, newtime)
nLat = akima.interpolate(timestep, track.Latitude, newtime)
elif interpolation_type == 'linear':
nLon = interp1d(timestep, track.Longitude, kind='linear')(newtime)
nLat = interp1d(timestep, track.Latitude, kind='linear')(newtime)
else:
nLon = splev(newtime,
splrep(timestep, track.Longitude, s=0),
der=0)
nLat = splev(newtime, splrep(timestep, track.Latitude, s=0), der=0)
if len(validIdx) >= 2:
# No valid data at the final new time,
# would require extrapolation:
firsttime = np.where(newtime >= timestep[validIdx[0]])[0][0]
lasttime = np.where(newtime <= timestep[validIdx[-1]])[0][-1]
if firsttime == lasttime:
# only one valid observation:
npCentre = np.zeros(len(newtime))
nwSpd = np.zeros(len(newtime))
npCentre[firsttime] = track.CentralPressure[validIdx[0]]
nwSpd[firsttime] = track.WindSpeed[validIdx[0]]
else:
npCentre = np.zeros(len(newtime))
nwSpd = np.zeros(len(newtime))
_npCentre = interp1d(timestep[validIdx],
track.CentralPressure[validIdx],
kind='linear')(
newtime[firsttime:lasttime])
_nwSpd = interp1d(timestep[validIdx],
track.Speed[validIdx],
kind='linear')(newtime[firsttime:lasttime])
npCentre[firsttime:lasttime] = _npCentre
nwSpd[firsttime:lasttime] = _nwSpd
npCentre[lasttime] = _npCentre[-1]
nwSpd[lasttime] = _nwSpd[-1]
elif len(validIdx) == 1:
npCentre = np.ones(len(newtime)) * track.CentralPressure[validIdx]
nwSpd = np.ones(len(newtime)) * track.WindSpeed[validIdx]
else:
npCentre = np.zeros(len(newtime))
nwSpd = np.zeros(len(newtime))
npEnv = interp1d(timestep, track.EnvPressure, kind='linear')(newtime)
nrMax = interp1d(timestep, track.rMax, kind='linear')(newtime)
if len(nLat) >= 2:
bear_, dist_ = latLon2Azi(nLat, nLon, 1, azimuth=0)
nthetaFm = np.zeros(newtime.size, dtype=float)
nthetaFm[:-1] = bear_
nthetaFm[-1] = bear_[-1]
dist = np.zeros(newtime.size, dtype=float)
dist[:-1] = dist_
dist[-1] = dist_[-1]
nvFm = dist / delta
else:
nvFm = track.Speed[-1]
nthetaFm = track.Bearing[-1]
nYear = [date.year for date in newdates]
nMonth = [date.month for date in newdates]
nDay = [date.day for date in newdates]
nHour = [date.hour for date in newdates]
nMin = [date.minute for date in newdates]
np.putmask(npCentre, npCentre > 10e+6, sys.maxsize)
np.putmask(npCentre, npCentre < 700, sys.maxsize)
newindex = np.zeros(len(newtime))
newindex[0] = 1
newTCID = np.ones(len(newtime)) * track.trackId[0]
newdata = np.empty(len(newtime),
dtype={
'names': TRACKFILE_COLS,
'formats': TRACKFILE_FMTS
})
for key, val in zip(TRACKFILE_COLS, [
newindex, newTCID, nYear, nMonth, nDay, nHour, nMin, newtime,
newdates, nLon, nLat, nvFm, nthetaFm, npCentre, nwSpd, nrMax, npEnv
]):
newdata[key] = val
newtrack = Track(newdata)
newtrack.trackId = track.trackId
newtrack.trackfile = track.trackfile
return newtrack
idx = np.zeros(
[K], np.int32) # index location of the k window in the spline array
idx[0] = 0
for k in range(1, K):
xspl = np.append(
xspl,
np.linspace(x[k - 1], x[k], num=100,
endpoint=False)) # 100 spline poins between windows
idx[k] = len(xspl)
xspl = np.append(xspl, x[-1])
### Integrate with bootstrapping
for i in range(BootCyc):
for k in range(K):
y[k] = np.random.normal(m[k], s[k], 1)
yspl = interpolate(x, y, xspl)
for k in range(K):
if aur == 'a' or aur == 'o' or aur == 'r': ### Attach/Release
intg[k, i] = np.trapz(
yspl[0:idx[k]], xspl[0:idx[k]]
) # not a negative because it's work by the system, not external. test with w = -fd
else: # Umbrella Translate
intg[k, i] = -1 * np.trapz(yspl[0:idx[k]], xspl[0:idx[k]])
### Write Integration
datfile = open('int-' + aur + '.%03.0f.dat' % prg[p], 'w')
for k in range(K):
datfile.write("%15.7f %15.7f %15.7f\n" %
(x[k], np.mean(intg[k]), np.std(intg[k])))
datfile.close()
def findInterpolatedPowerValues(timestamps, fileName):
amperages, timestampsPower = extract_fields(fileName)
i, j = findContainingRange(timestampsPower, timestamps)
return interpolate(timestampsPower[i:j], amperages[i:j], timestamps)
