def __get_subdomain(self, Nlim, Elim, Slim, Wlim, overwrite=False):
"""
This has now been moved to superclass Obs.
Return data array between bounds
If overwrite is True, replace class data with new subdomain
"""
data, lats, lons = utils.return_subdomain(self.data, self.lats,
self.lons, Nlim, Elim, Slim,
Wlim)
if overwrite:
self.lats = lats
self.lons = lons
self.data = data
return
else:
return data, lats, lons
def get_subdomain(self,Nlim,Elim,Slim,Wlim,data='self',overwrite=False):
"""
Return data array between bounds
If overwrite is True, replace class data with new subdomain
"""
if data == 'self':
data = self.data
data,lats,lons = utils.return_subdomain(data,self.lats,
self.lons,Nlim,Elim,Slim,Wlim)
if overwrite:
self.lats = lats
self.lons = lons
self.data = data
return
else:
return data,lats,lons
def cut(self,data,grid=None,lats=None,lons=None,return_grid=False):
""" Trim data provided to current grid.
Note:
User specifies grid or lat/lons.
"""
data = utils.enforce_2d(data)
ld = self.get_limits()
if lats is None:
old_lats = grid.lats
old_lons = grid.lons
else:
old_lats = lats
old_lons = lons
cut_data, cut_lats, cut_lons = utils.return_subdomain(
data=data,lats=old_lats,lons=old_lons,**ld)
# import mpl_toolkits.basemap
# cut_data = mpl_toolkits.basemap.interp(datain=data,xin=old_lons,
# yin=old_lats,xout=self.lons,yout=self.lats,
# checkbounds=True,)
# pdb.set_trace()
if return_grid:
newgrid = Grid(lats=cut_lats,lons=cut_lons)
return cut_data, newgrid
return cut_data, cut_lats, cut_lons
def interpolate(
dataA,
latsA,
lonsA,
latsB,
lonsB,
cut_only=False,
# cut_first=True,
# remove_negative=False,
save_to_fpath=None):
""" Interpolate data on gridA to gridB.
If cut_first, if gridA is a lot bigger (e.g., StageIV data), cut it to
a smaller size to improve interpolation efficiency.
"""
cut_first = True
if isinstance(dataA, str):
dataA = N.load(dataA)
if isinstance(latsA, str):
latsA = N.load(latsA)
lonsA = N.load(lonsA)
if isinstance(latsB, str):
latsB = N.load(latsB)
lonsB = N.load(lonsB)
assert latsA.ndim == 2
assert latsB.ndim == 2
# pdb.set_trace()
if cut_only:
assert dataA is not None
dataB, _latsB, _lonsB = utils.return_subdomain(dataA,
latsA,
lonsA,
cut_to_lats=latsB,
cut_to_lons=lonsB)
else:
if cut_first:
_dataA = N.copy(dataA)
_latsA = N.copy(latsA)
_lonsA = N.copy(lonsA)
Nlim = N.max(latsB) + 0.5
Elim = N.max(lonsB) + 0.5
Slim = N.min(latsB) - 0.5
Wlim = N.min(lonsB) - 0.5
Nidx = closest(latsA[:, 0], Nlim)
Eidx = closest(lonsA[0, :], Elim)
Sidx = closest(latsA[:, 0], Slim)
Widx = closest(lonsA[0, :], Wlim)
old_method = False
if old_method:
s1 = slice(Sidx, Nidx + 1)
s2 = slice(Widx, Eidx + 1)
dataA = dataA[s1, s2]
latsA = latsA[s1, s2]
lonsA = lonsA[s1, s2]
else:
dataA = dataA[Sidx:Nidx + 1, Widx:Eidx + 1]
latsA = latsA[Sidx:Nidx + 1, Widx:Eidx + 1]
lonsA = lonsA[Sidx:Nidx + 1, Widx:Eidx + 1]
# if "mrms" in save_to_fpath:
# pdb.set_trace()
bmap = create_bmap()
xxA, yyA = bmap(lonsA, latsA)
xxB, yyB = bmap(lonsB, latsB)
xdB = len(xxB[:, 0])
ydB = len(yyB[0, :])
# if "nexrad" in save_to_fpath:
# if "mrms" in save_to_fpath:
dataA = N.copy(dataA)
xxA = N.copy(xxA)
yyA = N.copy(yyA)
xxB = N.copy(xxB)
yyB = N.copy(yyB)
dataB = scipy.interpolate.griddata(points=(xxA.flat, yyA.flat),
values=dataA.flat,
xi=(xxB.flat, yyB.flat),
method='linear').reshape(xdB, ydB)
# if "mrms" in save_to_fpath:
# pdb.set_trace()
if save_to_fpath is not None:
utils.trycreate(save_to_fpath, debug=False)
_save(arr=dataB, file=save_to_fpath)
print("Saved to", save_to_fpath)
return
return dataB
d01_3km_latf, d01_3km_lonf = get_llf_fpath(casestr, "d01_3km")
if os.path.exists(d01_3km_latf):
# neutral_lats = N.load(neutral_latf)
# neutral_lons = N.load(neutral_lonf)
pass
else:
d01_latf, d01_lonf = get_llf_fpath(casestr, "d01_raw")
d02_latf, d02_lonf = get_llf_fpath(casestr, "d02_raw")
d01_lats = N.load(d01_latf)
d01_lons = N.load(d01_lonf)
d02_lats = N.load(d02_latf)
d02_lons = N.load(d02_lonf)
# new_lats,new_lons = interpolate(None,d01_lats,d01_lons,d02_lats,d02_lons,cut_only=True)
new_lats, new_lons = utils.return_subdomain(None,
d01_lats,
d01_lons,
cut_to_lats=d02_lats,
cut_to_lons=d02_lons)
#new_lats,new_lons = utils.return_subdomain(data=None,lats=d01_lats,
# lons=d01_lons,cut_to_lats=d02_lats,
# cut_to_lons=d02_lons)
utils.trycreate(d01_3km_latf, debug=False)
_save(arr=new_lats, file=d01_3km_latf)
_save(arr=new_lons, file=d01_3km_lonf)
# pdb.set_trace()
# Now the grids are there!
# Time to interpolate!
# This is a list of lists of arguments to send to interpolate().