def make_blk_wrf(wrfpath, grd, bulk, date0=False, date1=False, **kargs):
'''
see make_blk_interim
'''
quiet = kargs.get('quiet', 0)
create = kargs.get('create', 1)
model = kargs.get('model', 'roms') # or roms-agrif
wrffiles = kargs.get('wrffiles', 'wrfout*')
dt = kargs.get('dt', 6)
proj = kargs.get('proj', 'auto')
data = load_blkdata_wrf(wrfpath, wrffiles, date0, date1, quiet)
if not len(data): return
g = roms.Grid(grd)
if proj == 'auto': kargs['proj'] = g.get_projection()
q = gennc.GenBlk(bulk, grd, **kargs)
if create:
# about original data, run data2romsblk once to test for x_original:
tmp = data2romsblk(data[list(data.keys())[0]], g, **kargs)
if 'x_original' in tmp: original = tmp['x_original'].shape
else: original = False
q.create(model, original)
for d in data:
# be sure time increases. Note that in load_blkdata_wrf
# we checked if time increases in the dataset... not if dates are higher
# then previous dates in file
ntimes = netcdf.fdim(bulk, 'time')
if ntimes:
tin = netcdf.nctime(bulk, 'time')
if tin.size and (d - tin[-1]) < datetime.timedelta(hours=dt - 0.1):
print('-> not including %s' % d.isoformat())
continue
if model == 'roms':
if not quiet: print(' converting units:'),
conv_units(data[d], model, quiet)
D = data2romsblk(data[d], g, **kargs)
D['date'] = d
if not quiet: print(' =>filling date=%s' % d.isoformat(' '))
q.fill(D, quiet=quiet)
def make_blk_interim(interimpath,
grd,
bulk,
date0=False,
date1=False,
**kargs):
'''
kargs:
tunits, ex: 'seconds since yyyy-mm-dd'
quiet
create
model, 'roms' or 'roms-agrif'
title
keeporiginal, save original data in nc file
margin, for original data to be saved)
proj, use a map projection for the interpolations (grid default proj is used if auto)
attr, additional global arguments, ex: attr={'some_info': 'abc','what': 123}
past, use True for old data server data, default False
...
'''
quiet = kargs.get('quiet', 0)
create = kargs.get('create', 1)
model = kargs.get('model', 'roms') # or roms-agrif
past = kargs.get('past', False) # use True for old data server data
proj = kargs.get('proj', 'auto')
data = load_blkdata_interim(interimpath, date0, date1, quiet, past)
g = roms.Grid(grd)
if proj == 'auto': kargs['proj'] = g.get_projection()
# about original data, run data2romsblk once to test for x_original:
tmp = data2romsblk(data[list(data.keys())[0]], g, **kargs)
if 'x_original' in tmp: original = tmp['x_original'].shape
else: original = False
q = gennc.GenBlk(bulk, grd, **kargs)
if create: q.create(model, original)
for d in data:
if model == 'roms':
if not quiet: print(' converting units:'),
conv_units(data[d], model, quiet)
D = data2romsblk(data[d], g, **kargs)
D['date'] = d
if not quiet: print(' =>filling date=%s' % d.isoformat(' '))
q.fill(D, quiet=quiet)
def make_blk_narr(grd, bulk, date0, date1=False, **kargs):
'''
see make_blk_interim
ps: to not include original data in file, use kargg keepor=False
'''
quiet = kargs.get('quiet', 0)
create = kargs.get('create', 1)
model = kargs.get('model', 'roms') # or roms-agrif
proj = kargs.get('proj', 'auto')
data, miss = load_blkdata_narr(date0, date1, quiet=quiet)
g = roms.Grid(grd)
if proj == 'auto': kargs['proj'] = g.get_projection()
# about original data, run data2romsblk once to test for x_original:
tmp = data2romsblk(data[list(data.keys())[0]], g, **kargs)
if 'x_original' in tmp: original = tmp['x_original'].shape
else: original = False
# add narr INFO to file global attributes:
if 'attr' not in kargs: kargs['attr'] = {}
try:
s = ''
for k in data:
s += ' # ' + k.isoformat(
' ') + ' ' + data[k]['INFO_file'] + ' isbest ' + str(
data[k]['INFO_isbest'])
kargs['attr']['sources'] = s
except:
pass
# common to interim----------------------
q = gennc.GenBlk(bulk, grd, **kargs)
if create: q.create(model, original)
for d in data:
if model == 'roms':
if not quiet: print(' converting units:'),
conv_units(data[d], model, quiet)
D = data2romsblk(data[d], g, **kargs)
D['date'] = d
if not quiet: print(' =>filling date=%s' % d.isoformat(' '))
q.fill(D, quiet=quiet)
def make_blk_cordex(cordexClim, grd, bulk, date0=False, date1=False, **kargs):
'''
see make_blk_interim
ps: to not include original data in file, use karg keepor=False
'''
quiet = kargs.get('quiet', 0)
create = kargs.get('create', 1)
model = kargs.get('model', 'roms') # or roms-agrif
proj = kargs.get('proj', 'auto')
kargs['margin'] = 'no calc' # no need to extract a portion of the domain;
# may be slow and is already done in cordex.py
# besides, no need to do also for all variables as they share
# the same domain
data = load_blkdata_cordex(
cordexClim, date0, date1, quiet,
grd) # unique diff from make_blk_cordex/interim !!
# grd is provided to extract just a portion of cordex domain, otherwise there is a memory error
g = roms.Grid(grd)
if proj == 'auto': kargs['proj'] = g.get_projection()
# about original data, run data2romsblk once to test for x_original:
tmp = data2romsblk(data[list(data.keys())[0]], g, **kargs)
if 'x_original' in tmp: original = tmp['x_original'].shape
else: original = False
q = gennc.GenBlk(bulk, grd, **kargs)
if create: q.create(model, original)
for d in data:
if model == 'roms':
if not quiet: print(' converting units:'),
conv_units(data[d], model, quiet)
D = data2romsblk(data[d], g, **kargs)
D['date'] = d
if not quiet: print(' =>filling date=%s' % d.isoformat(' '))
q.fill(D, quiet=quiet)
def make_blk_era5(datapath, grd, bulk, date0=False, date1=False, **kargs):
'''
see make_blk_interim
ps: to not include original data in file, use karg keepor=False
'''
quiet = kargs.get('quiet', 0)
create = kargs.get('create', 1)
model = kargs.get('model', 'roms') # or roms-agrif
proj = kargs.get('proj', 'auto')
data = load_blkdata_era5(datapath, date0, date1, quiet)
g = roms.Grid(grd)
if proj == 'auto': kargs['proj'] = g.get_projection()
# about original data, run data2romsblk once to test for x_original:
tmp = data2romsblk(list(data.values())[0], g, **kargs)
if 'x_original' in tmp: original = tmp['x_original'].shape
else: original = False
# about wind speed and stress:
wspeed = 'wspd' in list(data.values())[0]
wstress = 'sustr' in list(data.values())[0]
q = gennc.GenBlk(bulk, grd, **kargs)
if create:
q.create(model=model,
original=original,
wspeed=wspeed,
wstress=wstress)
for d in data:
if model == 'roms':
if not quiet: print(' converting units:'),
conv_units(data[d], model, quiet)
D = data2romsblk(data[d], g, **kargs)
D['date'] = d
if not quiet: print(' =>filling date=%s' % d.isoformat(' '))
q.fill(D, quiet=quiet)
def make_blk_cfsr(cfsrpath, grd, bulk, date0=False, date1=False, **kargs):
'''
see make_blk_interim
ps: to not include original data in file, use karg keepor=False
'''
quiet = kargs.get('quiet', 0)
create = kargs.get('create', 1)
model = kargs.get('model', 'roms') # or roms-agrif
proj = kargs.get('proj', 'auto')
data = load_blkdata_cfsr(cfsrpath, date0, date1,
quiet) # unique diff from make_blk_interim !!
g = roms.Grid(grd)
if proj == 'auto': kargs['proj'] = g.get_projection()
# about original data, run data2romsblk once to test for x_original:
tmp = data2romsblk(data[list(data.keys())[0]], g, **kargs)
if 'x_original' in tmp: original = tmp['x_original'].shape
else: original = False
q = gennc.GenBlk(bulk, grd, **kargs)
if create: q.create(model, original)
for d in data:
if model == 'roms':
if not quiet: print(' converting units:'),
conv_units(data[d], model, quiet)
D = data2romsblk(data[d], g, **kargs)
D['date'] = d
if not quiet: print(' =>filling date=%s' % d.isoformat(' '))
q.fill(D, quiet=quiet)
def roms2roms(f0,grd,sparams,tind=0,**kargs):
'''
tind: ind or datetime
**kargs:
grd0
sparams0
tunits0
quiet
'''
grd0 = False
sparams0 = False
quiet = False
tunits0 = False
Z='auto'
ij='i'
for k in kargs.keys():
if k=='grd0': grd0 = kargs[k]
elif k=='sparams0': sparams0 = kargs['sparams0']
elif k=='quiet': quiet = kargs['quiet']
elif k=='tunits0': tunits0 = kargs['tunits0']
elif k=='Z': Z = kargs['Z']
elif k=='ij': ij = kargs['ij']
r0=roms.His(f0,grd=grd0)
g0=r0.grid
g1=roms.Grid(grd)
if sparams0 is False: sparams0=r0.s_params
# load data:
F0={}
for i in ('temp','salt','u','v','ssh','time','misc'): F0[i]=f0
F0['xy']=g0.name
if tind=='all':
times=range(r0.TIME)
else: times=[tind]
xlim=g1.lon.min(),g1.lon.max()
ylim=g1.lat.min(),g1.lat.max()
inds={}
outdata={}
outdatab={}
for tind in times:
inds[sett.tdim]=tind
data,msg=prognostic.load_data(F0,quiet=quiet,settings=sett,inds=inds,t_units=tunits0)
# z3d:
data['z3d']=r0.s_levels(tind)
# u,v at rho:
print ' u,v at rho ...'
u=np.ma.zeros((data['NZ'],data['NY'],data['NX']),data['u'].dtype)
v=np.ma.zeros((data['NZ'],data['NY'],data['NX']),data['v'].dtype)
u[:,:,1:-1]=(data['u'][:,:,:-1]+data['u'][:,:,1:])/2.
u[:,:,0]=data['u'][:,:,0]
u[:,:,-1]=data['u'][:,:,-1]
v[:,1:-1,:]=(data['v'][:,:-1,:]+data['v'][:,1:,:])/2.
v[:,0,:]=data['v'][:,0,:]
v[:,-1,:]=data['v'][:,-1,:]
print 'rot 2d from original grid'
for k in range(v.shape[0]):
u[k],v[k]=calc.rot2d(u[k],v[k],-g0.angle)
data['u']=u
data['v']=v
# simplify data:
print ' simplify data...'
i0,i1,j0,j1=calc.ij_limits(g0.lon,g0.lat,xlim,ylim,margin=3)
for v in 'z3d','temp','salt','u','v': data[v]=data[v][:,j0:j1,i0:i1]
for v in 'ssh','lon','lat': data[v]=data[v][j0:j1,i0:i1]
data['NZ'],data['NY'],data['NX']=data['temp'].shape
# interp depths:
if Z is 'auto':
h=-g0.h
Z=np.concatenate((np.arange(data['ssh'].max(),-2,-.05),np.arange(-2,-5,.2),np.arange(-5,-20,-1),np.arange(-20,-100,-2),
np.arange(-100,-500,-5),np.arange(-500,-1000,-20),np.arange(-1000,h.min()-100,-100)))
Z=Z[::3]
if Z[-1]>h.min(): Z[-1]=h.min()
data['depth']=Z
for v in 'temp','salt','u','v','ssh':
print ' %-6s %6.3f %6.3f'%(v,data[v].min(), data[v].max())
# to z levels:
Data=prognostic.data2z(data,quiet=quiet,ij=ij)
for v in 'temp','salt','u','v','ssh':
print ' %-6s %6.3f %6.3f'%(v,Data[v].min(), Data[v].max())
# clm:
data,HA=prognostic.data2roms(Data,grd,sparams,quiet=quiet,horizAux=True,ij=ij)
for v in 'temp','salt','u','v','zeta':
print ' %-6s %6.3f %6.3f'%(v,data[v].min(), data[v].max())
# bry:
datab=prognostic.data2romsbry(Data,grd,sparams,quiet=quiet,horizAux=HA)
outdata[tind] = data
outdatab[tind] = datab
if len(times)==1: return outdata[tind],outdatab[tind]
else: return outdata,outdatab
def update_wind(fname, data, new_wind_info, **kargs):
'''
new_wind_info will be added to fname as global attribute
(ex: 'new wind from database xxx')
'''
quiet = False
Margin = 4 # for griddata and for original data to keep
grd = False
keepOriginal = 2
for k in kargs.keys():
if k == 'quiet': quiet = kargs[k]
elif k == 'margin': Margin = kargs[k]
elif k == 'grid': grd = kargs[k]
elif k.lower().startswith('keepor'): keepOriginal = kargs[k]
if not grd: grd = netcdf.fatt(fname, 'grd_file')
g = roms.Grid(grd)
x0 = data['x']
y0 = data['y']
if x0.ndim == 1: x0, y0 = np.meshgrid(x0, y0)
dates = data.keys()[:]
dates.remove('x')
dates.remove('y')
dates = np.array(dates)
# interp in time:
time = netcdf.nctime(fname, 'time')
cond = False
tind = -1
fob = gennc.GenBlk(fname, grd)
for t in time:
newWind = {}
tind += 1
I, = np.where(dates == t)
if I.size:
I = I[0]
uv = data[dates[I]]
if not quiet: print(t, dates[I])
else:
i1, = np.where(dates > t)
i0, = np.where(dates < t)
if i0.size and i1.size:
i1 = i1[0]
i0 = i0[-1]
d0 = t - dates[i0]
d1 = dates[i1] - t
d0 = d0.days + d0.seconds / 86400.
d1 = d1.days + d1.seconds / 86400.
uv = (data[dates[i0]] * d1 + data[dates[i1]] * d0) / (d0 + d1)
if not quiet: print(t, dates[i0], dates[i1], d0, d1)
elif not i1.size:
uv = data[dates[-1]]
if not quiet: print(t, dates[-1])
elif not i0.size:
uv = data[dates[0]]
if not quiet: print(t, dates[0])
# interp to grid:
if cond is False:
cond, inds = rt.grid_vicinity(grd,
x0,
y0,
margin=Margin,
rect=True,
retinds=True)
i1, i2, j1, j2 = inds
if not quiet: print(' --> inter uv %s' % t.isoformat(' '))
u = calc.griddata(x0[cond],
y0[cond],
uv.real[cond],
g.lon,
g.lat,
extrap=True)
v = calc.griddata(x0[cond],
y0[cond],
uv.imag[cond],
g.lon,
g.lat,
extrap=True)
# rotate wind, calc stress:
if not quiet: print(' --> rot U,V wind and U,V wind stress')
wspd = np.sqrt(u**2 + v**2)
sustr, svstr = air_sea.wind_stress(u, v)
angle = g.use('angle')
uwnd, vwnd = calc.rot2d(u, v, angle)
sustr, svstr = calc.rot2d(sustr, svstr, angle)
sustr = rt.rho2uvp(sustr, 'u')
svstr = rt.rho2uvp(svstr, 'v')
# update wind data:
newWind['date'] = t
newWind['uwnd'] = uwnd
newWind['vwnd'] = vwnd
newWind['sustr'] = sustr
newWind['svstr'] = svstr
newWind['wspd'] = wspd
# original xy:
if tind == 0:
newWind['attr'] = {'new_wind_info': new_wind_info}
if not quiet: print(' --> original xy')
if keepOriginal == 1:
newWind['x_wind'] = x0
newWind['y_wind'] = y0
elif keepOriginal == 2:
newWind['x_wind'] = x0[j1:j2, i1:i2]
newWind['y_wind'] = y0[j1:j2, i1:i2]
# add to file:
if not quiet: print(' --> adding to file')
fob.update_wind(newWind, quiet=quiet)
if not quiet: print('')
def data2romsblk(data, grd, **kargs):
quiet = kargs.get('quiet', True)
Margin = kargs.get('margin',
4) # for griddata and for original data to keep
# if margin is 'no calc', no extraction of
# a domain portion is done
# about projection:
# - if auto will use grid default projection
# - if False, no projection is used
# - any Basemap projection can be used
proj = kargs.get('proj', 'auto')
# about origina data to keep:
# - if 2, will keep data only inside rt.grid_vicinity rectange
# - if 1, all original data is kept
keepOriginal = 2
for k in kargs:
if k.lower().startswith('keepor'): keepOriginal = kargs[k]
if cb.isstr(grd): g = roms.Grid(grd)
else: g = grd
if proj == 'auto': proj = g.get_projection()
if proj:
data_x, data_y = proj(data['x'], data['y'])
grd_x, grd_y = proj(g.lon, g.lat)
else:
data_x, data_y = data['x'], data['y']
grd_x, grd_y = g.lon, g.lat
cond = False
out = {}
for vname in data:
if vname.startswith('INFO') or vname in 'xy': continue
# vnames starting with INFO are an info key, without data
if not quiet: print(' interp %s' % vname)
if cond is False:
if Margin == 'no calc':
cond = np.ones_like(data['x'], 'bool')
i1, i1 = 0, 0
j2, i2 = data['x'].shape
else:
cond, inds = rt.grid_vicinity(grd,
data['x'],
data['y'],
margin=Margin,
rect=True,
retinds=True)
i1, i2, j1, j2 = inds
out[vname] = calc.griddata(data_x[cond],
data_y[cond],
data[vname][cond],
grd_x,
grd_y,
extrap=True)
if keepOriginal:
# keep original data:
if keepOriginal == 1:
out[vname +
'_original'] = data[vname] # keep all original data
elif keepOriginal == 2:
out[vname + '_original'] = data[vname][
j1:j2, i1:i2] # keep data only inside vicinity rectangle
if 'x_original' not in out:
if keepOriginal == 1:
out['x_original'] = data['x']
out['y_original'] = data['y']
elif keepOriginal == 2:
out['x_original'] = data['x'][j1:j2, i1:i2]
out['y_original'] = data['y'][j1:j2, i1:i2]
# about wind:
if not quiet: print(' --> rot U,V wind and U,V wind stress')
out['uwnd'], out['vwnd'] = calc.rot2d(out['uwnd'], out['vwnd'], g.angle)
out['sustr'], out['svstr'] = calc.rot2d(out['sustr'], out['svstr'],
g.angle)
out['sustr'] = rt.rho2uvp(out['sustr'], 'u')
out['svstr'] = rt.rho2uvp(out['svstr'], 'v')
return out
def data2romsblk(data, grd, **kargs):
quiet = True
keepOriginal = 2 # if 2, will keep data only inside rt.grid_vicinity rectange
# if 1, all original data is kept
Margin = 4 # for griddata and for original data to keep
for k in kargs.keys():
if k == 'quiet': quiet = kargs[k]
elif k.lower().startswith('keepor'): keepOriginal = kargs[k]
elif k == 'margin': Margin = kargs[k]
g = roms.Grid(grd)
cond = False
out = {}
for vname in data.keys():
if vname.startswith('INFO') or vname in 'xy': continue
# vnames starting with INFO are an info key, without data
if not quiet: print(' interp %s' % vname)
if cond is False:
cond, inds = rt.grid_vicinity(grd,
data['x'],
data['y'],
margin=Margin,
rect=True,
retinds=True)
i1, i2, j1, j2 = inds
out[vname] = calc.griddata(data['x'][cond],
data['y'][cond],
data[vname][cond],
g.lon,
g.lat,
extrap=True)
if keepOriginal:
# keep original data:
if keepOriginal == 1:
out[vname +
'_original'] = data[vname] # keep all original data
elif keepOriginal == 2:
out[vname + '_original'] = data[vname][
j1:j2, i1:i2] # keep data only inside vicinity rectangle
if not out.has_key('x_original'):
if keepOriginal == 1:
out['x_original'] = data['x']
out['y_original'] = data['y']
elif keepOriginal == 2:
out['x_original'] = data['x'][j1:j2, i1:i2]
out['y_original'] = data['y'][j1:j2, i1:i2]
# about wind:
if not quiet: print(' --> rot U,V wind and U,V wind stress')
angle = g.use('angle')
out['uwnd'], out['vwnd'] = calc.rot2d(out['uwnd'], out['vwnd'], angle)
out['sustr'], out['svstr'] = calc.rot2d(out['sustr'], out['svstr'], angle)
out['sustr'] = rt.rho2uvp(out['sustr'], 'u')
out['svstr'] = rt.rho2uvp(out['svstr'], 'v')
return out
def data2roms(data, grd, sparams, **kargs):
'''
Interpolates data to roms 3D grid.
The dict data must contain the prognostic variables temp, salt, u,
v (3d) and ssh (zeta, 2d), as well as lon, lat (2d), depth (1d) and
time/date info: date (data date), date0 (reference date) and time
(difference between date and date0). The input data can be provided
by load_data.
Parameters
----------
data : dict with prognostic variables
grd : ROMS netcdf grid file
sparams : s-coordinates parameters, theta_s,theta_b, hc and NLevels
**kargs:
ij : axis for vertical interpolations (*i,j)
ij_ind : list of i or j index for vertical interpolation, all by
default (ij_ind=False)
horizAux : if True, the original data horizontally interpolated is
returned and can be used for next data2roms call with
this same karg
quiet : output messages flag (false by default)
proj : projection - False, name or basemap proj - lcc by default
if False, horizontal interpolations will use lonxlat instead of distances
interp_opts: options for griddata
rep_surf: repeat surface level (new upper level)
'''
ij = kargs.get('ij', 'j')
ij_ind = kargs.get('ij_ind', False)
horizAux = kargs.get('horizAux', False)
quiet = kargs.get('quiet', False)
proj = kargs.get('proj', 'lcc') # lonxlat to distance before
# horizontal interpolation
interp_opts = kargs.get('interp_opts', {})
rep_surf = kargs.get('rep_surf', True) # create a surface upper level
# before interpolation
if not quiet: print 'using grid %s' % grd
g = roms.Grid(grd)
xr, yr, hr, mr = g.vars('r')
xu, yu, hu, mu = g.vars('u')
xv, yv, hv, mv = g.vars('v')
ny, nx = hr.shape
nz = sparams[3]
if proj:
print 'projecting coordinates...'
if isinstance(proj, basestring):
lonc = (xr.max() + xr.min()) / 2.
latc = (yr.max() + yr.min()) / 2.
from mpl_toolkits.basemap import Basemap
proj = Basemap(projection=proj,
width=1,
height=1,
resolution=None,
lon_0=lonc,
lat_0=latc,
lat_1=latc)
xr, yr = proj(xr, yr)
xu, yu = proj(xu, yu)
xv, yv = proj(xv, yv)
dlon, dlat = proj(data['lon'], data['lat'])
Rdz = 1 / 100. # distance to depth ratio (300km vs 3000m)
distance = lambda x, y: np.append(
0.,
np.sqrt(np.diff(x)**2 + np.diff(y)**2).cumsum())
else:
dlon, dlat = data['lon'], data['lat']
distance = calc.distance
# needed for s_levels and for rep_surf!
sshr = calc.griddata(dlon,
dlat,
data['ssh'],
xr,
yr,
extrap=True,
**interp_opts)
# repeat surface:
if rep_surf:
# copy data cos dont want to change the original dataset:
import copy
data = copy.deepcopy(data)
for vname in ['temp', 'salt', 'u', 'v', 'depth']:
if data[vname].ndim == 1: # depth !
if np.ma.isMA(data[vname]): vstack = np.ma.hstack
else: vstack = np.hstack
else:
if np.ma.isMA(data[vname]): vstack = np.ma.vstack
else: vstack = np.vstack
if data['depth'][0] > data['depth'][1]: # surf at ind 0
data[vname] = vstack((data[vname][0][np.newaxis], data[vname]))
if vname == 'depth': data[vname][0] = sshr.max()
else:
data[vname] = vstack(
(data[vname], data[vname][-1][np.newaxis]))
if vname == 'depth': data[vname][-1] = sshr.max()
data['NZ'] = data['NZ'] + 1
NX = data['NX']
NY = data['NY']
NZ = data['NZ']
if not quiet: print 'calc s levels...'
Zr = g.s_levels(sparams, sshr, hr, 'r')
Zu = g.s_levels(sparams, sshr, hr, 'u')
Zv = g.s_levels(sparams, sshr, hr, 'v')
# interp horiz:
retHorizAux = horizAux is True
if horizAux in (True, False):
TEMP = np.ma.masked_all((NZ, ny, nx), data['temp'].dtype)
SALT = np.ma.masked_all((NZ, ny, nx), data['salt'].dtype)
U = np.ma.masked_all((NZ, ny, nx), data['u'].dtype)
V = np.ma.masked_all((NZ, ny, nx), data['v'].dtype)
if not quiet: print 'horizontal interpolation:'
for i in range(NZ):
if not quiet and i % 10 == 0: print ' lev %d of %d' % (i, NZ)
#import pylab
#pylab.figure()
#pylab.pcolormesh(data['lon'],data['lat'],data['temp'][i,...])
try:
TEMP[i, ...] = calc.griddata(dlon,
dlat,
data['temp'][i, ...],
xr,
yr,
extrap=True,
**interp_opts)
except:
pass
try:
SALT[i, ...] = calc.griddata(dlon,
dlat,
data['salt'][i, ...],
xr,
yr,
extrap=True,
**interp_opts)
except:
pass
try:
U[i, ...] = calc.griddata(dlon,
dlat,
data['u'][i, ...],
xr,
yr,
extrap=True,
**interp_opts)
except:
pass
try:
V[i, ...] = calc.griddata(dlon,
dlat,
data['v'][i, ...],
xr,
yr,
extrap=True,
**interp_opts)
except:
pass
# rotate U,V:
if not quiet: print 'rotating U,V to grid angle'
angle = g.use('angle') # rad
U, V = calc.rot2d(U, V, angle)
U = rt.rho2uvp3d(U, 'u')
V = rt.rho2uvp3d(V, 'v')
horizAux = {}
horizAux['TEMP'] = TEMP
horizAux['SALT'] = SALT
horizAux['U'] = U
horizAux['V'] = V
else:
TEMP = horizAux['TEMP']
SALT = horizAux['SALT']
U = horizAux['U']
V = horizAux['V']
# interp vert:
nxu = nx - 1
nyv = ny - 1
#> -----------------------------------------------------------------
useInd = not ij_ind is False
if ij_ind is False:
if ij == 'j': ij_ind = range(ny)
elif ij == 'i': ij_ind = range(nx)
else:
try:
iter(ij_ind)
except:
ij_ind = [ij_ind]
if ij == 'j': ny = nyv = len(ij_ind)
elif ij == 'i': nx = nxu = len(ij_ind)
# -----------------------------------------------------------------<
Temp = np.zeros((nz, ny, nx), data['temp'].dtype)
Salt = np.zeros((nz, ny, nx), data['salt'].dtype)
Uvel = np.zeros((nz, ny, nxu), data['u'].dtype)
Vvel = np.zeros((nz, nyv, nx), data['v'].dtype)
jslice = lambda x, ind: x[:, ind, :]
islice = lambda x, ind: x[:, :, ind]
ZZr = np.tile(data['depth'], (nx, ny, 1)).T
ZZu = np.tile(data['depth'], (nxu, ny, 1)).T
ZZv = np.tile(data['depth'], (nx, nyv, 1)).T
if not useInd is False: #>------------------------------------------
if ij == 'j':
slice = jslice
sshr = sshr[ij_ind, :]
hr = hr[ij_ind, :]
elif ij == 'i':
slice = islice
sshr = sshr[:, ij_ind]
hr = hr[:, ij_ind]
Zr, Zu, Zv, TEMP, SALT, U, V = [
slice(k, ij_ind) for k in [Zr, Zu, Zv, TEMP, SALT, U, V]
]
# -----------------------------------------------------------------<
if useInd: # then store distances for a possible bry file
dtype = Temp.dtype
distr = np.zeros((nz, ny, nx), dtype)
distu = np.zeros((nz, ny, nxu), dtype)
distv = np.zeros((nz, nyv, nx), dtype)
if not quiet: print 'vertical interpolation:'
if ij == 'j':
for j in range(ny):
if not quiet and (ny < 10 or (ny >= 10 and j % 10 == 0)):
print ' j=%3d of %3d' % (j, ny)
ind = ij_ind[j]
dr = np.tile(distance(xr[ind, :], yr[ind, :]), (nz, 1))
du = np.tile(distance(xu[ind, :], yu[ind, :]), (nz, 1))
Dr = np.tile(distance(xr[ind, :], yr[ind, :]), (NZ, 1))
Du = np.tile(distance(xu[ind, :], yu[ind, :]), (NZ, 1))
if useInd:
distr[:, j, :] = dr
distu[:, j, :] = du
Temp[:, j, :] = calc.griddata(Rdz * Dr,
ZZr[:, j, :],
TEMP[:, j, :],
Rdz * dr,
Zr[:, j, :],
extrap=True,
**interp_opts)
Salt[:, j, :] = calc.griddata(Rdz * Dr,
ZZr[:, j, :],
SALT[:, j, :],
Rdz * dr,
Zr[:, j, :],
extrap=True,
**interp_opts)
if 0 and j % 10 == 0:
print Dr.shape, ZZr[:, j, :].shape
import pylab as pl
pl.figure(1)
pl.clf()
pl.pcolormesh(Dr, ZZr[:, j, :], SALT[:, j, :])
pl.colorbar()
clim = pl.gci().get_clim()
pl.figure(2)
pl.clf()
pl.pcolormesh(dr, Zr[:, j, :], Salt[:, j, :])
pl.clim(clim)
pl.colorbar()
raw_input()
Uvel[:, j, :] = calc.griddata(Rdz * Du,
ZZu[:, j, :],
U[:, j, :],
Rdz * du,
Zu[:, j, :],
extrap=True,
**interp_opts)
if j < Vvel.shape[1]:
dv = np.tile(distance(xv[ind, :], yv[ind, :]), (nz, 1))
Dv = np.tile(distance(xv[ind, :], yv[ind, :]), (NZ, 1))
Vvel[:, j, :] = calc.griddata(Rdz * Dv,
ZZv[:, j, :],
V[:, j, :],
Rdz * dv,
Zv[:, j, :],
extrap=True,
**interp_opts)
if useInd:
distv[:, j, :] = dv
if np.any(np.isnan(Temp[:, j, :])): print 'found nan in temp', j
if np.any(np.isnan(Salt[:, j, :])): print 'found nan in salt', j
if np.any(np.isnan(Uvel[:, j, :])): print 'found nan in u', j
if j < Vvel.shape[1] and np.any(np.isnan(Vvel[:, j, :])):
print 'found nan in v', j
elif ij == 'i':
for i in range(nx):
if not quiet and (nx < 10 or (nx >= 10 and i % 10 == 0)):
print ' i=%3d of %3d' % (i, nx)
ind = ij_ind[i]
dr = np.tile(distance(xr[:, ind], yr[:, ind]), (nz, 1))
dv = np.tile(distance(xv[:, ind], yv[:, ind]), (nz, 1))
Dr = np.tile(distance(xr[:, ind], yr[:, ind]), (NZ, 1))
Dv = np.tile(distance(xv[:, ind], yv[:, ind]), (NZ, 1))
if useInd:
distr[:, :, i] = dr
distv[:, :, i] = dv
Temp[:, :, i] = calc.griddata(Rdz * Dr,
ZZr[:, :, i],
TEMP[:, :, i],
Rdz * dr,
Zr[:, :, i],
extrap=True,
**interp_opts)
Salt[:, :, i] = calc.griddata(Rdz * Dr,
ZZr[:, :, i],
SALT[:, :, i],
Rdz * dr,
Zr[:, :, i],
extrap=True,
**interp_opts)
Vvel[:, :, i] = calc.griddata(Rdz * Dv,
ZZv[:, :, i],
V[:, :, i],
Rdz * dv,
Zv[:, :, i],
extrap=True,
**interp_opts)
if i < Uvel.shape[2]:
du = np.tile(distance(xu[:, ind], yu[:, ind]), (nz, 1))
Du = np.tile(distance(xu[:, ind], yu[:, ind]), (NZ, 1))
Uvel[:, :, i] = calc.griddata(Rdz * Du,
ZZu[:, :, i],
U[:, :, i],
Rdz * du,
Zu[:, :, i],
extrap=True,
**interp_opts)
if useInd:
distu[:, :, i] = du
# uv bar:
if not quiet: print 'calc uvbar'
if useInd is False:
ubar, vbar = rt.uvbar(Uvel, Vvel, sshr, hr, sparams)
else: #>------------------------------------------------------------
sshu = calc.griddata(dlon,
dlat,
data['ssh'],
xu,
yu,
extrap=True,
**interp_opts)
sshv = calc.griddata(dlon,
dlat,
data['ssh'],
xv,
yv,
extrap=True,
**interp_opts)
if ij == 'j':
sshu = sshu[ij_ind, :]
sshv = sshv[ij_ind, :]
hu = hu[ij_ind, :]
hv = hv[ij_ind, :]
elif ij == 'i':
sshu = sshu[:, ij_ind]
sshv = sshv[:, ij_ind]
hu = hu[:, ij_ind]
hv = hv[:, ij_ind]
ubar = rt.barotropic(Uvel, sshu, hu, sparams)
vbar = rt.barotropic(Vvel, sshv, hv, sparams)
# -----------------------------------------------------------------<
Vars = cb.odict()
Vars['temp'] = Temp
Vars['salt'] = Salt
Vars['u'] = Uvel
Vars['v'] = Vvel
Vars['zeta'] = sshr
Vars['ubar'] = ubar
Vars['vbar'] = vbar
Vars['date'] = data['date']
if not useInd is False: #>------------------------------------------
Vars['depth'] = Zr
Vars['depthu'] = Zu
Vars['depthv'] = Zv
Vars['dist'] = distr
Vars['distu'] = distu
Vars['distv'] = distv
# -----------------------------------------------------------------<
if retHorizAux: return Vars, horizAux
else: return Vars
def data2roms(data, grd, sparams, **kargs):
'''
Interpolates data to roms 3D grid.
The dict data must contain the prognostic variables temp, salt, u,
v (3d) and ssh (zeta, 2d), as well as lon, lat (2d), depth (1d) and
time/date info: date (data date), date0 (reference date) and time
(difference between date and date0). The input data can be provided
by load_data.
Parameters
----------
data : dict with prognostic variables
grd : ROMS netcdf grid file
sparams : s-coordinates parameters, theta_s,theta_b, hc and NLevels
**kargs:
ij : axis for vertical interpolations (*i,j)
ij_ind : list of i or j index for vertical interpolation, all by
default (ij_ind=False)
horizAux : if True, the original data horizontally interpolated is
returned and can be used for next data2roms call with
this same karg
quiet : output messages flag (false by default)
'''
ij = 'j'
ij_ind = False
horizAux = False
quiet = False
if 'ij' in kargs.keys(): ij = kargs['ij']
if 'ij_ind' in kargs.keys(): ij_ind = kargs['ij_ind']
if 'horizAux' in kargs.keys(): horizAux = kargs['horizAux']
if 'quiet' in kargs.keys(): quiet = kargs['quiet']
if not quiet: print 'using grid %s' % grd
g = roms.Grid(grd)
xr, yr, hr, mr = g.vars('r')
xu, yu, hu, mu = g.vars('u')
xv, yv, hv, mv = g.vars('v')
ny, nx = hr.shape
nz = sparams[3]
NX = data['NX']
NY = data['NY']
NZ = data['NZ']
if not quiet: print 'calc s levels...'
sshr = calc.griddata(data['lon'],
data['lat'],
data['ssh'],
xr,
yr,
extrap=True)
Zr = g.s_levels(sparams, sshr, hr, 'r')
Zu = g.s_levels(sparams, sshr, hr, 'u')
Zv = g.s_levels(sparams, sshr, hr, 'v')
# interp horiz:
retHorizAux = horizAux is True
if horizAux in (True, False):
TEMP = np.ma.masked_all((NZ, ny, nx), data['temp'].dtype)
SALT = np.ma.masked_all((NZ, ny, nx), data['salt'].dtype)
U = np.ma.masked_all((NZ, ny, nx), data['u'].dtype)
V = np.ma.masked_all((NZ, ny, nx), data['v'].dtype)
if not quiet: print 'horizontal interpolation:'
for i in range(NZ):
if not quiet and i % 10 == 0: print ' lev %d of %d' % (i, NZ)
#import pylab
#pylab.figure()
#pylab.pcolormesh(data['lon'],data['lat'],data['temp'][i,...])
try:
TEMP[i, ...] = calc.griddata(data['lon'],
data['lat'],
data['temp'][i, ...],
xr,
yr,
extrap=True)
except:
pass
try:
SALT[i, ...] = calc.griddata(data['lon'],
data['lat'],
data['salt'][i, ...],
xr,
yr,
extrap=True)
except:
pass
try:
U[i, ...] = calc.griddata(data['lon'],
data['lat'],
data['u'][i, ...],
xr,
yr,
extrap=True)
except:
pass
try:
V[i, ...] = calc.griddata(data['lon'],
data['lat'],
data['v'][i, ...],
xr,
yr,
extrap=True)
except:
pass
# rotate U,V:
if not quiet: print 'rotating U,V to grid angle'
angle = g.use('angle') # rad
U, V = calc.rot2d(U, V, angle)
U = rt.rho2uvp3d(U, 'u')
V = rt.rho2uvp3d(V, 'v')
horizAux = {}
horizAux['TEMP'] = TEMP
horizAux['SALT'] = SALT
horizAux['U'] = U
horizAux['V'] = V
else:
TEMP = horizAux['TEMP']
SALT = horizAux['SALT']
U = horizAux['U']
V = horizAux['V']
# interp vert:
nxu = nx - 1
nyv = ny - 1
#> -----------------------------------------------------------------
useInd = not ij_ind is False
if ij_ind is False:
if ij == 'j': ij_ind = range(ny)
elif ij == 'i': ij_ind = range(nx)
else:
try:
iter(ij_ind)
except:
ij_ind = [ij_ind]
if ij == 'j': ny = nyv = len(ij_ind)
elif ij == 'i': nx = nxu = len(ij_ind)
# -----------------------------------------------------------------<
Temp = np.zeros((nz, ny, nx), data['temp'].dtype)
Salt = np.zeros((nz, ny, nx), data['salt'].dtype)
Uvel = np.zeros((nz, ny, nxu), data['u'].dtype)
Vvel = np.zeros((nz, nyv, nx), data['v'].dtype)
jslice = lambda x, ind: x[:, ind, :]
islice = lambda x, ind: x[:, :, ind]
ZZr = np.tile(data['depth'], (nx, ny, 1)).T
ZZu = np.tile(data['depth'], (nxu, ny, 1)).T
ZZv = np.tile(data['depth'], (nx, nyv, 1)).T
if not useInd is False: #>------------------------------------------
if ij == 'j':
slice = jslice
sshr = sshr[ij_ind, :]
hr = hr[ij_ind, :]
elif ij == 'i':
slice = islice
sshr = sshr[:, ij_ind]
hr = hr[:, ij_ind]
Zr, Zu, Zv, TEMP, SALT, U, V = [
slice(k, ij_ind) for k in [Zr, Zu, Zv, TEMP, SALT, U, V]
]
# -----------------------------------------------------------------<
if useInd: # then store distances for a possible bry file
dtype = Temp.dtype
distr = np.zeros((nz, ny, nx), dtype)
distu = np.zeros((nz, ny, nxu), dtype)
distv = np.zeros((nz, nyv, nx), dtype)
if not quiet: print 'vertical interpolation:'
if ij == 'j':
for j in range(ny):
if not quiet and (ny < 10 or (ny >= 10 and j % 10 == 0)):
print ' j=%3d of %3d' % (j, ny)
ind = ij_ind[j]
dr = np.tile(calc.distance(xr[ind, :], yr[ind, :]), (nz, 1))
du = np.tile(calc.distance(xu[ind, :], yu[ind, :]), (nz, 1))
Dr = np.tile(calc.distance(xr[ind, :], yr[ind, :]), (NZ, 1))
Du = np.tile(calc.distance(xu[ind, :], yu[ind, :]), (NZ, 1))
if useInd:
distr[:, j, :] = dr
distu[:, j, :] = du
Temp[:, j, :] = calc.griddata(Dr,
ZZr[:, j, :],
TEMP[:, j, :],
dr,
Zr[:, j, :],
extrap=True)
Salt[:, j, :] = calc.griddata(Dr,
ZZr[:, j, :],
SALT[:, j, :],
dr,
Zr[:, j, :],
extrap=True)
if 0 and j % 10 == 0:
print Dr.shape, ZZr[:, j, :].shape
import pylab as pl
pl.figure(1)
pl.clf()
pl.pcolormesh(Dr, ZZr[:, j, :], SALT[:, j, :])
pl.colorbar()
clim = pl.gci().get_clim()
pl.figure(2)
pl.clf()
pl.pcolormesh(dr, Zr[:, j, :], Salt[:, j, :])
pl.clim(clim)
pl.colorbar()
raw_input()
Uvel[:, j, :] = calc.griddata(Du,
ZZu[:, j, :],
U[:, j, :],
du,
Zu[:, j, :],
extrap=True)
if j < Vvel.shape[1]:
dv = np.tile(calc.distance(xv[ind, :], yv[ind, :]), (nz, 1))
Dv = np.tile(calc.distance(xv[ind, :], yv[ind, :]), (NZ, 1))
Vvel[:, j, :] = calc.griddata(Dv,
ZZv[:, j, :],
V[:, j, :],
dv,
Zv[:, j, :],
extrap=True)
if useInd:
distv[:, j, :] = dv
if np.any(np.isnan(Temp[:, j, :])): print 'found nan in temp', j
if np.any(np.isnan(Salt[:, j, :])): print 'found nan in salt', j
if np.any(np.isnan(Uvel[:, j, :])): print 'found nan in u', j
if j < Vvel.shape[1] and np.any(np.isnan(Vvel[:, j, :])):
print 'found nan in v', j
elif ij == 'i':
for i in range(nx):
if not quiet and (nx < 10 or (nx >= 10 and i % 10 == 0)):
print ' i=%3d of %3d' % (i, nx)
ind = ij_ind[i]
dr = np.tile(calc.distance(xr[:, ind], yr[:, ind]), (nz, 1))
dv = np.tile(calc.distance(xv[:, ind], yv[:, ind]), (nz, 1))
Dr = np.tile(calc.distance(xr[:, ind], yr[:, ind]), (NZ, 1))
Dv = np.tile(calc.distance(xv[:, ind], yv[:, ind]), (NZ, 1))
if useInd:
distr[:, :, i] = dr
distv[:, :, i] = dv
Temp[:, :, i] = calc.griddata(Dr,
ZZr[:, :, i],
TEMP[:, :, i],
dr,
Zr[:, :, i],
extrap=True)
Salt[:, :, i] = calc.griddata(Dr,
ZZr[:, :, i],
SALT[:, :, i],
dr,
Zr[:, :, i],
extrap=True)
Vvel[:, :, i] = calc.griddata(Dv,
ZZv[:, :, i],
V[:, :, i],
dv,
Zv[:, :, i],
extrap=True)
if i < Uvel.shape[2]:
du = np.tile(calc.distance(xu[:, ind], yu[:, ind]), (nz, 1))
Du = np.tile(calc.distance(xu[:, ind], yu[:, ind]), (NZ, 1))
Uvel[:, :, i] = calc.griddata(Du,
ZZu[:, :, i],
U[:, :, i],
du,
Zu[:, :, i],
extrap=True)
if useInd:
distu[:, :, i] = du
# uv bar:
if not quiet: print 'calc uvbar'
if useInd is False:
ubar, vbar = rt.uvbar(Uvel, Vvel, sshr, hr, sparams)
else: #>------------------------------------------------------------
sshu = calc.griddata(data['lon'],
data['lat'],
data['ssh'],
xu,
yu,
extrap=True)
sshv = calc.griddata(data['lon'],
data['lat'],
data['ssh'],
xv,
yv,
extrap=True)
if ij == 'j':
sshu = sshu[ij_ind, :]
sshv = sshv[ij_ind, :]
hu = hu[ij_ind, :]
hv = hv[ij_ind, :]
elif ij == 'i':
sshu = sshu[:, ij_ind]
sshv = sshv[:, ij_ind]
hu = hu[:, ij_ind]
hv = hv[:, ij_ind]
ubar = rt.barotropic(Uvel, sshu, hu, sparams)
vbar = rt.barotropic(Vvel, sshv, hv, sparams)
# -----------------------------------------------------------------<
Vars = cb.odict()
Vars['temp'] = Temp
Vars['salt'] = Salt
Vars['u'] = Uvel
Vars['v'] = Vvel
Vars['zeta'] = sshr
Vars['ubar'] = ubar
Vars['vbar'] = vbar
Vars['date'] = data['date']
if not useInd is False: #>------------------------------------------
Vars['depth'] = Zr
Vars['depthu'] = Zu
Vars['depthv'] = Zv
Vars['dist'] = distr
Vars['distu'] = distu
Vars['distv'] = distv
# -----------------------------------------------------------------<
if retHorizAux: return Vars, horizAux
else: return Vars
