def is_valid_nc(filename): """ Return True if the file is a valid NetCDF file """ try: file = netcdf(filename, 'r') file.close() return True except Exception: return False
def getSlabDepth(x, y, utm=True): ''' Get the slab depth for any point Args: * x, y : coordinates of the point(s) you want to have the depth * [OPT] utm: if True (default), give UTM coordinates. Else lon/lat return: * z : depth of the slab ''' # import some stuffs from scipy.interpolate import interp2d from netCDF4 import Dataset as netcdf # Read slab fid = os.path.join(os.environ['DATA'], 'SLAB', 'SlabMrCrory.grd') fin = netcdf(fid, 'r', format='NETCDF4') los = fin.variables['x'][:] las = fin.variables['y'][:] zs = fin.variables['z'][:] zs = np.ma.filled(zs, fill_value=0) #mask = ~zs.mask.flatten() # Get dimensions nx = len(los) ny = len(las) LO, LA = np.meshgrid(los, las) LO = LO.flatten() LA = LA.flatten() # Create converter from ll to utm string = '+proj=utm +lat_0={} +lon_0={} +ellps={}'.format( 48.5, -123.6, 'WGS84') putm = pp.Proj(string) # Create interpolator #f = interp2d(LO[mask],LA[mask],zs[~zs.mask]) f = interp2d(los, las, zs) # convert to lon lat if necessary if utm: lo, la = putm(x, y, inverse=True) lo, la = np.array((lo)), np.array((la)) else: lo, la = np.array((x)), np.array((y)) # get depth if lo.size == 1: z = -1 * f(lo, la) else: z = np.zeros((len(lo))) for i in range(len(lo)): z[i] = -1 * f(lo[i], la[i])[0] # all done return z
def __init__(self, filename): self.fullname = filename self._filename = os.path.expanduser(filename) self._file = netcdf(self._filename, 'r') self.times = self._get_times() self.leadtimes = self._get_leadtimes() self.locations = self._get_locations() self.thresholds = self._get_thresholds() self.quantiles = self._get_quantiles() self.variable = self._get_variable()
def get_grd(gname): ncgrd = netcdf(gname, mode='r') mask = ncgrd.variables['mask_rho'][:] lon = ncgrd.variables['lon_rho'][:] lat = ncgrd.variables['lat_rho'][:] pm = ncgrd.variables['pm'][:] pn = ncgrd.variables['pn'][:] f = ncgrd.variables['f'][:] ncgrd.close() return mask, lon, lat, pm, pn, f
def isValid(filename): try: file = netcdf(filename, 'r') except: return False valid = False if (hasattr(file, "Conventions")): if (file.Conventions == "verif_1.0.0"): valid = True file.close() return valid
def is_valid(filename): """ Checks that 'filename' is a valid object of this type """ valid = True try: file = netcdf(filename, 'r') required_dimensions = ["Offset", "Date", "Location"] for dim in required_dimensions: valid = valid & (dim in file.dimensions) file.close() return valid except: return False
def __init__(self, filename): self.fullname = filename self._filename = os.path.expanduser(filename) self._file = netcdf(self._filename, 'r') self.times = self._get_times() self.leadtimes = self._get_leadtimes() self.locations = self._get_locations() self.thresholds = self._get_thresholds() self.quantiles = self._get_quantiles() self.variable = self._get_variable() regular_names = self.get_regular_names() + ["threshold", "cdf", "quantile", "x"] self.other_fields = [var for var in self._file.variables if var not in regular_names]
def __init__(self, filename): self.fullname = filename self._filename = os.path.expanduser(filename) self._file = netcdf(self._filename, 'r') # Pre-load these variables, to save time when queried repeatedly dates = verif.util.clean(self._file.variables["Date"]) self.times = np.array([verif.util.date_to_unixtime(int(date)) for date in dates], int) self.leadtimes = verif.util.clean(self._file.variables["Offset"]) self.thresholds = self._get_thresholds() self.quantiles = self._get_quantiles() self.locations = self._get_locations() self.variable = self._get_variable()
def create_nc_part_2d(nc_name, nq): ''' CREATE OUTPUT FILE ''' nc = netcdf(nc_name, 'w') nc.createDimension('time',0) nc.createDimension('nq',nq) nct = nc.createVariable('time','d',('time',)) ncf = nc.createVariable('frame','i',('time',)) ncpx = nc.createVariable('px','d',('time','nq')) ncpy = nc.createVariable('py','d',('time','nq')) nc.close()
def fill_cache(ds_var): nc = netcdf(f'cru_ts3.24.01.{startyear}.{endyear}.{ds_var}.dat.nc', 'r') nc_attrs, nc_dims, nc_vars = ncdump(nc) # Extract data from NetCDF file lats = nc.variables['lat'][:] # extract/copy the data lons = nc.variables['lon'][:] time = nc.variables['time'][:] nc_ds = nc.variables[ds_var][:] CACHE[ds_var]['lats'] = lats CACHE[ds_var]['lons'] = lons ts_dt = fix_time(time) CACHE[ds_var]['time'] = ts_dt CACHE[ds_var]['days'] = time CACHE[ds_var]['ds'] = nc_ds
def freadcrm(): crmvars = ['MCUP', 'Q1C', 'Q2'] crmdata = {} fid = netcdf(fcrm, 'r') crmdata['lev'] = fid.variables['p'][:] * 100 for ivar in range(len(crmvars)): crmdata[crmvars[ivar]] = fid.variables[crmvars[ivar]][:] print "CRM: ", tcrm[0], tcrm[-1] fid.close() return crmdata
def grid_for(bbox): """ Extract a grid of locations in bbox :param hdf5: optional hdf5 file. :param save: save / update hdf5 data :return: None. """ lats = [p[1] for p in bbox] lons = [p[0] for p in bbox] lat_min = min(lats) lon_min = min(lons) lat_max = max(lats) lon_max = max(lons) ds_var = 'tmp' nc = netcdf(f'cru_ts3.24.01.{startyear}.{endyear}.{ds_var}.dat.nc', 'r') nc_attrs, nc_dims, nc_vars = ncdump(nc) lats = nc.variables['lat'][:] # extract/copy the data lons = nc.variables['lon'][:] lats = numpy.array(lats) lons = numpy.array(lons) # invalidate all locations outside our given bbox # with 1 extra box spacing padding_lat = 0.55 padding_lon = 0.55 lats[lats < lat_min - padding_lat] = 0 lats[lats > lat_max + padding_lat] = 0 lons[lons < lon_min - padding_lon] = 0 lons[lons > lon_max + padding_lon] = 0 grid = [] grid_idx = [] for lon_idx, lat in enumerate(lats): for lat_idx, lon in enumerate(lons): if lat == 0: continue if lon == 0: continue grid.append((lon, lat)) grid_idx.append((lon_idx, lat_idx)) return grid, grid_idx
def is_valid(filename): # First check if the file is a valid Netcdf file try: file = netcdf(filename, 'r') valid = True # Check required dimensions dims = [dim for dim in file.dimensions] required_dims = ["time", "location", "leadtime"] for required_dim in required_dims: valid = valid and required_dim in dims # Check required variables required_vars = ["time", "location", "leadtime"] vars = [var for var in file.variables] for required_var in required_vars: valid = valid and required_var in vars file.close() return valid except: return False
def fncread(fn,var): # read a variable from a netcdf file fid = netcdf(fn, 'r') data = fid.variables[var][:] fid.close() return data
def create_bryfile(bryname,grdname,title,obc,\ theta_s,theta_b,hc,N,\ bry_time,cycle,vtransform): # # ################################################################ # # function create_bryfile(bryname,grdname,title,obc... # theta_s,theta_b,hc,N,... # bry_time,cycle,clobber) # # This function create the header of a Netcdf climatology # file. # # Input: # # bryname Netcdf climatology file name (character string). # grdname Netcdf grid file name (character string). # obc open boundaries flag (1=open , [S E N W]). # theta_s S-coordinate surface control parameter.(Real) # theta_b S-coordinate bottom control parameter.(Real) # hc Width (m) of surface or bottom boundary layer # where higher vertical resolution is required # during stretching.(Real) # N Number of vertical levels.(Integer) # bry_time time.(vector) # cycle Length (days) for cycling the climatology.(Real) # # ################################################################ # # print(' ') print(' Creating the file : '+bryname) print(' ') print(' VTRANSFORM = '+str(vtransform)) # # Read the grid file and check the topography # nc=netcdf(grdname, 'r') h=nc.variables['h'][:] maskr=nc.variables['mask_rho'][:] [Mp,Lp]=np.shape(h) nc.close() # # # hmin=np.min(h[np.where(maskr==1)]) if vtransform == 1: if hc > hmin: print('Error: hc ('+hc+' m) > hmin ('+hmin+' m)') L=Lp-1 M=Mp-1 Np=N+1 Nt=0 # # Create the boundary file # type = 'BOUNDARY file' history = 'CROCO' if os.path.exists(bryname): os.remove(bryname) print('Create: ' +bryname) nc=netcdf(bryname,'w',format='NETCDF4') # # set global attributes # nc.type='CROCO boundary file' nc.history = 'Created '+str(time.ctime(time.time())) nc.title = title nc.bry_file = bryname nc.grd_file = grdname # # Create dimensions # nc_dim_xi_u=nc.createDimension('xi_u',L) nc_dim_xi_v=nc.createDimension('xi_v',Lp) nc_dim_xi_rho=nc.createDimension('xi_rho',Lp) nc_dim_eta_u=nc.createDimension('eta_u',Mp) nc_dim_eta_v=nc.createDimension('eta_v',M) nc_dim_eta_rho=nc.createDimension('eta_rho',Mp) nc_dim_s_rho=nc.createDimension('s_rho',N) nc_dim_s_w=nc.createDimension('s_w',Np) nc_dim_tracer=nc.createDimension('tracer',2) nc_dim_bry_time=nc.createDimension('bry_time',Nt) nc_dim_tclm_time=nc.createDimension('tclm_time',Nt) nc_dim_temp_time=nc.createDimension('temp_time',Nt) nc_dim_sclm_time=nc.createDimension('sclm_time',Nt) nc_dim_salt_time=nc.createDimension('salt_time',Nt) nc_dim_uclm_time=nc.createDimension('uclm_time',Nt) nc_dim_vclm_time=nc.createDimension('vclm_time',Nt) nc_dim_v2d_time=nc.createDimension('v2d_time',Nt) nc_dim_v3d_time=nc.createDimension('v3d_time',Nt) nc_dim_ssh_time=nc.createDimension('ssh_time',Nt) nc_dim_zeta_time=nc.createDimension('zeta_time',Nt) nc_dim_one=nc.createDimension('one',1) # # Create variables and attributes # nc_spherical=nc.createVariable('spherical','S1', ('one',)) nc_spherical.long_name = 'grid type logical switch' nc_spherical.flag_values = 'T, F' nc_spherical.flag_meanings = 'spherical Cartesian' # nc_Vtransform=nc.createVariable('Vtransform','i4', ('one',)) nc_Vtransform.long_name = 'vertical terrain-following transformation equation' # nc_Vstretching=nc.createVariable('Vstretching','i4', ('one',)) nc_Vstretching.long_name = 'vertical terrain-following stretching function' # nc_tstart=nc.createVariable('tstart',np.float64, ('one',)) nc_tstart.long_name = 'start processing day' nc_tstart.units = 'day' # nc_tend=nc.createVariable('tend',np.float64, ('one',)) nc_tend.long_name = 'end processing day' nc_tend.units = 'day' # nc_theta_s=nc.createVariable('theta_s',np.float64, ('one',)) nc_theta_s.long_name = 'S-coordinate surface control parameter' nc_theta_s.units = 'nondimensional' # nc_theta_b=nc.createVariable('theta_b',np.float64, ('one',)) nc_theta_b.long_name = 'S-coordinate bottom control parameter' nc_theta_b.units = 'nondimensional' # nc_Tcline=nc.createVariable('Tcline',np.float64, ('one',)) nc_Tcline.long_name = 'S-coordinate surface/bottom layer width' nc_Tcline.units = 'meter' # nc_hc=nc.createVariable('hc',np.float64, ('one',)) nc_hc.long_name = 'S-coordinate parameter, critical depth' nc_hc.units = 'meter' # nc_sc_r=nc.createVariable('sc_r',np.float64, ('s_rho',)) nc_sc_r.long_name = 'S-coordinate at RHO-points' nc_sc_r.valid_min = -1. nc_sc_r.valid_max = 0. nc_sc_r.positive = 'up' if vtransform == 1: nc_sc_r.standard_name = 'ocean_s_coordinate_g1' elif vtransform == 2: nc_sc_r.standard_name = 'ocean_s_coordinate_g2' nc_sc_r.formula_terms = 's: s_rho C: Cs_r eta: zeta depth: h depth_c: hc' # nc_sc_w=nc.createVariable('sc_w',np.float64, ('s_w',)) nc_sc_w.long_name = 'S-coordinate at W-points' nc_sc_w.valid_min = -1. nc_sc_w.valid_max = 0. nc_sc_w.positive = 'up' if vtransform == 1: nc_sc_w.standard_name = 'ocean_s_coordinate_g1' elif vtransform == 2: nc_sc_w.standard_name = 'ocean_s_coordinate_g2' nc_sc_w.formula_terms = 's: s_w C: Cs_w eta: zeta depth: h depth_c: hc' # nc_Cs_r=nc.createVariable('Cs_r',np.float64, ('s_rho',)) nc_Cs_r.long_name = 'S-coordinate stretching curves at RHO-points' nc_Cs_r.units = 'nondimensional' nc_Cs_r.valid_min = -1 nc_Cs_r.valid_max = 0 # nc_Cs_w=nc.createVariable('Cs_w',np.float64, ('s_w',)) nc_Cs_w.long_name = 'S-coordinate stretching curves at W-points' nc_Cs_w.units = 'nondimensional' nc_Cs_w.valid_min = -1 nc_Cs_w.valid_max = 0 # nc_bry_time=nc.createVariable('bry_time',np.float64, ('bry_time',)) nc_bry_time.long_name = 'time for boundary climatology' nc_bry_time.units = 'day' nc_bry_time.calendar = 'XXX days in every year' nc_bry_time.cycle_length = cycle # nc_tclm_time=nc.createVariable('tclm_time',np.float64, ('tclm_time',)) nc_tclm_time.long_name = 'time for temperature climatology' nc_tclm_time.units = 'day' nc_tclm_time.calendar = 'XXX days in every year' nc_tclm_time.cycle_length = cycle # nc_temp_time=nc.createVariable('temp_time',np.float64, ('temp_time',)) nc_temp_time.long_name = 'time for temperature climatology' nc_temp_time.units = 'day' nc_temp_time.calendar = 'XXX days in every year' nc_temp_time.cycle_length = cycle # nc_sclm_time=nc.createVariable('sclm_time',np.float64, ('sclm_time',)) nc_sclm_time.long_name = 'time for salinity climatology' nc_sclm_time.units = 'day' nc_sclm_time.calendar = 'XXX days in every year' nc_sclm_time.cycle_length = cycle # nc_salt_time=nc.createVariable('salt_time',np.float64, ('salt_time',)) nc_salt_time.long_name = 'time for salinity climatology' nc_salt_time.units = 'day' nc_salt_time.calendar = 'XXX days in every year' nc_salt_time.cycle_length = cycle # nc_uclm_time=nc.createVariable('uclm_time',np.float64, ('uclm_time',)) nc_uclm_time.long_name = 'time climatological u' nc_uclm_time.units = 'day' nc_uclm_time.calendar = 'XXX days in every year' nc_uclm_time.cycle_length = cycle # nc_vclm_time=nc.createVariable('vclm_time',np.float64, ('vclm_time',)) nc_vclm_time.long_name = 'time climatological v' nc_vclm_time.units = 'day' nc_vclm_time.calendar = 'XXX days in every year' nc_vclm_time.cycle_length = cycle # nc_v2d_time=nc.createVariable('v2d_time',np.float64, ('v2d_time',)) nc_v2d_time.long_name = 'time for 2D velocity climatology' nc_v2d_time.units = 'day' nc_v2d_time.calendar = 'XXX days in every year' nc_v2d_time.cycle_length = cycle # nc_v3d_time=nc.createVariable('v3d_time',np.float64, ('v3d_time',)) nc_v3d_time.long_name = 'time for 3D velocity climatology' nc_v3d_time.units = 'day' nc_v3d_time.calendar = 'XXX days in every year' nc_v3d_time.cycle_length = cycle # nc_ssh_time=nc.createVariable('ssh_time',np.float64, ('ssh_time',)) nc_ssh_time.long_name = 'time for sea surface height' nc_ssh_time.units = 'day' nc_ssh_time.calendar = 'XXX days in every year' nc_ssh_time.cycle_length = cycle # nc_zeta_time=nc.createVariable('zeta_time',np.float64, ('zeta_time',)) nc_zeta_time.long_name = 'time for sea surface height' nc_zeta_time.units = 'day' nc_zeta_time.calendar = 'XXX days in every year' nc_zeta_time.cycle_length = cycle # if obc[0]==1: # # Southern boundary # nc_temp_south=nc.createVariable('temp_south',np.float64, ('temp_time','s_rho','xi_rho',)) nc_temp_south.long_name = 'southern boundary potential temperature' nc_temp_south.units = 'Celsius' nc_temp_south.coordinates = 'lon_rho s_rho temp_time' # nc_salt_south=nc.createVariable('salt_south',np.float64, ('salt_time','s_rho','xi_rho',)) nc_salt_south.long_name = 'southern boundary salinity' nc_salt_south.units = 'PSU' nc_salt_south.coordinates = 'lon_rho s_rho salt_time' # nc_u_south=nc.createVariable('u_south',np.float64, ('v3d_time','s_rho','xi_u',)) nc_u_south.long_name = 'southern boundary u-momentum component' nc_u_south.units = 'meter second-1' nc_u_south.coordinates = 'lon_u s_rho u_bry_time' # nc_v_south=nc.createVariable('v_south',np.float64, ('v3d_time','s_rho','xi_rho',)) nc_v_south.long_name = 'southern boundary v-momentum component' nc_v_south.units = 'meter second-1' nc_v_south.coordinates = 'lon_v s_rho vclm_time' # nc_ubar_south=nc.createVariable('ubar_south',np.float64, ('v2d_time','xi_u',)) nc_ubar_south.long_name = 'southern boundary vertically integrated u-momentum component' nc_ubar_south.units = 'meter second-1' nc_ubar_south.coordinates = 'lon_u uclm_time' # nc_vbar_south=nc.createVariable('vbar_south',np.float64, ('v2d_time','xi_rho',)) nc_vbar_south.long_name = 'southern boundary vertically integrated v-momentum component' nc_vbar_south.units = 'meter second-1' nc_vbar_south.coordinates = 'lon_v vclm_time' # nc_zeta_south=nc.createVariable('zeta_south',np.float64, ('zeta_time','xi_rho',)) nc_zeta_south.long_name = 'southern boundary sea surface height' nc_zeta_south.units = 'meter' nc_zeta_south.coordinates = 'lon_rho zeta_time' # if obc[1]==1: # # Eastern boundary # nc_temp_east=nc.createVariable('temp_east',np.float64, ('temp_time','s_rho','eta_rho',)) nc_temp_east.long_name = 'eastern boundary potential temperature' nc_temp_east.units = 'Celsius' nc_temp_east.coordinates = 'lat_rho s_rho temp_time' # nc_salt_east=nc.createVariable('salt_east',np.float64, ('salt_time','s_rho','eta_rho',)) nc_salt_east.long_name = 'eastern boundary salinity' nc_salt_east.units = 'PSU' nc_salt_east.coordinates = 'lat_rho s_rho salt_time' # nc_u_east=nc.createVariable('u_east',np.float64, ('v3d_time','s_rho','eta_rho',)) nc_u_east.long_name = 'eastern boundary u-momentum component' nc_u_east.units = 'meter second-1' nc_u_east.coordinates = 'lat_u s_rho u_bry_time' # nc_v_east=nc.createVariable('v_east',np.float64, ('v3d_time','s_rho','eta_v',)) nc_v_east.long_name = 'eastern boundary v-momentum component' nc_v_east.units = 'meter second-1' nc_v_east.coordinates = 'lat_v s_rho vclm_time' # nc_ubar_east=nc.createVariable('ubar_east',np.float64, ('v2d_time','eta_rho',)) nc_ubar_east.long_name = 'eastern boundary vertically integrated u-momentum component' nc_ubar_east.units = 'meter second-1' nc_ubar_east.coordinates = 'lat_u uclm_time' # nc_vbar_east=nc.createVariable('vbar_east',np.float64, ('v2d_time','eta_v',)) nc_vbar_east.long_name = 'eastern boundary vertically integrated v-momentum component' nc_vbar_east.units = 'meter second-1' nc_vbar_east.coordinates = 'lat_v vclm_time' # nc_zeta_east=nc.createVariable('zeta_east',np.float64, ('zeta_time','eta_rho',)) nc_zeta_east.long_name = 'eastern boundary sea surface height' nc_zeta_east.units = 'meter' nc_zeta_east.coordinates = 'lat_rho zeta_time' # if obc[2]==1: # # Northern boundary # nc_temp_north=nc.createVariable('temp_north',np.float64, ('temp_time','s_rho','xi_rho',)) nc_temp_north.long_name = 'northern boundary potential temperature' nc_temp_north.units = 'Celsius' nc_temp_north.coordinates = 'lon_rho s_rho temp_time' # nc_salt_north=nc.createVariable('salt_north',np.float64, ('salt_time','s_rho','xi_rho',)) nc_salt_north.long_name = 'northern boundary salinity' nc_salt_north.units = 'PSU' nc_salt_north.coordinates = 'lon_rho s_rho salt_time' # nc_u_north=nc.createVariable('u_north',np.float64, ('v3d_time','s_rho','xi_u',)) nc_u_north.long_name = 'northern boundary u-momentum component' nc_u_north.units = 'meter second-1' nc_u_north.coordinates = 'lon_u s_rho u_bry_time' # nc_v_north=nc.createVariable('v_north',np.float64, ('v3d_time','s_rho','xi_rho',)) nc_v_north.long_name = 'northern boundary v-momentum component' nc_v_north.units = 'meter second-1' nc_v_north.coordinates = 'lon_v s_rho vclm_time' # nc_ubar_north=nc.createVariable('ubar_north',np.float64, ('v2d_time','xi_u',)) nc_ubar_north.long_name = 'northern boundary vertically integrated u-momentum component' nc_ubar_north.units = 'meter second-1' nc_ubar_north.coordinates = 'lon_u uclm_time' # nc_vbar_north=nc.createVariable('vbar_north',np.float64, ('v2d_time','xi_rho',)) nc_vbar_north.long_name = 'northern boundary vertically integrated v-momentum component' nc_vbar_north.units = 'meter second-1' nc_vbar_north.coordinates = 'lon_v vclm_time' nc_zeta_north=nc.createVariable('zeta_north',np.float64, ('zeta_time','xi_rho',)) nc_zeta_north.long_name = 'northern boundary sea surface height' nc_zeta_north.units = 'meter' nc_zeta_north.coordinates = 'lon_rho zeta_time' # if obc[3]==1: # # Western boundary # nc_temp_west=nc.createVariable('temp_west',np.float64, ('temp_time','s_rho','eta_rho',)) nc_temp_west.long_name = 'western boundary potential temperature' nc_temp_west.units = 'Celsius' nc_temp_west.coordinates = 'lat_rho s_rho temp_time' # nc_salt_west=nc.createVariable('salt_west',np.float64, ('salt_time','s_rho','eta_rho',)) nc_salt_west.long_name = 'western boundary salinity' nc_salt_west.units = 'PSU' nc_salt_west.coordinates = 'lat_rho s_rho salt_time' # nc_u_west=nc.createVariable('u_west',np.float64, ('v3d_time','s_rho','eta_rho',)) nc_u_west.long_name = 'western boundary u-momentum component' nc_u_west.units = 'meter second-1' nc_u_west.coordinates = 'lat_u s_rho u_bry_time' # nc_v_west=nc.createVariable('v_west',np.float64, ('v3d_time','s_rho','eta_v',)) nc_v_west.long_name = 'western boundary v-momentum component' nc_v_west.units = 'meter second-1' nc_v_west.coordinates = 'lat_v s_rho vclm_time' # nc_ubar_west=nc.createVariable('ubar_west',np.float64, ('v2d_time','eta_rho',)) nc_ubar_west.long_name = 'western boundary vertically integrated u-momentum component' nc_ubar_west.units = 'meter second-1' nc_ubar_west.coordinates = 'lat_u uclm_time' # nc_vbar_west=nc.createVariable('vbar_west',np.float64, ('v2d_time','eta_v',)) nc_vbar_west.long_name = 'western boundary vertically integrated v-momentum component' nc_vbar_west.units = 'meter second-1' nc_vbar_west.coordinates = 'lat_v vclm_time' # nc_zeta_west=nc.createVariable('zeta_west',np.float64, ('zeta_time','eta_rho',)) nc_zeta_west.long_name = 'western boundary sea surface height' nc_zeta_west.units = 'meter' nc_zeta_west.coordinates = 'lat_rho zeta_time' # # # Compute S coordinates # (sc_r,Cs_r,sc_w,Cs_w) = vgrd.scoordinate(theta_s,theta_b,N,hc,vtransform) print('vtransform = '+str(vtransform)) # # Write variables # nc_spherical[:]='T' nc_Vtransform[:]=vtransform nc_Vstretching[:]=1 nc_tstart[:] = np.min(bry_time) nc_tend[:] = np.max(bry_time) nc_theta_s[:] = theta_s nc_theta_b[:] = theta_b nc_Tcline[:] = hc nc_hc[:] = hc nc_sc_r[:] = sc_r nc_sc_w[:] = sc_w nc_Cs_r[:] = Cs_r nc_Cs_w[:] = Cs_w nc_tclm_time[:] = bry_time nc_temp_time[:] = bry_time nc_sclm_time[:] = bry_time nc_salt_time[:] = bry_time nc_uclm_time[:] = bry_time nc_vclm_time[:] = bry_time nc_v2d_time[:] = bry_time nc_v3d_time[:] = bry_time nc_ssh_time[:] = bry_time nc_zeta_time[:] = bry_time nc_bry_time[:] = bry_time if obc[0]==1: nc_u_south[:] = 0. nc_v_south[:] = 0. nc_ubar_south[:] = 0. nc_vbar_south[:] = 0. nc_zeta_south[:] = 0. nc_temp_south[:] = 0. nc_salt_south[:] = 0. if obc[1]==1: nc_u_east[:] = 0. nc_v_east[:] = 0. nc_ubar_east[:] = 0. nc_vbar_east[:] = 0. nc_zeta_east[:] = 0. nc_temp_east[:] = 0. nc_salt_east[:] = 0. if obc[2]==1: nc_u_north[:] = 0. nc_v_north[:] = 0. nc_ubar_north[:] = 0. nc_vbar_north[:] = 0. nc_zeta_north[:] = 0. nc_temp_north[:] = 0. nc_salt_north[:] = 0. if obc[3]==1: nc_u_west[:] = 0. nc_v_west[:] = 0. nc_ubar_west[:] = 0. nc_vbar_west[:] = 0. nc_zeta_west[:] = 0. nc_temp_west[:] = 0. nc_salt_west[:] = 0. nc.close() return
print(' ') print(' Title: '+title) # # Create the CROCO boundary file # glor.create_bryfile(bryname,grdname,title,obc,\ theta_s,theta_b,hc,N,\ time_bry,cycle_bry,vtransform) # # get the CROCO grid # ncg = netcdf(grdname,'r') ncgrd = ncg.variables lon_rho = np.array(ncgrd['lon_rho'][:]) lat_rho = np.array(ncgrd['lat_rho'][:]) lon_u = np.array(ncgrd['lon_u'][:]) lat_u = np.array(ncgrd['lat_u'][:]) lon_v = np.array(ncgrd['lon_v'][:]) lat_v = np.array(ncgrd['lat_v'][:]) h = np.array(ncgrd['h'][:]) mask = np.array(ncgrd['mask_rho'][:]) angle = np.array(ncgrd['angle'][:]) [M,L] = np.shape(lon_rho) ncg.close() # # Open the CROCO boundary file for writing
time[1][1], '02') + '-' + format(time[1][2], '02') + '-' + format( time[1][3], '02') print tstr t0 = time[0][0] * 86400 + time[0][1] * 3600 + time[0][2] * 60 + time[0][3] t1 = time[-1][0] * 86400 + time[-1][1] * 3600 + time[-1][2] * 60 + time[-1][3] pics = [np.zeros([nlat, nlon]) for i in range(len(vars))] units = ['' for i in range(len(vars))] names = ['' for i in range(len(vars))] files = glob.glob(pdata + '*_d*.nc') files.sort(key=os.path.basename) nfile = 0 for i in range(len(files)): fid = netcdf(files[i], 'r') t = fid.variables['time'][:] if (t >= t0 and t <= t1): for ivar in range(len(vars)): print 'from: ', files[i], ', read ', vars[ivar] data = fid.variables[vars[ivar]] hyam = fid.variables['hyam'][:] hybm = fid.variables['hybm'][:] ps = np.exp(fid.variables['PS'][:][0]) if len(data[:][0].shape) == 2: pics[ivar] += data[:][0] else: for ilev in range(nlev - 1): flag1 = np.zeros([nlat, nlon]).astype(int) flag2 = np.zeros([nlat, nlon]).astype(int) p1 = hyam[ilev] * 1e5 + hybm[ilev] * ps
def create_inifile(ininame,grdname,title,theta_s,theta_b,hc,N,ini_time,vtransform): # # ################################################################ # # # This function create the header of a Netcdf climatology # file. # # Input: # # ininame Netcdf initial file name (character string). # grdname Netcdf grid file name (character string). # theta_s S-coordinate surface control parameter.(Real) # theta_b S-coordinate bottom control parameter.(Real) # hc Width (m) of surface or bottom boundary layer # where higher vertical resolution is required # during stretching.(Real) # N Number of vertical levels.(Integer) # ini_time Initial time.(Real) # clobber Switch to allow or not writing over an existing # file.(character string) # # # # ################################################################ # # print(' ') print(' Creating the file : '+ininame) print(' VTRANSFORM = '+str(vtransform)) # # Read the grid file and check the topography # nc=netcdf(grdname, 'r') h=nc.variables['h'][:] maskr=nc.variables['mask_rho'][:] [Mp,Lp]=np.shape(h) nc.close() # # # hmin=np.min(h[np.where(maskr==1)]) if vtransform == 1: if hc > hmin: print('Error: hc ('+hc+' m) > hmin ('+hmin+' m)') L=Lp-1 M=Mp-1 Np=N+1 # # Create the initial file # type = 'INITIAL file' history = 'CROCO' if os.path.exists(ininame): os.remove(ininame) print('Create: ' +ininame) nc=netcdf(ininame,'w',format='NETCDF3_CLASSIC') # # Create global attributes # nc.title = title nc.history = 'Created '+str(time.ctime(time.time())) nc.ini_file = ininame nc.grd_file = grdname nc.type='CROCO initial file' # # Create dimensions # nc_dim_xi_u=nc.createDimension('xi_u',L) nc_dim_xi_v=nc.createDimension('xi_v',Lp) nc_dim_xi_rho=nc.createDimension('xi_rho',Lp) nc_dim_eta_u=nc.createDimension('eta_u',Mp) nc_dim_eta_v=nc.createDimension('eta_v',M) nc_dim_eta_rho=nc.createDimension('eta_rho',Mp) nc_dim_s_rho=nc.createDimension('s_rho',N) nc_dim_s_w=nc.createDimension('s_w',Np) nc_dim_tracer=nc.createDimension('tracer',2) nc_dim_ini_time=nc.createDimension('ini_time',0) nc_dim_one=nc.createDimension('one',1) # # Create variables and attributes # nc_spherical=nc.createVariable('spherical','S1', ('one',)) nc_spherical.long_name = 'grid type logical switch' nc_spherical.flag_values = 'T, F' nc_spherical.flag_meanings = 'spherical Cartesian' # nc_Vtransform=nc.createVariable('Vtransform','i4', ('one',)) nc_Vtransform.long_name = 'vertical terrain-following transformation equation' # nc_Vstretching=nc.createVariable('Vstretching','i4', ('one',)) nc_Vstretching.long_name = 'vertical terrain-following stretching function' # nc_tstart=nc.createVariable('tstart',np.float64, ('one',)) nc_tstart.long_name = 'start processing day' nc_tstart.units = 'day' # nc_tend=nc.createVariable('tend',np.float64, ('one',)) nc_tend.long_name = 'end processing day' nc_tend.units = 'day' # nc_theta_s=nc.createVariable('theta_s',np.float64, ('one',)) nc_theta_s.long_name = 'S-coordinate surface control parameter' nc_theta_s.units = 'nondimensional' # nc_theta_b=nc.createVariable('theta_b',np.float64, ('one',)) nc_theta_b.long_name = 'S-coordinate bottom control parameter' nc_theta_b.units = 'nondimensional' # nc_Tcline=nc.createVariable('Tcline',np.float64, ('one',)) nc_Tcline.long_name = 'S-coordinate surface/bottom layer width' nc_Tcline.units = 'meter' # nc_hc=nc.createVariable('hc',np.float64, ('one',)) nc_hc.long_name = 'S-coordinate parameter, critical depth' nc_hc.units = 'meter' # nc_sc_r=nc.createVariable('sc_r',np.float64, ('s_rho',)) nc_sc_r.long_name = 'S-coordinate at RHO-points' nc_sc_r.valid_min = -1. nc_sc_r.valid_max = 0. nc_sc_r.positive = 'up' if vtransform == 1: nc_sc_r.standard_name = 'ocean_s_coordinate_g1' elif vtransform == 2: nc_sc_r.standard_name = 'ocean_s_coordinate_g2' nc_sc_r.formula_terms = 's: s_rho C: Cs_r eta: zeta depth: h depth_c: hc' # nc_sc_w=nc.createVariable('sc_w',np.float64, ('s_w',)) nc_sc_w.long_name = 'S-coordinate at W-points' nc_sc_w.valid_min = -1. nc_sc_w.valid_max = 0. nc_sc_w.positive = 'up' if vtransform == 1: nc_sc_w.standard_name = 'ocean_s_coordinate_g1' elif vtransform == 2: nc_sc_w.standard_name = 'ocean_s_coordinate_g2' nc_sc_w.formula_terms = 's: s_w C: Cs_w eta: zeta depth: h depth_c: hc' # nc_Cs_r=nc.createVariable('Cs_r',np.float64, ('s_rho',)) nc_Cs_r.long_name = 'S-coordinate stretching curves at RHO-points' nc_Cs_r.units = 'nondimensional' nc_Cs_r.valid_min = -1 nc_Cs_r.valid_max = 0 # nc_Cs_w=nc.createVariable('Cs_w',np.float64, ('s_w',)) nc_Cs_w.long_name = 'S-coordinate stretching curves at W-points' nc_Cs_w.units = 'nondimensional' nc_Cs_w.valid_min = -1 nc_Cs_w.valid_max = 0 # nc_scrum_time=nc.createVariable('scrum_time',np.float64, ('ini_time',)) nc_scrum_time.long_name = 'ini_time since initialization' nc_scrum_time.units = 'second' # nc_ocean_time=nc.createVariable('ocean_time',np.float64, ('ini_time',)) nc_ocean_time.long_name = 'ini_time since initialization' nc_ocean_time.units = 'second' # nc_u=nc.createVariable('u',np.float64, ('ini_time','s_rho','eta_u','xi_u',)) nc_u.long_name = 'u-momentum component' nc_u.units = 'meter second-1' # nc_v=nc.createVariable('v',np.float64, ('ini_time','s_rho','eta_v','xi_v',)) nc_v.long_name = 'v-momentum component' nc_v.units = 'meter second-1' # nc_ubar=nc.createVariable('ubar',np.float64, ('ini_time','eta_u','xi_u',)) nc_ubar.long_name = 'vertically integrated u-momentum component' nc_ubar.units = 'meter second-1' # nc_vbar=nc.createVariable('vbar',np.float64, ('ini_time','eta_v','xi_v',)) nc_vbar.long_name = 'vertically integrated v-momentum component' nc_vbar.units = 'meter second-1' # nc_zeta=nc.createVariable('zeta',np.float64, ('ini_time','eta_rho','xi_rho',)) nc_zeta.long_name = 'free-surface' nc_zeta.units = 'meter' # nc_temp=nc.createVariable('temp',np.float64, ('ini_time','s_rho','eta_rho','xi_rho',)) nc_temp.long_name = 'potential temperature' nc_temp.units = 'Celsius' # nc_salt=nc.createVariable('salt',np.float64, ('ini_time','s_rho','eta_rho','xi_rho',)) nc_salt.long_name = 'salinity' nc_salt.units = 'PSU' # # Compute S coordinates # (sc_r,Cs_r,sc_w,Cs_w) = vgrd.scoordinate(theta_s,theta_b,N,hc,vtransform) print('vtransform = '+str(vtransform)) # # Write variables # nc_spherical[:]='T' nc_Vtransform[:]=vtransform nc_Vstretching[:]=1 nc_tstart[:] = ini_time nc_tend[:] = ini_time nc_theta_s[:] = theta_s nc_theta_b[:] = theta_b nc_Tcline[:] = hc nc_hc[:] = hc nc_sc_r[:] = sc_r nc_Cs_r[:] = Cs_r nc_scrum_time[0] = ini_time*24.*3600. nc_ocean_time[0] = ini_time*24.*3600. nc_u[:] = 0 nc_v[:] = 0 nc_zeta[:] = 0 nc_ubar[:] = 0 nc_vbar[:] = 0 nc_temp[:] = 0 nc_salt[:] = 0 # nc.close() # return
assuming that the time unit are well documented. """ import os, sys #sys.path.append("/home/jouanno/Tools/MyPython/") from netCDF4 import Dataset as netcdf import datetime import netcdftime as nctime import numpy as np # if len(sys.argv) == 2: cfile = sys.argv[-1] else: print "USAGE :", sys.argv[0], "FILE" quit() cfile = sys.argv[-1] print " working for file :", cfile ncfile = netcdf(cfile, 'r') time_counter = ncfile.variables['time_counter'] units = time_counter.getncattr('units') cal = 'standard' cal = time_counter.getncattr('calendar') time = ncfile.variables['time_counter'][:] cdftime = nctime.utime(units, calendar=cal) dat = cdftime.num2date(time) npl = len(dat) for i in range(0, npl): print i + 1, dat[i] quit()
def fncread(fn, var): fid = netcdf(fn, 'r') data = fid.variables[var][:] fid.close() return data
print(' Making initial file: ' + ininame) print(' ') print(' Title: ' + title) # # Initial file # glor.create_inifile(ininame, grdname, title, theta_s, theta_b, hc, N, Tini, vtransform) # # get the CROCO grid # ncg = netcdf(grdname, 'r') ncgrd = ncg.variables lon_rho = np.array(ncgrd['lon_rho'][:]) lat_rho = np.array(ncgrd['lat_rho'][:]) lon_u = np.array(ncgrd['lon_u'][:]) lat_u = np.array(ncgrd['lat_u'][:]) lon_v = np.array(ncgrd['lon_v'][:]) lat_v = np.array(ncgrd['lat_v'][:]) h = np.array(ncgrd['h'][:]) mask = np.array(ncgrd['mask_rho'][:]) angle = np.array(ncgrd['angle'][:]) [M, L] = np.shape(lon_rho) ncg.close() lonmin = np.min(lon_rho) lonmax = np.max(lon_rho)
import cartopy.crs as ccrs import numpy as np from netCDF4 import Dataset as netcdf from datetime import datetime from datetime import timedelta ufilt_filename = sys.argv[1] vfilt_filename = sys.argv[2] u_filename = sys.argv[3] v_filename = sys.argv[4] ufield = sys.argv[5] vfield = sys.argv[6] to = int(sys.argv[7]) tf = int(sys.argv[8]) ufilt_file = netcdf(ufilt_filename, 'r', format='NETCDF4') vfilt_file = netcdf(vfilt_filename, 'r', format='NETCDF4') u_file = netcdf(u_filename, 'r', format='NETCDF4') v_file = netcdf(v_filename, 'r', format='NETCDF4') lon = u_file.variables['lon'][:] lat = u_file.variables['lat'][:] time = u_file.variables['time'][:] lons, lats = lons, lats = np.meshgrid(lon, lat) cmap = plt.cm.RdBu_r cmap.set_bad((0.2, 0.2, 0.2), 1.) FFMpegWriter = manimation.writers['ffmpeg'] metadata = dict(title='JRA55do Wind', artist='Mike Bueti') writer = FFMpegWriter(fps=12, metadata=metadata)
def isValid(filename): try: file = netcdf(filename, 'r') except: return False return True
# Ymin = 1993 Mmin = 01 Dmin = 01 # # Last date to process # # Ymax = 2017 Mmax = 05 Dmax = 10 # # dt = 3 # Interval between AVISO maps [days] # nc = netcdf('glorys_moz_sst.nc') lon_glo = nc.variables['lon'][:] lat_glo = nc.variables['lat'][:] T_glo = nc.variables['time'][:] # # choose domain to subset: !! don't go north of 23N !! # latmin = -30 latmax = -10 lonmin = 32 lonmax = 55 # # Time in days since 1/1/Yorig # romsdate=date.fromordinal(np.int(date.toordinal(date(Yorig,1,1))+t/(24*3600)))
def __init__(self, filename): Input.__init__(self, filename) self._file = netcdf(filename, 'r')
def main(argv): # Optional for the user to specify are the following # parameters: # -b <basedir> # -p <prefix> # -c <country> - the country in which all stations # will be iterated through. # (If not specified - the script iterates through # all countries.) # Mandatory for the user to specify are the following: # -s <source_name> - each user has a specific source_name # that they should know (if not, see Instructions, point 7). # -d <env> - the environment in which the data from the # WRF model is going to be stored. # -o <output> - either insert data into database or # export it to txt fomrat. basedir = './' prefix = 'wrfout_d02' source_name = '' country = 'All' # By default: 'All'. # Possible options are 'BG', 'GR', ... env = '' # possible options are 'dev' and 'prod'. output = 'db' # By default: 'db'. # Possible options: 'db' (write to SUADA db), # 'tro' (write to troposinex txt format). instrument_name = 'GNSS' try: opts, args = getopt.getopt(argv, "h:b:p:s:c:d:o:", [ "basedir=", "prefix=", "source_name=", "country=", "env=", "output=" ]) except getopt.GetoptError: print 'ncdf2db.py -b <basedir> [' + basedir + '] -p <prefix> [' + prefix + '] -s <source_name> [' + str( source_name) + '] -c <country> [' + str( country) + '] -d <env> [' + str(env) + '] -o <output> [' + str( output) + ']' sys.exit(2) for opt, arg in opts: if opt == '-h': print 'ncdf2db.py -b <basedir> [' + basedir + '] -p <prefix> [' + prefix + '] -s <source_name> [' + str( source_name) + '] -c <country> [' + str( country) + '] -d <env> [' + str( env) + '] -o <output> [' + str(output) + ']' sys.exit() elif opt in ("-b", "--basedir"): basedir = arg elif opt in ("-p", "--prefix"): prefix = arg elif opt in ("-s", "--source_name"): source_name = str(arg) elif opt in ("-c", "--country"): if country: country = str(arg) else: country = 'All' elif opt in ("-d", "--env"): env = str(arg) elif opt in ("-o", "--output"): output = str(arg) # Check whether the user has specified source name. # If not -> Error. if source_name == '': print 'Error: You must specify the source name! (-s <source_name>)' sys.exit() # Check whether the user has specified the database. # If not -> Error. if env == '': print 'Error: You must specify the database! (-d <env>)' sys.exit() if not output in {'db', 'tro'}: print('Error: Not a possible output {}'.format(output)) sys.exit() # Retrieve the list of all data files # starting with [prefix] inside [basedir] folder flist = listfiles(basedir, prefix) # Create the DB connection: db = None cur = None try: if env == 'dev': print('DB -> {}'.format(cfg.dev['db'])) db = MySQLdb.connect(host=cfg.dev['host'], \ user=cfg.dev['user'], \ passwd=cfg.dev['passwd'], \ db=cfg.dev['db']) elif env == 'prod': print('DB -> {}'.format(cfg.prod['db'])) db = MySQLdb.connect(host=cfg.prod['host'], \ user=cfg.prod['user'], \ passwd=cfg.prod['passwd'], \ db=cfg.prod['db']) elif env != {'dev', 'prod'}: print 'Error: No such database! (Possible options for -d <env> are "dev" and "prod".)' sys.exit() cur = db.cursor() except Exception as e: print('Failed to establish connection: {0}'.format(e)) cur.close() sys.exit(1) # Fetching source_id... print('Trying to fetch the source_id ...') source_id = get_source_id(cur, source_name) if source_id < 0: print 'Error: Can not find source_id for source_name: {}'.format( source_name) sys.exit(1) print('Source id: {} found for source name: {}'.format( source_id, source_name)) # Call the procedure that selects the stations' information # from the SUADA information tables: print('Get stations') stations = getstations(cur, source_name, country, instrument_name) # Now iterating over list of all data files: print('Iterate files') for file in flist: field2D = [] print 'Processing: ', file ncfile = netcdf(file) strDateTime = ncfile.variables['Times'][0].tostring().replace('_', ' ') local_tz = get_localzone() date = parser.parse(strDateTime) strDateTimeLocal = local_tz.localize(date) # Print the timestamp print('Dataset timestamp: {}'.format(strDateTimeLocal)) xlong = ncfile.variables['XLONG'][0] xlat = ncfile.variables['XLAT'][0] alt = ncfile.variables['HGT'][0] truelat1 = ncfile.TRUELAT1 truelat2 = ncfile.TRUELAT2 ref_lat = ncfile.CEN_LAT ref_lon = ncfile.CEN_LON stand_lon = ncfile.STAND_LON dx = ncfile.DX dy = ncfile.DY west_east = ncfile.dimensions['west_east'].size south_north = ncfile.dimensions['south_north'].size # Empty list to contain data: station_data = [] for station in stations: stationName = station['name'] stationId = station['id'] sensorId = station['senid'] print 'Station: ', station['name'], ' ID: ', station[ 'id'], ' sensorId: ', sensorId, 'Country Code: ', station[ 'country'] x0 = station['long'] y0 = station['latt'] z0 = station['alt'] indx = wrf.ll_to_ij(1, truelat1, truelat2, stand_lon, dx, dy, ref_lat, ref_lon, y0, x0) j0 = west_east / 2 + indx[0] - 1 i0 = south_north / 2 + indx[1] - 1 station['i0'] = i0 station['j0'] = j0 station['source_id'] = source_id if (i0 >= 0 and i0 < south_north) and (j0 >= 0 and j0 < west_east) and ( (country == 'All') or (country == station['country'])): if output == 'db': process_station(db, cur, station, ncfile, date) elif output == 'tro': # save result in # tropo_station_data tropo_station_data = process_station_tro( station, ncfile, date) # if tropo_station_data is # not None, # append to data list if tropo_station_data: station_data.append(tropo_station_data.copy()) if output == 'tro' and len(station_data) > 0: tropo_out(station_data) if not (len(flist)): print 'No candidates for import files found ...' sys.exit(1)
print 'Setting ROMS solutions paths for: ' + init_dict['ROMS_ID'] ROMS_obj = ROMS_out_paths.ROMS_run(init_dict['ROMS_ID']) ROMS_obj.set_paths() ##################################### #SET OUTPUT AND GRID FILE PATHS/NAMES #################################### grd_name = ROMS_obj.path_grid + ROMS_obj.grid_name dat_name = ROMS_obj.path_output + ROMS_obj.out_base_name if t_interp == 'spline': uv_name = ROMS_obj.path_ts_uv + 'ts_' + ROMS_obj.out_base_name ################################# # READ IN GRID to obtain dx, dy ################################## nc_grd = netcdf(grd_name, 'r') pm = nc_grd.variables['pm'][:] pn = nc_grd.variables['pn'][:] dx = 1. / pm.T dy = 1. / pn.T [Lx, Ly] = dx.shape ################################################################ ############################################################# # Make list of filenames with frame numbers of velocity data ############################################################# fnum = init_dict['fnum'] sub = init_dict['sub'] frpf = init_dict['frpf'] nfr = init_dict['nfr'] dfr = init_dict['dfr']
#SET OUTPUT AND GRID FILE PATHS/NAMES #################################### grd_name = ROMS_obj.path_grid + ROMS_obj.grid_name dat_name = ROMS_obj.path_output + ROMS_obj.out_base_name try: uv_name = ROMS_obj.path_ts_uv + 'ts_' + ROMS_obj.out_base_name #from mtspline omega_name = ROMS_obj.path_omega + 'ts_' + ROMS_obj.omega_name # from mtspline zs_name = ROMS_obj.path_zs + ROMS_obj.zs_name # from mtspline except: pass ################################################################ ################################# # READ IN GRID to obtain dx, dy ################################## nc_grd = netcdf(grd_name, 'r') pm = nc_grd.variables['pm'][:] pn = nc_grd.variables['pn'][:] dx = 1. / pm.T dy = 1. / pn.T mask_rho = nc_grd.variables['mask_rho'][:, :] [Lx, Ly] = dx.shape ################################################################ ############################################################# # Make list of filenames with frame numbers of velocity data ############################################################# t_interp = init_dict['t_interp'] omega_online = init_dict['omega_online'] tim_opt = init_dict['tim_opt'] fnum = init_dict['fnum']
def fncread(fn, var): # read a variable from a netcdf file fid = netcdf(fn, 'r') data = fid.variables[var][:] fid.close() return data
else: ntime = timeend // foutfreq for itime in range(40, ntime): #for itime in range(18): if foutfreq < 0: dsec = -foutfreq * tunit * itime else: dsec = foutfreq * timestep * itime time = inittime + timedelta(seconds=dsec) tstr = format(time.year,'04')+format(time.month,'02')+ \ format(time.day,'02')+'_'+format(time.hour,'02')+ \ '-'+format(time.minute,'02')+'-'+format(time.second,'02') fn = pcases + casename + '/' + casename + '_' + tstr + '.nc' status, fn = commands.getstatusoutput('ls ' + fn) if status == 0: pictime += [time] print fn fid = netcdf(fn, 'r') lev = fid.variables['lev'][:] lon = fid.variables['lon'][:] for ivar in range(len(vars)): if piclevs[ivar] < 0: data = np.mean(fid.variables[vars[ivar]][:, (nlat / 2 - 1):(nlat / 2 + 1), :], axis=1) reallev[vars[ivar]] = -1 else: ilev = np.argmin(np.abs(lev - piclevs[ivar])) reallev[vars[ivar]] = lev[ilev] data = np.mean(fid.variables[vars[ivar]][:, ilev, (nlat / 2 - 1):(nlat / 2 +
def write2netCDF(filename, lon, lat, z, increments=None, nSamples=None, title='CSI product', name='z', scale=1.0, offset=0.0, mask=None, xyunits=['Lon', 'Lat'], units='None', interpolation=True, verbose=True, noValues=np.nan): ''' Creates a netCDF file with the arrays in Z. Z can be list of array or an array, the size of lon. .. Args: * filename -> Output file name * lon -> 1D Array of lon values * lat -> 1D Array of lat values * z -> 2D slice to be saved * mask -> if not None, must be a 2d-array of a polynome to mask what is outside of it. This option is really long, so I don't use it... .. Kwargs: * title -> Title for the grd file * name -> Name of the field in the grd file * scale -> Scale value in the grd file * offset -> Offset value in the grd file .. Returns: * None ''' if interpolation: # Check if nSamples is not None: if type(nSamples) is int: nSamples = [nSamples, nSamples] dlon = (lon.max() - lon.min()) / nSamples[0] dlat = (lat.max() - lat.min()) / nSamples[1] if increments is not None: dlon, dlat = increments # Resample on a regular grid olon, olat = np.meshgrid(np.arange(lon.min(), lon.max(), dlon), np.arange(lat.min(), lat.max(), dlat)) else: # Get lon lat olon = lon olat = lat if increments is not None: dlon, dlat = increments else: dlon = olon[0, 1] - olon[0, 0] dlat = olat[1, 0] - olat[0, 0] # Create a file fid = netcdf(filename, 'w') # Create a dimension variable fid.createDimension('side', 2) if verbose: print('Create dimension xysize with size {}'.format(np.prod( olon.shape))) fid.createDimension('xysize', np.prod(olon.shape)) # Range variables fid.createVariable('x_range', 'd', ('side', )) fid.variables['x_range'].units = xyunits[0] fid.createVariable('y_range', 'd', ('side', )) fid.variables['y_range'].units = xyunits[1] # Spacing fid.createVariable('spacing', 'd', ('side', )) fid.createVariable('dimension', 'i4', ('side', )) # Informations if title is not None: fid.title = title fid.source = 'CSI.utils.write2netCDF' # Filing rnage and spacing if verbose: print('x_range from {} to {} with spacing {}'.format( olon[0, 0], olon[0, -1], dlon)) fid.variables['x_range'][0] = olon[0, 0] fid.variables['x_range'][1] = olon[0, -1] fid.variables['spacing'][0] = dlon if verbose: print('y_range from {} to {} with spacing {}'.format( olat[0, 0], olat[-1, 0], dlat)) fid.variables['y_range'][0] = olat[0, 0] fid.variables['y_range'][1] = olat[-1, 0] fid.variables['spacing'][1] = dlat if interpolation: # Interpolate interpZ = sciint.LinearNDInterpolator(np.vstack((lon, lat)).T, z, fill_value=noValues) oZ = interpZ(olon, olat) else: # Get values oZ = z # Masking? if mask is not None: # Import matplotlib.path import matplotlib.path as path # Create the path poly = path.Path([[lo, la] for lo, la in zip(mask[:, 0], mask[:, 1])], closed=False) # Create the list of points xy = np.vstack((olon.flatten(), olat.flatten())).T # Findthose outside bol = poly.contains_points(xy) # Mask those out oZ = oZ.flatten() oZ[bol] = np.nan oZ = oZ.reshape(olon.shape) # Range zmin = np.nanmin(oZ) zmax = np.nanmax(oZ) fid.createVariable('{}_range'.format(name), 'd', ('side', )) fid.variables['{}_range'.format(name)].units = units fid.variables['{}_range'.format(name)][0] = zmin fid.variables['{}_range'.format(name)][1] = zmax # Create Variable fid.createVariable(name, 'd', ('xysize', )) fid.variables[name].long_name = name fid.variables[name].scale_factor = scale fid.variables[name].add_offset = offset fid.variables[name].node_offset = 0 # Fill it fid.variables[name][:] = np.flipud(oZ).flatten() # Set dimension fid.variables['dimension'][:] = oZ.shape[::-1] # Synchronize and close fid.sync() fid.close() # All done return