def find_nearest_latlon_xarray(arr, lat=37.102400, lon=-76.392900, radius=12e3): """Short summary. Parameters ---------- arr : type Description of parameter `arr`. lat : type Description of parameter `lat` (the default is 37.102400). lon : type Description of parameter `lon` (the default is -76.392900). radius : type Description of parameter `radius` (the default is 12e3). Returns ------- type Description of returned object. """ from pyresample import utils, geometry from numpy import array, vstack grid1 = geometry.GridDefinition(lons=arr.longitude, lats=arr.latitude) grid2 = geometry.GridDefinition(lons=vstack([lon]), lats=vstack([lat])) row, col = utils.generate_nearest_neighbour_linesample_arrays( grid1, grid2, radius) row = row.flatten() col = col.flatten() return arr.sel(x=col).sel(y=row).squeeze()
def resample(layer, tl, br, samples=256): """ Returns a grid, which is resampled. """ data_grid = geometry.GridDefinition(lats=layer.lats, lons=layer.lons) # Form the coordinates for resampling rlons = np.linspace(tl[0], br[0], 256) rlats = np.linspace(tl[1], br[1], 256) resample_grid = geometry.GridDefinition( lats=np.tile(rlats, (rlons.size, 1)).T, lons=np.tile(rlons, (rlats.size, 1)) ) # Build a resampler. resampler = image.ImageContainerNearest( layer.values, data_grid, radius_of_influence=6500, reduce_data=True ) # Form the appropriate grid. grid = np.flipud(resampler.resample(resample_grid).image_data) grid[grid == 0] = np.nan return grid
def create_custom_grid(ds, filename, var_name, dl, custom_grid): cgrid = xr.open_dataset(custom_grid) clon = cgrid['lon'] clat = cgrid['lat'] cgrid_def = geometry.GridDefinition(lons=clon, lats=clat) ogrid_def = geometry.GridDefinition(lons=ds['lon'], lats=ds['lat']) # Convert data to custom grid obs_container = image.ImageContainerNearest(ds[var_name].data[0, :, :], ogrid_def, radius_of_influence=20000000) obs_modelgrid = obs_container.resample(cgrid_def) data_out = obs_modelgrid.image_data obs_container = image.ImageContainerNearest(ds['error_std'].data[0, :, :], ogrid_def, radius_of_influence=20000000) obs_modelgrid = obs_container.resample(cgrid_def) err_out = obs_modelgrid.image_data ds = xr.Dataset( { var_name: (('time', 'x', 'y'), np.expand_dims(data_out, axis=0)), "error_std": (('time', 'x', 'y'), np.expand_dims(err_out, axis=0)), "lon": (('x', 'y'), clon), "lat": (('x', 'y'), clat) }, coords={ 'time': dl[0:1], }, ) ds.to_netcdf(filename)
def interp_to_obs(var, df, lat, lon, radius=12000.): """Short summary. Parameters ---------- var : type Description of parameter `var`. df : type Description of parameter `df`. lat : type Description of parameter `lat`. lon : type Description of parameter `lon`. radius : type Description of parameter `radius` (the default is 12000.). Returns ------- type Description of returned object. """ from numpy import NaN, vstack from pyresample import geometry, image from pandas import to_timedelta, DataFrame # define CMAQ pyresample grid (source) grid1 = geometry.GridDefinition(lons=lon, lats=lat) # get unique sites from df dfn = df.drop_duplicates(subset=['Latitude', 'Longitude']) # define site grid (target) lats = dfn.Latitude.values lons = dfn.Longitude.values grid2 = geometry.GridDefinition(lons=vstack(lons), lats=vstack(lats)) # Create image container i = image.ImageContainerNearest(var.transpose('y', 'x', 'time').values, grid1, radius_of_influence=radius, fill_value=NaN) # resample ii = i.resample(grid2).image_data.squeeze() # recombine data e = DataFrame(ii, index=dfn.SCS, columns=var.time.values) w = e.stack().reset_index().rename(columns={ 'level_1': 'datetime', 0: 'model' }) w = w.merge(dfn.drop(['datetime', 'datetime_local', 'Obs'], axis=1), on='SCS', how='left') w = w.merge(df[['datetime', 'SCS', 'Obs']], on=['SCS', 'datetime'], how='left') # calculate datetime local w['datetime_local'] = w.datetime + to_timedelta(w.utcoffset, 'H') return w
def test_nearest_neighbor_grid_grid(self): from pyresample import utils, geometry lon_arr = create_test_longitude(-95.0, -85.0, (40, 50), dtype=np.float64) lat_arr = create_test_latitude(25.0, 35.0, (40, 50), dtype=np.float64) grid_dst = geometry.GridDefinition(lons=lon_arr, lats=lat_arr) lon_arr = create_test_longitude(-100.0, -80.0, (400, 500), dtype=np.float64) lat_arr = create_test_latitude(20.0, 40.0, (400, 500), dtype=np.float64) grid = geometry.GridDefinition(lons=lon_arr, lats=lat_arr) rows, cols = utils.generate_nearest_neighbour_linesample_arrays(grid, grid_dst, 12000.)
def construct_source_mask(self): """ Read the binary file and set the mask """ # Settings for the binary file xdim, ydim = 10800, 5400 mask_struct_fmt = "<%0.fB" % (xdim * ydim) n_bytes_header = 1392 # Read the content of the landmask in a string with open(self.mask_filepath, "rb") as fh: # Skip header fh.seek(n_bytes_header) content = fh.read(xdim * ydim) # decode string & order to array mask_val = np.array(struct.unpack(mask_struct_fmt, content)) mask = mask_val.reshape((xdim, ydim)) mask = mask.transpose() # Convert to only land/sea flag # Note: mask must be a byte data type since netCDF does not handle # variables of type bool very well mask = np.int8(mask > 0) # Compute longitude/latitude grids lons_1d = np.linspace(0., 360., xdim) lats_1d = np.linspace(-90, 90, ydim) lons, lats = np.meshgrid(lons_1d, lats_1d) # Create geometry definitions area_def = geometry.GridDefinition(lons=lons, lats=lats) # Set the mask self.set_mask(mask, area_def)
def test_dtype(self): lons = numpy.fromfunction(lambda y, x: 3 + x, (50, 10)) lats = numpy.fromfunction(lambda y, x: 75 - y, (50, 10)) grid_def = geometry.GridDefinition(lons, lats) lons = numpy.asarray(lons, dtype='f4') lats = numpy.asarray(lats, dtype='f4') swath_def = geometry.SwathDefinition(lons=lons, lats=lats) valid_input_index, valid_output_index, index_array, distance_array = \ kd_tree.get_neighbour_info(swath_def, grid_def, 50000, neighbours=1, segments=1)
def sample_latlon(layer, lat, lon): """ Returns a float which is a value grid, which is resampled. """ data_grid = geometry.GridDefinition(lats=layer.lats, lons=layer.lons) resampler = image.ImageContainerNearest( layer.values, data_grid, radius_of_influence=6500, reduce_data=False ) resample_grid = geometry.GridDefinition( lats=np.ones((1, 1)) * lat, lons=np.ones((1, 1)) * lon) # Form the appropriate grid. grid = resampler.resample(resample_grid).image_data return float(grid[0][0])
def test_nearest_neighbor_area_grid(self): from pyresample import utils, geometry lon_arr = create_test_longitude(-94.9, -90.0, (50, 100), dtype=np.float64) lat_arr = create_test_latitude(25.1, 30.0, (50, 100), dtype=np.float64) grid = geometry.GridDefinition(lons=lon_arr, lats=lat_arr) proj_str = "+proj=lcc +datum=WGS84 +ellps=WGS84 +lat_0=25 +lat_1=25 +lon_0=-95 +units=m +no_defs" proj_dict = utils.proj4.proj4_str_to_dict(proj_str) extents = [0, 0, 1000. * 5000, 1000. * 5000] area_def = geometry.AreaDefinition('CONUS', 'CONUS', 'CONUS', proj_dict, 400, 500, extents) rows, cols = utils.generate_nearest_neighbour_linesample_arrays(area_def, grid, 12000.)
def test_nearest_neighbor_grid_area(self): from pyresample import utils, geometry proj_str = "+proj=lcc +datum=WGS84 +ellps=WGS84 +lat_0=25 +lat_1=25 +lon_0=-95 +units=m +no_defs" proj_dict = pyresample.utils._proj4.proj4_str_to_dict(proj_str) extents = [0, 0, 1000. * 2500., 1000. * 2000.] area_def = geometry.AreaDefinition('CONUS', 'CONUS', 'CONUS', proj_dict, 40, 50, extents) lon_arr = create_test_longitude(-100.0, -60.0, (550, 500), dtype=np.float64) lat_arr = create_test_latitude(20.0, 45.0, (550, 500), dtype=np.float64) grid = geometry.GridDefinition(lons=lon_arr, lats=lat_arr) rows, cols = utils.generate_nearest_neighbour_linesample_arrays(grid, area_def, 12000.)
def grid_interpolation(src_grid, tar_grid, radius_of_influence=500000, fill_value=None): src_lat = src_grid['lat'] src_lon = src_grid['lon'] src_data = src_grid['data'] tar_lat = tar_grid['lat'] tar_lon = tar_grid['lon'] src_lon = src_lon % 360.0 tar_lon = tar_lon % 360.0 src_grid_def = geometry.GridDefinition(lons=src_lon, lats=src_lat) tar_grid_def = geometry.GridDefinition(lons=tar_lon, lats=tar_lat) src_img_container = image.ImageContainerNearest( src_data, src_grid_def, radius_of_influence=radius_of_influence, fill_value=fill_value) tar_data = src_img_container.resample(tar_grid_def) return tar_data.image_data
def get_grid_def(lon, lat): """Short summary. Parameters ---------- lon : type Description of parameter `lon`. lat : type Description of parameter `lat`. Returns ------- type Description of returned object. """ return geometry.GridDefinition(lons=lon, lats=lat)
def readE_P(): x_size = 251 y_size = 251 description = 'Arctic EASE grid' proj_id = 'ease_nh' from pyresample import geometry, utils, image area_id = 'ease_nh' area_extent = (-7326849.0625,-7326849.0625,7326849.0625,7326849.0625) proj_dict = {'a': '6371228.0', 'units': 'm', 'lon_0': '0', \ 'proj': 'laea', 'lat_0': '90'} area_def = geometry.AreaDefinition(area_id, description, proj_id, \ proj_dict, x_size, y_size, area_extent) e_p=np.zeros((20,241,480),float) nc=Dataset('evap_precip201411.nc','r') t=nc.variables['time'][:][20*4+2:30*4+2] t0=nc.variables['time'][:][0:1] e=nc.variables['e'][21*4+2:31*4+2,::-1,:] p=nc.variables['tp'][21*4+2:31*4+2,::-1,:] for i in range(1,e.shape[0],2): e[i,:,:]=e[i,:,:]-e[i-1,:,:] p[i,:,:]=p[i,:,:]-p[i-1,:,:] print datetime.datetime(1900,1,1)+datetime.timedelta(hours=int(t[0])) print datetime.datetime(1900,1,1)+datetime.timedelta(hours=int(t0[0])) print datetime.datetime(1900,1,1)+datetime.timedelta(hours=int(t[-1])) e_p=(e+p) lon,lat=np.meshgrid(0+np.arange(480)*0.75,-90+np.arange(241)*0.75) lon[lon>180]-=360. grid_def = geometry.GridDefinition(lons=lon, lats=lat) row_indices, \ col_indices = \ utils.generate_nearest_neighbour_linesample_arrays(grid_def, area_def, 200000) msg_con = image.ImageContainer(e_p.sum(axis=0), grid_def) e_p_grid = msg_con.get_array_from_linesample(row_indices, col_indices) return e_p_grid
x_size = 251 y_size = 251 description = 'Arctic EASE grid' proj_id = 'ease_nh' from pyresample import geometry, utils, image area_id = 'ease_nh' area_extent = (-7326849.0625, -7326849.0625, 7326849.0625, 7326849.0625) proj_dict = {'a': '6371228.0', 'units': 'm', 'lon_0': '0', \ 'proj': 'laea', 'lat_0': '90'} area_def = geometry.AreaDefinition(area_id, description, proj_id, \ proj_dict, x_size, y_size, area_extent) import numpy as np lon, lat = np.meshgrid(-180 + 0.75 / 2 + np.arange(480) * 0.75, -90 + np.arange(241) * 0.75) grid_def = geometry.GridDefinition(lons=lon, lats=lat) row_indices, \ col_indices = \ utils.generate_nearest_neighbour_linesample_arrays(grid_def, area_def, 200000) msg_con = image.ImageContainer(e_p.sum(axis=0), grid_def) e_p_grid = msg_con.get_array_from_linesample(row_indices, col_indices) import matplotlib.pyplot as plt import matplotlib matplotlib.rcParams.update({'font.size': 13}) m = Basemap(projection='npstere', boundinglat=20, lon_0=0, resolution='l') plt.suptitle('Moisture Transport from Lagrangian Analysis', fontsize=14) plt.subplot(111) m.drawcoastlines()
def resample_data(lats, lons, data): #Grid definition information of existing data grid_def = geometry.GridDefinition(lons=lons, lats=lats) #Wanted projection area_id = 'laps_scan' description = 'LAPS Scandinavian domain' proj_id = 'stere' proj = 'epsg:3995' lon_0 = 20.0 lat_0 = 90.0 #x_size = 1000 #y_size = 1000 #Corner points to be converted to wanted projection lon1 = -2.448425 lat1 = 68.79139 lon2 = 29.38635 lat2 = 54.67893 #Calculate coordinate points in projection p = Proj(init=proj) x1, y1 = p(lon1, lat1) x2, y2 = p(lon2, lat2) print x1, y1, x2, y2 print abs(x1 - x2) / abs(y1 - y2) print abs(y1 - y2) / abs(x1 - x2) x_size = 1000 y_size = abs(x1 - x2) / abs(y1 - y2) * 1000 area_extent = (x1, y1, x2, y2) proj_dict = { 'a': '6371228.0', 'units': 'm', 'lon_0': lon_0, 'proj': proj_id, 'lat_0': lat_0 } area_def = geometry.AreaDefinition(area_id, description, proj_id, proj_dict, x_size, y_size, area_extent) print area_def #Finland domain #lon1=16.52893 #lat1=70.34990 #lon2=31.85138 #lat2=58.76623 #Resampling data laps_con_quick = image.ImageContainerQuick(data, grid_def) area_con_quick = laps_con_quick.resample(area_def) result_data_quick = area_con_quick.image_data laps_con_nn = image.ImageContainerNearest(data, grid_def, radius_of_influence=50000) area_con_nn = laps_con_nn.resample(area_def) result_data_nn = area_con_nn.image_data print result_data_nn
def write_results(date, enkf_c_dir, ens_out_dir, Nens, save_dir, obs_list): smnd = str(date.month) if date.month > 9 else '0' + str(date.month) sday = str(date.day) if date.day > 9 else '0' + str(date.day) file = save_dir + 'Assim_summary_' + str(date.year) + smnd + sday + '.nc' # Generate the netcdf, shoudl contain aice, vice, before and after in addition, # mem1 aicen before and after and sst and vice # Can add more later on # Read in temp file and use this as template for the dimensions print(enkf_c_dir + 'ensemble_6565/mem001_temp.nc') tt = xr.open_dataset(enkf_c_dir + 'ensemble_6565/mem001_temp.nc') temp = tt['temp'] print(file) ds = nc.Dataset(file, 'w', format='NETCDF4') time = ds.createDimension('time', None) times = ds.createVariable('time', 'f4', ('time', )) times[:] = nc.date2num(date, units='days since 1990-01-01', calendar='gregorian') times.units = 'days since 1990-01-01' times.calendar = 'gregorian' de = ds.createDimension('de', Nens) # Ens di = ds.createDimension('di', 5) # Ice categories dz = ds.createDimension('dz', temp.shape[1]) # Depth levels dx = ds.createDimension('dx', temp.shape[2]) dy = ds.createDimension('dy', temp.shape[3]) des = ds.createVariable('de', 'f4', ('de', )) dis = ds.createVariable('di', 'f4', ('di', )) dzs = ds.createVariable('dz', 'f4', ('dz', )) dxs = ds.createVariable('dx', 'f4', ('dx', )) dys = ds.createVariable('dy', 'f4', ('dy', )) #print(Nens) #print(np.arange(0, Nens, 1.0)) des[:] = np.arange(0, Nens, 1.0) dis[:] = np.arange(0, 5, 1.0) dzs[:] = np.arange(0, temp.shape[1], 1.0) dxs[:] = np.arange(0, temp.shape[2], 1.0) dys[:] = np.arange(0, temp.shape[3], 1.0) tt.close() aicen_mem1_before = ds.createVariable('aicen1_inn', 'f4', ( 'time', 'di', 'dx', 'dy', )) aicen_mem1_after = ds.createVariable('aicen1_out', 'f4', ( 'time', 'di', 'dx', 'dy', )) vicen_mem1_before = ds.createVariable('vicen1_inn', 'f4', ( 'time', 'di', 'dx', 'dy', )) vicen_mem1_after = ds.createVariable('vicen1_out', 'f4', ( 'time', 'di', 'dx', 'dy', )) aice_before = ds.createVariable('aice_inn', 'f4', ( 'time', 'de', 'dx', 'dy', )) aice_after = ds.createVariable('aice_out', 'f4', ( 'time', 'de', 'dx', 'dy', )) vice_before = ds.createVariable('vice_inn', 'f4', ( 'time', 'de', 'dx', 'dy', )) vice_after = ds.createVariable('vice_out', 'f4', ( 'time', 'de', 'dx', 'dy', )) temp_mem1_before = ds.createVariable('temp1_inn', 'f4', ( 'time', 'dz', 'dx', 'dy', )) temp_mem1_after = ds.createVariable('temp1_out', 'f4', ( 'time', 'dz', 'dx', 'dy', )) sst_before = ds.createVariable('sst_inn', 'f4', ( 'time', 'de', 'dx', 'dy', )) sst_after = ds.createVariable('sst_out', 'f4', ( 'time', 'de', 'dx', 'dy', )) file_ens = open(enkf_c_dir + 'files_in_ensemble', 'r') Lines = file_ens.readlines() file_count = 0 for ll in Lines: file_count += 1 sens = str(file_count) if file_count > 9 else '0' + str(file_count) file_out_ice = ens_out_dir + 'iced.' + str( date.year) + smnd + sday + '_' + ll[0:-1] + '.nc' file_out_ocn = ens_out_dir + 'ocean.' + str( date.year) + smnd + sday + '_' + ll[0:-1] + '.nc' ############ Write the inn first ################### # Write aice_inn to res file_inn = enkf_c_dir + 'ensemble_6565/mem0' + sens + '_aice.nc' handle = xr.open_dataset(file_inn) aice_before[0, int(ll[0:-1]) - 1, :, :] = handle['aice'][0, :, :] handle.close() # Write vice_inn to res file_inn = enkf_c_dir + 'ensemble_6565/mem0' + sens + '_vice.nc' handle = xr.open_dataset(file_inn) vice_before[0, int(ll[0:-1]) - 1, :, :] = handle['vice'][0, :, :] handle.close() # Write sst_inn to res file_inn = enkf_c_dir + 'ensemble_6565/mem0' + sens + '_sst.nc' handle = xr.open_dataset(file_inn) sst_before[0, int(ll[0:-1]) - 1, :, :] = handle['sst'][0, :, :] handle.close() # Write the full member 1 states if file_count == 1: file_inn = enkf_c_dir + 'ensemble_6565/mem0' + sens + '_aicen.nc' handle = xr.open_dataset(file_inn) aicen_mem1_before[0, :, :, :] = handle['aicen'][0, :, :, :] nx_size = handle['aicen'].shape[2] handle.close() file_inn = enkf_c_dir + 'ensemble_6565/mem0' + sens + '_vicen.nc' handle = xr.open_dataset(file_inn) vicen_mem1_before[0, :, :, :] = handle['vicen'][0, :, :, :] handle.close() file_inn = enkf_c_dir + 'ensemble_6565/mem0' + sens + '_temp.nc' handle = xr.open_dataset(file_inn) temp_mem1_before[0, :, :, :] = handle['temp'][0, :, :, :] handle.close() ################################################################### ##################### Write the out results ##################### handle = xr.open_dataset(file_out_ocn) sst_after[0, int(ll[0:-1]) - 1, :, :] = handle['temp'][0, 41, :, :] if file_count == 1: temp_mem1_after[0, :, :, :] = handle['temp'][0, :, :, :] handle.close() handle = xr.open_dataset(file_out_ice) nx_size2 = handle['aicen'].shape[1] ice_halo_cells = True if nx_size2 > nx_size else False if ice_halo_cells: aice_after[0, int(ll[0:-1]) - 1, :, :] = np.sum(handle['aicen'][:, 1:-1, 1:-1], axis=0) vice_after[0, int(ll[0:-1]) - 1, :, :] = np.sum(handle['vicen'][:, 1:-1, 1:-1], axis=0) if file_count == 1: aicen_mem1_after[0, :, :, :] = handle['aicen'][:, 1:-1, 1:-1] vicen_mem1_after[0, :, :, :] = handle['vicen'][:, 1:-1, 1:-1] else: aice_after[0, int(ll[0:-1]) - 1, :, :] = np.sum( handle['aicen'][:, :, :], axis=0) vice_after[0, int(ll[0:-1]) - 1, :, :] = np.sum( handle['vicen'][:, :, :], axis=0) if file_count == 1: aicen_mem1_after[0, :, :, :] = handle['aicen'][:, :, :] vicen_mem1_after[0, :, :, :] = handle['vicen'][:, :, :] #################################################################### ##################### Also write the observations for easy reference? ##### # Might convert it first so it might be easier to compare? ################ # With several observations potentially a list of string could be used here, #OSISAF file_osisaf = enkf_c_dir + 'obs/OSISAF/this_day.nc' file_amsr = enkf_c_dir + 'obs/AMSR/this_day.nc' grid_file = enkf_c_dir + 'conf/new_grid_ice.nc' Nens = ds.createDimension('Nens', None) Obs1 = ds.createVariable('Obs1', 'f4', ( 'time', 'dx', 'dy', 'Nens', )) handle2 = xr.open_dataset(grid_file) lon_mod = handle2['lon'] lat_mod = handle2['lat'] mod_grid_def = geometry.GridDefinition(lons=lon_mod, lats=lat_mod) i = -1 for obs in obs_list: fileobs = enkf_c_dir + '/obs/' + obs + '/this_day.nc' if os.path.exists(fileobs): i += 1 if obs == 'AMSR' or obs == 'SSMIS': varname = 'ice_conc' elif obs == 'SMOS' or obs == 'CRYO': varname = 'sit' elif obs == 'MUR': varname = 'sst' handle = xr.open_dataset(fileobs) ice_conc = handle[varname] lon_obs = handle['lon'] lat_obs = handle['lat'] obs_grid_def = geometry.GridDefinition(lons=lon_obs, lats=lat_obs) # Fix future warning! obs_container = image.ImageContainerNearest( ice_conc[0, :, :].values, obs_grid_def, radius_of_influence=20000) obs_modelgrid = obs_container.resample(mod_grid_def) res = obs_modelgrid.image_data Obs1[0, :, :, i] = res[:] ds.close()
from pyresample import geometry, image date1 = datetime(2016, 7, 1, 15) ref_date = datetime(2016, 1, 1, 0) enddate = datetime(2016, 8, 2, 12) outname_03h = '/lustre/scratch/twixtrom/ST4_201607_03h.nc' outname_01h = '/lustre/scratch/twixtrom/ST4_201607_01h.nc' dtype = 'f4' print('Getting Obs Grid') # Open a stageIV file and get out the grid grib = pygrib.open('/lustre/scratch/twixtrom/stage4/ST4.2016010112.01h') apcp = grib.read(1)[0] obs_lat, obs_lon = apcp.latlons() obs_grid = geometry.GridDefinition(lons=obs_lon, lats=obs_lat) print('Getting forecast grids') # Get the 12-km forecast grid fcst_12km = Dataset('/lustre/scratch/twixtrom/adaptive_wrf_post/control_thompson/2016010112/wrfprst_d01_2016010112.nc') fcst_lat_12km = fcst_12km.variables['lat'][0,] fcst_lon_12km = fcst_12km.variables['lon'][0,] fcst_grid_12km = geometry.GridDefinition(lons=fcst_lon_12km, lats=fcst_lat_12km) # Get the 4-km forecast grid fcst_4km = Dataset('/lustre/scratch/twixtrom/adaptive_wrf_post/control_thompson/2016010112/wrfprst_d02_2016010112.nc') fcst_lat_4km = fcst_4km.variables['lat'][0,] fcst_lon_4km = fcst_4km.variables['lon'][0,] fcst_grid_4km = geometry.GridDefinition(lons=fcst_lon_4km, lats=fcst_lat_4km)
def download_MUR(date, obs_dir, custom_grid_file=None): # Because of size there is no option for storing the full original file # Same as for downloading the CRYO data there is a need for a username a earth data login # https://wiki.earthdata.nasa.gov/display/EL/How+To+Access+Data+With+cURL+And+Wget # Because the original MUR files are so large the only option currently is to get the observations # on the custom grid provided. cryo_usr = '******' mur_dir = obs_dir + '/MUR_new/' mur_postxt = '090000-JPL-L4_GHRSST-SSTfnd-MUR-GLOB-v02.0-fv04.1.nc' mur_pretxt = 'https://podaac-opendap.jpl.nasa.gov/opendap/allData/ghrsst/data/GDS2/L4/GLOB/JPL/MUR/v4.1/' dl = [date] mur_file = mur_dir + date.strftime('%Y%m%d') + mur_postxt res = cmd('wget -P ' + mur_dir + ' ' + cryo_usr + ' ' + mur_pretxt + date.strftime('%Y') + '/' + date.strftime('%j') + '/' + date.strftime('%Y%m%d') + mur_postxt) # If file exists if res == 0: cmd('ncks -O -d lat,13000,17998 ' + mur_file + ' ' + mur_file) cmd('ncks -O -v analysed_sst,analysis_error ' + mur_file + ' ' + mur_file) # Just make a new file as I need to convert the grid and also make new lon/lat files. DS = xr.open_dataset(mur_file) murlon = DS['lon'] murlat = DS['lat'] murlat2 = np.transpose(repmat(murlat.data, len(murlon), 1)) murlon2 = repmat(murlon.data, len(murlat), 1) mur_grid_def = geometry.GridDefinition(lons=murlon2, lats=murlat2) sst = DS['analysed_sst'] sst_err = DS['analysis_error'] #Read custom grid DS_bar = xr.open_dataset(custom_grid_file) barlon = DS_bar['lon'] barlat = DS_bar['lat'] bar_grid_def = geometry.GridDefinition(lons=barlon, lats=barlat) # Convert to barents obs_container = image.ImageContainerNearest(sst.data[0, :, :], mur_grid_def, radius_of_influence=2000) obs_modelgrid = obs_container.resample(bar_grid_def) sst_bar = obs_modelgrid.image_data obs_container = image.ImageContainerNearest(sst_err.data[0, :, :], mur_grid_def, radius_of_influence=2000) obs_modelgrid = obs_container.resample(bar_grid_def) sst_err2 = obs_modelgrid.image_data # Sematics # Remove nan values sst_bar = sst_bar - 273.15 sst_bar[np.isnan(sst_bar)] = -3 sst_err2[np.isnan(sst_err2)] = 10 # Write to file ds = xr.Dataset( { "sst": (('time', 'x', 'y'), np.expand_dims(sst_bar, axis=0)), "error_std": (('time', 'x', 'y'), np.expand_dims(sst_err2, axis=0)), "lon": (('x', 'y'), barlon), "lat": (('x', 'y'), barlat) }, coords={ 'time': dl[0:1], }, ) ds.to_netcdf(mur_dir + 'MUR_' + date.strftime("%Y%m%d") + '.nc') cmd('rm ' + mur_file)
def download_amsr_Sindre(date, wdir, enkf_c_dir, add_barents=True): # date = datetime.datetime(2018,1,1) # wdir = '/home/sindremf/PHD2/Work/Test_assimiation/' # enkf_c_dir = '/home/sindremf/PHD2/Work/Assim_enkf-c/' grid_file = enkf_c_dir + 'conf/new_grid_ice.nc' # Download data with Keguangfunction damsr.amsr2_download(date.strftime('%Y%m%d'), wdir) handle = nc.Dataset(wdir + 'amsr2_' + date.strftime('%Y%m%d') + '.nc', 'r') X0 = handle['x'][:] Y0 = handle['y'][:] X02 = npm.repmat(X0, len(Y0), 1) Y02 = npm.repmat(Y0, len(X0), 1).transpose() sic = handle['z'][:] # Get lon/lat from projection P = Proj('epsg:3411') lon2, lat2 = P(X02, Y02, inverse=True) # Calculate sic2 = sic * 0.01 # estimate uncertainty (see Spreen et al., 2008) Psw, Epsw = 82.0, 4.0 Psi, Epsi = 10.0, 4.0 Tauw, Etauw = 0.27, 0.1 Taui, Etaui = 0.14, 0.035 #d3, d2, d1, d0 = 1.64e-5, -1.6e-3, 1.92e-2, 0.971 d3, d2, d1, d0 = 5.587e-06, -5.218e-04, -1.226e-02, 1.116 Ps = sic2 * Psi + (1 - sic2) * Psw Tau = sic2 * Taui + (1 - sic2) * Tauw Etau = sic2 * Etaui + (1 - sic2) * Etauw ac = 1.1 * np.exp(-2 * Tau) - 0.11 * np.exp(-Tau) P = Ps * ac Ep2 = (Ps*Etau*(0.11*np.exp(-Tau)-2.2*np.exp(-2*Tau)))**2 + \ (ac*(1-sic2)*Epsw)**2 + (ac*sic2*Epsi)**2 err2 = np.abs(3 * d3 * P**2 + 2 * d2 * P + d1) * np.sqrt(Ep2) * 100 file = wdir + 'AMSR2Full-' + date.strftime('%Y%m%d') + '.nc' # Scale to decimal siconc = sic.data[:] / 100 err3 = err2.data[:] / 100 # Set nan values to -1 err3[np.isnan(siconc)] = -1 siconc[np.isnan(siconc)] = -1 # Change water uncertainty to 0.05, it is way to big err3[siconc == 0] = 0.05 # Create a new netcdf file try: os.remove(file) except: pass ds = nc.Dataset(file, 'w', format='NETCDF4') time = ds.createDimension('time', None) times = ds.createVariable('time', 'f4', ('time', )) times[:] = nc.date2num(date, units='days since 1990-01-01', calendar='gregorian') times.units = 'days since 1990-01-01' times.calendar = 'gregorian' #dx = ds.createDimension('dx', len(X0)) #dy = ds.createDimension('dy', len(Y0)) #dxs = ds.createVariable('dx', 'f4', ('dx',)) #dys = ds.createVariable('dy', 'f4', ('dy',)) #print(Nens) #print(np.arange(0, Nens, 1.0)) #dxs[:] = X0 #dys[:] = Y0 #lon = ds.createVariable('lon', 'f4', ('dy', 'dx',)) #lat = ds.createVariable('lat', 'f4', ('dy', 'dx',)) #lon[:] = lon2 #lat[:] = lat2 #err = ds.createVariable('error_std', 'f4', ('time', 'dy', 'dx',)) #iceconc = ds.createVariable('iceconc', 'f4', ('time', 'dy', 'dx',)) #iceconc[0,:,:] = siconc #err[0,:,:] = err3 if add_barents: # Load the barents grid handle2 = xr.open_dataset(grid_file) lon_mod = handle2['lon'] lat_mod = handle2['lat'] mod_grid_def = geometry.GridDefinition(lons=lon_mod, lats=lat_mod) dx2 = ds.createDimension('dx2', lon_mod.shape[0]) dy2 = ds.createDimension('dy2', lon_mod.shape[1]) #dxs2 = ds.createVariable('dx2', 'f4', ('dx',)) #dys2 = ds.createVariable('dy2', 'f4', ('dy',)) lon4 = ds.createVariable('lon', 'f4', ( 'dx2', 'dy2', )) lat4 = ds.createVariable('lat', 'f4', ( 'dx2', 'dy2', )) lon4[:] = lon_mod lat4[:] = lat_mod obs_grid_def = geometry.GridDefinition(lons=lon2, lats=lat2) # Convert sicconc to barents obs_container = image.ImageContainerNearest( siconc, obs_grid_def, radius_of_influence=200000000) obs_modelgrid = obs_container.resample(mod_grid_def) siconc_bar = obs_modelgrid.image_data # Convert error to barents obs_container = image.ImageContainerNearest( err3, obs_grid_def, radius_of_influence=200000000) obs_modelgrid = obs_container.resample(mod_grid_def) err3_bar = obs_modelgrid.image_data bar = ds.createVariable('ice_conc', 'f4', ( 'time', 'dx2', 'dy2', )) Err_bar = ds.createVariable('error_std', 'f4', ( 'time', 'dx2', 'dy2', )) bar[0, :, :] = siconc_bar Err_bar[0, :, :] = err3_bar ds.close() handle2.close() handle.close() os.remove(wdir + 'amsr2_' + date.strftime('%Y%m%d') + '.nc') os.rename(file, wdir + 'amsr2_' + date.strftime('%Y%m%d') + '.nc')