def run_post(conf): FIXdir = conf.get("DEFAULT","FIXbwrf") sfc_switch = conf.getint("post","plot_sfc") cloud_switch = conf.getint("post","plot_clouds") sfcdiags_switch = conf.getint("post","plot_sfcdiags") xcdiags_switch = conf.getint("post","plot_xcdiags") switch_700mb = conf.getint("post","plot_700mb") switch_500mb = conf.getint("post","plot_500mb") switch_300mb = conf.getint("post","plot_300mb") # sfc_switch = 0 # cloud_switch = 0 # sfcdiags_switch = 0 # xcdiags_switch = 0 # switch_700mb = 0 # switch_500mb = 0 # switch_300mb = 0 blat = conf.getfloat("post","blat") blon = conf.getfloat("post","blon") dx = conf.getfloat("wrf","dx") POSTwork = conf.get("DEFAULT","POSTwork") os.chdir(POSTwork) file_wrf = glob.glob("wrfout*")[0] print("Processing "+file_wrf) init_time = file_wrf[11:21]+" "+file_wrf[22:24]+"Z" # Download the states and coastlines states = cfeature.NaturalEarthFeature(category='cultural', scale='50m', facecolor='none', name='admin_1_states_provinces_shp') # Get counties. reader = shpreader.Reader(FIXdir+'/shapefiles/countyp010g.shp') counties = list(reader.geometries()) COUNTIES = cfeature.ShapelyFeature(counties, crs.PlateCarree()) # Open the NetCDF file ncfile = Dataset(file_wrf) # Get the times and convert to datetimes times = getvar(ncfile, "Times", timeidx=ALL_TIMES, meta=False) dtimes = [datetime.strptime(str(atime), '%Y-%m-%dT%H:%M:%S.000000000') for atime in times] numTimes = len(times) # Reflectivity ref = getvar(ncfile, "REFL_10CM", timeidx=ALL_TIMES) ref[0,0,0,0]=-21.0 # hack to plot a blank contour plot at the initial time # Get upper-air quantities. p = getvar(ncfile, "pressure", timeidx=ALL_TIMES) z = getvar(ncfile, "z", units="dm", timeidx=ALL_TIMES) u, v = getvar(ncfile, "uvmet", units="kt", timeidx=ALL_TIMES, meta=False) w = getvar(ncfile, "wa", units="m s-1", timeidx=ALL_TIMES)*100. # m/s to cm/s rh = getvar(ncfile, "rh", timeidx=ALL_TIMES) wspeed = (u**2.0+v**2.0)**0.5 tc = getvar(ncfile, "tc", timeidx=ALL_TIMES) dewT = getvar(ncfile, "td", units="degC", timeidx=ALL_TIMES) cloudfrac = getvar(ncfile, "cloudfrac", low_thresh=20., mid_thresh=955., high_thresh=4500., timeidx=ALL_TIMES) total_cloudfrac=np.max(cloudfrac,axis=0) low_cloudfrac = cloudfrac[0,:,:,:] mid_cloudfrac = cloudfrac[1,:,:,:] high_cloudfrac = cloudfrac[2,:,:,:] # Interpolate z_500 = smooth2d(interplevel(z, p, 500), 3) tc_500 = smooth2d(interplevel(tc, p, 500), 3) u_500 = interplevel(u, p, 500) v_500 = interplevel(v, p, 500) wspeed_500 = interplevel(wspeed, p, 500) z_300 = smooth2d(interplevel(z, p, 300), 3) u_300 = interplevel(u, p, 300) v_300 = interplevel(v, p, 300) z_700 = interplevel(z, p, 700) tc_700 = interplevel(tc, p, 700) u_700 = interplevel(u, p, 700) v_700 = interplevel(v, p, 700) w_700 = interplevel(w, p, 700) rh_700 = interplevel(rh, p, 700) if switch_700mb == 1: # Interpolate over NaNs. for itime in range(numTimes): z_700[itime,:,:] = interpnan(z_700[itime,:,:]) tc_700[itime,:,:] = interpnan(tc_700[itime,:,:]) rh_700[itime,:,:] = interpnan(rh_700[itime,:,:]) u_700[itime,:,:] = interpnan(u_700[itime,:,:]) v_700[itime,:,:] = interpnan(v_700[itime,:,:]) w_700[itime,:,:] = interpnan(w_700[itime,:,:]) z_700 = smooth2d(z_700, 3) tc_700 = smooth2d(tc_700, 3) w_700 = smooth2d(w_700, 3) div_300 = smooth2d(divergence([u_300*0.514444, v_300*0.514444], dx), 3) # kt to m/s # Get the sea level pressure slp = getvar(ncfile, "slp", timeidx=ALL_TIMES) # Get the wet bulb temperature twb = getvar(ncfile, "twb", units="degC", timeidx=ALL_TIMES) slp_levels=np.arange(980,1040,2) z_levels=np.arange(504,620,3) z_levels_300=np.arange(804,996,6) z_levels_700=np.arange(285,351,3) t2_levels=np.arange(-20,125,5) tc_levels=np.arange(-40,30,2) wspeed_levels=np.arange(40,150,10) ref_levels=np.arange(-20,60,5) rh_levels=np.arange(70,105,5) cldfrac_levels=np.arange(0.,1.1,0.1) twb_levels=np.arange(0,1,1) wup_levels=np.arange(5,55,10) wdown_levels=np.arange(-55,-5,10) div_levels=np.arange(-110,120,10) # Get the 10-m u and v wind components. u_10m, v_10m = getvar(ncfile, "uvmet10", units="kt", timeidx=ALL_TIMES) wind_10m = (u_10m**2.0+v_10m**2.0)**0.5 # Smooth the sea level pressure since it tends to be noisy near the mountains smooth_slp = smooth2d(slp, 3) twb=twb[:,0,:,:] # lowest model level twb=smooth2d(twb,3) # Get the latitude and longitude points lats, lons = latlon_coords(slp) # Get the cartopy mapping object cart_proj = get_cartopy(slp) if sfcdiags_switch == 1: bx, by = ll_to_xy(ncfile, blat, blon, meta=False, as_int=True) # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "precip.png" # should be variable ACSNOW # accumulated_snow = getvar(ncfile, "SNOWNC", timeidx=ALL_TIMES) liq_equiv = (getvar(ncfile, "RAINC", timeidx=ALL_TIMES) + getvar(ncfile, "RAINNC", timeidx=ALL_TIMES))/25.4 # mm to inches liq_equiv_bdu = liq_equiv[:,by,bx] prate = np.zeros(numTimes) for itime in range(numTimes): if itime > 0 and itime < numTimes-1: prate[itime] = 0.5*((liq_equiv_bdu[itime+1]+liq_equiv_bdu[itime]) - (liq_equiv_bdu[itime-1]+liq_equiv_bdu[itime])) elif itime == 0: prate[0] = liq_equiv_bdu[0] else: prate[numTimes-1] = liq_equiv_bdu[numTimes-1]-liq_equiv_bdu[numTimes-2] plt.bar(times, prate, width=0.0425, color="black") plt.plot(times, liq_equiv_bdu, color="blue") plt.xlim(min(times), max(times)) plt.title("Forecast Precipitation: Boulder, CO") plt.xlabel("Time (UTC)") plt.ylabel("Running total (line) and rate (bars, inches of liquid)") plt.grid(b=True, which="major", axis="both", color="gray", linestyle="--") fig.savefig("sfcdiags/"+fileout,bbox_inches='tight') plt.close(fig) # Create a figure fig, ax1 = plt.subplots(figsize=(12,9)) fileout = "t2m_td2m_wind10m_prate.png" t2m = 1.8*(getvar(ncfile, "T2", timeidx=ALL_TIMES)-273.15)+32. td2m = getvar(ncfile, "td2", units="degF", timeidx=ALL_TIMES) color = 'tab:blue' ax1.bar(times, prate, width=0.0425, color="blue") ax1.plot(times, liq_equiv_bdu, color="blue") ax1.set_ylim(0.,max([max(prate)/0.1+0.01,max(liq_equiv_bdu)+0.1])) ax1.set_xlabel("Time (UTC)") ax1.set_ylabel("Precipitation liquid amount (in) and rate (bars, in/hr)", color=color) ax1.tick_params(axis="y", labelcolor=color) ax1.grid(b=True, which="major", axis="x", color="gray", linestyle="--") ax2=ax1.twinx() ax2.plot(times, wind_10m[:,by,bx], color="black") ax2.barbs(times, wind_10m[:,by,bx], u_10m[:,by,bx], v_10m[:,by,bx]) ax2.plot(times, t2m[:,by,bx], color="red") ax2.plot(times, td2m[:,by,bx], color="green") ax2.set_xlim(min(times), max(times)) plt.title("Forecast near-surface variables: Boulder, CO") ax2.set_ylabel("2-m T (red) and 2-m Td (green, degF), 10-m wind (black, kt)") ax2.grid(b=True, which="major", axis="y", color="gray", linestyle="--") fig.tight_layout() fig.savefig("sfcdiags/"+fileout,bbox_inches='tight') plt.close(fig) if xcdiags_switch == 1: zinterp = np.arange(550, 880, 10) u_xc = vertcross(u, p, levels=zinterp, wrfin=ncfile, stagger='u', pivot_point=CoordPair(lat=blat,lon=blon), angle=90., meta=False) w_xc = vertcross(w, p, levels=zinterp, wrfin=ncfile, stagger='u', pivot_point=CoordPair(lat=blat,lon=blon), angle=90., meta=False) tc_xc = vertcross(tc, p, levels=zinterp, wrfin=ncfile, stagger='u', pivot_point=CoordPair(lat=blat,lon=blon), angle=90., meta=False) rh_xc = vertcross(rh, p, levels=zinterp, wrfin=ncfile, stagger='u', pivot_point=CoordPair(lat=blat,lon=blon), angle=90., meta=False) nx = np.shape(u_xc)[-1] xinterp = np.arange(0,nx,1) bx, by = ll_to_xy(ncfile, blat, blon, meta=False, as_int=True) for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "mtnwave_xc"+str(itime).zfill(2)+".png" ax=plt.gca() ax.set_facecolor("black") plt.contourf(xinterp, zinterp, u_xc[itime,:,:], cmap=get_cmap("seismic"), levels=np.arange(-50,55,5)) plt.colorbar(shrink=.62) w_contour = plt.contour(xinterp, zinterp, w_xc[itime,:,:], "--", levels=np.arange(-120,-20,20),colors="black") plt.clabel(w_contour, inline=1, fontsize=10, fmt="%i") w_contour = plt.contour(xinterp, zinterp, w_xc[itime,:,:], levels=np.arange(20,120,20),colors="black") plt.clabel(w_contour, inline=1, fontsize=10, fmt="%i") t_contour = plt.contour(xinterp, zinterp, tc_xc[itime,:,:], levels=[-20,-10,0], colors="yellow") plt.clabel(t_contour, inline=1, fontsize=10, fmt="%i") # Add location of Boulder to plot. plt.scatter(bx,np.max(zinterp),c='r',marker='+') plt.ylim([np.max(zinterp),np.min(zinterp)]) # plt.yscale("log") # plt.xticks([np.arange(900,475,-25)], ["900", "875", # "850", "825", "800", "775", "750", "725", "700", "675", "650", # "625", "600", "575", "550", "525", "500"]) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": zonal wind (fill, kt), temp (yellow lines, degC), VV (black lines, cm/s)") fig.savefig("xcdiags/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background xcdiags/mtnwave_xc*.png -loop 0 xcdiags/mtnwave_xc.gif") for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "mtnwave_xc_rh"+str(itime).zfill(2)+".png" ax=plt.gca() ax.set_facecolor("black") plt.contourf(xinterp, zinterp, rh_xc[itime,:,:], cmap=get_cmap("Greens"), levels=rh_levels, extend='both') plt.colorbar(shrink=.62) skip=2 plt.quiver(xinterp[::skip], zinterp[::skip], u_xc[itime,::skip,::skip], w_xc[itime,::skip,::skip]/2., scale=500, headwidth=3, color='black', pivot='middle') t_contour = plt.contour(xinterp, zinterp, tc_xc[itime,:,:], levels=[-20,-10,0], colors="yellow") plt.clabel(t_contour, inline=1, fontsize=10, fmt="%i") # Add location of Boulder to plot. plt.scatter(bx,np.max(zinterp),c='r',marker='+') plt.ylim([np.max(zinterp),np.min(zinterp)]) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": rh (fill), temp (yellow lines, degC), wind (arrows)") fig.savefig("xcdiags_rh/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background xcdiags_rh/mtnwave_xc_rh*.png -loop 0 xcdiags_rh/mtnwave_xc_rh.gif") zinterp = np.arange(150, 900, 25) rh_xc = vertcross(rh, p, levels=zinterp, wrfin=ncfile, stagger='u', pivot_point=CoordPair(lat=blat,lon=blon), angle=90., meta=False) tc_xc = vertcross(tc, p, levels=zinterp, wrfin=ncfile, stagger='u', pivot_point=CoordPair(lat=blat,lon=blon), angle=90., meta=False) nx = np.shape(u_xc)[-1] xinterp = np.arange(0,nx,1) bx, by = ll_to_xy(ncfile, blat, blon, meta=False, as_int=True) for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "mtnwave_xc_rh_big"+str(itime).zfill(2)+".png" ax=plt.gca() ax.set_facecolor("black") plt.contourf(xinterp, zinterp, rh_xc[itime,:,:], cmap=get_cmap("Greens"), levels=rh_levels, extend='both') plt.colorbar(shrink=.62) t_contour = plt.contour(xinterp, zinterp, tc_xc[itime,:,:], levels=[-20,-10,0], colors="yellow") plt.clabel(t_contour, inline=1, fontsize=10, fmt="%i") # Add location of Boulder to plot. plt.scatter(bx,np.max(zinterp),c='r',marker='+') plt.ylim([np.max(zinterp),np.min(zinterp)]) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": rh (fill), temp (yellow lines, degC)") fig.savefig("xcdiags_rh_big/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background xcdiags_rh_big/mtnwave_xc_rh_big*.png -loop 0 xcdiags_rh_big/mtnwave_xc_rh_big.gif") if sfc_switch == 1: bx, by = ll_to_xy(ncfile, blat, blon, meta=False, as_int=True) for itime in range(numTimes): ps = p[itime,:,by,bx] ps_temp = ps T = tc[itime,:,by,bx] Td = dewT[itime,:,by,bx] us = u[itime,:,by,bx] vs = v[itime,:,by,bx] ps = ps[ps_temp >= 100.] T = T[ps_temp >= 100.] Td = Td[ps_temp >= 100.] us = us[ps_temp >= 100.] vs = vs[ps_temp >= 100.] fig = plt.figure(figsize=(9, 9)) skew = SkewT(fig, rotation=45) fileout = "sounding"+str(itime).zfill(2)+".png" # Plot the data using normal plotting functions, in this case using # log scaling in Y, as dictated by the typical meteorological plot. skew.plot(ps, T, 'r') skew.plot(ps, Td, 'g') skew.plot_barbs(ps, us, vs) skew.ax.set_ylim(1000, 100) skew.ax.set_xlim(-40, 60) # Calculate LCL height and plot as black dot. Because `p`'s first value is # ~1000 mb and its last value is ~250 mb, the `0` index is selected for # `p`, `T`, and `Td` to lift the parcel from the surface. If `p` was inverted, # i.e. start from low value, 250 mb, to a high value, 1000 mb, the `-1` index # should be selected. lcl_pressure, lcl_temperature = mpcalc.lcl(ps[0], T[0], Td[0]) skew.plot(lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black') # Calculate full parcel profile and add to plot as black line prof = mpcalc.parcel_profile(ps, T[0], Td[0]).to('degC') skew.plot(ps, prof, 'k', linewidth=2) # Shade areas of CAPE and CIN # skew.shade_cin(ps, T, prof, Td) [cape, cin] = mpcalc.cape_cin(ps, T, Td, prof) # skew.shade_cape(ps, T, prof) # An example of a slanted line at constant T -- in this case the 0 # isotherm skew.ax.axvline(0, color='c', linestyle='--', linewidth=2) # Add the relevant special lines skew.plot_dry_adiabats() skew.plot_moist_adiabats() skew.plot_mixing_lines() plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": Boulder, CO, CAPE: "+str(round(cape.magnitude))+" J/kg CIN: "+str(round(cin.magnitude))+" J/kg") fig.savefig("sounding/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background sounding/sounding*.png -loop 0 sounding/sounding.gif") for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "sfc_fhr"+str(itime).zfill(2)+".png" # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Add the states and coastlines ax.add_feature(states, linewidth=0.8, edgecolor='gray') ax.add_feature(COUNTIES, linewidth=0.4, facecolor='none', edgecolor='gray') ax.coastlines('50m', linewidth=0.8) # Reflectivity at the lowest model level. plt.contourf(to_np(lons), to_np(lats), to_np(ref[itime,0,:,:]), transform=crs.PlateCarree(), cmap=get_cmap("jet"), levels=ref_levels) # Add a color bar plt.colorbar(ax=ax, shrink=.62) # Contour the wetbulb temperature at 0 degC. c_p = plt.contour(to_np(lons), to_np(lats), to_np(twb[itime,:,:]), transform=crs.PlateCarree(), colors="red", levels=twb_levels) plt.clabel(c_p, inline=1, fontsize=10, fmt="%i") # Make the contour outlines and filled contours for the smoothed sea level pressure. c_p = plt.contour(to_np(lons), to_np(lats), to_np(smooth_slp[itime,:,:]), transform=crs.PlateCarree(), colors="black", levels=slp_levels) plt.clabel(c_p, inline=1, fontsize=10, fmt="%i") # Add location of Boulder to plot. plt.scatter(blon,blat,c='r',marker='+',transform=crs.PlateCarree()) # Add the 10-m wind barbs, only plotting every other data point. skip=2 plt.barbs(to_np(lons[::skip,::skip]), to_np(lats[::skip,::skip]), to_np(u_10m[itime, ::skip, ::skip]), to_np(v_10m[itime, ::skip, ::skip]), transform=crs.PlateCarree(), length=5.25, linewidth=0.5) # Set the map limits. ax.set_xlim(cartopy_xlim(smooth_slp)) ax.set_ylim(cartopy_ylim(smooth_slp)) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": SLP (fill, hPa), 10-m wind (barbs, kt), LML Ref (fill, dBZ), LML WBT (red, degC)") fig.savefig("sfc/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background sfc/sfc*.png -loop 0 sfc/sfc.gif") for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "sfc_temp_fhr"+str(itime).zfill(2)+".png" # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Add the states and coastlines ax.add_feature(states, linewidth=0.8, edgecolor='gray') ax.add_feature(COUNTIES, linewidth=0.4, facecolor='none', edgecolor='gray') ax.coastlines('50m', linewidth=0.8) # 2-m air temperature t2 = 1.8*(getvar(ncfile, "T2", timeidx=ALL_TIMES) - 273.15)+32. plt.contourf(to_np(lons), to_np(lats), to_np(t2[itime,:,:]), transform=crs.PlateCarree(), cmap=get_cmap("jet"), levels=t2_levels) # Add a color bar plt.colorbar(ax=ax, shrink=.62) # Make the contour outlines and filled contours for the smoothed sea level pressure. c_p = plt.contour(to_np(lons), to_np(lats), to_np(smooth_slp[itime,:,:]), transform=crs.PlateCarree(), colors="black", levels=slp_levels) plt.clabel(c_p, inline=1, fontsize=10, fmt="%i") # Add location of Boulder to plot. plt.scatter(blon,blat,c='r',marker='+',transform=crs.PlateCarree()) # Add the 10-m wind barbs, only plotting every other data point. skip=2 plt.barbs(to_np(lons[::skip,::skip]), to_np(lats[::skip,::skip]), to_np(u_10m[itime, ::skip, ::skip]), to_np(v_10m[itime, ::skip, ::skip]), transform=crs.PlateCarree(), length=5.25, linewidth=0.5) # Set the map limits. ax.set_xlim(cartopy_xlim(smooth_slp)) ax.set_ylim(cartopy_ylim(smooth_slp)) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": SLP (contours, hPa), 10-m wind (barbs, kt), 2-m T (fill, degF)") fig.savefig("sfc_temp/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background sfc_temp/sfc_temp*.png -loop 0 sfc_temp/sfc_temp.gif") if cloud_switch == 1: for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "cldfrac_fhr"+str(itime).zfill(2)+".png" # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Add the states and coastlines ax.add_feature(states, linewidth=0.8, edgecolor='gray') ax.add_feature(COUNTIES, linewidth=0.4, facecolor='none', edgecolor='gray') ax.coastlines('50m', linewidth=0.8) # Compute and plot the total cloud fraction. plt.contourf(to_np(lons), to_np(lats), to_np(total_cloudfrac[itime,:,:]), transform=crs.PlateCarree(), cmap=get_cmap("Greys"), levels=cldfrac_levels, extend='both') # Add a color bar plt.colorbar(ax=ax, shrink=.62) # Add location of Boulder to plot. plt.scatter(blon,blat,c='r',marker='+',transform=crs.PlateCarree()) # Set the map limits. ax.set_xlim(cartopy_xlim(cloudfrac)) ax.set_ylim(cartopy_ylim(cloudfrac)) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": Total cloud fraction (fill)") fig.savefig("cldfrac/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background cldfrac/cldfrac*.png -loop 0 cldfrac/cldfrac.gif") for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "low_cldfrac_fhr"+str(itime).zfill(2)+".png" # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Add the states and coastlines ax.add_feature(states, linewidth=0.8, edgecolor='gray') ax.add_feature(COUNTIES, linewidth=0.4, facecolor='none', edgecolor='gray') ax.coastlines('50m', linewidth=0.8) # Compute and plot the cloud fraction. plt.contourf(to_np(lons), to_np(lats), to_np(low_cloudfrac[itime,:,:]), transform=crs.PlateCarree(), cmap=get_cmap("Greys"), levels=cldfrac_levels, extend='both') # Add a color bar plt.colorbar(ax=ax, shrink=.62) # Add location of Boulder to plot. plt.scatter(blon,blat,c='r',marker='+',transform=crs.PlateCarree()) # Set the map limits. ax.set_xlim(cartopy_xlim(cloudfrac)) ax.set_ylim(cartopy_ylim(cloudfrac)) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": Low cloud fraction (fill)") fig.savefig("low_cldfrac/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background low_cldfrac/low_cldfrac*.png -loop 0 low_cldfrac/low_cldfrac.gif") for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "mid_cldfrac_fhr"+str(itime).zfill(2)+".png" # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Add the states and coastlines ax.add_feature(states, linewidth=0.8, edgecolor='gray') ax.add_feature(COUNTIES, linewidth=0.4, facecolor='none', edgecolor='gray') ax.coastlines('50m', linewidth=0.8) # Compute and plot the cloud fraction. plt.contourf(to_np(lons), to_np(lats), to_np(mid_cloudfrac[itime,:,:]), transform=crs.PlateCarree(), cmap=get_cmap("Greys"), levels=cldfrac_levels, extend='both') # Add a color bar plt.colorbar(ax=ax, shrink=.62) # Add location of Boulder to plot. plt.scatter(blon,blat,c='r',marker='+',transform=crs.PlateCarree()) # Set the map limits. ax.set_xlim(cartopy_xlim(cloudfrac)) ax.set_ylim(cartopy_ylim(cloudfrac)) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": Mid cloud fraction (fill)") fig.savefig("mid_cldfrac/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background mid_cldfrac/mid_cldfrac*.png -loop 0 mid_cldfrac/mid_cldfrac.gif") for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "high_cldfrac_fhr"+str(itime).zfill(2)+".png" # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Add the states and coastlines ax.add_feature(states, linewidth=0.8, edgecolor='gray') ax.add_feature(COUNTIES, linewidth=0.4, facecolor='none', edgecolor='gray') ax.coastlines('50m', linewidth=0.8) # Compute and plot the cloud fraction. plt.contourf(to_np(lons), to_np(lats), to_np(high_cloudfrac[itime,:,:]), transform=crs.PlateCarree(), cmap=get_cmap("Greys"), levels=cldfrac_levels, extend='both') # Add a color bar plt.colorbar(ax=ax, shrink=.62) # Add location of Boulder to plot. plt.scatter(blon,blat,c='r',marker='+',transform=crs.PlateCarree()) # Set the map limits. ax.set_xlim(cartopy_xlim(cloudfrac)) ax.set_ylim(cartopy_ylim(cloudfrac)) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": High cloud fraction (fill)") fig.savefig("high_cldfrac/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background high_cldfrac/high_cldfrac*.png -loop 0 high_cldfrac/high_cldfrac.gif") if switch_500mb == 1: for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "500mb_fhr"+str(itime).zfill(2)+".png" # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Add the states and coastlines ax.add_feature(states, linewidth=0.8, edgecolor='gray') ax.add_feature(COUNTIES, linewidth=0.4, facecolor='none', edgecolor='gray') ax.coastlines('50m', linewidth=0.8) # wind color fill if np.max(wspeed_500[itime,:,:]) > np.min(wspeed_levels): plt.contourf(to_np(lons), to_np(lats), to_np(wspeed_500[itime,:,:]), transform=crs.PlateCarree(), cmap=get_cmap("rainbow"), levels=wspeed_levels) # Make the 500 mb height contours. c_z = plt.contour(to_np(lons), to_np(lats), to_np(z_500[itime,:,:]), transform=crs.PlateCarree(), colors="black", levels=z_levels) plt.clabel(c_z, inline=1, fontsize=10, fmt="%i") # Make the 500 mb temp contours. c_t = plt.contour(to_np(lons), to_np(lats), to_np(tc_500[itime,:,:]), transform=crs.PlateCarree(), colors="red", levels=tc_levels) plt.clabel(c_t, inline=1, fontsize=10, fontcolor="red", fmt="%i") # Add a color bar # plt.colorbar(ax=ax, shrink=.62) # Add location of Boulder to plot. plt.scatter(blon,blat,c='r',marker='+',transform=crs.PlateCarree()) # Add the 500mb wind barbs, only plotting every other data point. skip=3 plt.barbs(to_np(lons[::skip,::skip]), to_np(lats[::skip,::skip]), to_np(u_500[itime, ::skip, ::skip]), to_np(v_500[itime, ::skip, ::skip]), transform=crs.PlateCarree(), length=5.25, linewidth=0.5) # Set the map limits. ax.set_xlim(cartopy_xlim(z_500)) ax.set_ylim(cartopy_ylim(z_500)) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": 500-mb height (black, dm), temp (red, degC), and wind (fill/barbs, kt)") fig.savefig("500mb/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background 500mb/500mb*.png -loop 0 500mb/500mb.gif") if switch_700mb == 1: for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "700mb_fhr"+str(itime).zfill(2)+".png" # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Add the states and coastlines ax.add_feature(states, linewidth=0.8, edgecolor='gray') ax.add_feature(COUNTIES, linewidth=0.4, facecolor='none', edgecolor='gray') ax.coastlines('50m', linewidth=0.8) # rh color fill plt.contourf(to_np(lons), to_np(lats), to_np(rh_700[itime,:,:]), transform=crs.PlateCarree(), cmap=get_cmap("Greens"), levels=rh_levels, extend='both') # Add a color bar plt.colorbar(ax=ax, shrink=.62) # Make the 700 mb height contours. c_z = plt.contour(to_np(lons), to_np(lats), to_np(z_700[itime,:,:]), transform=crs.PlateCarree(), colors="black", levels=z_levels_700) plt.clabel(c_z, inline=1, fontsize=10, fmt="%i") # Make the 700 mb temp contours. c_t = plt.contour(to_np(lons), to_np(lats), to_np(tc_700[itime,:,:]), transform=crs.PlateCarree(), colors="red", levels=tc_levels) plt.clabel(c_t, inline=1, fontsize=10, fontcolor="red", fmt="%i") # Make the 700 mb VV contours. c_d = plt.contour(to_np(lons), to_np(lats), to_np(w_700[itime,:,:]), transform=crs.PlateCarree(), colors="magenta", levels=wup_levels, linewidths=0.9) plt.clabel(c_d, inline=1, fontsize=10, fontcolor="magenta", fmt="%i") c_c = plt.contour(to_np(lons), to_np(lats), to_np(w_700[itime,:,:]), transform=crs.PlateCarree(), colors="blue", levels=wdown_levels, linewidths=0.9) plt.clabel(c_c, inline=1, fontsize=10, fontcolor="blue", fmt="%i") # Add location of Boulder to plot. plt.scatter(blon,blat,c='r',marker='+',transform=crs.PlateCarree()) # Add the 700mb wind barbs, only plotting every other data point. skip=3 plt.barbs(to_np(lons[::skip,::skip]), to_np(lats[::skip,::skip]), to_np(u_700[itime, ::skip, ::skip]), to_np(v_700[itime, ::skip, ::skip]), transform=crs.PlateCarree(), length=5.25, linewidth=0.5) # Set the map limits. ax.set_xlim(cartopy_xlim(z_700)) ax.set_ylim(cartopy_ylim(z_700)) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": 700-mb hgt (black, dm), T (red, degC), wind (barbs, kt), VV (cm/s), rh (fill, %)") fig.savefig("700mb/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background 700mb/700mb*.png -loop 0 700mb/700mb.gif") if switch_300mb == 1: for itime in range(numTimes): # Create a figure fig = plt.figure(figsize=(12,9)) fileout = "300mb_fhr"+str(itime).zfill(2)+".png" # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Add the states and coastlines ax.add_feature(states, linewidth=0.8, edgecolor='gray') ax.add_feature(COUNTIES, linewidth=0.4, facecolor='none', edgecolor='gray') ax.coastlines('50m', linewidth=0.8) # 300 mb divergence plt.contourf(to_np(lons), to_np(lats), to_np(div_300[itime,:,:]), transform=crs.PlateCarree(), cmap=get_cmap("seismic"), levels=div_levels) # Add a color bar plt.colorbar(ax=ax, shrink=.62) # Make the 300 mb height contours. c_z = plt.contour(to_np(lons), to_np(lats), to_np(z_300[itime,:,:]), transform=crs.PlateCarree(), colors="black", levels=z_levels_300) plt.clabel(c_z, inline=1, fontsize=10, fmt="%i") # Make the 300 mb divergence contours. # c_d = plt.contour(to_np(lons), to_np(lats), to_np(div_300[itime,:,:]), transform=crs.PlateCarree(), # colors="red", levels=div_levels, linewidths=0.8) # plt.clabel(c_d, inline=1, fontsize=10, fontcolor="red", fmt="%i") # # c_c = plt.contour(to_np(lons), to_np(lats), to_np(div_300[itime,:,:]), transform=crs.PlateCarree(), # colors="blue", levels=conv_levels, linewidths=0.8) # plt.clabel(c_c, inline=1, fontsize=10, fontcolor="blue", fmt="%i") # Add location of Boulder to plot. plt.scatter(blon,blat,c='r',marker='+',transform=crs.PlateCarree()) # Add the 300mb wind barbs, only plotting every other data point. skip=3 plt.barbs(to_np(lons[::skip,::skip]), to_np(lats[::skip,::skip]), to_np(u_300[itime, ::skip, ::skip]), to_np(v_300[itime, ::skip, ::skip]), transform=crs.PlateCarree(), length=5.25, linewidth=0.5) # Set the map limits. ax.set_xlim(cartopy_xlim(z_300)) ax.set_ylim(cartopy_ylim(z_300)) plt_time=str(dtimes[itime]) plt_time=plt_time[0:13] plt.title(plt_time+"Z fhr "+str(itime).zfill(2)+": 300-mb height (black, dm), wind (barbs, kt), and divergence x 10^5 (red/blue, s^-1)") fig.savefig("300mb/"+fileout,bbox_inches='tight') plt.close(fig) os.system("convert -delay 90 -dispose background 300mb/300mb*.png -loop 0 300mb/300mb.gif")
import cartopy.crs as ccrs import cartopy.feature as cfeature import matplotlib.pyplot as plt # coordenadas estações meteorológicas do INMET estacoes_met = pd.read_json( "estationCities.json") # tabela com coordenada das estações # usando um arquivo da PCWRF para obter pontos de grade arq = nc.Dataset('../saidas/20200520_00/membro01/wrfout_d01_2020-05-20_00') # obtendo pontos de grade mais próximos das coordenadas LON,LAT fornecidas # estacoes_met_wrf[0,...] -> valores X (oeste-leste) # estacoes_met_wrf[1,...] -> valores Y (sul-norte) estacoes_met_wrf = wrf.ll_to_xy( arq, # coordenadas (X,Y) das estações INMET estacoes_met.iloc[:, 1].tolist(), estacoes_met.iloc[:, 2].tolist()) # obtendo LON,LAT dos pontos de grade obtidos acima # lat_lon_gridpoints[0,...] -> valores latitude # lat_lon_gridpoints[1,...] -> valores longitude lat_lon_gridpoints = wrf.xy_to_ll(arq, estacoes_met_wrf[0, :], estacoes_met_wrf[1, :]) # criando mapa com pontos de grade usados para extração e coordenadas das estações INMET projWRF = wrf.get_cartopy(wrfin=arq) estados = cfeature.NaturalEarthFeature(category='cultural', scale='50m', facecolor='none', name='admin_1_states_provinces_shp')
def make_result_file(opts): infilename = os.path.expanduser( os.path.join(opts.outdir, "ci_test_file.nc")) outfilename = os.path.expanduser( os.path.join(opts.outdir, "ci_result_file.nc")) with Dataset(infilename) as infile, Dataset(outfilename, "w") as outfile: for varname in WRF_DIAGS: var = getvar(infile, varname) add_to_ncfile(outfile, var, varname) for interptype in INTERP_METHS: if interptype == "interpline": hts = getvar(infile, "z") p = getvar(infile, "pressure") hts_850 = interplevel(hts, p, 850.) add_to_ncfile(outfile, hts_850, "interplevel") if interptype == "vertcross": hts = getvar(infile, "z") p = getvar(infile, "pressure") pivot_point = CoordPair(hts.shape[-1] // 2, hts.shape[-2] // 2) ht_cross = vertcross(hts, p, pivot_point=pivot_point, angle=90.) add_to_ncfile(outfile, ht_cross, "vertcross") if interptype == "interpline": t2 = getvar(infile, "T2") pivot_point = CoordPair(t2.shape[-1] // 2, t2.shape[-2] // 2) t2_line = interpline(t2, pivot_point=pivot_point, angle=90.0) add_to_ncfile(outfile, t2_line, "interpline") if interptype == "vinterp": tk = getvar(infile, "temp", units="k") interp_levels = [200, 300, 500, 1000] field = vinterp(infile, field=tk, vert_coord="theta", interp_levels=interp_levels, extrapolate=True, field_type="tk", log_p=True) add_to_ncfile(outfile, field, "vinterp") for latlonmeth in LATLON_METHS: if latlonmeth == "xy": # Hardcoded values from other unit tests lats = [22.0, 25.0, 27.0] lons = [-90.0, -87.5, -83.75] xy = ll_to_xy(infile, lats[0], lons[0]) add_to_ncfile(outfile, xy, "xy") else: # Hardcoded from other unit tests x_s = np.asarray([10, 50, 90], int) y_s = np.asarray([10, 50, 90], int) ll = xy_to_ll(infile, x_s[0], y_s[0]) add_to_ncfile(outfile, ll, "ll")
# .sel(TIME=period).sel(LAT=slice(lat_range[0],lat_range[1]), LON=slice(lon_range[0],lon_range[1])) * 3 # lat, lon = trmm.LAT, trmm.LON ### CMFD资料 file_path = '/home/zzhzhao/code/python/wrf-test-10/data/prec_CMFD_201706.nc' cmfd = xr.open_dataset(file_path)['prec'].sel(lat=slice(lat_range[0],lat_range[1]), lon=slice(lon_range[0],lon_range[1])) * 3 lat, lon =cmfd.lat, cmfd.lon ### 站点观测 df = pd.read_excel('data/纳木错站2017-2018.xlsx', index_col=0) obs_NamCo = df.loc[pd.date_range('2017-06-01','2017-06-30')]['降水量'] #%% # NamCo station NamCo_latlon = (30.75, 90.9) NamCo_position = w.ll_to_xy(wrflist, NamCo_latlon[0], NamCo_latlon[1]) prec1_NamCo = prec1.sel(south_north=NamCo_position[0], west_east=NamCo_position[1]).resample(Time='1D').sum() prec2_NamCo = prec2.sel(south_north=NamCo_position[0], west_east=NamCo_position[1]).resample(Time='1D').sum() # trmm_NamCo = trmm.sel(LAT=NamCo_latlon[0], LON=NamCo_latlon[1], method='ffill').resample(TIME='1D').sum() cmfd_NamCo = cmfd.sel(lat=NamCo_latlon[0], lon=NamCo_latlon[1], method='ffill').resample(time='1D').sum() #%% fig, ax = plt.subplots(figsize=(9,4)) ax.plot(obs_NamCo.index, obs_NamCo, lw=1.4, c='k', marker='o', mfc=None, markersize=3.5, label='OBS') ax.plot(prec1_NamCo.Time, prec1_NamCo, lw=1.4, c='r', marker='o', mfc=None, markersize=3.5, label='Ctrl') ax.plot(prec2_NamCo.Time, prec2_NamCo, lw=1.4, c='g', marker='o', mfc=None, markersize=3.5, label='nolake') # ax.plot(trmm_NamCo.TIME, trmm_NamCo, lw=1.4, c='b', marker='o', mfc=None, markersize=3.5, label='TRMM') ax.plot(cmfd_NamCo.time, cmfd_NamCo, lw=1.4, c='b', marker='o', mfc=None, markersize=3.5, label='CMFD') ax.set_title('NamCo Station', loc='left', y=0.9, x=0.02, fontsize=14, weight='bold') ax.set_ylabel('Precipitation $\mathrm{mmd^{-1}}$', fontsize=14) ax.legend(fontsize=13, loc='upper right', ncol=2, frameon=False)
dewpoint = getvar(ncfile, 'td') wspd = getvar(ncfile, 'wspd_wdir')[0, :] wdir = getvar(ncfile, 'wspd_wdir')[1, :] # Add computed variables to dataset ds = xr.open_dataset(filename) ds['pressure'] = (['bottom_top', 'south_north', 'west_east'], pressure) ds['height'] = (['bottom_top', 'south_north', 'west_east'], height) ds['temperature'] = (['bottom_top', 'south_north', 'west_east'], temperature) ds['dewpoint'] = (['bottom_top', 'south_north', 'west_east'], dewpoint) ds['wspd'] = (['bottom_top', 'south_north', 'west_east'], wspd) ds['wdir'] = (['bottom_top', 'south_north', 'west_east'], wdir) # Select location of sounding x_y = ll_to_xy(ncfile, lat, lon) ds_point = ds.sel(west_east=x_y[0], south_north=x_y[1]) # Get variables for location p = ds_point['pressure'].values * units.hPa T = ds_point['temperature'].values * units.degC Td = ds_point['dewpoint'].values * units.degC wind_speed = ds_point['wspd'].values * units.knots wind_dir = ds_point['wdir'].values * units.degrees # Limit pressure level for wind barbs p_200 = ds_point['pressure'] p_200 = p_200.where(p_200 > 200) p_200 = p_200.values * units.hPa
def obtain_background_data(nc_f, left_bottom, right_top, fields): background_data = {} nc_fid = Dataset(nc_f, 'r') lats_2d = nc_fid.variables['XLAT'][0, :, :] lons_2d = nc_fid.variables['XLONG'][0, :, :] left_bottom_xy = wrf.ll_to_xy(nc_fid, left_bottom[0], left_bottom[1]) right_top_xy = wrf.ll_to_xy(nc_fid, right_top[0], right_top[1]) if left_bottom_xy[1].values == right_top_xy[1].values: lat_start = left_bottom_xy[1].values lat_end = right_top_xy[1].values + 1 else: lat_start = left_bottom_xy[1].values lat_end = right_top_xy[1].values if left_bottom_xy[0].values == right_top_xy[0].values: lon_start = int(left_bottom_xy[0].values) lon_end = int(right_top_xy[0].values + 1) else: lon_start = int(left_bottom_xy[0].values) lon_end = int(right_top_xy[0].values) background_data['lat'] = lats_2d[ lat_start:lat_end, lon_start:lon_end] background_data['lon'] = lons_2d[ lat_start:lat_end, lon_start:lon_end] for field in fields: if not field in ['dbz', 'T', 'U', 'V']: raise Exception('{} is not supported'.format(field)) if field == 'dbz': pressure = wrf.g_pressure.get_pressure(nc_fid).values temperature = wrf.tk(pressure, wrf.g_temp.get_theta(nc_fid)) water_vapor_mixing_ratio = nc_fid.variables['QVAPOR'][0, :, :, :] rain_mixig_ratio = nc_fid.variables['QRAIN'][0, :, :, :] snow_mixig_ratio = nc_fid.variables['QSNOW'][0, :, :, :] graupel_mixing_ratio = nc_fid.variables['QGRAUP'][0, :, :, :] cur_background_data = wrf.dbz(pressure, temperature, water_vapor_mixing_ratio, rain_mixig_ratio, snow_mixig_ratio, graupel_mixing_ratio, use_varint=True, meta=False)[0, lat_start:lat_end, lon_start:lon_end] else: if field == 'T': field_in = 'T2' elif field == 'U' or field == 'V': field_in = field + '10' else: field_in = field cur_background_data = nc_fid.variables[field_in][ 0, lat_start:lat_end, lon_start:lon_end] background_data[field] = cur_background_data return background_data
qvap = qvap_1[tim_idx, :, :, :] qcld = qcld_1[tim_idx, :, :, :] thet = thet_1[tim_idx, :, :, :] hgt = hgt_1[tim_idx, :, :, :] terhgt = terhgt_1[0, :, :] ws = u_1[0, tim_idx, :, :, :] wd = u_1[1, tim_idx, :, :, :] dt = time.strftime("%Y%m%d%H", time.gmtime(p.datetime.data.astype(int) / 1000000000)) f_date = np.vstack(np.tile(dt, noloc * 44)) tloc = np.vstack(np.repeat(locs, 44)) tid = np.vstack(np.repeat(lst_f[:, 0], 44)) pre_mat = np.concatenate([tid, tloc, f_date], axis=1) x_y = wrf.ll_to_xy(wrf_list, points[:, 0], points[:, 1], as_int=True) pres = np.array([p[:, i, k] for i, k in x_y.data.T]).T temp = np.array([tmp[:, i, k] for i, k in x_y.data.T]).T rhum = np.array([rh[:, i, k] for i, k in x_y.data.T]).T dtemp = np.array([td[:, i, k] for i, k in x_y.data.T]).T mrio = np.array([qvap[:, i, k] for i, k in x_y.data.T]).T theta = np.array([thet[:, i, k] for i, k in x_y.data.T]).T qcloud = np.array([qcld[:, i, k] for i, k in x_y.data.T]).T qrain = np.array([qran[:, i, k] for i, k in x_y.data.T]).T wspd = np.array([ws[:, i, k] for i, k in x_y.data.T]).T wdir = np.array([wd[:, i, k] for i, k in x_y.data.T]).T thgt = np.array([terhgt[i, k] for i, k in x_y.data.T]).T mhgt = np.array([hgt[:, i, k] for i, k in x_y.data.T]).T pres = np.vstack(pres.flatten('F'))
# Make the contour outlines and filled contours for the smoothed sea level # pressure. # plt.contour(to_np(lons), to_np(lats), to_np(smooth_slp), 10, colors="blue", # transform=crs.PlateCarree()) # plt.contourf(to_np(lons), to_np(lats), to_np(smooth_slp), 10, # transform=crs.PlateCarree(), # cmap=get_cmap("Blues")) # Add a color bar # plt.colorbar(ax=ax, shrink=.98) # plot markers for San Francisco, Santa Cruz dummy = np.zeros(slp.shape) for here in [SanFrancisco, SantaCruz]: xu, yu = to_np(ll_to_xy(ncfile, *here, stagger='U')) xv, yv = to_np(ll_to_xy(ncfile, *here, stagger='V')) x, y = to_np(ll_to_xy(ncfile, *here, stagger=None)) print((xu, yu, xv, yv, x, y)) dummy[yv, xv] = 500 # dummy = ma.masked_less(dummy, 500) mylons = (lons[:, :-1] - (np.diff(lons, axis=1) / 2))[:-1, :] mylats = (lats[:-1, :] - (np.diff(lats, axis=0) / 2))[:, :-1] fig, ax = prepare_figure(smooth_slp) ax.imshow(dummy, alpha=0.5, extent=(*cartopy_xlim(slp), *cartopy_ylim(slp)), transform=get_cartopy(slp), origin='lower')
archivos = ls(Direccion + '*wrfout_d0'+Dominio+'_'+Fecha+'*') # Open the NetCDF file index = archivos[0].find("wrfout_d0") filename = Direccion+archivos[0][index:] # el programa debe estar en la misma carpeta de las extensiones .nc print(filename) ncfile = netCDF4.Dataset(filename) altura = ncfile.variables['HGT'][:] print(altura.shape) z = getvar(ncfile,'z',meta=False) wspd = getvar(ncfile, "uvmet_wspd_wdir",meta=False)[0,:] lats = getvar(ncfile, 'lat',meta=False) lons = getvar(ncfile, 'lon',meta=False) UU, VV = wrf.g_uvmet.get_uvmet(ncfile,meta= False) coor = wrf.ll_to_xy(ncfile, -17.6290737, -65.2842807, timeidx=0, meta=False, as_int=True) # Lat Lon cerca de Qollpana ncfile.close() print(lons[coor[1],coor[0]]) print(lats[coor[1],coor[0]]) # Extrayendo los datos con MFdataset Fecha = Anio+'-'+Mes archivos = ls(Direccion + 'wrfout_d0'+Dominio+'_'+Fecha+'*') # print(archivos) index = archivos[0].find("wrfout_d0") lista = archivos[:][index:] print(coor) start = time.time() # f = netCDF4.MFDataset("D:/WRF/WRF15-08-19/wrfout_d04*")
max_long = np1[1] minLat = np.asscalar(min_lat) maxLat = np.asscalar(max_lat) minLon = np.asscalar(min_long) maxLon = np.asscalar(max_long) print("minLat: " + str(minLat)) print("maxLat: " + str(maxLat)) print("minLon: " + str(minLon)) print("maxLon: " + str(maxLon)) minimo = ll_to_xy(ncfile, minLat, minLon, timeidx=0, squeeze=True, meta=True, stagger=None, as_int=True) massimo = ll_to_xy(ncfile, maxLat, maxLon, timeidx=0, squeeze=True, meta=True, stagger=None, as_int=True) # Interpolazione Per la visualizzazione in stile windy devi avere u10, v10, t2c, rh2, pslp .
# Open wrfouts wrfin = [Dataset(x) for x in wrf_filenames] # Define variables #vars = ("tc","td","ua","va","pressure") #for var in vars: # v = getvar(wrfin, var, timeidx=timex) tc = wrf.getvar(wrfin, "tc", timeidx=timex) td = wrf.getvar(wrfin, "td", timeidx=timex) ua = wrf.getvar(wrfin, "ua", timeidx=timex) va = wrf.getvar(wrfin, "va", timeidx=timex) pressure = wrf.getvar(wrfin, "pressure", timeidx=timex) # Find coordinate location on domain sonde_loc = wrf.ll_to_xy(wrfin, lat, lon, timeidx=timex, squeeze=True, meta=True, stagger=None, as_int=True) jj = sonde_loc[0]-1 ii = sonde_loc[1]-1 # Plot the data using normal plotting functions, in this case using # log scaling in Y, as dictated by the typical meteorological plot skew.plot(p[:], T[:], 'black',label='Observation') skew.plot(p[:], Td[:], 'black',linestyle='--',label='') skew.plot_barbs(p[::5], u[::5], v[::5], y_clip_radius=0.03) # plot WRF on Skew-T diagram skew.plot(pressure[::3,ii,jj], td[::3,ii,jj], 'r',linestyle='--',label='') skew.plot(pressure[::3,ii,jj], tc[::3,ii,jj], 'r',label='WRF') skew.plot_barbs(to_np(pressure[::5,ii,jj]),to_np(ms_to_kt(ua[::5,ii,jj])),to_np(ms_to_kt(va[::5,ii,jj])),y_clip_radius=0.03,color='r')
def get_indexes(self, lat, lon, height): i_lon, i_lat = ll_to_xy(self.input_file, lat, lon) i_h = np.searchsorted(self.heights, height) - 1 i_lat = i_lat - self.min_i_lat i_lon = i_lon - self.min_i_lon return i_lat, i_lon, i_h
def test(self): try: from netCDF4 import Dataset as NetCDF except: pass try: import Nio except: pass timeidx = 0 if not multi else None pat = os.path.join(dir, pattern) wrf_files = glob.glob(pat) wrf_files.sort() refnc = NetCDF(referent) try: refnc.set_always_mask(False) except: pass wrfin = [] for fname in wrf_files: if not pynio: f = NetCDF(fname) try: f.set_auto_mask(False) except: pass wrfin.append(f) else: if not fname.endswith(".nc"): _fname = fname + ".nc" else: _fname = fname f = Nio.open_file(_fname) wrfin.append(f) if testid == "xy": # Lats/Lons taken from NCL script, just hard-coding for now lats = [22.0, 25.0, 27.0] lons = [-90.0, -87.5, -83.75] # Just call with a single lat/lon if single: timeidx = 8 ref_vals = refnc.variables["xy2"][:] xy = ll_to_xy(wrfin, lats[0], lons[0], timeidx=timeidx, as_int=True) ref = ref_vals[:, 0] nt.assert_allclose(to_np(xy), ref) # Next make sure the 'proj' version works projparams = extract_proj_params(wrfin, timeidx=timeidx) xy_proj = ll_to_xy_proj(lats[0], lons[0], as_int=True, **projparams) nt.assert_allclose(to_np(xy_proj), to_np(xy)) else: ref_vals = refnc.variables["xy1"][:] xy = ll_to_xy(wrfin, lats, lons, timeidx=None, as_int=False) ref = ref_vals[:] nt.assert_allclose(to_np(xy), ref) if xy.ndim > 2: # Moving nest is_moving = True numtimes = xy.shape[-2] else: is_moving = False numtimes = 1 for tidx in range(9): # Next make sure the 'proj' version works projparams = extract_proj_params(wrfin, timeidx=tidx) xy_proj = ll_to_xy_proj(lats, lons, as_int=False, **projparams) if is_moving: idxs = (slice(None), tidx, slice(None)) else: idxs = (slice(None), ) nt.assert_allclose(to_np(xy_proj), to_np(xy[idxs])) else: # i_s, j_s taken from NCL script, just hard-coding for now # NCL uses 1-based indexing for this, so need to subtract 1 x_s = np.asarray([10, 50, 90], int) y_s = np.asarray([10, 50, 90], int) if single: timeidx = 8 ref_vals = refnc.variables["ll2"][:] ll = xy_to_ll(wrfin, x_s[0], y_s[0], timeidx=timeidx) ref = ref_vals[::-1, 0] nt.assert_allclose(to_np(ll), ref) # Next make sure the 'proj' version works projparams = extract_proj_params(wrfin, timeidx=8) ll_proj = xy_to_ll_proj(x_s[0], y_s[0], **projparams) nt.assert_allclose(to_np(ll_proj), to_np(ll)) else: ref_vals = refnc.variables["ll1"][:] ll = xy_to_ll(wrfin, x_s, y_s, timeidx=None) ref = ref_vals[::-1, :] nt.assert_allclose(to_np(ll), ref) if ll.ndim > 2: # Moving nest is_moving = True numtimes = ll.shape[-2] else: is_moving = False numtimes = 1 for tidx in range(numtimes): # Next make sure the 'proj' version works projparams = extract_proj_params(wrfin, timeidx=tidx) ll_proj = xy_to_ll_proj(x_s, y_s, **projparams) if is_moving: idxs = (slice(None), tidx, slice(None)) else: idxs = (slice(None), ) nt.assert_allclose(to_np(ll_proj), to_np(ll[idxs]))
def lagranto_plotting(traj_variable_name, start_time, end_time, trajs_bunch_level='all', subset=False, save=False): '''This function plots the chosen variables for the trajectories calculated with Lagranto. Supported variables for plotting procedure are water_vapor, updraft and height.''' ### Predefine some variables ### traj_data_dir = '/scratch3/thomasl/work/retrospective_part/lagranto/' 'traj_baden_10000_every1000_area_1200.ll' save_dir = '/scratch3/thomasl/work/retrospective_part' '/casestudy_baden/lagranto/' start_locations = 'area' # distinction between single and multiple # starting points of trajectories number_trajs_plot = 1 # Location of Initiation lat = 47.25 lon = 7.85 initiation = CoordPair(lat, lon) # Change extent of plot subset_extent = [7, 9, 47, 48] # Variables for getting PBL height of WRF model data date = '2018-05-30' time = '16:10' wrf_filename = '/scratch3/thomasl/work/data/casestudy_baden/' 'wrfout_d02_{}_{}:00'.format( date, time) # Variables: if traj_variable_name == 'water_vapor': traj_variable_name = 'QVAPOR' title_name = 'Trajectories of Water Vapor' colorbar_label_trajs = 'Water Vapor Mixing Ratio [$g$ $kg^{-1}$]' save_name = 'trajectory_water_vapor_{}_{}'.format(start_time, end_time) traj_variable_min = 0 traj_variable_max = 15 elif traj_variable_name == 'updraft': traj_variable_name = 'W_UP_MAX' title_name = 'Trajectories of Updraft' colorbar_label_trajs = 'Max Z-Wind Updraft [$m$ $s^-$$^1$]' save_name = 'trajectory_updraft_{}_{}'.format(start_time, end_time) traj_variable_min = 0 traj_variable_max = 10 elif traj_variable_name == 'height': traj_variable_name = 'z' title_name = 'Height of Trajectories' colorbar_label_trajs = 'Height of Trajectories [$m$]' save_name = 'trajectory_height_{}_{}'.format(start_time, end_time) traj_variable_min = 0 traj_variable_max = 10000 ### Plotting procedure ### trajs = Tra() trajs.load_ascii(traj_data_dir) # Get PBL out of WRF model data ncfile = Dataset(wrf_filename) wrf_file = xr.open_dataset(wrf_filename) data = wrf_file.PBLH location = ll_to_xy(ncfile, lat, lon) data_point = data.sel(west_east=location[0], south_north=location[1]) pbl = data_point.values # Separate trajectories in 3 vertical bunches # Trajectories of pbl (according to pbl height of WRF model data) trajspbl = [] for t in trajs: if (t['z'][0] <= pbl): trajspbl.append(t) # Trajectories between pbl and 5000 m trajs5 = [] for t in trajs: if (t['z'][0] > pbl and t['z'][0] < 5000): trajs5.append(t) # Trajectories between 5000 m and 10000 m trajs10 = [] for t in trajs: if (t['z'][0] > 5000 and t['z'][0] <= 10000): trajs10.append(t) if trajs_bunch_level == 'pbl': trajs_bunch = trajspbl elif trajs_bunch_level == '5': trajs_bunch = trajs5 elif trajs_bunch_level == '10': trajs_bunch = trajs10 elif trajs_bunch_level == 'all': trajs_bunch = trajs # Get terrain height terrain_height = getvar(ncfile, 'HGT') / 1000 # change to km # Define cart projection lats, lons = latlon_coords(terrain_height) cart_proj = ccrs.LambertConformal(central_longitude=8.722206, central_latitude=46.73585) # Create figure fig = plt.figure(figsize=(15, 10)) ax = plt.axes(projection=cart_proj) ### Set map extent ### domain_extent = [3.701088, 13.814863, 43.85472, 49.49499] if subset == True: ax.set_extent([ subset_extent[0], subset_extent[1], subset_extent[2], subset_extent[3] ], ccrs.PlateCarree()) else: ax.set_extent([ domain_extent[0] + 0.7, domain_extent[1] - 0.7, domain_extent[2] + 0.1, domain_extent[3] - 0.1 ], ccrs.PlateCarree()) # Plot trajectories levels_trajs = np.linspace(traj_variable_min, traj_variable_max, 11) rounded_levels_trajs = [round(elem, 1) for elem in levels_trajs] cmap = ListedColormap(sns.cubehelix_palette( 10, start=.5, rot=-.75, )) plt_trajs = plot_trajs(ax, trajs_bunch[0::number_trajs_plot], traj_variable_name, linewidth=2, levels=rounded_levels_trajs, cmap=cmap) # Plot the terrain height with colorbar levels = np.linspace(0, 4, 21) terrain = plt.contourf(to_np(lons), to_np(lats), to_np(terrain_height), levels=levels, transform=ccrs.PlateCarree(), cmap=get_cmap('Greys'), alpha=0.75) cbar = mpu.colorbar(terrain, ax, orientation='horizontal', aspect=40, shrink=.05, pad=0.075) cbar.set_label('Terrain Height [$km$]', fontsize=15) cbar.set_ticks(levels) # Make only every second color bar tick label visible for label in cbar.ax.xaxis.get_ticklabels()[1::2]: label.set_visible(False) # Add color bar for trajectory variable if traj_variable_name == 'QVAPOR': extend = 'both' else: extend = 'max' cbar_trajs = mpu.colorbar(plt_trajs, ax, orientation='vertical', aspect=40, shrink=.05, pad=0.05, extend=extend) cbar_trajs.set_label(colorbar_label_trajs, fontsize=15) cbar_trajs.set_ticks(rounded_levels_trajs) # Add borders and coastlines ax.add_feature(cfeature.BORDERS.with_scale('10m'), linewidth=0.8) ax.add_feature(cfeature.COASTLINE.with_scale('10m'), linewidth=0.8) # Add cross for initiation location for t in trajs: ax.plot(t['lon'][0], t['lat'][0], 'kx', transform=ccrs.PlateCarree()) # Add gridlines lon = np.arange(0, 20, 1) lat = np.arange(40, 60, 1) gl = ax.gridlines(xlocs=lon, ylocs=lat, zorder=3) # Add tick labels mpu.yticklabels(lat, ax=ax, fontsize=12.5) mpu.xticklabels(lon, ax=ax, fontsize=12.5) # Set title ax.set_title(title_name, loc='left', fontsize=20) ax.set_title('Time Range: {} - {} UTC'.format(start_time, end_time), loc='right', fontsize=15) plt.show() ### Save figure ### if save == True: if subset == True: if trajs_bunch_level == 'all': fig.savefig('{}{}_subset_{}.png'.format( save_dir, save_name, start_locations), bbox_inches='tight', dpi=300) else: fig.savefig('{}{}_subset_{}_{}.png'.format( save_dir, save_name, trajs_bunch_level, start_locations), bbox_inches='tight', dpi=300) else: if trajs_bunch_level == 'all': fig.savefig('{}{}_{}.png'.format(save_dir, save_name, start_locations), bbox_inches='tight', dpi=300) else: fig.savefig('{}{}_{}_{}.png'.format(save_dir, save_name, trajs_bunch_level, start_locations), bbox_inches='tight', dpi=300)
g, maps = salem.geogrid_simulator(fpath) maps[0].set_rgb(natural_earth='hr') maps[0].visualize(ax=ax_map, title='Domains') # export the figure fig_map.set_size_inches(6, 6) fig_map.savefig('fig/map.png') # load WRF results fl_WRF = sorted(glob('wrfout*')) ds = salem.open_mf_wrf_dataset(fl_WRF) dswrf = nc.Dataset(fl_WRF[0]) x_pos, y_pos = wrf.ll_to_xy(dswrf, latitude=[51.], longitude=[-0.1]) # ds.HFX[:, y_pos, x_pos].time # ds.HFX[:, y_pos, x_pos].plot.line(add_legend=True) ds_sel = ds[['HFX', 'LH', 'GRDFLX', 'SWDOWN', 'GLW']].resample( time='1h', label='left').mean() # Facet plotting ds_grp_clm = ds_sel.HFX.load().groupby('time.hour').median(axis=0) fig_spatial_clm = ds_grp_clm.plot( x='west_east', y='south_north', col='hour', col_wrap=4, robust=True).fig fig_spatial_clm.savefig('figures/QH_map.pdf') # print ds_sel.resample.__doc__
def temporal_evolution_trajectories(variable_name, trajs_bunch_level='all', save=False): '''This function plots the temporal evolution of trajectories from the chosen variables. Trajectories can be divided in bunches corresponding to different height levels (pbl, 5, 10). Supported variables are water_vapor, height and updraft.''' ### Predefine some variables ### number_trajs_plot = 1 dt = 5 # delta time between data files traj_data_dir = '/scratch3/thomasl/work/retrospective_part/lagranto/' 'traj_baden_10000_1200.ll' save_dir = '/scratch3/thomasl/work/retrospective_part' '/casestudy_baden/lagranto_evo/' # Variables for getting PBL height of WRF model data lat = 47.25 lon = 7.85 date = '2018-05-30' time = '16:20' filename = '/scratch3/thomasl/work/data/casestudy_baden/' 'wrfout_d02_{}_{}:00'.format( date, time) # Define plotting variables if variable_name == 'water_vapor': variable = 'QVAPOR' title_name = 'Water Vapor' y_label = 'Water Vapor Mixing Ratio [$g$ $kg^{-1}$]' elif variable_name == 'height': variable = 'z' title_name = 'Height' y_label = 'Height of Trajectories [$m$]' elif variable_name == 'updraft': variable = 'W_UP_MAX' title_name = 'Updraft' y_label = 'Max Z-Wind Updraft [$m$ $s^-$$^1$]' ### Plotting procedure ### trajs = Tra() trajs.load_ascii(traj_data_dir) # Get PBL out of WRF model data ncfile = Dataset(filename) wrf_file = xr.open_dataset(filename) data = wrf_file.PBLH location = ll_to_xy(ncfile, lat, lon) data_point = data.sel(west_east=location[0], south_north=location[1]) pbl = data_point.values # Separate trajectories in 3 vertical bunches # Trajectories of pbl (according to pbl height of WRF model data) trajspbl = [] for t in trajs: if (t['z'][0] <= pbl): trajspbl.append(t) # Trajectories between pbl and 5000 m trajs5 = [] for t in trajs: if (t['z'][0] > pbl and t['z'][0] < 5000): trajs5.append(t) # Trajectories between 5000 m and 10000 m trajs10 = [] for t in trajs: if (t['z'][0] > 5000 and t['z'][0] <= 10000): trajs10.append(t) trajs = np.array(trajspbl) # Get time delta xtime = np.arange(-len(trajs['time'][0]) * dt, 0, dt) + dt # Make figure fig = plt.figure(figsize=(15, 10)) ax = plt.axes() # Plot (bunch of) trajectories if trajs_bunch_level == 'pbl': for t in trajs[::number_trajs_plot]: ax.plot(xtime, np.flipud(t[variable][:]), '-', color='grey', lw=0.5) ax.plot(xtime, np.flipud(np.percentile(trajs[:][variable][:], 90, axis=0)), '--', color='blue', lw=2) ax.plot(xtime, np.flipud((np.percentile(trajs[:][variable][:], 10, axis=0))), '--', color='blue', lw=2) ax.plot(xtime, np.flipud(np.mean(trajs[:][variable][:], 0)), '-', color='blue', lw=2) elif trajs_bunch_level == '5': trajs = np.array(trajs5) for t in trajs[::number_trajs_plot]: ax.plot(xtime, np.flipud(t[variable][:]), '-', color='grey', lw=0.5) ax.plot(xtime, np.flipud(np.percentile(trajs[:][variable][:], 90, axis=0)), '--', color='orange', lw=2) ax.plot(xtime, np.flipud((np.percentile(trajs[:][variable][:], 10, axis=0))), '--', color='orange', lw=2) ax.plot(xtime, np.flipud(np.mean(trajs[:][variable][:], 0)), '-', color='orange', lw=2) elif trajs_bunch_level == '10': trajs = np.array(trajs10) for t in trajs[::number_trajs_plot]: ax.plot(xtime, np.flipud(t[variable][:]), '-', color='grey', lw=0.5) ax.plot(xtime, np.flipud(np.percentile(trajs[:][variable][:], 90, axis=0)), '--', color='red', lw=2) ax.plot(xtime, np.flipud((np.percentile(trajs[:][variable][:], 10, axis=0))), '--', color='red', lw=2) ax.plot(xtime, np.flipud(np.mean(trajs[:][variable][:], 0)), '-', color='red', lw=2) elif trajs_bunch_level == 'all': for t in trajs[::number_trajs_plot]: ax.plot(xtime, np.flipud(t[variable][:]), '-', color='grey', lw=0.5) ax.plot(xtime, np.flipud(np.percentile(trajs[:][variable][:], 90, axis=0)), '--', color='blue', lw=2) ax.plot(xtime, np.flipud((np.percentile(trajs[:][variable][:], 10, axis=0))), '--', color='blue', lw=2) ax.plot(xtime, np.flipud(np.mean(trajs[:][variable][:], 0)), '-', color='blue', lw=2) trajs = np.array(trajs5) for t in trajs[::number_trajs_plot]: ax.plot(xtime, np.flipud(t[variable][:]), '-', color='grey', lw=0.5) ax.plot(xtime, np.flipud(np.percentile(trajs[:][variable][:], 90, axis=0)), '--', color='orange', lw=2) ax.plot(xtime, np.flipud((np.percentile(trajs[:][variable][:], 10, axis=0))), '--', color='orange', lw=2) ax.plot(xtime, np.flipud(np.mean(trajs[:][variable][:], 0)), '-', color='orange', lw=2) trajs = np.array(trajs10) for t in trajs[::number_trajs_plot]: ax.plot(xtime, np.flipud(t[variable][:]), '-', color='grey', lw=0.5) ax.plot(xtime, np.flipud(np.percentile(trajs[:][variable][:], 90, axis=0)), '--', color='red', lw=2) ax.plot(xtime, np.flipud((np.percentile(trajs[:][variable][:], 10, axis=0))), '--', color='red', lw=2) ax.plot(xtime, np.flipud(np.mean(trajs[:][variable][:], 0)), '-', color='red', lw=2) # Add y- and x-axis label ax.set_ylabel(y_label, fontsize=12.5) ax.set_ylim(0, trajs[variable].max()) ax.set_xlabel('Time [$min$]', fontsize=12.5) ax.set_xlim(xtime[0], 0) # Add horizontal gridlines according to height levels plt.grid(axis='y', linestyle='--', color='grey') # Plot legend if trajs_bunch_level == 'pbl': line_mean = mlines.Line2D([], [], color='k', linestyle='-', linewidth=2, label='Mean') line_percentiles = mlines.Line2D([], [], color='k', linestyle='--', linewidth=2, label='10th and 90th Percentile') line_mean_col_pbl = mlines.Line2D([], [], color='b', linestyle='-', linewidth=2, label='Planetary Boundary Layer') ax.legend(handles=[line_mean, line_percentiles, line_mean_col_pbl], loc='upper left', fontsize=10) elif trajs_bunch_level == '5': line_mean = mlines.Line2D([], [], color='k', linestyle='-', linewidth=2, label='Mean') line_percentiles = mlines.Line2D([], [], color='k', linestyle='--', linewidth=2, label='10th and 90th Percentile') line_mean_col_5 = mlines.Line2D([], [], color='orange', linestyle='-', linewidth=2, label='PBL until 5 km') ax.legend(handles=[line_mean, line_percentiles, line_mean_col_5], loc='upper left', fontsize=10) elif trajs_bunch_level == '10': line_mean = mlines.Line2D([], [], color='k', linestyle='-', linewidth=2, label='Mean') line_percentiles = mlines.Line2D([], [], color='k', linestyle='--', linewidth=2, label='10th and 90th Percentile') line_mean_col_10 = mlines.Line2D([], [], color='r', linestyle='-', linewidth=2, label='5 km until 10 km') ax.legend(handles=[line_mean, line_percentiles, line_mean_col_10], loc='upper left', fontsize=10) else: line_mean = mlines.Line2D([], [], color='k', linestyle='-', linewidth=2, label='Mean') line_percentiles = mlines.Line2D([], [], color='k', linestyle='--', linewidth=2, label='10th and 90th Percentile') line_mean_col_pbl = mlines.Line2D([], [], color='b', linestyle='-', linewidth=2, label='Planetary Boundary Layer') line_mean_col_5 = mlines.Line2D([], [], color='orange', linestyle='-', linewidth=2, label='PBL until 5 km') line_mean_col_10 = mlines.Line2D([], [], color='r', linestyle='-', linewidth=2, label='5 km until 10 km') ax.legend(handles=[ line_mean, line_percentiles, line_mean_col_pbl, line_mean_col_5, line_mean_col_10 ], loc='upper left', fontsize=10) # Add title ax.set_title('Temporal Evolution of {} along Trajectories\n' '@ Location of Thunderstorm Initiation ({}, {})'.format( title_name, lat, lon), fontsize=15) plt.show() ### Save figure ### if save == True: fig.savefig('{}lagranto_evo_{}_{}_{}_{}.png'.format( save_dir, variable_name, trajs_bunch_level, lat, lon), bbox_inches='tight', dpi=300)
t_diff_list = dict() tsk_list = dict() t2_list = dict() lat = 30.75 lon = 90.75 for testname in testname_list: data_path = os.path.join(data_dir, testname) domain = 1 tsk, lats, lons, time, wrflist = load_wrfdata1(data_path, domain) t2, lats, lons, time = load_wrfdata2(data_path, domain) tsk = xr.where(tsk > 0, tsk, np.nan) t2 = xr.where(t2 > 0, t2, np.nan) x, y = w.ll_to_xy(wrflist, lat, lon) t2_list[testname] = t2.sel(west_east=x, south_north=y) tsk_list[testname] = tsk.sel(west_east=x, south_north=y) #%% labels = [ 'CTL_285K', 'CTL', # 'WY', # 'WY2', # 'WY3', 'WY4', 'CTL3_285K', ]
from __future__ import print_function from netCDF4 import Dataset from wrf import getvar, interpline, CoordPair, xy_to_ll, ll_to_xy ncfile = Dataset("coa_I_t01.nc") lat_lon = xy_to_ll(ncfile, [400,105], [200,205]) print(lat_lon) x_y = ll_to_xy(ncfile, lat_lon[0,:], lat_lon[1,:]) print (x_y)
if i == inittime: rainc = nc_file.variables['RAINC'][i, :, :] rainnc = nc_file.variables['RAINNC'][i, :, :] rain = rainc + rainnc if i > inittime: rainc1 = nc_file.variables['RAINC'][i, :, :] rainnc1 = nc_file.variables['RAINNC'][i, :, :] rainc = nc_file.variables['RAINC'][i - 1, :, :] - rainc1 rainnc = nc_file.variables['RAINNC'][i - 1, :, :] - rainnc1 rain = rainc1 + rainnc1 # Calculate the XY location throught the specified latitude and longitude coordinates. latlon = ll_to_xy(nc_file, lat, lon, timeidx=i, squeeze=True, meta=False, as_int=True, stagger='m') # Store the data from the desired location. rh = rh[latlon[0], latlon[1]] uvmet = uvmet[0, latlon[0], latlon[1]] slp = slp[latlon[0], latlon[1]] tc = tc[latlon[0], latlon[1]] tc = tc - 273.15 rain = rain[latlon[0], latlon[1]] tc_list[i] = round(tc, 1) rh_list[i] = round(rh, 0) slp_list[i] = round(slp, 1) uvmet_list[i] = round(uvmet, 1)
def main(folder, append, extract_yr, extract_wrf, extract_met): #sourceIDlist = ["424242"] sourceIDlist = [ '424242', #Frankfurt airport '2925507', #Fränkisch-Crumbach '2926120', #Flörsheim '2925533', #Frankfurt am Main '2926300', #Fleisbach '7290400', #Airport Frankfurt Main '2926419', #Flacht '2925550', #Frankenthal '3220966', #Landkreis Darmstadt-Dieburg '2925665', #Frammersbach '7290401', #Niederrad 'SN18700', # OSLO - BLINDERN 'SN6700', # RV3 Svingen - Elverum 'SN71900', # Bessaker 'SN71990', # Buholmråsa fyr 'SN76914' ] # ITASMOBAWS1 - Rikshospitalet i Oslo for sourceID in sourceIDlist: ######################################################################## # Get coordinates for observation point (lon,lat) if sourceID[0:2] == 'SN': # Assume Norwegian station number format endpoint = 'https://frost.met.no/sources/v0.jsonld' parameters = { 'ids': sourceID, } data_source = getMetdata(endpoint, parameters, 'data') masl = data_source[0]['masl'] lon = data_source[0]['geometry']['coordinates'][0] lat = data_source[0]['geometry']['coordinates'][1] else: masl = np.NAN df = pd.read_json(home + '/kode/wrfStudies/city.list.json') lon = df[df.id == float(sourceID)].coord.item()['lon'] lat = df[df.id == float(sourceID)].coord.item()['lat'] ######################################################################## # Get data from met file if extract_met: print('Not implemented') ######################################################################## # Get data from WRF file if extract_wrf: print('Extracting wrf data') i_domain = 10 isOutside = True while isOutside: if i_domain < 0: print('The observation station ' + str(sourceID) + ' is not inside the solution domain') break i_domain -= 1 try: ncfile = Dataset('wrfout_d0' + str(i_domain) + '.nc') except: continue xy = wrf.ll_to_xy(ncfile, lat, lon, as_int=False) if ncfile.MAP_PROJ_CHAR == 'Cylindrical Equidistant' and i_domain == 1: xy[0] += 360 / 0.25 #HGT = getvar(ncfile, "HGT") #maslg = HGT.interp(west_east=xy[0], south_north=xy[1]) #lat_lon = wrf.xy_to_ll(ncfile,xy[0],xy[1]) df_wrf = pd.DataFrame( {'time': wrf.getvar(ncfile, 'Times', wrf.ALL_TIMES)}) df_wrf['air_temperature'] = wrf.to_np( wrf.getvar(ncfile, 'T2', wrf.ALL_TIMES).interp( west_east=xy[0], south_north=xy[1])) - 273.15 if df_wrf.isnull().values.any(): continue else: isOutside = False df_wrf['wind_speed'] = wrf.g_uvmet.get_uvmet10_wspd_wdir( ncfile, wrf.ALL_TIMES).interp(west_east=xy[0], south_north=xy[1])[0] df_wrf[ 'wind_from_direction'] = wrf.g_uvmet.get_uvmet10_wspd_wdir( ncfile, wrf.ALL_TIMES).interp(west_east=xy[0], south_north=xy[1])[1] df_wrf['time'] = pd.to_datetime(df_wrf['time']) df_wrf = df_wrf.reset_index() if path.exists(folder + 'df_wrf_' + sourceID + '.csv') and append: df_wrf_hist = pd.read_csv(folder + 'df_wrf_' + sourceID + '.csv') if datetime.strptime( df_wrf_hist['time'].iloc[-1], "%Y-%m-%d %H:%M:%S") < df_wrf['time'].iloc[-1]: df_wrf_hist = df_wrf_hist[ df_wrf_hist['time'] <= str(df_wrf['time'][0])] df_wrf_hist = df_wrf_hist.append(df_wrf) df_wrf_hist.to_csv(folder + 'df_wrf_' + sourceID + '.csv', index=False) else: df_wrf.to_csv(folder + 'df_wrf_' + sourceID + '.csv', index=False) print('Sucessfully extracted wrf data') ######################################################################## # Get YR forecast if extract_yr: endpoint = 'https://api.met.no/weatherapi/locationforecast/2.0/complete' endpoint = 'https://api.met.no/weatherapi/locationforecast/2.0/compact' parameters = { 'lon': str(lon), 'lat': str(lat), } if not np.isnan(masl): parameters['altitude'] = masl fields = [ 'time', 'air_temperature', 'wind_speed', 'wind_from_direction' ] data_YR = getYRdata(endpoint, parameters, 'properties') data_YR = data_YR['timeseries'] df = pd.DataFrame() for i in range(len(data_YR)): row = pd.DataFrame({'time': [data_YR[i]['time']]}) for j in range(1, len(fields)): row[fields[j]] = data_YR[i]['data']['instant']['details'][ fields[j]] df = df.append(row) df_YR = df[fields].copy() # Convert the time value to something Python understands df_YR['time'] = pd.to_datetime(df_YR['time']).dt.tz_convert(None) df_YR = df_YR.reset_index() if path.exists(folder + 'df_YR_' + sourceID + '.csv') and append: df_YR_hist = pd.read_csv(folder + 'df_YR_' + sourceID + '.csv') df_YR_hist = df_YR_hist[ df_YR_hist['time'] <= str(df_YR['time'][0])] df_YR_hist = df_YR_hist.append(df_YR) df_YR_hist.to_csv(folder + 'df_YR_' + sourceID + '.csv', index=False) else: df_YR.to_csv(folder + 'df_YR_' + sourceID + '.csv', index=False) print('Sucessfully extracted YR data')
def getXeY(wrf_file: str, lat: float, lon: float): """ Obtiene los x e y del lat long """ (x, y) = ll_to_xy(wrf_file, lat, lon) return int(x), int(y)
month = input('month (e.g., 09): ') year = input('year: ') scenario = input('scenario: ') wrfout = [Dataset(i) for i in sorted(glob.glob('../wrfout_diss/wrfout_d02_'+year+'-'+month+'-*'))] print("Extracting RAINC and RAINNC variables, named as rainc and rainnc") rainc = wrf.getvar(wrfout,'RAINC',timeidx=wrf.ALL_TIMES, method='cat') rainnc = wrf.getvar(wrfout,'RAINNC',timeidx=wrf.ALL_TIMES, method='cat') print("Reading file with station location points") cetesb_stations = pd.read_csv('./cetesb2017_latlon.dat') print(cetesb_stations) # Locating stations in west_east (x) and north_south (y) coordinates stations_xy = wrf.ll_to_xy(wrfout, latitude=cetesb_stations.lat, longitude=cetesb_stations.lon) cetesb_stations['x'] = stations_xy[0] cetesb_stations['y'] = stations_xy[1] # Filter stations inside WRF domain filter_dom = (cetesb_stations.x > 0) & (cetesb_stations.x < rainc.shape[2]) & (cetesb_stations.y > 0) & \ (cetesb_stations.y < rainc.shape[1]) cetesb_dom = cetesb_stations[filter_dom] # Function to retrieve variables from WRF-Chem def cetesb_from_wrf(i, to_local=True): wrf_est = pd.DataFrame({ 'date': rainc.Time.values, 'rainc': rainc.sel(south_north=cetesb_dom.y.values[i], west_east=cetesb_dom.x.values[i]).values,