def plot_all(folder_path="", limit_levels=1): if folder_path == "": folder_path = sys.argv[1] for f in os.listdir(folder_path): # skip files other than monthly if not "monthly_fields.rpn" in f.lower(): continue r = RPN(os.path.join(folder_path, f)) #Exclude coordinate variables vlist = [v for v in r.get_list_of_varnames() if v not in ["^^", ">>"]] #remove coordinates from the list for varname in vlist: data = r.get_4d_field(name=varname) img_folder = os.path.join(folder_path, "img") params = r.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**params) lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() plot_variable(varname, data, img_folder=img_folder, lons=lons, lats=lats, bmap=rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats), limit_levels=limit_levels)
def main(): # path = "/skynet3_exec2/aganji/2GW_new/guziy-water_route_offline-d4627cd00b84/infocell.nc" path = "/skynet3_rech1/huziy/temp/directions_north_america_0.44deg_arman.v5.nc" # projection definition rll = RotatedLatLon(lon1=-97, lat1=47.5, lon2=-7.0, lat2=0.0) ds = Dataset(path) print(list(ds.variables.keys())) # read data from the infocell file fdv = ds.variables["flow_direction_value"][:] lons, lats = ds.variables["lon"][:], ds.variables["lat"][:] # get basemap object bmp = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats, resolution="c") x, y = bmp(lons, lats) colors = get_basin_map(fdv) save_matrix_to_netcdf(colors) im = bmp.pcolormesh(x, y, colors) bmp.colorbar(im) bmp.drawcoastlines() plt.show()
def get_target_lons_lats_basemap(run_config: RunConfig=None): base_dir = Path(run_config.data_path) for month_dir in base_dir.iterdir(): if month_dir.is_dir(): for f in month_dir.iterdir(): if f.name.startswith("."): continue with RPN(str(f)) as r: assert isinstance(r, RPN) vlist = r.get_list_of_varnames() vname = [v for v in vlist if v not in [">>", "^^", "HY"]][0] r.get_first_record_for_name(vname) lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**r.get_proj_parameters_for_the_last_read_rec()) basemap = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats) return lons, lats, basemap
def get_basemap(self, varname_internal, **bmap_kwargs): if self.data_source_type == data_source_types.SAMPLES_FOLDER_FROM_CRCM_OUTPUT: for month_dir in self.base_folder.iterdir(): if not month_dir.is_dir(): continue for data_file in month_dir.iterdir(): try: # skip files that do not contain the variable if varname_internal in self.varname_to_file_prefix: if not data_file.name.startswith(self.varname_to_file_prefix[varname_internal]): continue # print(self.varname_mapping) # print(data_file) with RPN(str(data_file)) as r: r.get_first_record_for_name(self.varname_mapping[varname_internal]) lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**r.get_proj_parameters_for_the_last_read_rec()) return rll.get_basemap_object_for_lons_lats(lons, lats, **bmap_kwargs) except Exception as exc: # Try to look into several files before giving up print(exc) else: raise NotImplementedError("Not impelmented for the data_source_type = {}".format(self.data_source_type))
def plot_all(folder_path="", limit_levels=1): if folder_path == "": folder_path = sys.argv[1] for f in os.listdir(folder_path): # skip files other than monthly if not "monthly_fields.rpn" in f.lower(): continue r = RPN(os.path.join(folder_path, f)) #Exclude coordinate variables vlist = [v for v in r.get_list_of_varnames() if v not in ["^^", ">>"]] #remove coordinates from the list for varname in vlist: data = r.get_4d_field(name=varname) img_folder = os.path.join(folder_path, "img") params = r.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**params) lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() plot_variable(varname, data, img_folder=img_folder, lons=lons, lats=lats, bmap=rll.get_basemap_object_for_lons_lats( lons2d=lons, lats2d=lats), limit_levels=limit_levels)
def get_basemap(self, **kwargs): from rpn.domains.rotated_lat_lon import RotatedLatLon rll = RotatedLatLon(**self.projection_params) return rll.get_basemap_object_for_lons_lats(lons2d=self.lons, lats2d=self.lats, **kwargs)
def main(): #data_folder = "/home/huziy/b2_fs2/sim_links_frm_Katja/Arctic_0.5deg_Peat_SC_26L_CanHR85_spn_Vspng_Diagnostics/1971-2000" data_folder = "/home/huziy/b2_fs2/sim_links_frm_Katja/Arctic_0.5deg_Peat_SC_26L_CanHR85_spn_Vspng_Diagnostics/2071-2100" var_name = "I0" # layer_widths = [0.1, 0.2, 0.3, 0.5, 0.9, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, # 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, # 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5] layer_widths = [0.1, 0.2, 0.3, 0.4, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 1.0, 3.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, ] print(len(layer_widths)) crcm_data_manager = CRCMDataManager(layer_widths=layer_widths, data_folder=data_folder) #get the mask r = RPN("/b1_fs2/winger/Arctic/land_sea_glacier_lake_mask_free") msk = r.get_first_record_for_name("FMSK") start_year = 2071 end_year = 2100 # alt - using globally max temperature profile #alt = crcm_data_manager.get_alt_using_files_in(data_folder, vname=var_name) #calculate alt for each year and then take mean alt_list = [] for y in range(start_year, end_year + 1): tmax = crcm_data_manager.get_Tmax_profiles_for_year_using_monthly_means(y, var_name=var_name) alt1 = crcm_data_manager.get_alt(tmax) alt1[alt1 < 0] = np.nan alt_list.append(alt1) alt = np.mean(alt_list, axis=0) alt[np.isnan(alt)] = -1 alt = np.ma.masked_where(alt < 0, alt) alt = np.ma.masked_where(msk < 0.1, alt) #get the coordinates fcoord = os.listdir(data_folder)[0] fcoord = os.path.join(data_folder, fcoord) r = RPN(fcoord) i0 = r.get_first_record_for_name(var_name) lons2d, lats2d = r.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**r.get_proj_parameters_for_the_last_read_rec()) basemap = rll.get_basemap_object_for_lons_lats(lons2d=lons2d, lats2d=lats2d) plot_values(basemap, lons2d, lats2d, alt, "{}-{}(Arctic-peat-26L)".format(start_year, end_year))
def main(): bathymetry_path = "" topo_path = "/RECH2/huziy/coupling/coupled-GL-NEMO1h_30min/geophys_452x260_directions_new_452x260_GL+NENA_0.1deg_SAND_CLAY_LDPT_DPTH.fst" plot_utils.apply_plot_params() with RPN(topo_path) as r: assert isinstance(r, RPN) topo = r.get_first_record_for_name("ME") lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() print(lons.shape) prj_params = r.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**prj_params) bmap = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats, resolution="i") xx, yy = bmap(lons, lats) plt.figure() ax = plt.gca() lons1 = np.where(lons <= 180, lons, lons - 360) topo = maskoceans(lons1, lats, topo) topo_clevs = [0, 100, 200, 300, 400, 500, 600, 800, 1000, 1200] # bn = BoundaryNorm(topo_clevs, len(topo_clevs) - 1) cmap = cm.get_cmap("terrain") ocean_color = cmap(0.18) cmap, norm = colors.from_levels_and_colors(topo_clevs, cmap(np.linspace(0.3, 1, len(topo_clevs) - 1))) add_rectangle(ax, xx, yy, margin=20, edge_style="solid") add_rectangle(ax, xx, yy, margin=10, edge_style="dashed") im = bmap.pcolormesh(xx, yy, topo, cmap=cmap, norm=norm) bmap.colorbar(im, ticks=topo_clevs) bmap.drawcoastlines(linewidth=0.3) bmap.drawmapboundary(fill_color=ocean_color) bmap.drawparallels(np.arange(-90, 90, 10), labels=[1, 0, 0, 1], color="0.3") bmap.drawmeridians(np.arange(-180, 190, 10), labels=[1, 0, 0, 1], color="0.3") plt.savefig("GL_452x260_0.1deg_domain.png", dpi=300, bbox_inches="tight")
def get_basemap_obj_and_coords_from_rpn_file(path=""): assert len(path) > 0, "The path should not be empty." r = RPN(path) vname = [v for v in r.get_list_of_varnames() if v.strip() not in [">>", "^^"]][0] r.get_first_record_for_name(vname) lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() projparams = r.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**projparams) bmp = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats, resolution="l") return bmp, lons, lats
def main(): bathymetry_path = "" topo_path = "/RECH2/huziy/coupling/coupled-GL-NEMO1h_30min/geophys_452x260_directions_new_452x260_GL+NENA_0.1deg_SAND_CLAY_LDPT_DPTH.fst" plot_utils.apply_plot_params() with RPN(topo_path) as r: assert isinstance(r, RPN) topo = r.get_first_record_for_name("ME") lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() print(lons.shape) prj_params = r.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**prj_params) bmap = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats, resolution="i") xx, yy = bmap(lons, lats) plt.figure() ax = plt.gca() lons1 = np.where(lons <= 180, lons, lons - 360) topo = maskoceans(lons1, lats, topo) topo_clevs = [0, 100, 200, 300, 400, 500, 600, 800, 1000, 1200] # bn = BoundaryNorm(topo_clevs, len(topo_clevs) - 1) cmap = cm.get_cmap("terrain") ocean_color = cmap(0.18) cmap, norm = colors.from_levels_and_colors( topo_clevs, cmap(np.linspace(0.3, 1, len(topo_clevs) - 1))) add_rectangle(ax, xx, yy, margin=20, edge_style="solid") add_rectangle(ax, xx, yy, margin=10, edge_style="dashed") im = bmap.pcolormesh(xx, yy, topo, cmap=cmap, norm=norm) bmap.colorbar(im, ticks=topo_clevs) bmap.drawcoastlines(linewidth=0.3) bmap.drawmapboundary(fill_color=ocean_color) bmap.drawparallels(np.arange(-90, 90, 10), labels=[1, 0, 0, 1], color="0.3") bmap.drawmeridians(np.arange(-180, 190, 10), labels=[1, 0, 0, 1], color="0.3") plt.savefig("GL_452x260_0.1deg_domain.png", dpi=300, bbox_inches="tight")
def read_and_plot_ts_cross(path="", exp_name=""): var_interest = "ADD" path_to_dpth_to_bedrock = "/skynet1_rech3/huziy/CLASS_offline_VG/GEOPHYSICAL_FIELDS/test_analysis.rpn" # read depth to bedrock r = RPN(path_to_dpth_to_bedrock) _ = r.get_first_record_for_name("DPTH") lons2d, lats2d = r.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**r.get_proj_parameters_for_the_last_read_rec()) b = rll.get_basemap_object_for_lons_lats(lons2d=lons2d, lats2d=lats2d, resolution="c") r.close() layer_widths = [0.1, 0.2, 0.3, 0.5, 0.9, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5] nlayers = 7 nt = 200*12 layer_widths = layer_widths[:nlayers] print(len(layer_widths)) #calculate depths of soil layer centers soil_lev_tops = np.cumsum([0, ] + layer_widths[:-1]) soil_lev_bottoms = np.cumsum(layer_widths) soil_levs = 0.5 * (soil_lev_tops + soil_lev_bottoms) i_interest_list, j_interest_list = [120, 120, 160, 170], [50, 60, 60, 60] r = RPN(path) data = r.get_4d_field_fc_hour_as_time(name=var_interest) lev_sorted = list(sorted(list(data.items())[0][1].keys()))[:nlayers] fc_sorted = list(sorted(data.keys()))[:nt] for i_interest, j_interest in zip(i_interest_list, j_interest_list): data1 = np.asarray( [[data[fc][lev][i_interest, j_interest] for lev in lev_sorted] for fc in fc_sorted]) plot_time_series(data=data1, soil_levels=soil_levs, basemap=b, i_interest=i_interest, j_interest=j_interest, longitude=lons2d[i_interest, j_interest], latitude=lats2d[i_interest, j_interest], exp_name=exp_name)
def __update_bmp_info_from_rpnfile_obj(self, r): # save projection paarams for a possible re-use in the future proj_params = r.get_proj_parameters_for_the_last_read_rec() self.lons, self.lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() rlons, rlats = r.get_tictacs_for_the_last_read_record() rll = RotatedLatLon(**proj_params) bmp = rll.get_basemap_object_for_lons_lats(self.lons, self.lats) assert isinstance(bmp, Basemap) self.basemap_info_of_the_last_imported_field = { "rlon": rlons, "rlat": rlats, } self.basemap_info_of_the_last_imported_field.update(bmp.projparams)
def get_data_and_coords(): """ :rtype: (dict, np.ndarray, np.ndarray, Basemap) :return: dict with {level: field} data """ path = "/skynet3_rech1/huziy/geofields_interflow_exp/pm1979010100_00000000p" vname = "D9" r = RPN(path) data = list(r.get_4d_field(name=vname).items())[0][1] params = r.get_proj_parameters_for_the_last_read_rec() lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**params) bmp = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats) r.close() return data, lons, lats, bmp
def plot_basin_outlets(shape_file=BASIN_BOUNDARIES_FILE, bmp_info=None, directions=None, accumulation_areas=None, lake_fraction_field=None): assert isinstance(bmp_info, BasemapInfo) driver = ogr.GetDriverByName("ESRI Shapefile") print(driver) ds = driver.Open(shape_file, 0) assert isinstance(ds, ogr.DataSource) layer = ds.GetLayer() assert isinstance(layer, ogr.Layer) print(layer.GetFeatureCount()) latlong_proj = osr.SpatialReference() latlong_proj.ImportFromEPSG(4326) utm_proj = layer.GetSpatialRef() # create Coordinate Transformation coord_transform = osr.CoordinateTransformation(latlong_proj, utm_proj) utm_coords = coord_transform.TransformPoints( list(zip(bmp_info.lons.flatten(), bmp_info.lats.flatten()))) utm_coords = np.asarray(utm_coords) x_utm = utm_coords[:, 0].reshape(bmp_info.lons.shape) y_utm = utm_coords[:, 1].reshape(bmp_info.lons.shape) basin_mask = np.zeros_like(bmp_info.lons) cell_manager = CellManager(directions, accumulation_area_km2=accumulation_areas, lons2d=bmp_info.lons, lats2d=bmp_info.lats) index = 1 basins = [] basin_names = [] basin_name_to_mask = {} for feature in layer: assert isinstance(feature, ogr.Feature) # print feature["FID"] geom = feature.GetGeometryRef() assert isinstance(geom, ogr.Geometry) basins.append(ogr.CreateGeometryFromWkb(geom.ExportToWkb())) basin_names.append(feature["abr"]) accumulation_areas_temp = accumulation_areas.copy() lons_out, lats_out = [], [] basin_names_out = [] name_to_ij_out = OrderedDict() min_basin_area = min(b.GetArea() * 1.0e-6 for b in basins) while len(basins): fm = np.max(accumulation_areas_temp) i, j = np.where(fm == accumulation_areas_temp) i, j = i[0], j[0] p = ogr.CreateGeometryFromWkt("POINT ({} {})".format( x_utm[i, j], y_utm[i, j])) b_selected = None name_selected = None for name, b in zip(basin_names, basins): assert isinstance(b, ogr.Geometry) assert isinstance(p, ogr.Geometry) if b.Contains(p.Buffer(2000 * 2**0.5)): # Check if there is an upstream cell from the same basin the_mask = cell_manager.get_mask_of_upstream_cells_connected_with_by_indices( i, j) # Save the mask of the basin for future use basin_name_to_mask[name] = the_mask # if is_part_of_points_in(b, x_utm[the_mask == 1], y_utm[the_mask == 1]): # continue b_selected = b name_selected = name # basin_names_out.append(name) lons_out.append(bmp_info.lons[i, j]) lats_out.append(bmp_info.lats[i, j]) name_to_ij_out[name] = (i, j) basin_mask[the_mask == 1] = index index += 1 break if b_selected is not None: basins.remove(b_selected) basin_names.remove(name_selected) outlet_index_in_basin = 1 current_basin_name = name_selected while current_basin_name in basin_names_out: current_basin_name = name_selected + str(outlet_index_in_basin) outlet_index_in_basin += 1 basin_names_out.append(current_basin_name) print(len(basins), basin_names_out) accumulation_areas_temp[i, j] = -1 plot_utils.apply_plot_params(font_size=12, width_pt=None, width_cm=20, height_cm=20) gs = GridSpec(2, 2, width_ratios=[1.0, 0.5], wspace=0.01) fig = plt.figure() ax = fig.add_subplot(gs[1, 0]) xx, yy = bmp_info.get_proj_xy() bmp_info.basemap.drawcoastlines(linewidth=0.5, ax=ax) bmp_info.basemap.drawrivers(zorder=5, color="0.5", ax=ax) upstream_edges = cell_manager.get_upstream_polygons_for_points( model_point_list=[ ModelPoint(ix=i, jy=j) for (i, j) in name_to_ij_out.values() ], xx=xx, yy=yy) upstream_edges_latlon = cell_manager.get_upstream_polygons_for_points( model_point_list=[ ModelPoint(ix=i, jy=j) for (i, j) in name_to_ij_out.values() ], xx=bmp_info.lons, yy=bmp_info.lats) plot_utils.draw_upstream_area_bounds(ax, upstream_edges=upstream_edges, color="r", linewidth=0.6) plot_utils.save_to_shape_file(upstream_edges_latlon, in_proj=None) xs, ys = bmp_info.basemap(lons_out, lats_out) bmp_info.basemap.scatter(xs, ys, c="0.75", s=30, zorder=10) bmp_info.basemap.drawparallels(np.arange(-90, 90, 5), labels=[True, False, False, False], linewidth=0.5) bmp_info.basemap.drawmeridians(np.arange(-180, 180, 5), labels=[False, False, False, True], linewidth=0.5) cmap = cm.get_cmap("rainbow", index - 1) bn = BoundaryNorm(list(range(index + 1)), index - 1) # basin_mask = np.ma.masked_where(basin_mask < 0.5, basin_mask) # bmp_info.basemap.pcolormesh(xx, yy, basin_mask, norm=bn, cmap=cmap, ax=ax) xmin, xmax = ax.get_xlim() ymin, ymax = ax.get_ylim() print(xmin, xmax, ymin, ymax) dx = xmax - xmin dy = ymax - ymin step_y = 0.1 step_x = 0.12 y0_frac = 0.75 y0_frac_bottom = 0.02 x0_frac = 0.35 bname_to_text_coords = { "RDO": (xmin + x0_frac * dx, ymin + y0_frac_bottom * dy), "STM": (xmin + (x0_frac + step_x) * dx, ymin + y0_frac_bottom * dy), "SAG": (xmin + (x0_frac + 2 * step_x) * dx, ymin + y0_frac_bottom * dy), "BOM": (xmin + (x0_frac + 3 * step_x) * dx, ymin + y0_frac_bottom * dy), "MAN": (xmin + (x0_frac + 4 * step_x) * dx, ymin + y0_frac_bottom * dy), "MOI": (xmin + (x0_frac + 5 * step_x) * dx, ymin + y0_frac_bottom * dy), "ROM": (xmin + (x0_frac + 5 * step_x) * dx, ymin + (y0_frac_bottom + step_y) * dy), "NAT": (xmin + (x0_frac + 5 * step_x) * dx, ymin + (y0_frac_bottom + 2 * step_y) * dy), ###### "CHU": (xmin + (x0_frac + 5 * step_x) * dx, ymin + y0_frac * dy), "GEO": (xmin + (x0_frac + 5 * step_x) * dx, ymin + (y0_frac + step_y) * dy), "BAL": (xmin + (x0_frac + 5 * step_x) * dx, ymin + (y0_frac + 2 * step_y) * dy), "PYR": (xmin + (x0_frac + 4 * step_x) * dx, ymin + (y0_frac + 2 * step_y) * dy), "MEL": (xmin + (x0_frac + 3 * step_x) * dx, ymin + (y0_frac + 2 * step_y) * dy), "FEU": (xmin + (x0_frac + 2 * step_x) * dx, ymin + (y0_frac + 2 * step_y) * dy), "ARN": (xmin + (x0_frac + 1 * step_x) * dx, ymin + (y0_frac + 2 * step_y) * dy), ###### "CAN": (xmin + 0.1 * dx, ymin + 0.80 * dy), "GRB": (xmin + 0.1 * dx, ymin + (0.80 - step_y) * dy), "LGR": (xmin + 0.1 * dx, ymin + (0.80 - 2 * step_y) * dy), "RUP": (xmin + 0.1 * dx, ymin + (0.80 - 3 * step_y) * dy), "WAS": (xmin + 0.1 * dx, ymin + (0.80 - 4 * step_y) * dy), "BEL": (xmin + 0.1 * dx, ymin + (0.80 - 5 * step_y) * dy), } # bmp_info.basemap.readshapefile(".".join(BASIN_BOUNDARIES_FILE.split(".")[:-1]).replace("utm18", "latlon"), "basin", # linewidth=1.2, ax=ax, zorder=9) for name, xa, ya, lona, lata in zip(basin_names_out, xs, ys, lons_out, lats_out): ax.annotate(name, xy=(xa, ya), xytext=bname_to_text_coords[name], textcoords='data', ha='right', va='bottom', bbox=dict(boxstyle='round,pad=0.4', fc='white'), arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0', linewidth=0.25), font_properties=FontProperties(size=8), zorder=20) print(r"{} & {:.0f} \\".format( name, accumulation_areas[name_to_ij_out[name]])) # Plot zonally averaged lake fraction ax = fig.add_subplot(gs[1, 1]) ydata = range(lake_fraction_field.shape[1]) ax.plot(lake_fraction_field.mean(axis=0) * 100, ydata, lw=2) ax.fill_betweenx(ydata, lake_fraction_field.mean(axis=0) * 100, alpha=0.5) ax.set_xlabel("Lake fraction (%)") ax.set_ylim(min(ydata), max(ydata)) ax.xaxis.set_tick_params(direction='out', width=1) ax.yaxis.set_tick_params(direction='out', width=1) ax.xaxis.set_ticks_position("bottom") ax.yaxis.set_ticks_position("none") ax.spines["top"].set_visible(False) ax.spines["right"].set_visible(False) for tl in ax.yaxis.get_ticklabels(): tl.set_visible(False) # plot elevation, buffer zone, big lakes, grid cells ax = fig.add_subplot(gs[0, :]) geophy_file = "/RESCUE/skynet3_rech1/huziy/from_guillimin/geophys_Quebec_0.1deg_260x260_with_dd_v6" r = RPN(geophy_file) elev = r.get_first_record_for_name("ME") lkfr = r.get_first_record_for_name("LKFR") fldr = r.get_first_record_for_name("FLDR") params = r.get_proj_parameters_for_the_last_read_rec() lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**params) bsmp = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats, resolution="l") xx, yy = bsmp(lons, lats) dx = (xx[0, 0] - xx[-1, 0]) / xx.shape[0] dy = (yy[0, 0] - yy[0, -1]) / yy.shape[1] xx_ll_crnrs = xx - dx / 2 yy_ll_crnrs = yy - dy / 2 xx_ur_crnrs = xx + dx / 2 yy_ur_crnrs = yy + dy / 2 ll_lon, ll_lat = bsmp(xx_ll_crnrs[0, 0], yy_ll_crnrs[0, 0], inverse=True) ur_lon, ur_lat = bsmp(xx_ur_crnrs[-1, -1], yy_ur_crnrs[-1, -1], inverse=True) crnr_lons = np.array([[ll_lon, ll_lon], [ur_lon, ur_lon]]) crnr_lats = np.array([[ll_lat, ll_lat], [ur_lat, ur_lat]]) bsmp = rll.get_basemap_object_for_lons_lats(lons2d=crnr_lons, lats2d=crnr_lats) # plot elevation levs = [0, 100, 200, 300, 500, 700, 1000, 1500, 2000, 2800] norm = BoundaryNorm(levs, len(levs) - 1) the_cmap = my_colormaps.get_cmap_from_ncl_spec_file( path="colormap_files/OceanLakeLandSnow.rgb", ncolors=len(levs) - 1) lons[lons > 180] -= 360 me_to_plot = maskoceans(lons, lats, elev, resolution="l") im = bsmp.contourf(xx, yy, me_to_plot, cmap=the_cmap, levels=levs, norm=norm, ax=ax) bsmp.colorbar(im) bsmp.drawcoastlines(linewidth=0.5, ax=ax) # show large lake points gl_lakes = np.ma.masked_where((lkfr < 0.6) | (fldr <= 0) | (fldr > 128), lkfr) gl_lakes[~gl_lakes.mask] = 1.0 bsmp.pcolormesh(xx, yy, gl_lakes, cmap=cm.get_cmap("Blues"), ax=ax, vmin=0, vmax=1, zorder=3) # show free zone border margin = 20 x1 = xx_ll_crnrs[margin, margin] x2 = xx_ur_crnrs[-margin, margin] y1 = yy_ll_crnrs[margin, margin] y2 = yy_ur_crnrs[margin, -margin] pol_corners = ((x1, y1), (x2, y1), (x2, y2), (x1, y2)) ax.add_patch(Polygon(xy=pol_corners, fc="none", ls="solid", lw=3, zorder=5)) # show blending zone border (with halo zone) margin = 10 x1 = xx_ll_crnrs[margin, margin] x2 = xx_ur_crnrs[-margin, margin] y1 = yy_ll_crnrs[margin, margin] y2 = yy_ur_crnrs[margin, -margin] pol_corners = ((x1, y1), (x2, y1), (x2, y2), (x1, y2)) ax.add_patch( Polygon(xy=pol_corners, fc="none", ls="dashed", lw=3, zorder=5)) # show the grid step = 20 xx_ll_crnrs_ext = np.zeros([n + 1 for n in xx_ll_crnrs.shape]) yy_ll_crnrs_ext = np.zeros([n + 1 for n in yy_ll_crnrs.shape]) xx_ll_crnrs_ext[:-1, :-1] = xx_ll_crnrs yy_ll_crnrs_ext[:-1, :-1] = yy_ll_crnrs xx_ll_crnrs_ext[:-1, -1] = xx_ll_crnrs[:, -1] yy_ll_crnrs_ext[-1, :-1] = yy_ll_crnrs[-1, :] xx_ll_crnrs_ext[-1, :] = xx_ur_crnrs[-1, -1] yy_ll_crnrs_ext[:, -1] = yy_ur_crnrs[-1, -1] bsmp.pcolormesh(xx_ll_crnrs_ext[::step, ::step], yy_ll_crnrs_ext[::step, ::step], np.ma.masked_all_like(xx_ll_crnrs_ext)[::step, ::step], edgecolors="0.6", ax=ax, linewidth=0.05, zorder=4, alpha=0.5) ax.set_title("Elevation (m)") # plt.show() fig.savefig("qc_basin_outlets_points.png", bbox_inches="tight") # plt.show() plt.close(fig) return name_to_ij_out, basin_name_to_mask
def main(plot_vals=False): varname = "RFAC" multiplier = 24 * 3600 data_folder = Path( "/home/huziy/skynet3_rech1/CNRCWP/Calgary_flood/atm_data_for_Arman_simulations" ) day_range = range(19, 22) dates_of_interest = [datetime(2013, 6, d) for d in day_range] img_folder = Path("calgary_flood/2D") if not img_folder.is_dir(): img_folder.mkdir(parents=True) lons, lats, bmp = None, None, None the_mask = get_bow_river_basin_mask() i_list, j_list = np.where(the_mask > 0.5) imin, imax = i_list.min() - 2, i_list.max() + 5 jmin, jmax = j_list.min() - 2, j_list.max() + 5 # Calculate daily means sim_label_to_date_to_mean = OrderedDict() for sim_dir in data_folder.iterdir(): mr = MultiRPN(str(sim_dir.joinpath("pm*"))) print(str(sim_dir)) print(mr.get_number_of_records()) label = sim_dir.name.split("_")[-2].replace("NoDrain", "").replace( "frozen", "Frozen").replace("Bow", "") sim_label_to_date_to_mean[label] = OrderedDict() data = mr.get_4d_field(varname) data = { d: list(v.items())[0][1] for d, v in data.items() if d.day in day_range } for d in dates_of_interest: sim_label_to_date_to_mean[label][d] = np.array([ field for d1, field in data.items() if d1.day == d.day ]).mean(axis=0) * multiplier if lons is None: lons, lats = mr.get_longitudes_and_latitudes_of_the_last_read_rec() for f in sim_dir.iterdir(): if f.name.startswith("pm"): r = RPN(str(f)) r.get_first_record_for_name(varname=varname) rll = RotatedLatLon( **r.get_proj_parameters_for_the_last_read_rec()) bmp = rll.get_basemap_object_for_lons_lats( lons2d=lons[imin:imax, jmin:jmax], lats2d=lats[imin:imax, jmin:jmax], resolution="i") r.close() break mr.close() # reorder simulations sim_label_to_date_to_mean = OrderedDict([ (k, sim_label_to_date_to_mean[k]) for k in sorted( sim_label_to_date_to_mean, key=lambda z: len(z), reverse=True) ]) key_list = [k for k in sim_label_to_date_to_mean] key_list[-2], key_list[-1] = key_list[-1], key_list[-2] sim_label_to_date_to_mean = OrderedDict([(k, sim_label_to_date_to_mean[k]) for k in key_list]) # do the plots (subplots: vertically - simulations, horizontally - days) plot_utils.apply_plot_params(width_cm=24, height_cm=28, font_size=10) fig = plt.figure() nrows = len(sim_label_to_date_to_mean) ncols = len(day_range) gs = GridSpec(nrows, ncols, wspace=0, hspace=0.1) clevs_vals = [0, 0.1, 20, 50, 100, 150, 200, 300] base_label = None clevs_diff = [1, 5, 10, 20, 50, 100] clevs_diff = [-c for c in reversed(clevs_diff)] + [0] + clevs_diff cmap_diff = cm.get_cmap("bwr", len(clevs_diff) - 1) cmap_vals = get_cmap_from_ncl_spec_file( path="colormap_files/precip3_16lev.rgb", ncolors=len(clevs_vals) - 1) xx, yy = bmp(lons, lats) title = "Total runoff ({}, mm/day)".format(varname) fig.suptitle(title) for row, (sim_label, date_to_field) in enumerate(sim_label_to_date_to_mean.items()): if row == 0 or plot_vals: base_sim = OrderedDict([(k, 0) for k, v in date_to_field.items()]) base_label = sim_label plot_label = sim_label clevs = clevs_vals cmap = cmap_vals extend = "max" else: base_sim = list(sim_label_to_date_to_mean.items())[0][1] plot_label = "{}\n-\n{}".format(sim_label, base_label) clevs = clevs_diff cmap = cmap_diff extend = "both" bn = BoundaryNorm(boundaries=clevs, ncolors=len(clevs) - 1) for col, (the_date, field) in enumerate(date_to_field.items()): ax = fig.add_subplot(gs[row, col]) to_plot = np.ma.masked_where(the_mask < 0.5, field - base_sim[the_date]) # cs = bmp.contourf(xx[~to_plot.mask], yy[~to_plot.mask], to_plot[~to_plot.mask], levels=clevs, extend="max", tri=True) cs = bmp.pcolormesh(xx, yy, to_plot[:-1, :-1], norm=bn, vmin=clevs[0], vmax=clevs[-1], cmap=cmap) bmp.drawcoastlines(ax=ax, linewidth=0.3) assert isinstance(bmp, Basemap) bmp.readshapefile(BOW_RIVER_SHP[:-4], "basin", zorder=5) cb = bmp.colorbar(cs, ax=ax, ticks=clevs, extend=extend, pad="4%", size="10%") if plot_vals: cb.ax.set_visible(col == ncols - 1 and row == 0) else: cb.ax.set_visible(col == ncols - 1 and row in (0, 1)) if col == 0: ax.set_ylabel(plot_label) if row == 0: ax.set_title(the_date.strftime("%b %d")) if plot_vals: img_file = img_folder.joinpath("{}.png".format(varname)) else: img_file = img_folder.joinpath("{}_diff.png".format(varname)) fig.savefig(str(img_file)) plt.close(fig)
def main(save_to_nc=True): """ Read geotiff file with the field capacity field in mm, interpolate it to model grid, divide by the depth to bedrock, and save to netcdf file """ # Read model data obs_fields_path = "/skynet3_rech1/huziy/geofields_interflow_exp/pm1979010100_00000000p" robj = RPN(obs_fields_path) thfc = robj.get_first_record_for_name_and_level(varname="D9", level=1) bdrck_depth = _get_depth_to_bedrock(obs_fields_path) proj_params = robj.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**proj_params) t_lons, t_lats = robj.get_longitudes_and_latitudes_for_the_last_read_rec() t_lons[t_lons > 180] -= 360.0 bmp = rll.get_basemap_object_for_lons_lats(lons2d=t_lons, lats2d=t_lats) robj.close() intp_img = read_observed_bfc().resample( SwathDefinition(t_lons.flatten(), t_lats.flatten()) ) fig = plt.figure(figsize=(10, 6)) assert isinstance(fig, Figure) gs = GridSpec(1, 3, width_ratios=[0.95, 1, 1]) # Observed bulk field capacity ax = fig.add_subplot(gs[0, 0]) x, y = bmp(t_lons, t_lats) to_plot = intp_img.image_data.reshape(t_lons.shape) to_plot = np.ma.masked_where(to_plot < 0, to_plot) / (1.0e3 * bdrck_depth) im = bmp.pcolormesh(x, y, to_plot, vmin=0, vmax=0.5) bmp.drawcoastlines() ax.set_title("ORNL DAAC") # Currently used in the model ax = fig.add_subplot(gs[0, 1]) thfc_to_plot = np.ma.masked_where(to_plot.mask, thfc) im = bmp.pcolormesh(x, y, thfc_to_plot, vmin=0, vmax=0.5) bmp.colorbar(im, ax=ax) bmp.drawcoastlines(ax=ax) ax.set_title("Current") bmp.colorbar(im, ax=ax) # Current - (ORNL DAAC) ax = fig.add_subplot(gs[0, 2]) x, y = bmp(t_lons, t_lats) cmap = cm.get_cmap("RdBu_r", 21) im = bmp.pcolormesh(x, y, thfc_to_plot - to_plot, vmin=-0.5, vmax=0.5, cmap=cmap) bmp.colorbar(im, ax=ax) bmp.drawcoastlines(ax=ax) ax.set_title("Current - (ORNL-DAAC)") bmp.colorbar(im, ax=ax) plt.show() pass
def main(): plot_permafrost = True plot_glaciers = True if not os.path.isdir(img_folder): print(os.mkdir(img_folder)) geophy_file = "misc_plots/geophys_CORDEX_NA_0.11deg_695x680_filled_grDes_barBor_Crop2Gras_peat_with_directions" # Save the permafrost mask to file pfmask_file = os.path.join(img_folder, "pf_mask_na_0.11deg.nc") if not os.path.isfile(pfmask_file): save_pf_mask_to_netcdf(rpn_field_name_with_target_grid="VF", path_to_rpn_with_target_grid=geophy_file, path=pfmask_file) with Dataset(pfmask_file) as ds: pf_mask = ds.variables["pf_type"][:] r = RPN(geophy_file) lkfr = r.get_record_for_name_and_level(varname="VF", level=3) glac = r.get_record_for_name_and_level(varname="VF", level=2) lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() proj_params = r.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**proj_params) ill, jll = 0, 250 right_margin = 50 lkfr = lkfr[ill:-right_margin, jll:] lons = lons[ill:-right_margin, jll:] lats = lats[ill:-right_margin, jll:] glac = glac[ill:-right_margin, jll:] pf_mask = pf_mask[ill:-right_margin, jll:] bmp = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats, resolution="l") xx, yy = bmp(lons, lats) plot_utils.apply_plot_params(font_size=8, width_cm=10, height_cm=10) fig = plt.figure() # Plot lakes clevs = np.arange(0, 1.1, 0.1) lkfr = np.ma.masked_where(lkfr <= 0, lkfr) cs = bmp.contourf(xx, yy, lkfr, levels=clevs, cmap="Blues") # bmp.colorbar(cs) bmp.drawcoastlines(linewidth=0.1) bmp.drawcountries(linewidth=0.1) # plot glaciers glval = 0.65 glac = (glac > 0.001) * glval glac = np.ma.masked_where(glac < 0.5, glac) cmap = cm.get_cmap("Greys") if plot_glaciers: cs = bmp.pcolormesh(xx, yy, glac, cmap="Greys", alpha=0.7, vmin=0, vmax=1) #plt.legend([Rectangle((0, 0), 5, 5, fc=cmap(glval)), ], ["Glaciers", ], loc=3) # Plot permafrost boundaries with Dataset("permafrost_types_arctic_using_contains.nc") as ds: # pf_mask = ds.variables["pf_type"][:] # lons_s, lats_s = ds.variables["longitude"][:], ds.variables["latitude"][:] # # x, y, z = lat_lon.lon_lat_to_cartesian(lons_s.flatten(), lats_s.flatten()) # ktree = KDTree(list(zip(x, y, z))) # # lons_copy = lons.copy() # lons_copy[lons > 180] -= 360 # tmp = np.zeros_like(lons) # tmp = maskoceans(lons_copy, lats, tmp, inlands=False) # # xt, yt, zt = lat_lon.lon_lat_to_cartesian(lons[~tmp.mask], lats[~tmp.mask]) # dists, inds = ktree.query(list(zip(xt, yt, zt))) # # pf_mask1[~tmp.mask] = pf_mask.flatten()[inds] pf_mask1 = np.ma.masked_where((pf_mask > 2) | (pf_mask < 1), pf_mask) pf_mask1[~pf_mask1.mask] = 1 # bmp.contourf(xx, yy, pf_mask, levels=[2.5, 3.5, 4.5], cmap=ListedColormap(["yellow", "orange", "red"]), alpha=0.7) #bmp.contour(xx, yy, pf_mask, levels=[2.5, 3.5, 4.5], colors="k", linewidths=1) # bmp.drawrivers(color=cm.get_cmap("Blues")(0.8)) ncolors = 2 norm = BoundaryNorm([0.5, 1.5, 2.5], ncolors=ncolors) cmap = ListedColormap(["c", "violet"]) alpha = 0.7 if plot_permafrost: bmp.pcolormesh(xx, yy, pf_mask1, norm=norm, cmap=cmap, alpha=alpha) # plt.legend([Rectangle((0, 0), 5, 5, fc=cmap(0), alpha=alpha), ], ["Permafrost",], loc=3) # tree line bmp.readshapefile(os.path.join(img_folder, "Bernardo/treeline_current"), "treeline", linewidth=0.5, color="orange") bmp.readshapefile(os.path.join(img_folder, "Bernardo/treeline_future"), "treeline", linewidth=0.5, color="red") print(os.path.join(img_folder, "lakes_glaciers_pf_veg.png")) fig.savefig(os.path.join(img_folder, "lakes_glaciers_pf_veg.png"), dpi=400, bbox_inches="tight", transparent=True)
def main(): path = "/snow3/huziy/geophysics_files/geophys_452x260_0.1deg_GL_NENA_and_directions_452x260_GL+NENA_0.1deg_SAND_CLAY_LDPT_DPTH.fst" # get rotated latlon projection and grid parameters with RPN(path) as r: assert isinstance(r, RPN) lkfr = r.variables["LKFR"][:].squeeze() print(r.variables) lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() rll_obj = RotatedLatLon( **r.get_proj_parameters_for_the_last_read_rec()) rlon, rlat = r.get_tictacs_for_the_last_read_record() plot_utils.apply_plot_params() lons[lons > 180] -= 360 crs_map = ccrs.Orthographic(central_latitude=50, central_longitude=-80) ax = plt.axes(projection=crs_map) # b = Basemap(projection="ortho", lat_0=50, lon_0=-80) # # b.drawcoastlines(linewidth=0.5) # b.shadedrelief() # b.warpimage() # b.drawmapboundary(fill_color="#94e3e8") # aximg = b.etopo() # assert isinstance(aximg, AxesImage) # aximg.set_cmap("bwr") topo, lonst, latst = get_etopo() lonst[lonst >= 180] -= 360 oc_mask = maskoceans(lonst, latst, topo) clevs = [ -500, 0, 100, 200, 300, 400, 500, 600, 700, 800, 1000, 1200, 1400, 1600, 1800, 2000, 2200, 2400, 2600, 2800, 3000, 3500, 4000, 4500, 5000 ] cmap = get_cmap(clevs) topo[topo < 0] = -600 topo[oc_mask.mask] = -600 cs = ax.contourf(lonst, latst, topo, cmap=cmap, levels=clevs, transform=ccrs.Geodetic()) ax.colorbar(cs) # show_coast_lines(b, resolution="h") ax = plt.gca() for gc in get_gridcell_polygons(rll_obj, rlon, rlat, step=20): ax.add_patch(gc) plt.savefig("carrtopy_GL_NENA_ortho0.1deg.png", bbox_inches="tight", dpi=400)
def plot_domain_and_interest_region(ax: Axes, topo_nc_file_path: Path, focus_region_lonlat_nc_file: Path = None): """ :param focus_region_lonlat_nc_file: Path to the file containing focus region lons and lats :param region_mask_lats: latitudes corresponding to the region mask :param region_mask_lons: :param ax: :param topo_nc_file_path: :param region_mask: Note: below is the expected structure of the input netcdf file $ ncdump -h geophys_452x260_me.nc netcdf geophys_452x260_me { dimensions: x = 452 ; y = 260 ; variables: float ME(x, y) ; float lon(x, y) ; float lat(x, y) ; int proj_params ; proj_params:grid_type = "E" ; proj_params:lat1 = 0. ; proj_params:lon1 = 180. ; proj_params:lat2 = 1. ; proj_params:lon2 = 276. ; } """ # read the model topography from the file with xarray.open_dataset(topo_nc_file_path) as topo_ds: topo_lons, topo_lats, topo = [ topo_ds[k].values for k in ["lon", "lat", "ME"] ] prj_params = topo_ds["proj_params"] rll = RotatedLatLon(lon1=prj_params.lon1, lat1=prj_params.lat1, lon2=prj_params.lon2, lat2=prj_params.lat2) rot_pole_cpy = rll.get_cartopy_projection_obj() ax.set_visible(False) ax = ax.figure.add_axes(ax.get_position().bounds, projection=rot_pole_cpy) # ax.coastlines() gl_mask = get_gl_mask(topo_nc_file_path) region_mask = get_mask_of_points_near_lakes(gl_mask, npoints_radius=20) topo_lons[topo_lons > 180] -= 360 xll, yll = rot_pole_cpy.transform_point(topo_lons[0, 0], topo_lats[0, 0], cartopy.crs.PlateCarree()) xur, yur = rot_pole_cpy.transform_point(topo_lons[-1, -1], topo_lats[-1, -1], cartopy.crs.PlateCarree()) map_extent = [xll, xur, yll, yur] print("Map extent: ", map_extent) topo_clevs = [0, 100, 200, 300, 400, 500, 600, 800, 1000, 1200] # bn = BoundaryNorm(topo_clevs, len(topo_clevs) - 1) cmap = cm.get_cmap("terrain") ocean_color = cmap(0.18) cmap, norm = colors.from_levels_and_colors( topo_clevs, cmap(np.linspace(0.3, 1, len(topo_clevs) - 1))) xyz_coords = rot_pole_cpy.transform_points(cartopy.crs.PlateCarree(), topo_lons, topo_lats) xx = xyz_coords[:, :, 0] yy = xyz_coords[:, :, 1] add_rectangle(ax, xx, yy, margin=20, edge_style="solid", zorder=10, linewidth=0.5) add_rectangle(ax, xx, yy, margin=10, edge_style="dashed", zorder=10, linewidth=0.5) # plot a rectangle for the focus region if focus_region_lonlat_nc_file is not None: with xarray.open_dataset(focus_region_lonlat_nc_file) as fr: focus_lons, focus_lats = fr["lon"].data, fr["lat"].data xyz_coords = rot_pole_cpy.transform_points( cartopy.crs.PlateCarree(), focus_lons, focus_lats) xxf, yyf = xyz_coords[..., 0], xyz_coords[..., 1] add_rectangle(ax, xxf, yyf, edge_style="solid", margin=0, edgecolor="magenta", zorder=10, linewidth=1) cs = ax.pcolormesh(topo_lons[:, :], topo_lats[:, :], topo[:, :], transform=cartopy.crs.PlateCarree(), cmap=cmap, norm=norm) to_plot = np.ma.masked_where(region_mask < 0.5, region_mask) ax.scatter(topo_lons, topo_lats, to_plot * 0.01, c="cyan", transform=cartopy.crs.PlateCarree(), alpha=0.5) # Add geographic features line_color = "k" ax.add_feature(common_params.LAKES_50m, facecolor=cartopy.feature.COLORS["water"], edgecolor=line_color, linewidth=0.5) ax.add_feature(common_params.OCEAN_50m, facecolor=cartopy.feature.COLORS["water"], edgecolor=line_color, linewidth=0.5) ax.add_feature(common_params.COASTLINE_50m, facecolor="none", edgecolor=line_color, linewidth=0.5) ax.add_feature(common_params.RIVERS_50m, facecolor="none", edgecolor=line_color, linewidth=0.5) ax.set_extent(map_extent, crs=rot_pole_cpy) # improve colorbar divider = make_axes_locatable(ax) ax_cb = divider.new_vertical(size="5%", pad=0.1, axes_class=plt.Axes, pack_start=True) ax.figure.add_axes(ax_cb) cb = plt.colorbar(cs, cax=ax_cb, orientation="horizontal") cb.ax.set_xticklabels(topo_clevs, rotation=45) return ax
def to_gridconfig(self): return GridConfig(rll=self.rll, ni=self.nx, nj=self.ny, iref=self.iref, jref=self.jref, dx=self.dx, dy=self.dy, xref=self.lonref, yref=self.latref) known_projections = { "GLK_210x130_0.1deg": RotatedLatLon(lon1=180., lat1=0., lon2=-84., lat2=1.0) } known_domains = { "GLK_210x130_0.1deg": Grid(rll=RotatedLatLon(lon1=180., lat1=0., lon2=-84., lat2=1.0), nx=210, ny=130, iref=105, jref=100, lonref=-84, latref=48, dx=0.1, dy=0.1), "GLK_440x260_0.1deg":
def main(): plot_permafrost = False plot_glaciers = False if not os.path.isdir(img_folder): print(os.mkdir(img_folder)) geophy_file = "/BIG1/skynet1_exec1/winger/Floods/Geophys/geophys_CORDEX_NA_0.11deg_695x680_filled_grDes_barBor_Crop2Gras_peat" # Save the permafrost mask to file pfmask_file = os.path.join(img_folder, "pf_mask_na_0.11deg.nc") if not os.path.isfile(pfmask_file): save_pf_mask_to_netcdf(rpn_field_name_with_target_grid="VF", path_to_rpn_with_target_grid=geophy_file, path=pfmask_file) with Dataset(pfmask_file) as ds: pf_mask = ds.variables["pf_type"][:] r = RPN(geophy_file) lkfr = r.get_record_for_name_and_level(varname="VF", level=3) glac = r.get_record_for_name_and_level(varname="VF", level=2) lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() proj_params = r.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**proj_params) ill, jll = 0, 250 right_margin = 50 lkfr = lkfr[ill:-right_margin, jll:] lons = lons[ill:-right_margin, jll:] lats = lats[ill:-right_margin, jll:] glac = glac[ill:-right_margin, jll:] pf_mask = pf_mask[ill:-right_margin, jll:] bmp = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats, resolution="l") xx, yy = bmp(lons, lats) plot_utils.apply_plot_params(font_size=8, width_cm=10, height_cm=10) fig = plt.figure() # Plot lakes clevs = np.arange(0, 1.1, 0.1) lkfr = np.ma.masked_where(lkfr <= 0, lkfr) cs = bmp.contourf(xx, yy, lkfr, levels=clevs, cmap="Blues") # bmp.colorbar(cs) bmp.drawcoastlines(linewidth=0.1) bmp.drawcountries(linewidth=0.1) # plot glaciers glval = 0.65 glac = (glac > 0.001) * glval glac = np.ma.masked_where(glac < 0.5, glac) cmap = cm.get_cmap("Greys") if plot_glaciers: cs = bmp.pcolormesh(xx, yy, glac, cmap="Greys", alpha=0.7, vmin=0, vmax=1) #bmp.readshapefile(os.path.join(img_folder, "sasha_glaciers/sasha_glaciers"), "glacier_poly", color=cmap(glval)) plt.legend([Rectangle((0, 0), 5, 5, fc=cmap(glval)), ], ["Glaciers", ], loc=3) # Plot permafrost boundaries with Dataset("permafrost_types_arctic_using_contains.nc") as ds: # pf_mask = ds.variables["pf_type"][:] # lons_s, lats_s = ds.variables["longitude"][:], ds.variables["latitude"][:] # # x, y, z = lat_lon.lon_lat_to_cartesian(lons_s.flatten(), lats_s.flatten()) # ktree = KDTree(list(zip(x, y, z))) # # lons_copy = lons.copy() # lons_copy[lons > 180] -= 360 # tmp = np.zeros_like(lons) # tmp = maskoceans(lons_copy, lats, tmp, inlands=False) # # xt, yt, zt = lat_lon.lon_lat_to_cartesian(lons[~tmp.mask], lats[~tmp.mask]) # dists, inds = ktree.query(list(zip(xt, yt, zt))) # # pf_mask1[~tmp.mask] = pf_mask.flatten()[inds] pf_mask1 = np.ma.masked_where((pf_mask > 2) | (pf_mask < 1), pf_mask) pf_mask1[~pf_mask1.mask] = 1 # bmp.contourf(xx, yy, pf_mask, levels=[2.5, 3.5, 4.5], cmap=ListedColormap(["yellow", "orange", "red"]), alpha=0.7) #bmp.contour(xx, yy, pf_mask, levels=[2.5, 3.5, 4.5], colors="k", linewidths=1) # bmp.drawrivers(color=cm.get_cmap("Blues")(0.8)) ncolors = 2 norm = BoundaryNorm([0.5, 1.5, 2.5], ncolors=ncolors) cmap = ListedColormap(["c", "violet"]) alpha = 0.7 if plot_permafrost: bmp.pcolormesh(xx, yy, pf_mask1, norm=norm, cmap=cmap, alpha=alpha) plt.legend([Rectangle((0, 0), 5, 5, fc=cmap(0), alpha=alpha), ], ["Permafrost",], loc=3) # tree line # bmp.readshapefile(os.path.join(img_folder, "Bernardo/treeline_current"), "treeline", linewidth=0.5, color="orange") # bmp.readshapefile(os.path.join(img_folder, "Bernardo/treeline_future"), "treeline", linewidth=0.5, color="orange") print(os.path.join(img_folder, "lakes_glaciers_pf_veg.png")) fig.savefig(os.path.join(img_folder, "lakes_glaciers_pf_veg.png"), dpi=400, bbox_inches="tight", transparent=True)
from rpn.domains.rotated_lat_lon import RotatedLatLon from domains.grid_config import GridConfig # The projection used in the last 2 papers of Huziy's thesis qc_rll_projection_huziy_thesis = RotatedLatLon(lon1=360 - 68, lat1=52, lon2=16.65, lat2=0) qc_rll_domain_huziy_thesis = GridConfig(rll=qc_rll_projection_huziy_thesis, iref=142, jref=122, dx=0.1, dy=0.1, xref=180, yref=0, ni=260, nj=260) qc_rll_domain_huziy_thesis_04 = qc_rll_domain_huziy_thesis.decrease_resolution_keep_free_domain_same( 4) if __name__ == "__main__": print(qc_rll_domain_huziy_thesis_04)
def main(): soiltemp_var_name = "TBAR" path1 = "/skynet1_rech3/huziy/class_offline_simulations_VG/dpth_var/CLASS_output_CLASSoff1_Arctic_0.5_ERA40_dpth_to_bdrck_var_1980-2009/TBAR.rpn" label1 = "Variable (real) depth to bedrock" path2 = "/skynet1_rech3/huziy/class_offline_simulations_VG/dpth_3.6m/CLASS_output_CLASSoff1_Arctic_0.5_ERA40_dpth_to_bdrck_constant_1980-2009/TBAR.rpn" label2 = "Fixed depth to bedrock (3.6 m)" path_to_dpth_to_bedrock = "/skynet1_rech3/huziy/CLASS_offline_VG/GEOPHYSICAL_FIELDS/test_analysis.rpn" # read depth to bedrock r = RPN(path_to_dpth_to_bedrock) dpth = r.get_first_record_for_name("DPTH") r.close() layer_widths = [0.1, 0.2, 0.3, 0.5, 0.9, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5] print(len(layer_widths)) crcm_data_manager = CRCMDataManager(layer_widths=layer_widths) # Read in the temperature profiles r1 = RPN(path1) soiltemp1 = r1.get_4d_field(name=soiltemp_var_name) lons2d, lats2d = r1.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**r1.get_proj_parameters_for_the_last_read_rec()) b = rll.get_basemap_object_for_lons_lats(lons2d=lons2d, lats2d=lats2d, resolution="c") r1.close() r2 = RPN(path2) soiltemp2 = r2.get_4d_field(name=soiltemp_var_name) r2.close() dates_sorted = list(sorted(soiltemp1.keys())) levels_sorted = list(sorted(list(soiltemp1.items())[0][1].keys())) # group dates for each year alt1_list = [] alt2_list = [] for year, dates_group in itertools.groupby(dates_sorted, lambda par: par.year): t1 = [] t2 = [] for d in dates_group: t1.append([soiltemp1[d][lev] for lev in levels_sorted]) t2.append([soiltemp2[d][lev] for lev in levels_sorted]) # Get maximum temperature profiles t1max = np.max(t1, axis=0).transpose(1, 2, 0) t2max = np.max(t2, axis=0).transpose(1, 2, 0) print(t1max.shape, t2max.shape) #calculate and save alts h1 = crcm_data_manager.get_alt(t1max) h2 = crcm_data_manager.get_alt(t2max) h1[h1 < 0] = np.nan h2[h2 < 0] = np.nan alt1_list.append(h1) alt2_list.append(h2) #take into account permafrost alt1_list_pf = [] alt2_list_pf = [] n_years_for_pf = 3 for i in range(len(alt1_list) - n_years_for_pf): alt1_list_pf.append(np.max(alt1_list[i:i+n_years_for_pf], axis=0)) alt2_list_pf.append(np.max(alt2_list[i:i+n_years_for_pf], axis=0)) # calculate climatological mean alt1 = np.mean(alt1_list_pf, axis=0) alt2 = np.mean(alt2_list_pf, axis=0) print(np.isnan(alt1).any(), np.isnan(alt2).any()) #mask nans alt1 = np.ma.masked_where(np.isnan(alt1), alt1) alt2 = np.ma.masked_where(np.isnan(alt2), alt2) #calculate change due to fixed depth to bedrock delta = alt2 - alt1 # for i in range(len(alt1_list)): alt1_list[i] = np.ma.masked_where(np.isnan(alt1_list[i]), alt1_list[i]) alt2_list[i] = np.ma.masked_where(np.isnan(alt2_list[i]), alt2_list[i]) #tval, pval = ttest_ind(alt1_list, alt2_list) #mask oceans lons2d[lons2d > 180] -= 360 dpth = maskoceans(lons2d, lats2d, dpth) delta = np.ma.masked_where(dpth.mask, delta) #calculate differences in SWE path_swe_1 = path1.replace("TBAR.rpn", "SNO.rpn") r1 = RPN(path_swe_1) swe1 = r1.get_all_time_records_for_name("SNO") r1.close() swe1_winter_clim = np.mean( [field for key, field in swe1.items() if key.month in [1, 2, 12]], axis=0) swe1_winter_clim = np.ma.masked_where((swe1_winter_clim >= 999) | dpth.mask, swe1_winter_clim) path_swe_2 = path2.replace("TBAR.rpn", "SNO.rpn") r2 = RPN(path_swe_2) swe2 = r2.get_all_time_records_for_name("SNO") r2.close() swe2_winter_clim = np.mean( [field for key, field in swe2.items() if key.month in [1, 2, 12]], axis=0) swe2_winter_clim = np.ma.masked_where((swe2_winter_clim >= 999) | dpth.mask, swe2_winter_clim) #plotting print("Start plotting ...") plot_differences(b, lons2d, lats2d, dpth, delta, label="ALT(DPTH=3.6m) - ALT(DPTH~)", pvalue=None, swe_diff=swe2_winter_clim - swe1_winter_clim)
def main(plot_vals=False): varname = "RFAC" multiplier = 24 * 3600 data_folder = Path("/home/huziy/skynet3_rech1/CNRCWP/Calgary_flood/atm_data_for_Arman_simulations") day_range = range(19, 22) dates_of_interest = [datetime(2013, 6, d) for d in day_range] img_folder = Path("calgary_flood/2D") if not img_folder.is_dir(): img_folder.mkdir(parents=True) lons, lats, bmp = None, None, None the_mask = get_bow_river_basin_mask() i_list, j_list = np.where(the_mask > 0.5) imin, imax = i_list.min() - 2, i_list.max() + 5 jmin, jmax = j_list.min() - 2, j_list.max() + 5 # Calculate daily means sim_label_to_date_to_mean = OrderedDict() for sim_dir in data_folder.iterdir(): mr = MultiRPN(str(sim_dir.joinpath("pm*"))) print(str(sim_dir)) print(mr.get_number_of_records()) label = sim_dir.name.split("_")[-2].replace("NoDrain", "").replace("frozen", "Frozen").replace("Bow", "") sim_label_to_date_to_mean[label] = OrderedDict() data = mr.get_4d_field(varname) data = {d: list(v.items())[0][1] for d, v in data.items() if d.day in day_range} for d in dates_of_interest: sim_label_to_date_to_mean[label][d] = ( np.array([field for d1, field in data.items() if d1.day == d.day]).mean(axis=0) * multiplier ) if lons is None: lons, lats = mr.get_longitudes_and_latitudes_of_the_last_read_rec() for f in sim_dir.iterdir(): if f.name.startswith("pm"): r = RPN(str(f)) r.get_first_record_for_name(varname=varname) rll = RotatedLatLon(**r.get_proj_parameters_for_the_last_read_rec()) bmp = rll.get_basemap_object_for_lons_lats( lons2d=lons[imin:imax, jmin:jmax], lats2d=lats[imin:imax, jmin:jmax], resolution="i" ) r.close() break mr.close() # reorder simulations sim_label_to_date_to_mean = OrderedDict( [ (k, sim_label_to_date_to_mean[k]) for k in sorted(sim_label_to_date_to_mean, key=lambda z: len(z), reverse=True) ] ) key_list = [k for k in sim_label_to_date_to_mean] key_list[-2], key_list[-1] = key_list[-1], key_list[-2] sim_label_to_date_to_mean = OrderedDict([(k, sim_label_to_date_to_mean[k]) for k in key_list]) # do the plots (subplots: vertically - simulations, horizontally - days) plot_utils.apply_plot_params(width_cm=24, height_cm=28, font_size=10) fig = plt.figure() nrows = len(sim_label_to_date_to_mean) ncols = len(day_range) gs = GridSpec(nrows, ncols, wspace=0, hspace=0.1) clevs_vals = [0, 0.1, 20, 50, 100, 150, 200, 300] base_label = None clevs_diff = [1, 5, 10, 20, 50, 100] clevs_diff = [-c for c in reversed(clevs_diff)] + [0] + clevs_diff cmap_diff = cm.get_cmap("bwr", len(clevs_diff) - 1) cmap_vals = get_cmap_from_ncl_spec_file(path="colormap_files/precip3_16lev.rgb", ncolors=len(clevs_vals) - 1) xx, yy = bmp(lons, lats) title = "Total runoff ({}, mm/day)".format(varname) fig.suptitle(title) for row, (sim_label, date_to_field) in enumerate(sim_label_to_date_to_mean.items()): if row == 0 or plot_vals: base_sim = OrderedDict([(k, 0) for k, v in date_to_field.items()]) base_label = sim_label plot_label = sim_label clevs = clevs_vals cmap = cmap_vals extend = "max" else: base_sim = list(sim_label_to_date_to_mean.items())[0][1] plot_label = "{}\n-\n{}".format(sim_label, base_label) clevs = clevs_diff cmap = cmap_diff extend = "both" bn = BoundaryNorm(boundaries=clevs, ncolors=len(clevs) - 1) for col, (the_date, field) in enumerate(date_to_field.items()): ax = fig.add_subplot(gs[row, col]) to_plot = np.ma.masked_where(the_mask < 0.5, field - base_sim[the_date]) # cs = bmp.contourf(xx[~to_plot.mask], yy[~to_plot.mask], to_plot[~to_plot.mask], levels=clevs, extend="max", tri=True) cs = bmp.pcolormesh(xx, yy, to_plot[:-1, :-1], norm=bn, vmin=clevs[0], vmax=clevs[-1], cmap=cmap) bmp.drawcoastlines(ax=ax, linewidth=0.3) assert isinstance(bmp, Basemap) bmp.readshapefile(BOW_RIVER_SHP[:-4], "basin", zorder=5) cb = bmp.colorbar(cs, ax=ax, ticks=clevs, extend=extend, pad="4%", size="10%") if plot_vals: cb.ax.set_visible(col == ncols - 1 and row == 0) else: cb.ax.set_visible(col == ncols - 1 and row in (0, 1)) if col == 0: ax.set_ylabel(plot_label) if row == 0: ax.set_title(the_date.strftime("%b %d")) if plot_vals: img_file = img_folder.joinpath("{}.png".format(varname)) else: img_file = img_folder.joinpath("{}_diff.png".format(varname)) fig.savefig(str(img_file)) plt.close(fig)
def main(): soiltemp_var_name = "TBAR" path1 = "/skynet1_rech3/huziy/class_offline_simulations_VG/dpth_var/CLASS_output_CLASSoff1_Arctic_0.5_ERA40_dpth_to_bdrck_var_1980-2009/TBAR.rpn" label1 = "Variable (real) depth to bedrock" path2 = "/skynet1_rech3/huziy/class_offline_simulations_VG/dpth_3.6m/CLASS_output_CLASSoff1_Arctic_0.5_ERA40_dpth_to_bdrck_constant_1980-2009/TBAR.rpn" label2 = "Fixed depth to bedrock (3.6 m)" path_to_dpth_to_bedrock = "/skynet1_rech3/huziy/CLASS_offline_VG/GEOPHYSICAL_FIELDS/test_analysis.rpn" # read depth to bedrock r = RPN(path_to_dpth_to_bedrock) dpth = r.get_first_record_for_name("DPTH") r.close() layer_widths = [ 0.1, 0.2, 0.3, 0.5, 0.9, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5 ] print(len(layer_widths)) crcm_data_manager = CRCMDataManager(layer_widths=layer_widths) # Read in the temperature profiles r1 = RPN(path1) soiltemp1 = r1.get_4d_field(name=soiltemp_var_name) lons2d, lats2d = r1.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**r1.get_proj_parameters_for_the_last_read_rec()) b = rll.get_basemap_object_for_lons_lats(lons2d=lons2d, lats2d=lats2d, resolution="c") r1.close() r2 = RPN(path2) soiltemp2 = r2.get_4d_field(name=soiltemp_var_name) r2.close() dates_sorted = list(sorted(soiltemp1.keys())) levels_sorted = list(sorted(list(soiltemp1.items())[0][1].keys())) # group dates for each year alt1_list = [] alt2_list = [] for year, dates_group in itertools.groupby(dates_sorted, lambda par: par.year): t1 = [] t2 = [] for d in dates_group: t1.append([soiltemp1[d][lev] for lev in levels_sorted]) t2.append([soiltemp2[d][lev] for lev in levels_sorted]) # Get maximum temperature profiles t1max = np.max(t1, axis=0).transpose(1, 2, 0) t2max = np.max(t2, axis=0).transpose(1, 2, 0) print(t1max.shape, t2max.shape) #calculate and save alts h1 = crcm_data_manager.get_alt(t1max) h2 = crcm_data_manager.get_alt(t2max) h1[h1 < 0] = np.nan h2[h2 < 0] = np.nan alt1_list.append(h1) alt2_list.append(h2) #take into account permafrost alt1_list_pf = [] alt2_list_pf = [] n_years_for_pf = 3 for i in range(len(alt1_list) - n_years_for_pf): alt1_list_pf.append(np.max(alt1_list[i:i + n_years_for_pf], axis=0)) alt2_list_pf.append(np.max(alt2_list[i:i + n_years_for_pf], axis=0)) # calculate climatological mean alt1 = np.mean(alt1_list_pf, axis=0) alt2 = np.mean(alt2_list_pf, axis=0) print(np.isnan(alt1).any(), np.isnan(alt2).any()) #mask nans alt1 = np.ma.masked_where(np.isnan(alt1), alt1) alt2 = np.ma.masked_where(np.isnan(alt2), alt2) #calculate change due to fixed depth to bedrock delta = alt2 - alt1 # for i in range(len(alt1_list)): alt1_list[i] = np.ma.masked_where(np.isnan(alt1_list[i]), alt1_list[i]) alt2_list[i] = np.ma.masked_where(np.isnan(alt2_list[i]), alt2_list[i]) #tval, pval = ttest_ind(alt1_list, alt2_list) #mask oceans lons2d[lons2d > 180] -= 360 dpth = maskoceans(lons2d, lats2d, dpth) delta = np.ma.masked_where(dpth.mask, delta) #calculate differences in SWE path_swe_1 = path1.replace("TBAR.rpn", "SNO.rpn") r1 = RPN(path_swe_1) swe1 = r1.get_all_time_records_for_name("SNO") r1.close() swe1_winter_clim = np.mean( [field for key, field in swe1.items() if key.month in [1, 2, 12]], axis=0) swe1_winter_clim = np.ma.masked_where( (swe1_winter_clim >= 999) | dpth.mask, swe1_winter_clim) path_swe_2 = path2.replace("TBAR.rpn", "SNO.rpn") r2 = RPN(path_swe_2) swe2 = r2.get_all_time_records_for_name("SNO") r2.close() swe2_winter_clim = np.mean( [field for key, field in swe2.items() if key.month in [1, 2, 12]], axis=0) swe2_winter_clim = np.ma.masked_where( (swe2_winter_clim >= 999) | dpth.mask, swe2_winter_clim) #plotting print("Start plotting ...") plot_differences(b, lons2d, lats2d, dpth, delta, label="ALT(DPTH=3.6m) - ALT(DPTH~)", pvalue=None, swe_diff=swe2_winter_clim - swe1_winter_clim)
def main(): path = "/RESCUE/skynet3_rech1/huziy/CNRCWP/Calgary_flood/Global_NA_v1/Samples/Global_NA_v1_201306/pm2013010100_00017280p" varname = "PR" plot_units = "mm/day" mult_coeff = 1000 * 24 * 3600 add_offset = 0 img_folder = "/RESCUE/skynet3_rech1/huziy/CNRCWP/Calgary_flood/glob_sim/{}/monthly/{}".format(varname, os.path.basename(path)) img_folder = Path(img_folder) if not img_folder.is_dir(): img_folder.mkdir(parents=True) r = RPN(path=path) pr = r.get_all_time_records_for_name(varname=varname) lons2d, lats2d = r.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**r.get_proj_parameters_for_the_last_read_rec()) bmp = rll.get_basemap_object_for_lons_lats(lons2d=lons2d, lats2d=lats2d, resolution="c", no_rot=True) # bmp = Basemap(projection="robin", lon_0=180) xx, yy = bmp(lons2d, lats2d) dates = list(sorted(pr.keys())) data = np.array([pr[d] for d in dates]) p = pd.Panel(data=data, items=dates, major_axis=range(data.shape[1]), minor_axis=range(data.shape[2])) # p_daily = p.groupby(lambda d: d.day, axis="items").mean() p_daily = p.apply(np.mean, axis="items") print(p_daily.head()) lons2d[lons2d > 180] -= 360 bmap_params = bmp.projparams bmap_params.update({ 'llcrnrlon': lons2d[0, 0], 'urcrnrlon': lons2d[-1, -1], 'llcrnrlat': lats2d[0, 0], 'urcrnrlat': lats2d[-1, -1] }) rpole_crs = ccrs.RotatedPole(pole_longitude=bmap_params["lon_0"] + 180, pole_latitude=bmap_params["o_lat_p"]) clevs = [0, 0.01, 0.1, 1, 1.5, 2, 5, 10, 20, 40, 60, 80] norm = BoundaryNorm(clevs, ncolors=len(clevs) - 1) cmap = cm.get_cmap(cm_basemap.s3pcpn, len(clevs) - 1) field = p_daily.values * mult_coeff + add_offset fig = plt.figure() plt.title("{}, {}/{}/{}, {}".format(varname, 1, dates[0].month, dates[0].year, plot_units)) ax = plt.axes(projection=rpole_crs) ax.coastlines(resolution='110m') ax.gridlines() ax.gridlines() # cs = bmp.contourf(xx, yy, field, clevs, norm=norm, extend="max", cmap=cmap) cs = ax.pcolormesh(lons2d[:-1, :-1], lats2d[:-1, :-1], field[:-1, :-1], norm=norm, cmap=cmap, transform=rpole_crs) plt.colorbar(cs, ticks=clevs, extend="max", ax=ax) img_file = img_folder.joinpath("{:02d}-{:02d}-{}.png".format(1, dates[0].month, dates[0].year)) # bmp.drawcoastlines() # bmp.drawstates() # bmp.drawcounties() # bmp.drawcountries() plt.savefig(img_file.open("wb")) plt.close(fig) print(pr[dates[0]].mean())
def main(): path = "/RESCUE/skynet3_rech1/huziy/CNRCWP/Calgary_flood/Global_NA_v1/Samples/Global_NA_v1_201306/pm2013010100_00017280p" varname = "PR" plot_units = "mm/day" mult_coeff = 1000 * 24 * 3600 add_offset = 0 img_folder = "/RESCUE/skynet3_rech1/huziy/CNRCWP/Calgary_flood/glob_sim/{}/monthly/{}".format( varname, os.path.basename(path)) img_folder = Path(img_folder) if not img_folder.is_dir(): img_folder.mkdir(parents=True) r = RPN(path=path) pr = r.get_all_time_records_for_name(varname=varname) lons2d, lats2d = r.get_longitudes_and_latitudes_for_the_last_read_rec() rll = RotatedLatLon(**r.get_proj_parameters_for_the_last_read_rec()) bmp = rll.get_basemap_object_for_lons_lats(lons2d=lons2d, lats2d=lats2d, resolution="c", no_rot=True) # bmp = Basemap(projection="robin", lon_0=180) xx, yy = bmp(lons2d, lats2d) dates = list(sorted(pr.keys())) data = np.array([pr[d] for d in dates]) p = pd.Panel(data=data, items=dates, major_axis=range(data.shape[1]), minor_axis=range(data.shape[2])) # p_daily = p.groupby(lambda d: d.day, axis="items").mean() p_daily = p.apply(np.mean, axis="items") print(p_daily.head()) lons2d[lons2d > 180] -= 360 bmap_params = bmp.projparams bmap_params.update({ 'llcrnrlon': lons2d[0, 0], 'urcrnrlon': lons2d[-1, -1], 'llcrnrlat': lats2d[0, 0], 'urcrnrlat': lats2d[-1, -1] }) rpole_crs = ccrs.RotatedPole(pole_longitude=bmap_params["lon_0"] + 180, pole_latitude=bmap_params["o_lat_p"]) clevs = [0, 0.01, 0.1, 1, 1.5, 2, 5, 10, 20, 40, 60, 80] norm = BoundaryNorm(clevs, ncolors=len(clevs) - 1) cmap = cm.get_cmap(cm_basemap.s3pcpn, len(clevs) - 1) field = p_daily.values * mult_coeff + add_offset fig = plt.figure() plt.title("{}, {}/{}/{}, {}".format(varname, 1, dates[0].month, dates[0].year, plot_units)) ax = plt.axes(projection=rpole_crs) ax.coastlines(resolution='110m') ax.gridlines() ax.gridlines() # cs = bmp.contourf(xx, yy, field, clevs, norm=norm, extend="max", cmap=cmap) cs = ax.pcolormesh(lons2d[:-1, :-1], lats2d[:-1, :-1], field[:-1, :-1], norm=norm, cmap=cmap, transform=rpole_crs) plt.colorbar(cs, ticks=clevs, extend="max", ax=ax) img_file = img_folder.joinpath("{:02d}-{:02d}-{}.png".format( 1, dates[0].month, dates[0].year)) # bmp.drawcoastlines() # bmp.drawstates() # bmp.drawcounties() # bmp.drawcountries() plt.savefig(img_file.open("wb")) plt.close(fig) print(pr[dates[0]].mean())
def main(save_to_nc=True): """ Read geotiff file with the field capacity field in mm, interpolate it to model grid, divide by the depth to bedrock, and save to netcdf file """ # Read model data obs_fields_path = "/skynet3_rech1/huziy/geofields_interflow_exp/pm1979010100_00000000p" robj = RPN(obs_fields_path) thfc = robj.get_first_record_for_name_and_level(varname="D9", level=1) bdrck_depth = _get_depth_to_bedrock(obs_fields_path) proj_params = robj.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**proj_params) t_lons, t_lats = robj.get_longitudes_and_latitudes_for_the_last_read_rec() t_lons[t_lons > 180] -= 360.0 bmp = rll.get_basemap_object_for_lons_lats(lons2d=t_lons, lats2d=t_lats) robj.close() intp_img = read_observed_bfc().resample( SwathDefinition(t_lons.flatten(), t_lats.flatten())) fig = plt.figure(figsize=(10, 6)) assert isinstance(fig, Figure) gs = GridSpec(1, 3, width_ratios=[0.95, 1, 1]) # Observed bulk field capacity ax = fig.add_subplot(gs[0, 0]) x, y = bmp(t_lons, t_lats) to_plot = intp_img.image_data.reshape(t_lons.shape) to_plot = np.ma.masked_where(to_plot < 0, to_plot) / (1.0e3 * bdrck_depth) im = bmp.pcolormesh(x, y, to_plot, vmin=0, vmax=0.5) bmp.drawcoastlines() ax.set_title("ORNL DAAC") # Currently used in the model ax = fig.add_subplot(gs[0, 1]) thfc_to_plot = np.ma.masked_where(to_plot.mask, thfc) im = bmp.pcolormesh(x, y, thfc_to_plot, vmin=0, vmax=0.5) bmp.colorbar(im, ax=ax) bmp.drawcoastlines(ax=ax) ax.set_title("Current") bmp.colorbar(im, ax=ax) # Current - (ORNL DAAC) ax = fig.add_subplot(gs[0, 2]) x, y = bmp(t_lons, t_lats) cmap = cm.get_cmap("RdBu_r", 21) im = bmp.pcolormesh(x, y, thfc_to_plot - to_plot, vmin=-0.5, vmax=0.5, cmap=cmap) bmp.colorbar(im, ax=ax) bmp.drawcoastlines(ax=ax) ax.set_title("Current - (ORNL-DAAC)") bmp.colorbar(im, ax=ax) plt.show() pass