def load_blkdata_wrf(wrfpath, wrffiles="wrfout*", date0=False, date1=False, quiet=True): from okean.datasets import wrf a = wrf.WRFData(wrfpath, wrffiles) data = a.data(date0, date1, quiet) out = cb.odict() if not data: print "no data found !" return out time = data["time"] for it in range(len(time)): # be sure time increases! if out.keys() and time[it] <= out.keys()[-1]: continue out[time[it]] = {} for k in data.keys(): if k in ("time",): continue elif k.startswith("INFO"): out[time[it]][k] = data[k] else: out[time[it]][k] = data[k].data[it, ...] # x and y should be the same, so: if not out[time[it]].has_key("x"): out[time[it]]["x"] = data[k].x out[time[it]]["y"] = data[k].y return out
def load_blkdata_gfs(gfspath, date0, date1=False, nforec=0, quiet=True): """ nforec=0 means not forecast, auto means default from config file """ from okean.datasets import gfs a = gfs.GFSData(gfspath) if nforec == 0: data, miss = a.data_analysis(date0, date1, quiet=quiet) else: data, miss = a.data_forecast(date0, nforec, quiet=quiet) out = cb.odict() time = data.keys() for t in time: out[t] = {} for k in data[t].keys(): if k.startswith("INFO"): out[t][k] = data[t][k] else: out[t][k] = data[t][k].data # x and y may change with time, but should be the same for each time (gfs file) if not out[t].has_key("x"): out[t]["x"] = data[t][k].x out[t]["y"] = data[t][k].y return out, miss
def load_blkdata_interim(interimpath, date0=False, date1=False, quiet=True, past=False): ''' If past, then module interim_past will be used to extract data from old interim server. Otherwise interim module will be used. ''' if past: from okean.datasets import interim_past as interim else: from okean.datasets import interim a = interim.INTERIMData(interimpath) data = a.data(date0, date1, quiet) out = cb.odict() time = data['time'] for it in range(len(time)): out[time[it]] = {} for k in data.keys(): if k in ('time', ): continue elif k.startswith('INFO'): out[time[it]][k] = data[k] else: out[time[it]][k] = data[k].data[it, ...] # x and y should be the same, so: if not out[time[it]].has_key('x'): out[time[it]]['x'] = data[k].x out[time[it]]['y'] = data[k].y return out
def __dims(self): '''Returns variable dimensions dict''' d=cbt.odict() if self._interface=='pycdf': names = self._nc.dimensions() elif self._interface=='scientific': names = self._nc.dimensions elif self._interface=='netcdf4': names = self._nc.dimensions if self._interface in ('pycdf','scientific'): for n in names: d[n]=self.parent.dims[n] # In netcdf 4, dimensions are scoped such that they can be seen # in all descendant groups. That is, dimensions can be shared # between variables in different groups, if they are defined in # a parent group. elif self._interface == 'netcdf4': for n in names: p=self.parent while True: if p.dims.has_key(n): d[n]=p.dims[n] break if p.parent: p=p.parent else: break return d
def __dims(self): '''Returns variable dimensions dict''' d = cbt.odict() if self._interface == 'pycdf': names = self._nc.dimensions() elif self._interface == 'scientific': names = self._nc.dimensions elif self._interface == 'netcdf4': names = self._nc.dimensions if self._interface in ('pycdf', 'scientific'): for n in names: d[n] = self.parent.dims[n] # In netcdf 4, dimensions are scoped such that they can be seen # in all descendant groups. That is, dimensions can be shared # between variables in different groups, if they are defined in # a parent group. elif self._interface == 'netcdf4': for n in names: p = self.parent while True: if p.dims.has_key(n): d[n] = p.dims[n] break if p.parent: p = p.parent else: break return d
def __dims(self): '''Returns file dimensions dict''' dims = cbt.odict() if self._interface == 'pycdf': for i in range(self._nc.inq_ndims()): dims[self._nc.dim(i).inq()[0]] = self._nc.dim(i).inq()[1] elif self._interface == 'scientific': # get ordered dims: if not self._ncdump_info is False: odims = self._ncdump_info['dimensions'] else: odims = False if not odims: odims = self._nc.dimensions.keys() for k in odims: dims[k] = self._nc.dimensions[k] elif self._interface == 'netcdf4': # get ordered dims: if not self._ncdump_info is False: odims = self._ncdump_info['dimensions'] else: odims = False if not odims: odims = self._nc.dimensions.keys() for k in odims: dims[k] = len(self._nc.dimensions[k]) return dims
def load_blkdata_interim(interimpath, date0=False, date1=False, quiet=True, past=False): """ If past, then module interim_past will be used to extract data from old interim server. Otherwise interim module will be used. """ if past: from okean.datasets import interim_past as interim else: from okean.datasets import interim a = interim.INTERIMData(interimpath) data = a.data(date0, date1, quiet) out = cb.odict() time = data["time"] for it in range(len(time)): out[time[it]] = {} for k in data.keys(): if k in ("time",): continue elif k.startswith("INFO"): out[time[it]][k] = data[k] else: out[time[it]][k] = data[k].data[it, ...] # x and y should be the same, so: if not out[time[it]].has_key("x"): out[time[it]]["x"] = data[k].x out[time[it]]["y"] = data[k].y return out
def load_blkdata_wrf(wrfpath, wrffiles='wrfout*', date0=False, date1=False, quiet=True): from okean.datasets import wrf a = wrf.WRFData(wrfpath, wrffiles) data = a.data(date0, date1, quiet) out = cb.odict() if not data: print('no data found !') return out time = data['time'] for it in range(len(time)): # be sure time increases! if out.keys() and time[it] <= out.keys()[-1]: continue out[time[it]] = {} for k in data.keys(): if k in ('time', ): continue elif k.startswith('INFO'): out[time[it]][k] = data[k] else: out[time[it]][k] = data[k].data[it, ...] # x and y should be the same, so: if not out[time[it]].has_key('x'): out[time[it]]['x'] = data[k].x out[time[it]]['y'] = data[k].y return out
def load_blkdata_cfsr(cfsrpath, date0=False, date1=False, quiet=True): from okean.datasets import cfsr a = cfsr.CFSRData(cfsrpath) data = a.data(date0, date1, quiet) out = cb.odict() time = data["time"] for it in range(len(time)): out[time[it]] = {} for k in data.keys(): if k in ("time",): continue elif k.startswith("INFO"): out[time[it]][k] = data[k] else: out[time[it]][k] = data[k].data[it, ...] # x and y should be the same, so: if not out[time[it]].has_key("x"): out[time[it]]["x"] = data[k].x out[time[it]]["y"] = data[k].y return out
def load_blkdata_gfs(gfspath, date0, date1=False, nforec=0, quiet=True): ''' nforec=0 means not forecast, auto means default from config file ''' from okean.datasets import gfs a = gfs.GFSData(gfspath) if nforec == 0: data, miss = a.data_analysis(date0, date1, quiet=quiet) else: data, miss = a.data_forecast(date0, nforec, quiet=quiet) out = cb.odict() time = data.keys() for t in time: out[t] = {} for k in data[t].keys(): if k.startswith('INFO'): out[t][k] = data[t][k] else: out[t][k] = data[t][k].data # x and y may change with time, but should be the same for each time (gfs file) if not out[t].has_key('x'): out[t]['x'] = data[t][k].x out[t]['y'] = data[t][k].y return out, miss
def __groups(self): out=cbt.odict() if self._interface=='netcdf4': gs=self._nc.groups try: gnames=gs.keys() except: gnames=() for k in gnames: out[k]=Pyncgroup(nc=gs[k],name=k,parent=self) else: print ':: groups only implemented in interface ','netcdf4' return out
def read_log(f): out=cb.odict() if os.path.isfile(f): L=open(log).readlines() for l in L: tmp=l.split(' ',1) sdate=tmp[0] scontents=tmp[1].rstrip().split(' + ') out[tmp[0]]=scontents return out
def read_log(f): out = cb.odict() if os.path.isfile(f): L = open(log).readlines() for l in L: tmp = l.split(' ', 1) sdate = tmp[0] scontents = tmp[1].rstrip().split(' + ') out[tmp[0]] = scontents return out
def __atts(self): '''Returns netcdf ordered attributes, with types and values''' att = cbt.odict() if self._interface == 'pycdf': for i in range(self._nc.inq_natts()): a = self._nc.attr(i) # ps: a.get() produces a segmentation fault for large # strings, so: L = a.inq_len() if L >= 250: val = 'PYCDF ERROR: CANNOT READ !!!!' else: attvalue = a.get() # find nctype: nctype = nctypes.type_pycdf2nc(a.inq_type()) att[a.inq_name()] = Pyncatt(self._nc, a.inq_name(), attvalue, nctype=nctype, ncversion=self.ncversion, interface=self._interface) elif self._interface == 'scientific': a = self._nc.__dict__ # get ordered atts: if not self._ncdump_info is False: oatts = self._ncdump_info['vattributes'][self.varname] else: oatts = False if oatts: keys = oatts else: keys = a.keys() for k in keys: attvalue = a[k] att[k] = Pyncatt(self._nc, k, attvalue, ncversion=self.ncversion, interface=self._interface) elif self._interface == 'netcdf4': aname = self._nc.ncattrs() # already ordered! for a in aname: attvalue = getattr(self._nc, a) att[a] = Pyncatt(self._nc, a, attvalue, ncversion=self.ncversion, interface=self._interface) return att
def __groups(self): out = cbt.odict() if self._interface == 'netcdf4': gs = self._nc.groups try: gnames = gs.keys() except: gnames = () for k in gnames: out[k] = Pyncgroup(nc=gs[k], name=k, parent=self) else: print ':: groups only implemented in interface ', 'netcdf4' return out
def __vars(self): '''Returns file variables''' var=cbt.odict() if self._interface=='pycdf': names=[self._nc.var(i).inq_name() for i in range(self._nc.inq_nvars())] elif self._interface in ('scientific','netcdf4'): # get ordered names: if not self._ncdump_info is False: onames=self._ncdump_info['variables'].keys() else: onames=False if onames: names=onames else: names=self._nc.variables.keys() for vname in names: var[vname]=Pyncvar(self,vname) return var
def list_files(cf,date1,date2,io,type,FA,nest=0,quiet=True): files=cb.odict() date=date1 while date<=date2: f=opt.nameof(io,type,date,FA,nest,cf) if os.path.isfile(f): files[date]=f else: files[date]=False date=dateu.next_date(date,1) if not quiet: for d in files.keys(): if files[d]: f=files[d] hs=cb.hsize(os.path.getsize(f)) print d,' ', f, ' ',hs[0],hs[1] else: print d,' no file' return files
def load_blkdata_narr(date0, date1, quiet=True): from okean.datasets import narr a = narr.NARRData() data, miss = a.data(date0, date1, quiet=quiet) out = cb.odict() time = data.keys() for t in time: out[t] = {} for k in data[t].keys(): if k.startswith('INFO'): out[t][k] = data[t][k] else: out[t][k] = data[t][k].data if not out[t].has_key('x'): out[t]['x'] = data[t][k].x out[t]['y'] = data[t][k].y return out, miss
def list_files(cf, date1, date2, io, type, FA, nest=0, quiet=True): files = cb.odict() date = date1 while date <= date2: f = opt.nameof(io, type, date, FA, nest, cf) if os.path.isfile(f): files[date] = f else: files[date] = False date = dateu.next_date(date, 1) if not quiet: for d in files.keys(): if files[d]: f = files[d] hs = cb.hsize(os.path.getsize(f)) print d, ' ', f, ' ', hs[0], hs[1] else: print d, ' no file' return files
def __vars(self): '''Returns file variables''' var = cbt.odict() if self._interface == 'pycdf': names = [ self._nc.var(i).inq_name() for i in range(self._nc.inq_nvars()) ] elif self._interface in ('scientific', 'netcdf4'): # get ordered names: if not self._ncdump_info is False: onames = self._ncdump_info['variables'].keys() else: onames = False if onames: names = onames else: names = self._nc.variables.keys() for vname in names: var[vname] = Pyncvar(self, vname) return var
def load_blkdata_narr(date0,date1,quiet=True): from okean.datasets import narr a=narr.NARRData() data,miss=a.data(date0,date1,quiet=quiet) out=cb.odict() time=data.keys() for t in time: out[t]={} for k in data[t].keys(): if k.startswith('INFO'): out[t][k]=data[t][k] else: out[t][k]=data[t][k].data if not out[t].has_key('x'): out[t]['x']=data[t][k].x out[t]['y']=data[t][k].y return out, miss
def __atts(self): '''Returns netcdf ordered attributes, with types and values''' att=cbt.odict() if self._interface=='pycdf': for i in range(self._nc.inq_natts()): a=self._nc.attr(i) # ps: a.get() produces a segmentation fault for large # strings, so: L= a.inq_len() if L>=250: val='PYCDF ERROR: CANNOT READ !!!!' else: attvalue=a.get() # find nctype: nctype=nctypes.type_pycdf2nc(a.inq_type()) att[a.inq_name()]=Pyncatt(self._nc,a.inq_name(),attvalue, nctype=nctype,ncversion=self.ncversion, interface=self._interface) elif self._interface=='scientific': a=self._nc.__dict__ # get ordered atts: if not self._ncdump_info is False: oatts=self._ncdump_info['vattributes'][self.varname] else: oatts=False if oatts: keys=oatts else: keys= a.keys() for k in keys: attvalue=a[k] att[k]=Pyncatt(self._nc,k,attvalue,ncversion=self.ncversion, interface=self._interface) elif self._interface=='netcdf4': aname=self._nc.ncattrs() # already ordered! for a in aname: attvalue=getattr(self._nc,a) att[a]=Pyncatt(self._nc,a,attvalue,ncversion=self.ncversion, interface=self._interface) return att
def data(self,date0,date1=False,xlim=False,ylim=False,quiet=True): files,time=self.files(date0,date1) res=cb.odict() for i in range(len(files)): if not quiet: print('|-> getting from file %s' % files[i]) try: data=narr_file_data(files[i],xlim,ylim,quiet=quiet) except: if not quiet: print('CANNOT use data for %s' % time[i].isoformat()) continue if data: data['INFO_file'] = files[i] res[time[i]]=data else: if not quiet: print('NO DATA for %s' % time[i].isoformat()) miss={} return res,miss
def add_group(self,groupname): ''' Creates netcdf groups See: http://netcdf4-python.googlecode.com/svn/trunk/docs/netCDF4-module.html ''' if self._interface=='netcdf4': self._nc.createGroup(groupname) newgroup=Pyncgroup(groupname,self) # update self.groups: self.groups[groupname]=newgroup # update ncdump info: if not self._ncdump_info is False: self._ncdump_info['groups'][groupname]=cbt.odict() return newgroup else: print ':: add_group only implemented in interface ','netcdf4' return False
def add_group(self, groupname): ''' Creates netcdf groups See: http://netcdf4-python.googlecode.com/svn/trunk/docs/netCDF4-module.html ''' if self._interface == 'netcdf4': self._nc.createGroup(groupname) newgroup = Pyncgroup(groupname, self) # update self.groups: self.groups[groupname] = newgroup # update ncdump info: if not self._ncdump_info is False: self._ncdump_info['groups'][groupname] = cbt.odict() return newgroup else: print ':: add_group only implemented in interface ', 'netcdf4' return False
def load_blkdata_cfsr(cfsrpath, date0=False, date1=False, quiet=True): from okean.datasets import cfsr a = cfsr.CFSRData(cfsrpath) data = a.data(date0, date1, quiet) out = cb.odict() time = data['time'] for it in range(len(time)): out[time[it]] = {} for k in data.keys(): if k in ('time', ): continue elif k.startswith('INFO'): out[time[it]][k] = data[k] else: out[time[it]][k] = data[k].data[it, ...] # x and y should be the same, so: if not out[time[it]].has_key('x'): out[time[it]]['x'] = data[k].x out[time[it]]['y'] = data[k].y return out
def __dims(self): '''Returns file dimensions dict''' dims=cbt.odict() if self._interface=='pycdf': for i in range(self._nc.inq_ndims()): dims[self._nc.dim(i).inq()[0]]=self._nc.dim(i).inq()[1] elif self._interface=='scientific': # get ordered dims: if not self._ncdump_info is False: odims=self._ncdump_info['dimensions'] else: odims=False if not odims: odims=self._nc.dimensions.keys() for k in odims: dims[k]=self._nc.dimensions[k] elif self._interface=='netcdf4': # get ordered dims: if not self._ncdump_info is False: odims=self._ncdump_info['dimensions'] else: odims=False if not odims: odims=self._nc.dimensions.keys() for k in odims: dims[k]=len(self._nc.dimensions[k]) return dims
def update_wind_blended2(fname, datapaths, **kargs): ''' In days without blended data will try to use quikscat data ''' from okean.datasets import quikscat from okean.datasets import blended_wind a = blended_wind.WINDData(datapaths[0]) b = quikscat.WINDData(datapaths[1]) time = netcdf.nctime(fname, 'time') date0 = dts.next_date(time[0], -1) date1 = dts.next_date(time[-1], +2) data = a.data(date0, date1) # limit are... otherwise, quikscat interp will be very slow! grd = netcdf.fatt(fname, 'grd_file') import os if not os.path.isfile(grd): grd = kargs['grd'] cond, inds = rt.grid_vicinity(grd, data['x'], data['y'], margin=5, rect=True, retinds=True) i1, i2, j1, j2 = inds for d in data.keys(): if d == 'x': data[d] = data[d][i1:i2] elif d == 'y': data[d] = data[d][j1:j2] else: data[d] = data[d][j1:j2, i1:i2] # check for missing days: time0 = data.keys() x0 = data['x'] y0 = data['y'] x0, y0 = np.meshgrid(x0, y0) time0.remove('x') time0.remove('y') out = cb.odict() out['x'] = x0 out['y'] = y0 info = '' qs_ij_limits_done = False for d in dts.drange(date0, date1): found = 0 for t in time0: if (t.year, t.month, t.day) == (d.year, d.month, d.day): print('==> blended : ', t) out[t] = data[t] found = 1 if not found: # use quikscat: print('==> quikscat : ', d.strftime('%Y-%m-%d')) tmp = b.data(d, dts.next_date(d)) if not tmp.has_key('x'): continue x, y = tmp['x'], tmp['y'] x, y = np.meshgrid(x, y) # reduce qs data: if not qs_ij_limits_done: i1, i2, j1, j2 = calc.ij_limits(x, y, [x0.min(), x0.max()], [y0.min(), y0.max()]) qs_ij_limits_done = True x = x[j1:j2, i1:i2] y = y[j1:j2, i1:i2] tmp[tmp.keys()[0]] = tmp[tmp.keys()[0]][j1:j2, i1:i2] print(' griddata u') u = calc.griddata(x, y, tmp[tmp.keys()[0]].real, x0, y0) print(' griddata v') v = calc.griddata(x, y, tmp[tmp.keys()[0]].imag, x0, y0) out[tmp.keys()[0]] = u + 1.j * v info += '#' + d.strftime('%Y%m%d') new_wind_info = 'blended+quikscat at days: ' + info update_wind(fname, out, new_wind_info, **kargs)
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) 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
def update_wind_blended2(fname, datapaths, **kargs): """ In days without blended data will try to use quikscat data """ from okean.datasets import quikscat from okean.datasets import blended_wind a = blended_wind.WINDData(datapaths[0]) b = quikscat.WINDData(datapaths[1]) time = netcdf.nctime(fname, "time") date0 = dts.next_date(time[0], -1) date1 = dts.next_date(time[-1], +2) data = a.data(date0, date1) # limit are... otherwise, quikscat interp will be very slow! grd = netcdf.fatt(fname, "grd_file") import os if not os.path.isfile(grd): grd = kargs["grd"] cond, inds = rt.grid_vicinity(grd, data["x"], data["y"], margin=5, rect=True, retinds=True) i1, i2, j1, j2 = inds for d in data.keys(): if d == "x": data[d] = data[d][i1:i2] elif d == "y": data[d] = data[d][j1:j2] else: data[d] = data[d][j1:j2, i1:i2] # check for missing days: time0 = data.keys() x0 = data["x"] y0 = data["y"] x0, y0 = np.meshgrid(x0, y0) time0.remove("x") time0.remove("y") out = cb.odict() out["x"] = x0 out["y"] = y0 info = "" qs_ij_limits_done = False for d in dts.drange(date0, date1): found = 0 for t in time0: if (t.year, t.month, t.day) == (d.year, d.month, d.day): print "==> blended : ", t out[t] = data[t] found = 1 if not found: # use quikscat: print "==> quikscat : ", d.strftime("%Y-%m-%d") tmp = b.data(d, dts.next_date(d)) if not tmp.has_key("x"): continue x, y = tmp["x"], tmp["y"] x, y = np.meshgrid(x, y) # reduce qs data: if not qs_ij_limits_done: i1, i2, j1, j2 = calc.ij_limits(x, y, [x0.min(), x0.max()], [y0.min(), y0.max()]) qs_ij_limits_done = True x = x[j1:j2, i1:i2] y = y[j1:j2, i1:i2] tmp[tmp.keys()[0]] = tmp[tmp.keys()[0]][j1:j2, i1:i2] print " griddata u" u = calc.griddata(x, y, tmp[tmp.keys()[0]].real, x0, y0) print " griddata v" v = calc.griddata(x, y, tmp[tmp.keys()[0]].imag, x0, y0) out[tmp.keys()[0]] = u + 1.0j * v info += "#" + d.strftime("%Y%m%d") new_wind_info = "blended+quikscat at days: " + info update_wind(fname, out, new_wind_info, **kargs)
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
def add_var(self, varname, vartype, dimnames, **kargs): ''' Creates netcdf variable Ex: add_var('temp','float32',('lon','lat','z')) About compression: Compression kargs options (available for netcdf4 interface) zlib, default True, turn on compression lsd (least_significant_digit), default is None: lossy compression with lsd precision complevel, 1..9, copression level, default 4 About vartype: i) netcdf type names: for netcdf3: byte,char,short,int,float,double for netcdf4: + int64, ushort, uint,uint64, string ii) Numeric type code: fd1silbwuc iii) Numpy dtype or type name kargs are required when vartype is a netcdf type name and the interface is scientific, see type_2numeric and when interface is netcdf4, see type_2dtype No need for kargs when: 1. interface = pycdf 2. interface is scientific and vartype is numpy type name or dtype, or vartipe is numeric typecode 3. interface is netcdf4 and vartype is numpy type name or dtype ''' if self._interface == 'pycdf': vartype = nctypes.type_2pycdf(vartype) self._nc.def_var(varname, vartype, dimnames) elif self._interface == 'scientific': vartype = type_2numeric(vartype, **kargs) self._nc.createVariable(varname, vartype, dimnames) elif self._interface == 'netcdf4': vartype = nctypes.type_2numpy(vartype, **kargs) # NOTA: ocorre erro ao criar ex int64 em ncver 3. Pode fazer sentido # converter para int? ie, qd o tipo nao e suportado pela ncver!? zlib = kargs.get('zlib', True) lsd = kargs.get('lsd', None) complevel = kargs.get('complevel', 4) fill_value = kargs.get('fill_value', None) self._nc.createVariable(varname, vartype, dimnames, zlib=zlib, complevel=complevel, least_significant_digit=lsd, fill_value=fill_value) newvar = Pyncvar(self, varname) # update self.vars and self.varnames: self.vars[varname] = newvar # update ncdump_info: if not self._ncdump_info is False: self._ncdump_info['variables'][varname] = cbt.odict() return newvar
def add_var(self,varname,vartype,dimnames,**kargs): ''' Creates netcdf variable Ex: add_var('temp','float32',('lon','lat','z')) About compression: Compression kargs options (available for netcdf4 interface) gzip, default True: gzip compression lsd (least_significant_digit), default is None: lossy compression with lsd precision About vartype: i) netcdf type names: for netcdf3: byte,char,short,int,float,double for netcdf4: + int64, ushort, uint,uint64, string ii) Numeric type code: fd1silbwuc iii) Numpy dtype or type name kargs are required when vartype is a netcdf type name and the interface is scientific, see type_2numeric and when interface is netcdf4, see type_2dtype No need for kargs when: 1. interface = pycdf 2. interface is scientific and vartype is numpy type name or dtype, or vartipe is numeric typecode 3. interface is netcdf4 and vartype is numpy type name or dtype ''' if self._interface=='pycdf': vartype=nctypes.type_2pycdf(vartype) self._nc.def_var(varname,vartype,dimnames) elif self._interface=='scientific': vartype=type_2numeric(vartype,**kargs) self._nc.createVariable(varname,vartype,dimnames) elif self._interface=='netcdf4': vartype=nctypes.type_2numpy(vartype,**kargs) # NOTA: ocorre erro ao criar ex int64 em ncver 3. Pode fazer sentido # converter para int? ie, qd o tipo nao e suportado pela ncver!? zlib=True lsd=None fill_value=None if 'gzip' in kargs: zlib = kargs['gzip'] if 'lsd' in kargs: lsd = kargs['lsd'] if 'fill_value' in kargs: fill_value = kargs['fill_value'] self._nc.createVariable(varname,vartype,dimnames,zlib=zlib, least_significant_digit=lsd,fill_value=fill_value) newvar=Pyncvar(self,varname) # update self.vars and self.varnames: self.vars[varname]=newvar # update ncdump_info: if not self._ncdump_info is False: self._ncdump_info['variables'][varname]=cbt.odict() return newvar