def test_interpolate_to_points(method, test_data):
r"""Test main grid interpolation function."""
xp, yp, z = test_data
obs_points = np.vstack([xp, yp]).transpose() * 10
with get_test_data('interpolation_test_points.npz') as fobj:
test_points = np.load(fobj)['points']
extra_kw = {}
if method == 'cressman':
extra_kw['search_radius'] = 200
extra_kw['minimum_neighbors'] = 1
elif method == 'barnes':
extra_kw['search_radius'] = 400
extra_kw['minimum_neighbors'] = 1
extra_kw['gamma'] = 1
elif method == 'shouldraise':
with pytest.raises(ValueError):
interpolate_to_points(
obs_points, z, test_points, interp_type=method, **extra_kw)
return
img = interpolate_to_points(obs_points, z, test_points, interp_type=method, **extra_kw)
with get_test_data('{0}_test.npz'.format(method)) as fobj:
truth = np.load(fobj)['img'].reshape(-1)
assert_array_almost_equal(truth, img)
def test_interpolate_to_points(method, test_data):
r"""Test main grid interpolation function."""
xp, yp, z = test_data
obs_points = np.vstack([xp, yp]).transpose() * 10
with get_test_data('interpolation_test_points.npz') as fobj:
test_points = np.load(fobj)['points']
extra_kw = {}
if method == 'cressman':
extra_kw['search_radius'] = 200
extra_kw['minimum_neighbors'] = 1
elif method == 'barnes':
extra_kw['search_radius'] = 400
extra_kw['minimum_neighbors'] = 1
extra_kw['gamma'] = 1
elif method == 'shouldraise':
with pytest.raises(ValueError):
interpolate_to_points(obs_points,
z,
test_points,
interp_type=method,
**extra_kw)
return
img = interpolate_to_points(obs_points,
z,
test_points,
interp_type=method,
**extra_kw)
with get_test_data(f'{method}_test.npz') as fobj:
truth = np.load(fobj)['img'].reshape(-1)
assert_array_almost_equal(truth, img)
def step(uVals,
vVals,
thisX,
thisY,
iZ,
og_coords,
levs,
dx,
dy,
dz,
roa,
output=True):
# First find the layer average wind by finding the value of the starting point
# and the value of the point directly above
# u/v values of the current level and the level above
u0 = interp.interpolate_to_points(og_coords / dx, uVals[iZ].flatten(),
np.column_stack((thisX, thisY)) / dx)
v0 = interp.interpolate_to_points(og_coords / dy, vVals[iZ].flatten(),
np.column_stack((thisX, thisY)) / dy)
u1 = interp.interpolate_to_points(og_coords / dx, uVals[iZ + 1].flatten(),
np.column_stack((thisX, thisY)) / dx)
v1 = interp.interpolate_to_points(og_coords / dy, vVals[iZ + 1].flatten(),
np.column_stack((thisX, thisY)) / dy)
u = ((u0 + u1) / 2) * units.meter / units.second
v = ((v0 + v1) / 2) * units.meter / units.second
# Second, use that value to figure out new x and y locations
# outX = ((dz/roa)*u)+thisX
#print(dz)
#print(roa)
#print(u[0])
#print(thisX[0])
dz_roa = dz / roa
outX = ((dz_roa) * u) + thisX
print(iZ)
#print(outX.shape)
#print(((dz_roa)*u)[0])
#print()
outY = ((dz_roa) * v) + thisY
if output:
print("Layer is from " + str(levs[iZ]) + " to " + str(levs[iZ + 1]) +
".")
print("Average u component = " + str(u[0]))
print("Average v component = " + str(v[0]))
print("Average wind speed = " + str(((u[0]**2) + (v[0]**2))**.5))
print("ROA = " + str(roa))
print("dz = " + str(dz))
print("Amount of time spent in layer: " + str((dz_roa)))
print("DX = " + str(((dz_roa) * u)[0]))
print("Return X is " + str((outX[0])))
print()
return outX, outY
def test_interpolate_to_points_invalid(test_data):
"""Test that interpolate_to_points raises when given an invalid method."""
xp, yp, z = test_data
obs_points = np.vstack([xp, yp]).transpose() * 10
with get_test_data('interpolation_test_points.npz') as fobj:
test_points = np.load(fobj)['points']
with pytest.raises(ValueError):
interpolate_to_points(obs_points, z, test_points, interp_type='shouldraise')
def _interpolation(self, rbf_funct):
"""
Aqui se interpola los valores de viento (u,v) a los puntos de
rejilla usando funciones radiales. Se interpola u y v por separado.
El tipo de interpolacion radial lo define "rbf_funct". Ver "scipy.interpolate.rbf"
para mas informacion
"""
#print(self.up)
#grid_xy=None
#self.xgrid,self.ygrid,self.ugrid= grid.interpolate(self.xp, self.yp, self.up,rbf_funct,hres=0.005,search_radius=8000)
#self.xgrid,self.ygrid,self.vgrid= grid.interpolate(self.xp, self.yp, self.vp,rbf_funct,hres=0.005,search_radius=8000)
mygrid = np.array(list(zip(self.xgrid.flatten(),
self.ygrid.flatten())))
mypoints = np.array(list(zip(self.xp, self.yp)))
self.ugrid = interpolate_to_points(mypoints,
self.up,
xi=mygrid,
interp_type=rbf_funct,
search_radius=8000)
self.vgrid = interpolate_to_points(mypoints,
self.vp,
xi=mygrid,
interp_type=rbf_funct,
search_radius=8000)
#print("******************************************",self.ugrid)
#rbf_v = Rbf(self.xp, self.yp, self.vp, interp_type=rbf_funct)
#self.ugrid = rbf_u( self.xgrid.flatten(), self.ygrid.flatten() )
# self.vgrid = rbf_v( self.xgrid.flatten(), self.ygrid.flatten() )
#print("******************************************",self.vgrid.shape)
self.ugrid.shape = self.xgrid.shape
self.vgrid.shape = self.ygrid.shape
def test_interpolate_to_points(method, assume_units, test_data):
r"""Test main grid interpolation function."""
xp, yp, z = test_data
obs_points = np.vstack([xp, yp]).transpose() * 10
with get_test_data('interpolation_test_points.npz') as fobj:
test_points = np.load(fobj)['points']
if method == 'cressman':
extra_kw = {'search_radius': 200, 'minimum_neighbors': 1}
elif method == 'barnes':
extra_kw = {'search_radius': 400, 'minimum_neighbors': 1, 'gamma': 1}
else:
extra_kw = {}
with get_test_data(f'{method}_test.npz') as fobj:
truth = np.load(fobj)['img'].reshape(-1)
if assume_units:
z = units.Quantity(z, assume_units)
truth = units.Quantity(truth, assume_units)
img = interpolate_to_points(obs_points, z, test_points, interp_type=method, **extra_kw)
assert_array_almost_equal(truth, img)
y_masked,
p,
interp_type='linear',
hres=2000)
prec_p = np.ma.masked_where(np.isnan(prec_p), prec_p)
inter_point_Lon = float(input('unesite vrednost za longitudu: ' ' '))
inter_point_Lat = float(input('unesite vrednost za latitudu: ' ' '))
xy = np.vstack([lon, lat]).T
#xi = [inter_point_Lon,inter_point_Lat]
xi = ([inter_point_Lon, inter_point_Lat])
#xii = np.vstack([inter_point_Lon,inter_point_Lat]).T
inter_point = interpolate_to_points(xy, prec, xi, interp_type='linear')
#inter_point =natural_neighbor_to_points(xy,prec,xii)
print(inter_point)
proj = ccrs.PlateCarree()
#pt_x, pt_y = ccrs.Mercator().transform_points(ccrs.PlateCarree(),xp, yp)
#ovo radi
#pt_x=proj.transform_points(to_proj, yp, xp)
#create 1 colone data
back_to_lon = precx.ravel()
back_to_lat = precy.ravel()
back_to_prec = prec_p.ravel()
#r = {'lon':back_to_lon,'lat':back_to_lat,'prec':back_to_prec}
#
lon, lat = np.meshgrid(x_grid, y_grid)
lon = lon.reshape((-1, 1))
lat = lat.reshape((-1, 1))
lonlat = np.concatenate([lon, lat], axis=1)
ecpre_tmp_path = './Data/ecpre_tmp/'
stadatacell = [i for i in range(tforenum)]
for tt in range(tforenum):
print(tt)
stadata = np.full([varnum, tnum, stanums], np.nan)
for var in range(varnum):
for inx, daystr in enumerate(pstr):
filename = ecpre_tmp_path + daystr + '.npy'
try:
M = np.load(filename)
fredata = M[tt, var].reshape((-1, 1))
stadata[var, inx, :] = list(
interpolate_to_points(lonlat, fredata, xi))
except:
print(filename + ' is not exsit!')
continue
stadatacell[tt] = stadata
for tt in range(tforenum):
filepath = './Data/forecastdata_daily/' + str(tt + 1) + '/'
if not os.path.exists(filepath):
os.makedirs(filepath)
for inx, daystr in enumerate(pstr):
np.save(filepath + daystr + '.npy', stadatacell[tt][:, inx, :])
ecpre_tmp_path='./Data/ecpre_tmp/'
pstr=rangedate(startday,endday)
tnum=len(pstr)
stadatacell=[i for i in range(tforenum)]
for tt in range(tforenum):
print(tt)
stadata=np.full([varnum,tnum,stanums],np.nan)
for var in range(varnum):
for inx,daystr in enumerate(pstr):
filename=ecpre_tmp_path+daystr+'.npy'
try:
M=np.load(filename)
fredata=M[tt,var].reshape((-1,1))
stadata[var,inx,:]=list(interpolate_to_points(lonlat,fredata,xi))
except:
# print(filename+' is not exsit!')
continue
stadatacell[tt]=stadata
#
stafore2obs=[i for i in range(tforenum)]
for tt in range(tforenum):
stafore2obs[tt]=np.full([varnum,tnum+tt+1,stanums],np.nan)
foretmp=np.full([varnum,tnum+tt+1,stanums],np.nan)
foretmp[:,tt+1:,:]=stadatacell[tt]
stafore2obs[tt]=foretmp
for tt in range(tforenum):
filepath='./Data/forecastdata/'+str(tt+1)+'/'
if not os.path.exists(filepath):
def period_daily_prec(year,month,day,year1,month1,day1,lon,lat,inter):
cnx = sqlite3.connect(DB1)
cursor = cnx.cursor()
table = 'daily'
year = int(year)
year1 = int(year1)
month = int(month)
month1 = int(month1)
day = int (day)
day1 = int(day1)
a = date(year, month, day)
b = date(year1, month1, day1)
newlist = []
newlist1 = []
newlist2 = []
for dt in rrule(DAILY, dtstart=a, until=b):
i= dt.strftime("%Y-%-m-%-d")
newlist2.append(i)
query = '''
SELECT dates, cell, prec FROM %s WHERE dates = "%s" ;
''' % (table,i)
df = pd.read_sql_query(query, cnx)
tacka = '''SELECT id, lon, lat,country,altitude FROM %s;''' % 'grid1'
grid1 = pd.read_sql_query(tacka, cnx)
lon_n = grid1['lon'].values
lat_n = grid1['lat'].values
prec = df['prec'].values
x_masked, y_masked, prec_p = remove_nan_observations(lon_n, lat_n, prec)
lon = float(lon)
lat =float(lat)
xy = np.vstack([x_masked,y_masked]).T
xi = np.vstack([lon,lat]).T
if inter == "linear":
inter_point = interpolate_to_points(xy,prec_p,xi, interp_type='linear')
elif inter == "cressman":
inter_point =interpolate_to_points(xy,prec_p,xi, interp_type='cressman', minimum_neighbors=3,
gamma=0.25, kappa_star=5.052, search_radius=None, rbf_func='linear',
rbf_smooth=0)
elif inter == "barnes":
inter_point =interpolate_to_points(xy,prec_p,xi, interp_type='cressman', minimum_neighbors=3,
gamma=0.25, kappa_star=5.052, search_radius=None, rbf_func='linear',
rbf_smooth=0)
for y in inter_point:
newlist.append(y)
for z in xi:
newlist1.append(z)
xi =str(xi)
newlist_fix = [str(a) for a in newlist]
d = {'Year-Month-Day':newlist2,'Lon&Lat':newlist1, 'Rainfall':newlist}
df = pd.DataFrame(d)
return (df)
def period_month_temp(year,month,year1,month1,lon,lat,inter):
cnx = sqlite3.connect(DB)
cursor = cnx.cursor()
table = 'monthly'
year = int(year)
year1 = int(year1)
month = int(month)
month1 = int(month1)
a=[]
for m in month_iter(year,month,year1,month1):
temp_m = list(filter(lambda x: x != None, m))
result = '-'.join(list(map(str, temp_m)))
a.append(result)
newlist = []
newlist1 = []
newlist2 = []
for i in a:
newlist2.append(i)
query = '''
SELECT dates, cell, temp FROM %s WHERE dates = "%s" ;
''' % (table,i)
df = pd.read_sql_query(query, cnx)
tacka = '''SELECT id, lon, lat,country,altitude FROM %s;''' % 'grid'
grid = pd.read_sql_query(tacka, cnx)
lon_n = grid['lon'].values
lat_n = grid['lat'].values
temp = df['temp'].values
x_masked, y_masked, temp_p = remove_nan_observations(lon_n, lat_n, temp)
lon = float(lon)
lat =float(lat)
xy = np.vstack([x_masked,y_masked]).T
xi = np.vstack([lon,lat]).T
if inter == "linear":
inter_point = interpolate_to_points(xy,temp_p,xi, interp_type='linear')
elif inter == "cressman":
inter_point =interpolate_to_points(xy,temp_p,xi, interp_type='cressman', minimum_neighbors=3,
gamma=0.25, kappa_star=5.052, search_radius=None, rbf_func='linear',
rbf_smooth=0)
elif inter == "barnes":
inter_point =interpolate_to_points(xy,temp_p,xi, interp_type='cressman', minimum_neighbors=3,
gamma=0.25, kappa_star=5.052, search_radius=None, rbf_func='linear',
rbf_smooth=0)
for y in inter_point:
newlist.append(y)
for z in xi:
newlist1.append(z)
xi=str(xi)
newlist_fix = [str(a) for a in newlist]
d = {'Year-Month':newlist2,'Lon&Lat':newlist1,'Temperature':newlist_fix}
df = pd.DataFrame(d)
return (df)
def period_year_temp(year,year1,lon,lat,inter):
cnx = sqlite3.connect(DB)
cursor = cnx.cursor()
table = 'yearly'
year = int(year)
year1 = int(year1)
newlist = []
newlist1 = []
newlist2 = []
for i in range (year,year1+1,1):
newlist2.append(i)
query = '''
SELECT dates, cell, temp FROM %s WHERE dates = "%s" ;
''' % (table, i)
df = pd.read_sql_query(query, cnx)
tacka = '''SELECT id, lon, lat,country,altitude FROM %s;''' % 'grid'
grid = pd.read_sql_query(tacka, cnx)
podaci = pd.merge(df,grid,left_on='cell',right_on='id')
podaci_a = podaci.drop(['cell','id','country','altitude'],axis=1)
lon_n = podaci_a['lon'].values
lat_n = podaci_a['lat'].values
temp =podaci_a['temp'].values
x_masked, y_masked, temp_p = remove_nan_observations(lon_n, lat_n, temp)
lon = float(lon)
lat =float(lat)
xy = np.vstack([x_masked,y_masked]).T
xi = np.vstack([lon,lat]).T
if inter == "linear":
inter_point = interpolate_to_points(xy,temp_p,xi, interp_type='linear')
elif inter == "cressman":
inter_point =interpolate_to_points(xy,temp_p,xi, interp_type='cressman', minimum_neighbors=3,
gamma=0.25, kappa_star=5.052, search_radius=None, rbf_func='linear',
rbf_smooth=0)
elif inter == "barnes":
inter_point =interpolate_to_points(xy,temp_p,xi, interp_type='cressman', minimum_neighbors=3,
gamma=0.25, kappa_star=5.052, search_radius=None, rbf_func='linear',
rbf_smooth=0)
for y in inter_point:
newlist.append(y)
for z in xi:
newlist1.append(z)
xi= str(xi)
newlist_fix = [str(a) for a in newlist]
d = {'Year':newlist2,'Lon&Lat':newlist1,'Temperature':newlist_fix}
df = pd.DataFrame(d)
return (df)
def period_year_prec(year,year1,lon,lat,inter):
cnx = sqlite3.connect(DB1)
cursor = cnx.cursor()
table = 'yearly'
year = int(year)
year1 = int(year1)
newlist = []
newlist1 = []
newlist2 = []
for i in range (year,year1+1,1):
newlist2.append(i)
query = '''
SELECT dates, cell, prec FROM %s WHERE dates = "%s" ;
''' % (table, i)
df = pd.read_sql_query(query, cnx)
tacka = '''SELECT id, lon, lat,country,altitude FROM %s;''' % 'grid1'
grid1 = pd.read_sql_query(tacka, cnx)
lon_n = grid1['lon'].values
lat_n = grid1['lat'].values
prec = df['prec'].values
x_masked, y_masked, prec_p = remove_nan_observations(lon_n, lat_n, prec)
lon = float(lon)
lat = float(lat)
xy = np.vstack([x_masked,y_masked]).T
xi = np.vstack([lon,lat]).T
if inter == "linear":
inter_point = interpolate_to_points(xy,prec_p,xi, interp_type='linear')
elif inter == "cressman":
inter_point =interpolate_to_points(xy,prec_p,xi, interp_type='cressman', minimum_neighbors=3,
gamma=0.25, kappa_star=5.052, search_radius=None, rbf_func='linear',
)
elif inter == "barnes":
inter_point =interpolate_to_points(xy,prec_p,xi, interp_type='cressman', minimum_neighbors=3,
gamma=0.25, kappa_star=5.052, search_radius=None, rbf_func='linear',
)
for y in inter_point:
newlist.append(y)
for z in xi:
newlist1.append(z)
xi= str(xi)
newlist_fix = [str(a) for a in newlist]
#sarr1 = [str(a) for a in newlist1]
d = {'Year':newlist2,'Lon&Lat':newlist1, 'Rainfall':newlist}
#d = {'Year':newlist2,'Rainfall':newlist_fix}
df = pd.DataFrame(d)
return (df)
