def compute_sst(varvals,time,gvars): """Method to compute the sea surface temperature sst_in: sea surface temperature [K] time: list of times corresponding to sst 1st dimension --- sst_out: sea surface temperature [K] atts: attributes of the output variable to be used in the output netcdf """ sst_in=varvals['SST'][:] sst_in=np.ma.masked_equal(sst_in,pm.const.missingval) filemask=nc.Dataset(gvars.fileref_att,'r') mask=filemask.variables['LANDMASK'][:] filemask.close() if len(time)!=sst_in.shape[0]: sys.exit('ERROR in compute_sst: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="sea_surface_temperature",ln="sea surface temperature",un="K",ts="time: point values %s seconds" %(tseconds)) sst_out=sst_in sst_out[:,mask==1]=pm.const.missingval return sst_out,atts
def compute_evspsbl(varvals,time,gvars): """Method to compute surface evaporation flux The original variable was accumulated throughout the simulation. Accumulation must be removed. sfcevp: accumulated surface evaporation. Including the timestep previous to the first one in this period [kg m-2] time: list of times corresponding to sfcevp 1st dimension --- evspsbl: Surface evaporation flux [kg m-2 s-1] atts: attributes of the output variable to be used in the output netcdf """ sfcevp=varvals['SFCEVP'][:] sfcevp=np.ma.masked_equal(sfcevp,pm.const.missingval) #sfcevp includes the timestep previous to the first one to remove the accumulation. if len(time)!=sfcevp.shape[0]-1: sys.exit('ERROR in compute_evspsbl: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="water_evaporation_flux",ln="Surface evaporation",un="kg m-2 s-1",ts="time: point values %s seconds" %(tseconds)) #Calculating difference between each timestep to remove the accumulation #Divided by the number of seconds in each timestep to calculate the flux evspsbl=np.zeros((sfcevp.shape[0]-1,)+sfcevp.shape[1:],dtype=np.float64) evspsbl[:,:,:]=np.diff(sfcevp,axis=0)/tseconds return evspsbl,atts
def compute_potevp(varvals,time,gvars): """Method to compute surface potential evaporation flux The original variable (POTEVP) was accumulated every 3 hours and has units of m. The units in the original wrfout says W/m2 but this is WRONG based on looking at the code and the magnitude of the values obtained assuming W/m2. Convert the units from [m] to [kg m-2 s-1]: multiply by the density of water and divide by the total number of seconds in the averaged period (3*3600). time: list of times corresponding to potevp 1st dimension --- potevp_out: Potential evaporation flux [kg m-2 s-1] atts: attributes of the output variable to be used in the output netcdf """ potevp_in=varvals['POTEVP'][:] potevp_in=np.ma.masked_equal(potevp_in,pm.const.missingval) #potevp includes the timestep previous to the first one to remove the accumulation. if len(time)!=potevp_in.shape[0]-1: sys.exit('ERROR in compute_potevp: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="water_potential_evaporation_flux",ln="Potential evaporation",un="kg m-2 s-1",ts="time: point values %s seconds" %(tseconds)) #Calculating difference between each timestep to remove the accumulation #Divided by the number of seconds in each timestep to calculate the flux potevp_out=np.zeros((potevp_in.shape[0]-1,)+potevp_in.shape[1:],dtype=np.float64) potevp_out[:,:,:]=np.diff(potevp_in,axis=0)*pm.const.rhowater/tseconds return potevp_out,atts
def compute_vas(varvals,time,gvars): """Method to compute northward wind (ROTATED - EARTH COORDINATES) u10: zonal wind [m s-1] v10: meridional wind [m s-1] time: list of times corresponding to v10 dimension --- vas: earth-coordinates northward wind [m s-1] atts: attributes of the output variable to be used in the output netcdf """ u10=varvals['U10'][:] v10=varvals['V10'][:] u10=np.ma.masked_equal(u10,pm.const.missingval) v10=np.ma.masked_equal(v10,pm.const.missingval) if (len(time)!=u10.shape[0]) or (len(time)!=v10.shape[0]): sys.exit('ERROR in compute_vas: The lenght of time variable does not correspond to U10 or V10 first dimension') fileref=nc.Dataset(gvars.fileref_att,'r') sina=fileref.variables['SINALPHA'][:] cosa=fileref.variables['COSALPHA'][:] sina_all=np.tile(sina, (len(time),1,1)) cosa_all=np.tile(cosa, (len(time),1,1)) tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="northward_wind",ln="Northward near-surface wind",un="m s-1",ts="time: point values %s seconds" %(tseconds),hg="10 m") vas = v10[:]*cosa_all[:]+u10[:]*sina_all[:] return vas,atts
def compute_wss(varvals,time,gvars): """Method to compute wind speed u10: zonal wind [m s-1] v10: meridional wind [m s-1] time: list of times corresponding to u10 and v10 1st dimensions --- wss: wind speed [m s-1] atts: attributes of the output variable to be used in the output netcdf """ u10=varvals['U10'][:] v10=varvals['V10'][:] u10=np.ma.masked_equal(u10,pm.const.missingval) v10=np.ma.masked_equal(v10,pm.const.missingval) if (len(time)!=u10.shape[0]) or (len(time)!=v10.shape[0]): sys.exit('ERROR in compute_wss: The lenght of time variable does not correspond to u10 or v10 first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="air_velocity",ln="Surface wind speed",un="m s-1",ts="time: point values %s seconds" %(tseconds),hg="10 m") #Winds need to be unstagged #Wu10_unstagged=0.5*(u10[:,:,:-1]+u10[:,:,1:]) #Wv10_unstagged=0.5*(v10[:,:-1,:]+v10[:,1:,:]) wss=(u10**2+v10**2)**0.5 return wss,atts
def compute_hurs(varvals,time,gvars): """Method to compute relative humidity psfc: psfc from wrf files [Pa] t2: T2 from wrf files [K] q2: mixing ratio [kg kg-2] time: list of times corresponding to t2 1st dimension --- hurs: relative humidity [%] atts: attributes of the output variable to be used in the output netcdf """ psfc=varvals['PSFC'][:] psfc=np.ma.masked_equal(psfc,pm.const.missingval) t2=varvals['T2'][:] t2=np.ma.masked_equal(t2,pm.const.missingval) q2=varvals['Q2'][:] q2=np.ma.masked_equal(q2,pm.const.missingval) if len(time)!=t2.shape[0]: sys.exit('ERROR in compute_hurs: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="relative_humidity",ln="Near-Surface Relative Humidity",un="%",ts="time: point values %s seconds" %(tseconds),hg="2 m") e = q2*psfc/(100.*(const.epsilon_gamma+q2)) #e in hPA es = np.where( t2-const.tkelvin <=0., const.es_base_tetens*10.**(((t2-const.tkelvin)*const.es_Atetens_ice)/ ((t2-const.tkelvin)+const.es_Btetens_ice)), #ICE const.es_base_tetens*10.**(((t2-const.tkelvin)*const.es_Atetens_vapor)/ ((t2-const.tkelvin)+const.es_Btetens_vapor))) #(else) Vapor hurs=(e/es)*100 return hurs,atts
def compute_mrso(varvals,time,gvars): """Method to compute the total soil moisture content Uses SMSTOT which is moisture integrated through all layers smstot: total soil moisture [kg m-2] or [mm]. NOTE: wrfout files incorrectly list units as m3 m-3. The correct units are [mg m-2] or [mm]. dzs: thickness of each soil layer [m] time: list of times corresponding to smstot 1st dimension --- mrso: total soil moisture content [kg m-2] atts: attributes of the output variable to be used in the output netcdf """ smstot=varvals['SMSTOT'][:] smstot=np.ma.masked_equal(smstot,pm.const.missingval) filemask=nc.Dataset(gvars.fileref_att,'r') mask=filemask.variables['LANDMASK'][:] filemask.close() if len(time)!=smstot.shape[0]: sys.exit('ERROR in compute_mrso: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="soil_moisture_content",ln="Total soil moisture content",un="kg m-2",ts="time: point values %s seconds" %(tseconds)) mrso=smstot mrso[:,mask==0]=pm.const.missingval return mrso,atts
def compute_pracc(varvals,time,gvars): """Method to compute precipitation The original variable was accumulated throughout the simulation. Accumulation must be removed (But it is not converted to flux) rainc: convective rainfall accumulated. Including the timestep previous to the first one in this period [kg m-2] rainnc: non-convective rainfall accumulated.Including the timestep previous to the first one in this period [kg m-2] time: list of times corresponding to rainc 1st dimension --- pracc: accumulated rainfall (pracc) since last record [kg m-2] atts: attributes of the output variable to be used in the output netcdf """ rainc=varvals['RAINC'][:] rainnc=varvals['RAINNC'][:] rainc=np.ma.masked_equal(rainc,pm.const.missingval) rainnc=np.ma.masked_equal(rainnc,pm.const.missingval) #rainc and rainnc includes the timestep previous to the first one to remove the accumulation. if (len(time)!=rainc.shape[0]-1) or (len(time)!=rainnc.shape[0]-1): sys.exit('ERROR in compute_pracc: The lenght of time variable does not correspond to rainc or rainnc first dimension') #Generating a dictionary with the output attributes of the #variable tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="precipitation_amount",ln="Accumulated precipitation",un="Kg m-2",ts="time: point values %s seconds" %(tseconds)) #Calculating difference between each timestep to remove the accumulation pracc=np.zeros((rainc.shape[0]-1,)+rainc.shape[1:],dtype=np.float64) pracc[:,:,:]=np.diff(rainc+rainnc,axis=0) pracc[pracc>pm.const.missingval]=pm.const.missingval return pracc,atts
def compute_snc(varvals,time,gvars): """Method to compute snow area fraction snowc: SNOWC - flag indicating snow coverage from wrf outputs [] time: list of times corresponding to snowc dimension --- snc: snow area fraction [%] atts: attributes of the output variable to be used in the output netcdf """ snowc=varvals['SNOWC'][:] snowc=np.ma.masked_equal(snowc,pm.const.missingval) if (len(time)!=snowc.shape[0]-1): sys.exit('ERROR in compute_snc: The lenght of time variable does not correspond to snowc first dimension') #Generating a dictionary with the output attributes of the variable tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_snow_area_fraction",ln="Snow area fraction",un="%",ts="time: point values %s seconds" %(tseconds)) snc[:,:,:]=snowc return snc,atts
def compute_snw(varvals,time,gvars): """Method to compute surface snow amount snow: SNOW - snow water equivalent from wrf outputs [kg m-2] time: list of times corresponding to snowc dimension --- snw: snow area fraction [%] atts: attributes of the output variable to be used in the output netcdf """ snow=varvals['SNOW'][:] snow=np.ma.masked_equal(snow,pm.const.missingval) if (len(time)!=snowc.shape[0]-1): sys.exit('ERROR in compute_snw: The lenght of time variable does not correspond to snow first dimension') #Generating a dictionary with the output attributes of the variable tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_snow_amount",ln="Surface snow amount",un="kg m-2",ts="time: point values %s seconds" %(tseconds)) snw[:,:,:]=snow return snw,atts
def compute_snd(varvals,time,gvars): """Method to compute snow depth snowh: SNOWH - physical snowdepth from wrf outputs [m] time: list of times corresponding to snowh dimension --- snd: snow depth [m] atts: attributes of the output variable to be used in the output netcdf """ snowh=varvals['SNOWH'][:] snowh=np.ma.masked_equal(snowh,pm.const.missingval) if (len(time)!=snowh.shape[0]): sys.exit('ERROR in compute_snd: The lenght of time variable does not correspond to snowh first dimension') #Generating a dictionary with the output attributes of the variable tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_snow_thickness",ln="Snow depth",un="m",ts="time: point values %s seconds" %(tseconds)) snd[:,:,:]=snowh return snd,atts
def compute_wss1Hmaxtstep(varvals,time,gvars): """Method to compute the max 1-hour wind speed using all timesteps of the model uv10max1H: maximum 1-hour wind speed using all timesteps [m s-1] time: list of times corresponding to uv10max1H 1st dimension --- wss1Hmaxtstep:maximum 1-hour wind speed using all timesteps [m s-1] atts: attributes of the output variable to be used in the output netcdf """ uv10max1H=varvals['UV10MAX1H'][:] uv10max1H=np.ma.masked_equal(uv10max1H,pm.const.missingval) if len(time)!=uv10max1H.shape[0]: sys.exit('ERROR in compute_wss1Hmaxtstep: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="1Hmax_air_velocity",ln="Max. 1-hour time-window moving averaged surface wind speed",un="m s-1",ts="time: maximum 1-hour time-window moving averaged values from point values 60.0 second") wss1Hmaxtstep=uv10max1H return wss1Hmaxtstep,atts
def compute_rlds(varvals,time,gvars): """Method to compute downward longwave surface radiation glw: downward long wave flux at ground surface [W m-2] time: list of times corresponding to glw 1st dimension --- rlds: downward shortwave surface radiation [W m-2] atts: attributes of the output variable to be used in the output netcdf """ glw=varvals['GLW'][:] glw=np.ma.masked_equal(glw,pm.const.missingval) if len(time)!=glw.shape[0]: sys.exit('ERROR in compute_rlds: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_downwelling_longwave_flux_in_air",ln="Downward LW surface radiation",un="W m-2",ts="time: point values %s seconds" %(tseconds)) rlds=glw return rlds,atts
def compute_wssmaxtstep(varvals,time,gvars): """Method to compute the daily max wind speed using all timesteps of the model spduv10max: daily max wind speed over all timesteps [m s-1] time: list of times corresponding to uv10max5 1st dimension --- wssmaxtstep:maximum daily max wind speed over all timesteps [m s-1] atts: attributes of the output variable to be used in the output netcdf """ spduv10max=varvals['SPDUV10MAX'][:] spduv10max=np.ma.masked_equal(spduv10max,pm.const.missingval) if len(time)!=spduv10max.shape[0]: sys.exit('ERROR in compute_wssmaxtstep: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="air_velocity",ln="Max. surface wind speed",un="m s-1",ts="time: maximum 24 hour value from point values 60.0 second") wssmaxtstep=spduv10max return wssmaxtstep,atts
def compute_pr1Hmaxtstep(varvals,time,gvars): """Method to compute the max 1-hour precipitationusing all timesteps of the model prmax1H: maximum 1-hour precipitation using all timesteps [kg m-2 s-1] time: list of times corresponding to swdown 1st dimension --- pr1Hmaxtstep:maximum 1-hour precipitation using all timesteps [kg m-2 s-1] atts: attributes of the output variable to be used in the output netcdf """ prmax1H=varvals['PRMAX1H'][:] prmax1H=np.ma.masked_equal(prmax1H,pm.const.missingval) if len(time)!=prmax1H.shape[0]: sys.exit('ERROR in compute_pr1Hmaxtstep: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="1Hmax_precipitation_flux",ln="Max. 1-hour time-window moving averaged precipitation rate",un="kg m-2 s-1",ts="time: maximum 1-hour time-window moving averaged values from point values 60.0 second") pr1Hmaxtstep=prmax1H return pr1Hmaxtstep,atts
def compute_emiss(varvals,time,gvars): """Method to compute surface emissivity emiss_in: surface emissivity time: list of times corresponding to emiss 1st dimension --- emiss_out: surface emissivity atts: attributes of the output variable to be used in the output netcdf """ emiss_in=varvals['EMISS'][:] emiss_in=np.ma.masked_equal(emiss_in,pm.const.missingval) if len(time)!=emiss_in.shape[0]: sys.exit('ERROR in compute_emiss: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_emissivity",ln="Surface emissivity",un="",ts="time: point values %s seconds" %(tseconds)) emiss_out=emiss_in return emiss_out,atts
def compute_tasmaxtstep(varvals,time,gvars): """Method to compute the daily max 2-m temperature using all timesteps of the model t2max: max 2-m temperature over all timesteps [K] time: list of times corresponding to swdown 1st dimension --- tasmaxtstep:max 2-m temperature over all timesteps [K] atts: attributes of the output variable to be used in the output netcdf """ t2max=varvals['T2MAX'][:] t2max=np.ma.masked_equal(t2max,pm.const.missingval) if len(time)!=t2max.shape[0]: sys.exit('ERROR in compute_tasmaxtstep: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="air_temperature",ln="Maximum surface air temperature",un="K",ts="time: max 24 hour value from point values 60.0 second",hg="2 m") tasmaxtstep=t2max return tasmaxtstep,atts
def compute_albedo(varvals,time,gvars): """Method to compute surface albedo albedo_in: surface albedo time: list of times corresponding to emiss 1st dimension --- albedo_out: surface albedo atts: attributes of the output variable to be used in the output netcdf """ albedo_in=varvals['ALBEDO'][:] albedo_in=np.ma.masked_equal(albedo_in,pm.const.missingval) if len(time)!=albedo_in.shape[0]: sys.exit('ERROR in compute_albedo: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="albedo",ln="Surface albedo",un="",ts="time: point values %s seconds" %(tseconds)) albedo_out=albedo_in return albedo_out,atts
def compute_hfss(varvals,time,gvars): """Method to compute surface sensible heat flux hfx: upward heat flux at the surface [W m-2] time: list of times corresponding to emiss 1st dimension --- hfss: upward sensible heat flux at the surface [W m-2] atts: attributes of the output variable to be used in the output netcdf """ hfx=varvals['HFX'][:] hfx=np.ma.masked_equal(hfx,pm.const.missingval) if len(time)!=hfx.shape[0]: sys.exit('ERROR in compute_hfss: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_upward_sensible_heat_flux",ln="Heat flux at the surface",un="W m-2",ts="time: point values %s seconds" %(tseconds)) hfss=hfx return hfss,atts
def compute_hfls(varvals,time,gvars): """Method to compute surface latent heat flux lh: latent heat flux at the surface [W m-2] time: list of times corresponding to lh 1st dimension --- hfls: upward latent heat flux at the surface [W m-2] atts: attributes of the output variable to be used in the output netcdf """ lh=varvals['LH'][:] lh=np.ma.masked_equal(lh,pm.const.missingval) if len(time)!=lh.shape[0]: sys.exit('ERROR in compute_hfls: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_upward_latent_heat_flux",ln="Latent heat flux at surface",un="W m-2",ts="time: point values %s seconds" %(tseconds)) hfls=lh return hfls,atts
def compute_huss(varvals,time,gvars): """Method to compute specific humidity q2: mixing ratio [kg kg-2] time: list of times corresponding to q2 1st dimension --- huss: specific humidity [] atts: attributes of the output variable to be used in the output netcdf """ q2=varvals['Q2'][:] q2=np.ma.masked_equal(q2,pm.const.missingval) if len(time)!=q2.shape[0]: sys.exit('ERROR in compute_huss: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="specific_humidity",ln="Surface specific humidity", un="kg/kg ",ts="time: point values %s seconds" %(tseconds),hg="2 m") huss=q2/(1+q2) return huss,atts
def compute_clt(varvals,time,gvars): """ Method to compute cloud fraction cldfra: CLDFRA from wrf files [] time: list of times corresponding to cldfra 1st dimension --- clt: cloud fraction [%] atts: attributes of the output variable to be used in the output netcdf """ cldfra=varvals['CLDFRA'][:] cldfra=np.ma.masked_equal(cldfra,pm.const.missingval) if len(time)!=cldfra.shape[0]: sys.exit('ERROR in compute_clt: The lenght of time variable does not correspond to var first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="cloud_area_fraction",ln="Total cloud fraction",un="%",ts="time: point values %s seconds" %(tseconds)) clt=cldfra*100. return clt,atts
def compute_tas(varvals,time,gvars): """Method to compute 2-m temperature t2: T2 from wrf files [K] time: list of times corresponding to t2 1st dimension --- tas: output temperature tas [K] atts: attributes of the output variable to be used in the output netcdf """ t2=varvals['T2'][:] t2=np.ma.masked_equal(t2,pm.const.missingval) if len(time)!=t2.shape[0]: sys.exit('ERROR in compute_tas: The lenght of time variable does not correspond to t2 first dimension') #Generating a dictionary with the output attributes of the #variable tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="air_temperature",ln="Surface air temperature",un="K",ts="time: point values %s seconds" %(tseconds),hg="2 m") tas=t2[:] return tas,atts
def compute_ps(varvals,time,gvars): """Method to compute surface pressure psfc: psfc from wrf files [Pa] time: list of times corresponding to t2 1st dimension --- ps: output surface pressure [Pa] atts: attributes of the output variable to be used in the output netcdf """ psfc=varvals['PSFC'][:] psfc=np.ma.masked_equal(psfc,pm.const.missingval) if len(time)!=psfc.shape[0]: sys.exit('ERROR in compute_ps: The lenght of time variable does not correspond to psfc first dimension') #Generating a dictionary with the output attributes of the #variable tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_air_pressure",ln="surface pressure",un="Pa",ts="time: point values %s seconds" %(tseconds)) ps=psfc return ps,atts
def compute_nonrotuas(varvals,time,gvars): """Method to compute eastward wind (NOT ROTATED) u10: zonal wind [m s-1] time: list of times corresponding to u10 1st dimension --- uas: eastward wind [m s-1] atts: attributes of the output variable to be used in the output netcdf """ u10=varvals['U10'][:] u10=np.ma.masked_equal(u10,pm.const.missingval) if len(time)!=u10.shape[0]: sys.exit('ERROR in compute_uas: The lenght of time variable does not correspond to uas first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="eastward_wind",ln="Eastward near-surface wind (not rotated)",un="m s-1",ts="time: point values %s seconds" %(tseconds),hg="10 m") # Zonal wind unstagged # uas=0.5*(u10[:,:,:-1]+u10[:,:,1:]) uas = u10 return uas,atts
def compute_snm(varvals,time,gvars): """Method to compute surface snow melt acsnom: ACSNOM - accumulated snow melt from wrf outputs [kg m-2] time: list of times corresponding to acsnom dimension (-1 because accumulated) --- snm: surface snow melt [kg m-2 s-1] atts: attributes of the output variable to be used in the output netcdf """ acsnom=varvals['ACSNOM'][:] acsnom=np.ma.masked_equal(acsnom,pm.const.missingval) if (len(time)!=acsnom.shape[0]-1): sys.exit('ERROR in compute_snm: The lenght of time variable does not correspond to acsnom first dimension') #Generating a dictionary with the output attributes of the variable tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_snow_melt_flux",ln="Surface snow melt",un="Kg m-2 s-1",ts="time: point values %s seconds" %(tseconds)) #Calculating difference between each timestep to remove the accumulation snm=np.zeros((acsnom.shape[0]-1,)+acsnom.shape[1:],dtype=np.float64) snm[:,:,:]=np.diff(snm,axis=0)/tseconds snm[snm>pm.const.missingval]=pm.const.missingval return snm,atts
def compute_nonrotvas(varvals,time,gvars): """Method to compute northward wind (NOT ROTATED) v10: meridional wind [m s-1] time: list of times corresponding to v10 dimension --- vas: northward wind [m s-1] atts: attributes of the output variable to be used in the output netcdf """ v10=varvals['V10'][:] v10=np.ma.masked_equal(v10,pm.const.missingval) if len(time)!=v10.shape[0]: sys.exit('ERROR in compute_vas: The lenght of time variable does not correspond to vas first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="northward_wind",ln="Northward near-surface wind (not rotated)",un="m s-1",ts="time: point values %s seconds" %(tseconds),hg="10 m") # Zonal wind unstagged # vas=0.5*(v10[:,:-1,:]+v10[:,1:,:]) vas = v10 return vas,atts
def compute_rlus(varvals,time,gvars): """Method to compute upward longwave surface radiation tsk: surface skin temperature [K] emiss: surface emissivity time: list of times corresponding to swdown 1st dimension --- rlus: upward longwave surface radiation [W m-2] atts: attributes of the output variable to be used in the output netcdf """ tsk=varvals['TSK'][:] emiss=varvals['EMISS'][:] tsk=np.ma.masked_equal(tsk,pm.const.missingval) emiss=np.ma.masked_equal(emiss,pm.const.missingval) if (len(time)!=tsk.shape[0]) or(len(time)!=emiss.shape[0]) : sys.exit('ERROR in compute_rlus: The lenght of time variable does not correspond to emiss or tsk first dimension') tseconds=round(((time[-1]-time[0]).total_seconds()/(len(time)-1))) atts=pm.get_varatt(sn="surface_upwelling_longwave_flux_in_air",ln="Upwelling surface LW radiation",un="W m-2",ts="time: point values %s seconds" %(tseconds)) #calculating with net lw radiation using Stefan-Boltzmann rlus=emiss*(pm.const.stefanboltz)*tsk**4 return rlus,atts