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")
def _smooth_model_error_over_frequencies(lam_err, glb_err, total_model_levels, smooth_number=3): """smoothing error matrix over frequencies""" for lvl in range(0, total_model_levels): lam_err[lvl, :, :] = smooth2d(deepcopy(lam_err[lvl, :, :]), smooth_number) glb_err[lvl, :, :] = smooth2d(deepcopy(glb_err[lvl, :, :]), smooth_number) return lam_err, glb_err
def smooth_and_plot(var, passes, interp=False, height=False, doplot=True): X = getdata(var, interp=interp, height=height) yvals = getdata('lat') xvals = getdata('lon') print("Smoothing...") Xsmooth = wrf.smooth2d(X, passes) print("done") X = wrf.to_np(X) Xsmooth = wrf.to_np(Xsmooth) dX = X - Xsmooth yvals = wrf.to_np(yvals) xvals = wrf.to_np(xvals) nanwarning(X) nanwarning(Xsmooth) plottitle = str(passes) + "times smoothed " + var plotname = "Smooth" + str(passes) + "_" + var if not (interp == False): plottitle = plottitle + " at height " + str(height) + "km" plotname = plotname + "_height_" + str(height) if doplot: plotsmooth(X, Xsmooth, yvals, xvals, plottitle, plotname) return X, Xsmooth, dX, yvals, xvals
def readdiag(nvar): var = getvar(ncfile, nvar) smooth_var = smooth2d(var, 3) lats, lons = latlon_coords(smooth_var) lons = to_np(lons) lats = to_np(lats) cart_proj = get_cartopy(var) return lons,lats
def set_smoothness(self, passes, update=True): """ passes (int) :: number of times to apply smoothing to field. """ if passes == None: passes = 1000 filename = datapath + 'smooth_files_' + self.whichdata + '/' + self.str_id + "_" + str( passes) if self.derived: self.U.set_smoothness(passes, update=False) self.V.set_smoothness(passes, update=False) self.Xsmooth = switch[self.str_id](self.U.Xsmooth, self.V.Xsmooth) else: try: f = open(filename + '.npy') f.close() except: print("Smoothing " + self.str_id + " " + str(passes) + " times...") self.Xsmooth = wrf.smooth2d(self.X, passes) print("Done.") np.save(filename, self.Xsmooth) else: print("Reading data from " + filename) Xsmooth = np.load(filename + '.npy') self.Xsmooth = wrf.smooth2d(self.X, 1) self.Xsmooth[:, ] = Xsmooth self.passes = passes self.dXall = self.X - self.Xsmooth self.turb_ratio = self.dXall / self.Xsmooth if update: self.update(1) return
def compute_PSL(filename, inputinf=None): """ Function to calculate PSL using wrf-python diagnostics It also provides variable attribute CF-Standard Note: this function was also coded manually for in compute_vars.py """ ncfile = nc.Dataset(filename, 'r') # Get the sea level pressure using wrf-python psl = wrf.getvar(ncfile, "slp", wrf.ALL_TIMES) # Smooth the sea level pressure since it tends to be noisy near the mountains smooth_psl = wrf.smooth2d(psl, 3) atts = { "standard_name": "air_pressure_at_mean_sea_level", "long_name": "Sea Level Pressure", "units": "Pa", } ncfile.close() return smooth_psl, atts
def pmdbz(wrf_file,times,m,save_dir,drawclb): for time in range(times.shape[0]): mdbz = getvar(wrf_file, "mdbz",timeidx=time) lats, lons = latlon_coords(mdbz) x, y = m(to_np(lons), to_np(lats)) mdbz = to_np(mdbz) smooth_mdbz = smooth2d(mdbz, 3) smooth_mdbz = to_np(smooth_mdbz) mask = smooth_mdbz <= 0 smooth_mdbz[mask] = np.nan bounds = np.arange(0,80,5) colors = ['#00FFFF','#009DFF','#0000FF','#0982AF','#00FF00',\ '#08AF14','#FFD600','#FF9800','#FF0000','#DD001B','#BC0036',\ '#79006D','#7933A0','#C3A3D4','#FFFFFF'] im = m.contourf(x,y, smooth_mdbz,10,levels=bounds,colors=colors) if drawclb: cax = fig.add_axes([0.9, 0.1, 0.02, 0.78]) clb = fig.colorbar(im,shrink=0.75,ticks=bounds,pad=0.05,cax=cax) clb.ax.tick_params(labelsize=15) clb.solids.set_edgecolor("face") for l in clb.ax.yaxis.get_ticklabels(): l.set_family('Arial') clb.set_label('Reflectivity (dBZ)',fontsize=15) name = str(times[time])[:10] + '_' + str(times[time])[11:16] + 'UTC' plt.title(str(times[time])[11:13]+str(times[time])[14:16] + ' UTC WRF-Chem',{'size':28},x=0.02,y=0.91,loc='left',bbox=dict(facecolor=(1,1,1,0.5),edgecolor=(0,0,0,0))) plt.savefig(save_dir+name+'.png',bbox_inches = 'tight') # remove elements if times.shape[0] > 1 if drawclb: cax.remove() for im in im.collections: im.remove()
def modfields(passes): fnew = Dataset("wrfinput_d01_new.nc", 'r+') filenames = [datapath+f for f in os.listdir(datapath) \ if f.startswith('wrfout_xhka')] f0 = Dataset(filenames[0]) f2 = Dataset(filenames[-1]) scalingdict = { 'U': 0.75, 'V': 0.75, 'U10': 0.75, 'V10': 0.75, 'T': 0.5, 'TH2': 1.0, 'QVAPOR': 0.5, } for str_id in ['U', 'V', 'T', 'QVAPOR']: Xnew = fnew.variables[str_id][0] X0 = wrf.getvar(f0, str_id, meta=False) X2 = wrf.getvar(f2, str_id, meta=False) filename = "../data/" + str_id + "_final_time_" + str(passes) try: f = open(filename + '.npy') f.close() except: print("Smoothing " + str_id + " " + str(passes) + " times...") Xsmooth = wrf.smooth2d(X2, passes) print("Done.") np.save(filename, Xsmooth) else: print("Reading data from " + filename) Xsmooth = np.load(filename + '.npy') print('done') dX = X2 - Xsmooth mu = scalingdict[str_id] print('calculating new field...') turb = dX / np.max(np.abs(Xsmooth)) newfield = X0 * (1 + 2 * mu * turb) del turb Xnew[:, ] = 0 Xnew[:, ] = newfield[:, ] del newfield print('done') fnew.close() return
def postprocessing(filename, outputdir, utch): # postprocessing(filename,outputdir,utch) # Function compute and save in outputdir all the variables named in # RASPURI/postprocessing/file_index in form of matrix ready to plot. # ---INPUTS: # filename="wrfout_d02_2020-01-11_15_00_00"#filename to get the data # outputdir='data/' #output directory # utch string utc time for filename # ---OUTPUTS: # matrix data on output dir ######################################################################### ################## OPEN FILE ######################################################################### try: ncfile = Dataset(filename) #outputdir='aaaaa/' except Exception as e: print('****Error opening file postprocessing , functions.py****') print(e) ######################################################################### ################## GET VARS ######################################################################### try: slp = getvar(ncfile, "slp") # Sea Level Pressure z = getvar(ncfile, "z") # Geopotential Height p = getvar(ncfile, "pressure") # Pressure (hPa) t = getvar(ncfile, "tc") # temperature in Celsius ua = getvar(ncfile, "ua") # winds va = getvar(ncfile, "va") wa = getvar(ncfile, "wa") wspd_wdir = getvar(ncfile, "wspd_wdir") #uv10 = getvar(ncfile, "uvmet10") wspd_wdir10 = getvar(ncfile, "wspd_wdir10") cape_2d = getvar(ncfile, "cape_2d") cloudfrac = getvar(ncfile, "cloudfrac") # clouds ctt = getvar(ncfile, "ctt") # Cloud Top Temperature pw = getvar(ncfile, "pw") # Precipitable water bldepth = getvar(ncfile, "PBLH") #bl depth (metres) ter = getvar(ncfile, "HGT") #Terrain Height (metres) qcloud = getvar(ncfile, "QCLOUD") #"Cloud water mixing ratio" t2 = getvar(ncfile, "T2") # TEMP at 2 M uv = getvar(ncfile, "uvmet") # u,v NOT rotated to grid in m/s p = getvar(ncfile, "P") #"perturbation pressure" pb = getvar(ncfile, "PB") #"BASE STATE PRESSURE" hfx = getvar(ncfile, "HFX") #for sfc. sensible heat flux in w/m2 142 thetac = getvar( ncfile, "T") + 26.85 #"perturbation potential temperature theta-t0" qvapor = getvar(ncfile, "QVAPOR") #"Water vapor mixing ratio" vhf = getvar(ncfile, "LH") #"LATENT HEAT FLUX AT THE SURFACE" td = getvar(ncfile, "td") #dew point temperature (C) td2 = getvar(ncfile, "td2") #dew point temperature at 2 M (C) snow = getvar(ncfile, "SNOW") #"SNOW WATER EQUIVALENT" rainc = getvar(ncfile, "RAINC") #"ACCUMULATED TOTAL CUMULUS PRECIPITATION" rainnc = getvar( ncfile, "RAINNC") #"ACCUMULATED TOTAL GRID SCALE PRECIPITATION" snowh = getvar(ncfile, "SNOWH") #"PHYSICAL SNOW DEPTH" pblh = bldepth #lats, lons = latlon_coords(slp) lats = getvar(ncfile, "XLAT") lons = getvar(ncfile, "XLONG") dx = slp.projection.dx dy = slp.projection.dy except Exception as e: print('****Error reading vars postprocessing , functions.py****') print(e) ######################################################################### ################## VARS TRANSFORMATIONS ######################################################################### try: ### wspd_all = wspd_wdir[0, :] wdir_all = wspd_wdir[1, :] # Interpolate geopotential height, u, and v winds to 500 hPa ->5000m ht_500 = interplevel(z, p, 500.) wdir_500 = interplevel(wdir_all, p, 500) wspd_500 = interplevel(wspd_all, p, 500) t_500 = interplevel(t, p, 500) # Interpolate geopotential height, u, and v winds to 700 hPa ->3000m ht_700 = interplevel(z, p, 700.) wdir_700 = interplevel(wdir_all, p, 700) wspd_700 = interplevel(wspd_all, p, 700) t_700 = interplevel(t, p, 700) # Interpolate geopotential height, u, and v winds to 925 hPa ->762m ht_925 = interplevel(z, p, 925.) wdir_925 = interplevel(wdir_all, p, 925) wspd_925 = interplevel(wspd_all, p, 925) t_925 = interplevel(t, p, 925) # Clouds cloudfrac_low = cloudfrac[0, :, :] #300m cloudfrac_mid = cloudfrac[1, :, :] #2000m cloudfrac_high = cloudfrac[2, :, :] #6000m # Surface smooth_slp = smooth2d( slp, 7, cenweight=3 ) # Smooth the sea level pressure since it tends to be noisy near the mountains sfctemp = t2 - 273.16 #Surface temp hbl_mag = pblh.values + ter.values #"Height of BL Top wspd10 = wspd_wdir10[0, :] #Surface wind speed wdir10 = wspd_wdir10[1, :] #Surface wind dir mcape = cape_2d[0, :, :] mcin = cape_2d[1, :, :] lcl = cape_2d[2, :, :] lfc = cape_2d[3, :, :] rainTot = rainc + rainnc # Aux dr jack uEW = uv[0, :, :] vNS = uv[1, :, :] pmb = var = 0.01 * (p.values + pb.values ) # press is vertical coordinate in mb vhf = np.clip(vhf.values, a_min=0, a_max=np.max(vhf.values)) vhf = hfx + 0.000245268 * (t[0, :, :] + 273.16) * vhf except Exception as e: print('****Error transforming vars postprocessing , functions.py****') print(e) ######################################################################### ################## SAVE ######################################################################### try: np.save(outputdir + 'lons', (lons.values)) np.save(outputdir + 'lats', (lats.values)) np.save(outputdir + 'ter', (ter.values)) np.save(outputdir + 'mcape' + utch, mcape.values) np.save(outputdir + 'mcin' + utch, mcin.values) np.save(outputdir + 'lcl' + utch, lcl.values) np.save(outputdir + 'lfc' + utch, lfc.values) np.save(outputdir + 'sfctemp' + utch, (sfctemp.values)) np.save(outputdir + 'bldepth' + utch, (bldepth.values)) np.save(outputdir + 'wspd10' + utch, (wspd10.values)) np.save(outputdir + 'wdir10' + utch, (wdir10.values)) np.save(outputdir + 'pw' + utch, (pw.values)) np.save(outputdir + 'ctt' + utch, ctt.values) np.save(outputdir + 'hbl' + utch, hbl_mag) np.save(outputdir + 'cloudfrac_low' + utch, cloudfrac_low.values) np.save(outputdir + 'cloudfrac_mid' + utch, cloudfrac_mid.values) np.save(outputdir + 'cloudfrac_high' + utch, cloudfrac_high.values) np.save(outputdir + 'slp' + utch, (smooth_slp.values)) np.save(outputdir + 'hfx' + utch, (hfx.values)) np.save(outputdir + 'snow' + utch, (snow.values)) np.save(outputdir + 'rainTot' + utch, (rainTot.values)) np.save(outputdir + 'snowh' + utch, (snowh.values)) np.save(outputdir + 'td2' + utch, td2.values) np.save(outputdir + 'ht_500' + utch, ht_500.values) np.save(outputdir + 'wdir_500' + utch, wdir_500.values) np.save(outputdir + 'wspd_500' + utch, wspd_500.values) np.save(outputdir + 't_500' + utch, t_500.values) np.save(outputdir + 'ht_700' + utch, ht_700.values) np.save(outputdir + 'wdir_700' + utch, wdir_700.values) np.save(outputdir + 'wspd_700' + utch, wspd_700.values) np.save(outputdir + 't_700' + utch, t_700.values) np.save(outputdir + 'ht_925' + utch, ht_925.values) np.save(outputdir + 'wdir_925' + utch, wdir_925.values) np.save(outputdir + 'wspd_925' + utch, wspd_925.values) np.save(outputdir + 't_925' + utch, t_925.values) except Exception as e: print('****Error saving vars postprocessing , functions.py****') print(e) ######################################################################### ################## DR jack transf ######################################################################### try: # Variables size = (z.values).shape nz = size[0] ny = size[1] nx = size[2] # Transforms '''For NCL arrays, the fastest-varying dimension is the rightmost, while for Fortran it is the leftmost dimension. Therefore, if XA is a Fortran array dimensioned idim x jdim, this array will be dimensioned jdim x idim in NCL''' pblh = np.transpose(pblh.values) ter = np.transpose(ter.values) wa = np.transpose(wa.values) z = np.transpose(z.values) qcloud = np.transpose(qcloud.values) uEW = np.transpose(uEW.values) vNS = np.transpose(vNS.values) qvapor = np.transpose(qvapor.values) tc = np.transpose(t.values) pmb = np.transpose(pmb) vhf = np.transpose(vhf.values) td = np.transpose(td.values) thetac = np.transpose(thetac.values) ua = np.transpose(ua.values) va = np.transpose(va.values) # Other Constants time = 0 # Seems time is always 0 for DrJack's code cdbl = 0.003 # Coefficient of Drag for Boundary Layer cwbasecriteria = 0.000010 # Cloud Water criterion #"BL Max. Up/Down Motion" wblMxMn = ncl_jack_fortran.calc_wblmaxmin(0, wa, z, ter, pblh) #"BL Explicit Cloud Base [AGL]" laglcwbase = 1 criteriondegc = 1.0 maxcwbasem = 5486.40 blcwbase = ncl_jack_fortran.calc_blcloudbase(qcloud, z, ter, pblh, cwbasecriteria, maxcwbasem, laglcwbase) #"BL Avg Wind" ublavgwind = ncl_jack_fortran.calc_blavg(uEW, z, ter, pblh) vblavgwind = ncl_jack_fortran.calc_blavg(vNS, z, ter, pblh) blavgwindspeed = np.sqrt( np.power(ublavgwind, 2) + np.power(vblavgwind, 2)) #"Wind at BL Top" utop, vtop = ncl_jack_fortran.calc_bltopwind(uEW, vNS, z, ter, pblh) bltopwindspeed = np.sqrt(np.power(utop, 2) + np.power(vtop, 2)) #"BL Cloud Cover" blcldpct = ncl_jack_fortran.calc_subgrid_blcloudpct_grads( qvapor, qcloud, tc, pmb, z, ter, pblh, cwbasecriteria) #"Thermal Updraft Velocity" wstar = ncl_jack_fortran.calc_wstar(vhf, pblh, 0) #"Height of Critical Updraft Strength" hwcrit = ncl_jack_fortran.calc_hcrit(wstar, ter, pblh) #"Cu Cloudbase ~I~where Cu Potential > 0~P~" zsfclcl = ncl_jack_fortran.calc_sfclclheight(pmb, tc, td, z, ter, pblh) #"OvercastDevelopment Cloudbase" qvaporblavg = ncl_jack_fortran.calc_blavg(qvapor, z, ter, pblh) zblcl = ncl_jack_fortran.calc_blclheight(pmb, tc, qvaporblavg, z, ter, pblh) #"Thermalling Height" hglider_aux = np.minimum(hwcrit, zsfclcl) hglider = np.minimum(hglider_aux, zblcl) #"BL Top Uncertainty/Variability" bltopvariab = ncl_jack_fortran.calc_bltop_pottemp_variability( thetac, z, ter, pblh, criteriondegc) #"BL Vertical Wind Shear" blwindshear = ncl_jack_fortran.calc_blwinddiff(ua, va, z, ter, pblh) except Exception as e: print( '****Error computing dr jack vars postprocessing , functions.py****' ) print(e) # Save try: np.save(outputdir + 'wblMxMn' + utch, np.transpose(wblMxMn)) np.save(outputdir + 'blcwbase' + utch, np.transpose(blcwbase)) np.save(outputdir + 'ublavgwind' + utch, np.transpose(ublavgwind)) np.save(outputdir + 'vblavgwind' + utch, np.transpose(vblavgwind)) np.save(outputdir + 'blavgwindspeed' + utch, np.transpose(blavgwindspeed)) np.save(outputdir + 'utop' + utch, np.transpose(utop)) np.save(outputdir + 'vtop' + utch, np.transpose(vtop)) np.save(outputdir + 'bltopwindspeed' + utch, np.transpose(bltopwindspeed)) np.save(outputdir + 'blcldpct' + utch, np.transpose(blcldpct)) np.save(outputdir + 'wstar' + utch, np.transpose(wstar)) np.save(outputdir + 'hwcrit' + utch, np.transpose(hwcrit)) np.save(outputdir + 'zsfclcl' + utch, np.transpose(zsfclcl)) np.save(outputdir + 'zblcl' + utch, np.transpose(zblcl)) np.save(outputdir + 'hglider' + utch, np.transpose(hglider)) np.save(outputdir + 'bltopvariab' + utch, np.transpose(bltopvariab)) np.save(outputdir + 'blwindshear' + utch, np.transpose(blwindshear)) except Exception as e: print( '****Error saving dr jacks vars postprocessing , functions.py****') print(e) return dx, dy
u = getvar(files, 'ua', timeidx=params['time_index'], units="kt") v = getvar(files, 'va', timeidx=params['time_index'], units="kt") ter_3d=np.tile(ter.values,[41,1,1]) z.values=z.values-ter.values u2 = interplevel(u, z, 1000) v2 = interplevel(v, z, 1000) uvmet = getvar(files, 'uvmet10', timeidx=params['time_index'], units='kt') ufld = uvmet.isel(u_v=0) vfld = uvmet.isel(u_v=1) u2.values=u2.values-ufld.values v2.values=v2.values-vfld.values lfield = uvmet10.isel(wspd_wdir=0) lfield.values=smooth2d(np.sqrt(u2.values**2.+v2.values**2.),3) lfield2 = getvar(files, 'ter', timeidx=params['time_index'], units='m') sounding_parameters=getvar(files, 'cape_2d', timeidx=params['time_index']) cffield = sounding_parameters.isel(mcape_mcin_lcl_lfc=3) cffield.attrs['description']='lcl, 0-1 km bulk wind difference' cffield.attrs['units']='m; kt' uvmet = getvar(files, 'uvmet10', timeidx=params['time_index'], units='kt') ufld = u2 vfld = v2 make_plot(cffield,lfield,lfield2,ufld,vfld,params)
from matplotlib.cm import get_cmap import cartopy.crs as crs from cartopy.feature import NaturalEarthFeature from wrf import ALL_TIMES, to_np, getvar, smooth2d, get_cartopy, cartopy_xlim, cartopy_ylim, latlon_coords # Open the NetCDF file ncfile = Dataset( "/Users/zhenkunli/Dropbox/share/results/wrfout_d01_2014-07-01_00:00:00") # Get the sea level pressure T2 = getvar(ncfile, "T2", timeidx=ALL_TIMES) print T2 # Smooth the sea level pressure since it tends to be noisy near the mountains T2 = smooth2d(T2, 3) # Get the latitude and longitude points lats, lons = latlon_coords(T2) # Get the cartopy mapping object cart_proj = get_cartopy(T2) print cart_proj # Create a figure fig = plt.figure(figsize=(8, 6)) # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Download and add the states and coastlines states = NaturalEarthFeature(category='cultural',
_modified_ = datetime(2017, 07, 20) _version_ = "0.1" _status_ = "Development" # Open the NetCDF file. ncfile = Dataset("/media/uesleisutil/Ueslei/INPE/2014/Outputs/wrf_I_t01.nc") # Get the data. slp = getvar(ncfile, "slp", timeidx=78) uvmet10 = getvar(ncfile, "uvmet10", units="km h-1", timeidx=78) u10 = uvmet10[1,:,:] v10 = uvmet10[0,:,:] lh = getvar(ncfile, "LH", timeidx=78) # Smooth the sea level pressure since it tends to be noisy near the mountains. smooth_slp = smooth2d(slp, 5) # Get the latitude and longitude points. lats, lons = latlon_coords(slp) # Get the cartopy mapping object. cart_proj = get_cartopy(slp) # Create a figure. fig = plt.figure(figsize=(12,9)) # Set the GeoAxes to the projection used by WRF. ax = plt.axes(projection=cart_proj) # Download and add the states and coastlines. states = NaturalEarthFeature(category='cultural', scale='50m', facecolor='none',name='admin_0_countries')
if ncidp.horizontal == 1: horizontal = "2D" else: horizontal = "3D" for it in range(0, ntime): # ntime print(ptime_convert[it], end='\r', flush=True) lons = data[it, :, 0] lats = data[it, :, 1] hgts = data[it, :, 2] / 1000 itt = np.where(ztime_convert == ptime_convert[it])[0].tolist() if itt != []: z = ncidz.variables["z"][itt, level, :, :] smooth_z = smooth2d(z[0, :, :], 6, cenweight=4) del z fig = plt.figure(figsize=(6, 4), dpi=300) plt.rcParams.update({'font.size': 6}) m.drawcoastlines(linewidth=0.1) m.drawparallels(np.arange(-90., 91., 5.), linestyle='--', linewidth=0.1) m.drawmeridians(np.arange(-180, 180., 5.), linestyle='--', linewidth=0.1) # m.drawparallels(np.arange(0,80,15),labels=[False,True,False,False]) m.drawmeridians(np.arange(-180, 180., 5.), linestyle='--', linewidth=0.1) m.fillcontinents('tab:gray', alpha=0.7) titlestrL = "%s" % (ptime_convert[it]) titlestrR = "%4.1f%%" % ( (float(lons.count()) / float(lons.shape[0]) * 100.))
from matplotlib.cm import get_cmap import cartopy.crs as crs from cartopy.feature import NaturalEarthFeature from wrf import ALL_TIMES, to_np, getvar, smooth2d, get_cartopy, cartopy_xlim, cartopy_ylim, latlon_coords # Open the NetCDF file ncfile = Dataset( "/Users/zhenkunli/Dropbox/share/results/wrfout_d01_2014-07-01_00:00:00") # Get the sea level pressure HFX = getvar(ncfile, "HFX", timeidx=ALL_TIMES) print HFX # Smooth the sea level pressure since it tends to be noisy near the mountains HFX = smooth2d(HFX, 3) # Get the latitude and longitude points lats, lons = latlon_coords(HFX) # Get the cartopy mapping object cart_proj = get_cartopy(HFX) print cart_proj # Create a figure fig = plt.figure(figsize=(8, 6)) # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Download and add the states and coastlines states = NaturalEarthFeature(category='cultural',
def plot_spatial_wrf_surf_press(file_path, case_name, timeidx): # Open the NetCDF file ncfile = Dataset(file_path) # Get the sea level pressure slp = getvar(ncfile, "slp",timeidx=timeidx) # print(slp) # Smooth the sea level pressure since it tends to be noisy near the # mountains smooth_slp = smooth2d(slp, 3, cenweight=4) # Get the latitude and longitude points lats, lons = latlon_coords(slp) # Get the cartopy mapping object cart_proj = get_cartopy(slp) # Create the figure fig = plt.figure(figsize=(12,6)) fig.subplots_adjust(hspace=0.3) fig.subplots_adjust(wspace=0.2) plt.rcParams['text.usetex'] = False plt.rcParams['font.family'] = "sans-serif" plt.rcParams['font.serif'] = "Helvetica" plt.rcParams['axes.linewidth'] = 1.5 plt.rcParams['axes.labelsize'] = 14 plt.rcParams['font.size'] = 14 plt.rcParams['legend.fontsize'] = 12 plt.rcParams['xtick.labelsize'] = 12 plt.rcParams['ytick.labelsize'] = 14 almost_black = '#262626' # change the tick colors also to the almost black plt.rcParams['ytick.color'] = almost_black plt.rcParams['xtick.color'] = almost_black # change the text colors also to the almost black plt.rcParams['text.color'] = almost_black # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Download and add the states and coastlines states = NaturalEarthFeature(category="cultural", scale="50m", facecolor="none", name="admin_1_states_provinces_shp") ax.add_feature(states, linewidth=.5, edgecolor="black") ax.coastlines('50m', linewidth=0.8) # 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, vmin=980, vmax=1020, colors="black", transform=crs.PlateCarree()) plt.contourf(to_np(lons), to_np(lats), to_np(smooth_slp), 10, vmin=980, vmax=1020, transform=crs.PlateCarree(), cmap=get_cmap("rainbow")) #"jet" # Add a color bar plt.colorbar(ax=ax, shrink=.98) # Set the map bounds ax.set_xlim(cartopy_xlim(smooth_slp)) ax.set_ylim(cartopy_ylim(smooth_slp)) # Add the gridlines ax.gridlines(color="black", linestyle="dotted") plt.title("Sea Level Pressure (hPa) of timestep-"+str(timeidx)) fig.savefig("./plots/spatial_wrf_slp_"+case_name+"_"+str(timeidx), bbox_inches='tight', pad_inches=0.1) return ax
img_plot.yformatter = LATITUDE_FORMATTER return fig, ax projection = ccrs.PlateCarree() fig, ax = brazil() states = NaturalEarthFeature(category='cultural', scale='50m', facecolor='none', name='admin_1_states_provinces_shp', linewidth=0.4) states = ax.add_feature(states, edgecolor='black') prnm = sgl['msl'][0][:][:] prnm = prnm / 100 smooth_press = smooth2d(prnm, 10, cenweight=0.5) t_850 = ps['t'][0][4][:][:] - 273.15 hgt_500 = ps['z'][0][0][:][:] hgt_1000 = ps['z'][0][2][:][:] thk = (hgt_500 - hgt_1000) / 10 plt.title( '{} \n PRNM (hPa), Temperatura em 850 hPa e \n Espessura de Geopotencial (m)' .format(tempo), fontsize=14) img_plot = plt.contourf(lons, lats, t_850, transform=projection,
from matplotlib.cm import get_cmap import cartopy.crs as crs from cartopy.feature import NaturalEarthFeature from wrf import to_np, getvar, smooth2d, get_cartopy, cartopy_xlim, cartopy_ylim, latlon_coords # Open the NetCDF file ncfile = Dataset( '/Users/sunt05/Documents/20180813WRF-SUEWS-London/wrfout_d03_2014-07-01_00:00:00' ) # Get the sea level pressure slp = getvar(ncfile, "T2", 10) # Smooth the sea level pressure since it tends to be noisy near the mountains smooth_slp = smooth2d(slp, 3) # Get the latitude and longitude points lats, lons = latlon_coords(slp) # Get the cartopy mapping object cart_proj = get_cartopy(slp) # Create a figure fig = plt.figure(figsize=(12, 9)) # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Download and add the states and coastlines states = NaturalEarthFeature(category='cultural', scale='50m',
def makesmooth(str_id, passes): X = getdata(str_id) Xsmooth = wrf.smooth2d(X, passes) return Xsmooth
def metpy_read_wrf(fwrf, fout, lons_out, lats_out): wrfin = Dataset(fwrf) ds = xr.Dataset() slp = getvar(wrfin, "slp", timeidx=ALL_TIMES) ds['slp'] = smooth2d(slp, 3, cenweight=4) lats, lons = latlon_coords(slp) ds['lats'] = lats ds['lons'] = lons rainc = [] for tidx in range(len(ds.Time)): rainc0 = extract_vars(wrfin, timeidx=tidx, varnames=["RAINNC"]).get("RAINNC") if tidx > 0: rainc0 -= extract_vars(wrfin, timeidx=tidx - 1, varnames=["RAINNC"]).get("RAINNC") rainc.append(smooth2d(rainc0, 3, cenweight=4)) ds['rain'] = xr.DataArray(rainc, ds.slp.coords, ds.slp.dims, ds.slp.attrs) ds['latent'] = extract_vars(wrfin, timeidx=ALL_TIMES, varnames=["LH"]).get("LH") ds['u10'] = extract_vars(wrfin, timeidx=ALL_TIMES, varnames=["U10"]).get("U10") ds['v10'] = extract_vars(wrfin, timeidx=ALL_TIMES, varnames=["V10"]).get("V10") ds['t2m'] = extract_vars(wrfin, timeidx=ALL_TIMES, varnames=["T2"]).get("T2") ds['q2m'] = extract_vars(wrfin, timeidx=ALL_TIMES, varnames=["Q2"]).get("Q2") ds['sst'] = extract_vars(wrfin, timeidx=ALL_TIMES, varnames=["SST"]).get("SST") ds['td2'] = getvar(wrfin, "td2", timeidx=ALL_TIMES) ds['th2'] = extract_vars(wrfin, timeidx=ALL_TIMES, varnames=["TH2"]).get("TH2") ds['mask'] = extract_vars(wrfin, timeidx=ALL_TIMES, varnames=["LANDMASK"]).get("LANDMASK") ds['p'] = getvar(wrfin, "pressure", timeidx=ALL_TIMES) ds['z'] = getvar(wrfin, "geopt", timeidx=ALL_TIMES) ds['u'] = getvar(wrfin, "ua", timeidx=ALL_TIMES) ds['v'] = getvar(wrfin, "va", timeidx=ALL_TIMES) ds['w'] = getvar(wrfin, "wa", timeidx=ALL_TIMES) ds['omega'] = getvar(wrfin, "omega", timeidx=ALL_TIMES) ds['tk'] = getvar(wrfin, "tk", timeidx=ALL_TIMES) ds['th'] = getvar(wrfin, "th", timeidx=ALL_TIMES, units='K') ds['eth'] = getvar(wrfin, "eth", timeidx=ALL_TIMES, units='K') ds['avo'] = getvar(wrfin, "avo", timeidx=ALL_TIMES) ds['pvo'] = getvar(wrfin, "pvo", timeidx=ALL_TIMES) ds['wspd'] = getvar(wrfin, "wspd_wdir", timeidx=ALL_TIMES, units="m/s")[0, :] ds = ds.rename({'south_north': 'eta_rho', 'west_east': 'xi_rho'}) ds = ds.rename({"XLAT": "lat", "XLONG": "lon"}) ds = ds.drop(['wspd_wdir']) interp_method = 'bilinear' ds_out = xr.Dataset({ 'lat': (['lat'], lats_out), 'lon': (['lon'], lons_out) }) regridder = xe.Regridder(ds, ds_out, interp_method) regridder.clean_weight_file() ds = regridder(ds) ds = ds.squeeze() #accrain = ds.rain.rolling(Time=6, center=True).sum() #acclatent = ds.latent.rolling(Time=6, center=True).sum() #ds = ds.rolling(Time=6, center=True).mean() accrain = ds.rain.rolling(Time=12, center=False).sum() acclatent = ds.latent.rolling(Time=12, center=False).sum() #ds = ds.rolling(Time=6, center=True).mean() ds['accrain'] = accrain ds['acclatent'] = acclatent ds.to_netcdf(fout) return ds
from netCDF4 import Dataset import matplotlib.pyplot as plt from matplotlib.cm import get_cmap from mpl_toolkits.basemap import * from wrf import to_np, getvar, smooth2d, get_basemap, latlon_coords # Open the NetCDF file ncfile = Dataset("wrfout_d01_2019-01-26_12_00_00") # Get the sea level pressure slp = getvar(ncfile, "slp") # Smooth the sea level pressure since it tends to be noisy near the # mountains smooth_slp = smooth2d(slp, 3, cenweight=4) # Get the latitude and longitude points lats, lons = latlon_coords(slp) # Get the basemap object bm = get_basemap(slp) # Create a figure fig = plt.figure(figsize=(12,9)) # Add geographic outlines bm.drawcoastlines(linewidth=0.25) bm.drawstates(linewidth=0.25) bm.drawcountries(linewidth=0.25)
import matplotlib.pyplot as plt from matplotlib.cm import get_cmap import cartopy.crs as crs from cartopy.feature import NaturalEarthFeature from wrf import ALL_TIMES, to_np, getvar, smooth2d, get_cartopy, cartopy_xlim, cartopy_ylim, latlon_coords # Open the NetCDF file ncfile = Dataset("/Users/zhenkunli/Dropbox/share/results/wrfout_d01_2014-07-01_00:00:00") # Get the sea level pressure LH = getvar(ncfile, "LH", timeidx=ALL_TIMES) print LH # Smooth the sea level pressure since it tends to be noisy near the mountains LH = smooth2d(LH, 3) # Get the latitude and longitude points lats, lons = latlon_coords(LH) # Get the cartopy mapping object cart_proj = get_cartopy(LH) print cart_proj # Create a figure fig = plt.figure(figsize=(8,6)) # Set the GeoAxes to the projection used by WRF ax = plt.axes(projection=cart_proj) # Download and add the states and coastlines states = NaturalEarthFeature(category='cultural', scale='50m', facecolor='none',
'llevels2': [1000], 'llevels3': None, 'time_index': tindex, 'times': times, 'zoom': zoom, 'skip': 17 } uvmet10 = getvar(files, 'wspd_wdir10', timeidx=params['time_index'], units="kt") cffield = uvmet10.isel(wspd_wdir=0) cffield.attrs['description'] = '10 m wind' lfield = smooth2d( getvar(files, 'slp', timeidx=params['time_index'], units='hPa'), 3) lfield2 = getvar(files, 'ter', timeidx=params['time_index'], units='m') lfield3 = None uvmet = getvar(files, 'uvmet10', timeidx=params['time_index'], units='kt') ufld = uvmet.isel(u_v=0) vfld = uvmet.isel(u_v=1) make_plot(cffield, lfield, lfield2, lfield3, ufld, vfld, params) # In[415]: #=====================0-1 KM WIND========================= params = { 'outpath': outpath, 'modname': modname, 'modfld': 'Lifting_Condensation_Level',
def metpy_read_wrf(tidx, froms, froms0, fwrf, lons_out, lats_out): wrfin = Dataset(fwrf) ds = xr.Dataset() slp = getvar(wrfin, "slp", timeidx=tidx) ds['slp'] = smooth2d(slp, 3, cenweight=4) lats, lons = latlon_coords(slp) ds['lats'] = lats ds['lons'] = lons landmask = extract_vars(wrfin, timeidx=tidx, varnames=["LANDMASK"]).get("LANDMASK") u10 = extract_vars(wrfin, timeidx=tidx, varnames=["U10"]).get("U10") v10 = extract_vars(wrfin, timeidx=tidx, varnames=["V10"]).get("V10") ds['u10'] = u10.where(landmask == 0) ds['v10'] = v10.where(landmask == 0) latent = extract_vars(wrfin, timeidx=tidx, varnames=["LH"]).get("LH") ds['latent'] = smooth2d(latent, 3, cenweight=4) #latent.where(landmask==0) t2m = extract_vars(wrfin, timeidx=tidx, varnames=["T2"]).get("T2") - 273.15 ds['t2m'] = smooth2d(t2m, 3, cenweight=4) sst = extract_vars(wrfin, timeidx=tidx, varnames=["SST"]).get("SST") ds['sst'] = sst.where(landmask == 0) romsin = xr.open_dataset(froms) romsin = romsin.rename({"lat_rho": "lat", "lon_rho": "lon"}) romsin = romsin.isel(ocean_time=tidx) ds['sst_5m'] = romsin.isel(z_r=0).temp ds['water_temp'] = romsin.temp ds['water_ucur'] = romsin.ucur / 100 ds['water_vcur'] = romsin.vcur / 100 ds.water_ucur.attrs['units'] = 'm/s' ds.water_vcur.attrs['units'] = 'm/s' romsin = xr.open_dataset(froms0) romsin = romsin.rename({"lat_rho": "lat", "lon_rho": "lon"}) romsin = romsin.isel(ocean_time=tidx) ds['h'] = romsin.h mld = get_oml_depth(froms0, t_in=tidx) mld = smooth2d(mld, 3, cenweight=4) ds['oml_depth'] = xr.DataArray(mld, ds.sst_5m.coords, ds.sst_5m.dims, ds.sst_5m.attrs) ds['oml_depth2'] = ds.oml_depth.where(ds.h > 20) ds = ds.drop(['XLONG', 'XLAT', 'XTIME', 'Time']) ds = ds.rename({'south_north': 'eta_rho', 'west_east': 'xi_rho'}) interp_method = 'bilinear' ds_out = xr.Dataset({ 'lat': (['lat'], lats_out), 'lon': (['lon'], lons_out) }) regridder = xe.Regridder(ds, ds_out, interp_method) regridder.clean_weight_file() ds = regridder(ds) ds = ds.squeeze() dxy = 10000. ds = ds.metpy.parse_cf().squeeze() utau, vtau = wind_stress(to_np(ds.u10), to_np(ds.v10)) ds['u_tau'] = xr.DataArray(utau, ds.u10.coords, ds.u10.dims, ds.u10.attrs) ds['v_tau'] = xr.DataArray(vtau, ds.v10.coords, ds.v10.dims, ds.v10.attrs) curl = mpcalc.vorticity(utau * units('m/s'), utau * units('m/s'), dx=dxy * units.meter, dy=dxy * units.meter) ds['wind_stress_curl'] = xr.DataArray(np.array(curl), ds.u10.coords, ds.u10.dims, ds.u10.attrs) div = [] for z in range(len(ds.z_r)): div0 = mpcalc.divergence(ds.water_ucur.isel(z_r=z) * units('m/s'), ds.water_vcur.isel(z_r=z) * units('m/s'), dx=dxy * units.meter, dy=dxy * units.meter) div.append(div0) ds['cur_div'] = xr.DataArray(div, ds.water_ucur.coords, ds.water_ucur.dims, ds.water_ucur.attrs) div = mpcalc.divergence(ds.water_ucur.isel(z_r=2) * units('m/s'), ds.water_vcur.isel(z_r=2) * units('m/s'), dx=dxy * units.meter, dy=dxy * units.meter) ds['surf_cur_div'] = xr.DataArray(np.array(div), ds.u10.coords, ds.u10.dims, ds.u10.attrs) print(ds) return ds
def get_sea_level_pressure(wrf_data): slp = getvar(wrf_data, "slp") # sea level pressure (2D) slp = smooth2d(slp, 3) # Smooth sea level pressure return slp