Chapter 8: Post-Processing Utilities
Table of Contents
· NCL
· RIP4
· ARWpost
· WPP
· VAPOR
· Tools
Introduction
There are a number of visualization tools available to display WRF-ARW (http://wrf-model.org/) model data. Model data in netCDF format, can essentially be displayed using any tool capable of displaying this data format.
Currently the following post-processing utilities are supported, NCL, RIP4, ARWpost (converter to GrADS and Vis5D), WPP, and VAPOR.
NCL, RIP4 and VAPOR can currently only read data in netCDF format, while ARWpost can read data in netCDF and GRIB1 format, and WPP can read data in netCDF and binary format.
Required software
The only library that is always required is the netCDF package from Unidata (http://www.unidata.ucar.edu/: login > Downloads > NetCDF - registration login required).
netCDF stands for Network
Common Data Form.
This format is platform independent, i.e., data files can be read on both
big-endian and little-endian computers, regardless of where the file was
created. To use the netCDF libraries, ensure that the paths to these libraries
are set correct in your login scripts as well as all Makefiles.
Additional libraries required by each of the supported post-processing packages:
· NCL (http://www.ncl.ucar.edu)
· GrADS (http://grads.iges.org/home.html)
· Vis5D (http://www.ssec.wisc.edu/~billh/vis5d.html)
·
GEMPAK
(http://my.unidata.ucar.edu/content/software/gempak/index.html)
·
VAPOR
(http://www.vapor.ucar.edu)
NCL
With the use of NCL Libraries (http://www.ncl.ucar.edu), WRF-ARW data can easily be displayed.
The information on these pages has been put together to help users generate NCL scripts to display their WRF-ARW model data.
Some example scripts are available online (http://www2.mmm.ucar.edu/wrf/OnLineTutorial/Graphics/NCL/NCL_examples.htm), but in order to fully utilize the functionality of the NCL Libraries, users should adapt these for their own needs, or write their own scripts.
NCL can process WRF ARW static, input and output files, as well as WRF-Var output data. Both single and double precision data can be processed.
What is NEW?
In July 2007, the WRF-NCL processing scripts have been incorporated into
the NCL Libraries,
thus only the NCL Libraries, are now needed. NCL version 4.3.1 or higher is required. (NOTE: Since the release of NCL version 4.3.1, the WRFUserARW.ncl script incorporated in the NCL libraries has
been updated significantly, and users should get a new version of this script
from the WRF-ARW web
site - http://www2.mmm.ucar.edu/wrf/OnLineTutorial/Graphics/NCL/Examples/WRFUserARW.ncl).
With the NCL version 4.3.1 release all WRF related functions / procedures needed to plot WRF-ARW are now located in "$NCARG_ROOT/lib/ncarg/nclscripts/wrf/WRFUsersARW.ncl".
All the FORTRAN subroutines used for diagnostics and interpolation (previously located in wrf_user_fortran_util_0.f) has been re-coded into NCL in-line functions. This means users no longer need to compile these routines.
What is NCL
The NCAR Command Language (NCL) is a free interpreted language designed specifically for scientific data processing and visualization. NCL has robust file input and output. It can read in netCDF, HDF4, HDF4-EOS, GRIB, binary and ASCII data. The graphics are world class and highly customizable.
It runs on many different operating systems including
Solaris, AIX, IRIX, Linux, MacOSX, Dec Alpha, and Cygwin/X running on Windows.
The NCL binaries are freely available at: http://www.ncl.ucar.edu/Download/
To read more about NCL, visit: http://www.ncl.ucar.edu/overview.shtml
Necessary software
NCL libraries, version 4.3.1 or higher. Version 5.0.0 is
recommended.
Environment Variable
Set the environment variable NCARG_ROOT to the location where you installed the NCL libraries. Typically (for cshrc shell):
setenv
NCARG_ROOT /usr/local/ncl
.hluresfile
Create a file called .hluresfile in your $HOME directory. This file controls the
color / background / fonts and basic size of your plot. For more information
regarding this file, see: http://www.ncl.ucar.edu/Document/Graphics/hlures.shtml.
NOTE: This file
must reside in your $HOME directory and not where you plan on running NCL.
Below is the .hluresfile used in the example scripts posted on the web (scripts are
available at: http://www2.mmm.ucar.edu/wrf/users/graphics/NCL/NCL.htm).
If a different color table is used, the plots will appear different. Copy the
following to your ~/.hluresfile. (A copy of this file is available at: http://www2.mmm.ucar.edu/wrf/OnLineTutorial/Graphics/NCL/.hluresfile)
*wkColorMap
: BlAqGrYeOrReVi200
*wkBackgroundColor
: white
*wkForegroundColor
: black
*FuncCode
: ~
*TextFuncCode
: ~
*Font
: helvetica
*wkWidth
: 900
*wkHeight
: 900
NOTE:
If your image has a black background with white lettering, your .hluresfile has not been created correctly, or it is in the wrong location.
wkColorMap, as set in your
.hluresfile can be overwritten in any NCL script with the use of the function “gsn_define_colormap”, so you do not need to change your .hluresfile
if you just want to change the color map for a single plot.
Create NCL scripts
The basic outline of any NCL
script will look as follows:
|
load external functions and
procedures begin ; Open input file(s) ; Open graphical output ; Read variables ; Set up plot resources & Create plots ; Output graphics end |
For example, let’s create a script to plot Surface Temperature, Sea Level Pressure and Wind as shown in the picture below.
|
;
load functions and procedures load
"$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_code.ncl" load
"$NCARG_ROOT/lib/ncarg/nclscripts/wrf/WRFUserARW.ncl" begin ;
WRF ARW input file a
= addfile("../wrfout_d01_2000-01-24_12:00:00.nc","r") ;
Output on screen. Output will be called "plt_Surface1" type
= "x11" wks
= gsn_open_wks(type,"plt_Surface1") ;
Set basic resources res
= True res@MainTitle
= "REAL-TIME WRF" ; Give
plot a main title res@Footer
= False
; Set Footers off ;---------------------------------------------------------------
times
= wrf_user_list_times(a)
; get times in the file it
= 0
; only interested in
first time
res@TimeLabel
= times(it)
; keep some time information
;--------------------------------------------------------------- ;
Get variables slp
= wrf_user_getvar(a,"slp",it)
Get slp
wrf_smooth_2d( slp, 3 )
; Smooth slp tc2
= t2-273.16
; Convert to deg C tf2
= 1.8*tc2+32.
; Convert to deg F
tf2@description = "Surface Temperature"
tf2@units = "F" u10
= wrf_user_getvar(a,"U10",it)
; Get U10
v10
= wrf_user_getvar(a,"V10",it)
; Get V10 u10
= u10*1.94386
; Convert to knots v10
= v10*1.94386
u10@units = "kts"
v10@units = "kts" ;---------------------------------------------------------------
opts
= res
; Add basic resources opts@cnFillOn
= True
; Shaded plot opts@ContourParameters
= (/ -20., 90., 5./) ;
Contour intervals
opts@gsnSpreadColorEnd
= -3 contour_tc
= wrf_contour(a,wks,tf2,opts)
; Create plot delete(opts)
;
Plotting options for SLP opts
= res
; Add basic resources opts@cnLineColor
= "Blue"
; Set line color opts@cnHighLabelsOn
= True
; Set labels opts@cnLowLabelsOn
= True opts@ContourParameters
= (/ 900.,1100.,4./) ;
Contour intervals contour_psl
= wrf_contour(a,wks,slp,opts) ;
Create plot
delete(opts)
;
Plotting options for Wind Vectors opts
= res
; Add basic resources opts@FieldTitle
= "Winds"
; Overwrite the field title opts@NumVectors
= 47
; Density of wind barbs vector
= wrf_vector(a,wks,u10,v10,opts)
; Create plot delete(opts) ;
MAKE PLOTS plot
= wrf_map_overlays(a,wks, \ ;--------------------------------------------------------------- end |
Extra sample scripts are available at, http://www2.mmm.ucar.edu/wrf/OnLineTutorial/Graphics/NCL/NCL_examples.htm
Run NCL scripts
1.
Ensure NCL is successfully installed on your computer.
2.
Ensure that the environment variable NCARG_ROOT is set to the
location where NCL is installed on your computer. Typically (for cshrc
shell), the command will look as follows:
setenv
NCARG_ROOT /usr/local/ncl
3. Create an NCL plotting script.
4. Run the NCL script you created:
ncl NCL_script
The output type created with this command is controlled by the line:
wks = gsn_open_wk
(type,"Output")
; inside the NCL script
where type can be x11,
pdf, ncgm, ps, or eps
For high quality images, create pdf / ps or eps images
directly via the ncl scripts (type = pdf / ps / eps)
See the Tools section at the end of this chapter for more information concerning other types of graphical formats and conversions between graphical formats.
Functions / Procedures under "$NCARG_ROOT/lib/ncarg/nclscripts/wrf/" (WRFUserARW.ncl)
function wrf_user_getvar (nc_file,
fld, it)
Usage: ter = wrf_user_getvar (a, “HGT”,
0)
Get fields from netCDF file for any given time.
Currently only a single time can be extracted with each
call to wrf_user_getvar.
Any field available in the netCDF file can be extracted.
fld is case sensitive. The policy adapted during development was to set all diagnostic variables calculated by NCL to lower-case to distinguish them from fields directly available from the netCDF files.
List of available diagnostics (currently most of these
only work of wrfout files):
th –
Potential Temperature (K)
tk –
Temperature (K)
tc – Temperature (C)
td – Dewpoint Temperature (C)
td2 –
2m Dewpoint Temperature (C)
rh – Relative Humidity (%)
slp –
Sea Level Pressure (hPa)
pressure – Full model
pressure (hPa)
z -
Geopotential Height (m)
ua -
U-component of the wind on mass points (un-staggered)
va -
V-component of the wind on mass points (un-staggered)
wa -
W-component of the wind on mass points (un-staggered)
uvmet –
winds rotated to earth coordinates. Used specifically for sounding and to
compare model winds to observations. This diagnostics is unique as it returns a
4D field, where uvmet(0,:,:,:) contains the U-component and uvmet(1,:,:,:)
contains the V-component of the wind (un-staggered).
function wrf_user_list_times
(nc_file)
Usage: times = wrf_user_list_times
(a)
Obtain a list of times available in the input file. The function returns a 1D array containing the times (type: character) in the input file.
function wrf_contour (nc_file, wks, data, res)
Usage: contour = wrf_contour
(a, wks, ter, opts)
Returns a graphic (contour), of the data to be contoured. This graphic is only created, but not plotted to a wks. This enables a user to generate many such graphics and overlay them before plotting the resulting picture to a wks.
The returned graphic (contour) does not contain map information, and can therefore be used for both real and idealized data cases.
This function can plot both line contours and shaded
contours. Default is line contours.
Many resources are set for a user, of which most can be overwritten. Below is a list of resources you may want to consider changing before generating your own graphics:
opts@MainTitle :
Controls main title on the plot.
opts@MainTitlePos : Main title
position – Left/Right/Center. Default is Left.
opts@NoHeaderFooter : Switch off all Headers and Footers.
opts@Footer : Add some model information to the plot as a footer. Default is True.
opts@InitTime : Plot initial time on graphic. Default is True. If True, the initial time will be extracted from the input file.
opts@ValidTime : Plot valid time on graphic. Default is True. A user must set opts@TimeLabel to the correct time.
opts@TimeLabel : Time to plot as valid time.
opts@TimePos : Time
position – Left/Right. Default is “Right”.
opts@cnFillOn : Set to True for shaded plots. Default is False.
opts@ContourParameters : A single value is treated as an interval. Three values represent: Start, End, and Interval.
opts@cnLineColor : Color of line plot.
opts@FieldTitle : Overwrite the field title.
opts@lbTitleOn : Set to False to switch the title on the label bar off. Default is True.
optr@cnLevelSelectionMode
; opts @cnLevels ; opts@cnFillColors ; optr@cnConstFLabelOn : Can be used to set contour levels and colors
manually.
function wrf_vector (nc_file, wks, data_u, data_v, res)
Usage: vector = wrf_vector
(a, wks, ua, va, opts)
Returns a graphic (vector) of the data. This graphic is only created, but not plotted to a wks. This enables a user to generate many graphics and overlay them before plotting the resulting picture to a wks.
The returned graphic (vector) does not contain map information, and can therefore be used for both real and idealized data cases.
Many resources are set for a user, of which most can be overwritten. Below is a list of resources you may want to consider changing before generating your own graphics:
opts@MainTitle
; opts@MainTitlePos ; opts@NoHeaderFooter ; opts@Footer ; opts@InitTime ;
opts@ValidTime ; opts@TimeLabel ; opts@TimePos ; opts@FieldTitle : Applies and are the same as described for wrf_contour.
opts@NumVectors : Density of wind vectors.
opts@vcGlyphStyle : Wind style. “WindBarb” is default.
function wrf_map_overlays (nc_file, wks, (/graphics/),
pltres, mpres)
Usage: plot = wrf_map_overlays (a, wks, (/contour,vector/), pltres, mpres)
Overlay contour and vector plots generated with wrf_contour and wrf_vector. Can overlay any number of graphics. Overlays will be done in order give, so always list shaded plots before line or vector plots, to ensure the lines and vectors are visible and not hidden behind the shaded plot.
A map background will automatically be added to the plot. Map details are controlled with the mpres resource. Common map resources you may want to set are:
mpres@mpGeophysicalLineColor
; mpres@mpNationalLineColor ; mpres@mpUSStateLineColor ; mpres@mpGridLineColor
; mpres@mpLimbLineColor ; mpres@mpPerimLineColor
If you want to zoom into the plot, set mpres@ZoomIn to True, and mpres@Xstart, mpres@Xend, mpres@Ystart, mpres@Yend, to the corner x/y positions of the zoomed plot.
pltres@NoTitles : Set to True to remove all field titles on a plot.
pltres@CommonTitle : Overwrite field titles with a common title for the overlaid plots. Must set pltres@PlotTitle to desired new plot title.
If you want to generate images for a panel plot, set pltres@PanelPot to True.
If you want to add text/lines to the plot before advancing the frame, set pltres@FramePlot to False. Add your text/lines directly after the call to the wrf_map_overlays function. Once you are done adding text/lines, advance the frame with the command “frame(wks)”.
function wrf_overlays (nc_file, wks, (/graphics/),
pltres)
Usage: plot = wrf_overlays (a, wks, (/contour,vector/), pltres)
Overlay contour and vector plots generated with wrf_contour and wrf_vector. Can overlay any number of graphics. Overlays will be done in order give, so always list shaded plots before line or vector plots, to ensure the lines and vectors are visible and not hidden behind the shaded plot.
Typically used for idealized data or cross-sections, which does not have map background information.
pltres@NoTitles : Set to True to remove all field titles on a plot.
pltres@CommonTitle : Overwrite field titles with a common title for the overlaid plots. Must set pltres@PlotTitle to desired new plot title.
If you want to generate images for a panel plot, set pltres@PanelPot to True.
If you want to add text/lines to the plot before advancing the frame, set pltres@FramePlot to False. Add your text/lines directly after the call to the wrf_overlays function. Once you are done adding text/lines, advance the frame with the command “frame(wks)”.
function wrf_map (nc_file, wks, res)
Usage: map =
wrf_map (a, wks, opts)
Create a map background.
As maps are added to plots automatically via the wrf_map_overlays function, this function is seldom needed as a stand-alone.
function wrf_user_intrp3d
(var3d, H, plot_type, loc_param, angle, res)
This function is used for both horizontal and vertical interpolation.
var3d: The variable to interpolate.
H: The field to interpolate to. Either pressure or z.
plot_type: “h” for horizontally and “v” for vertically interpolated plots.
loc_param: Can be a scalar, or an array
holding either 2 or 4 values.
For plot_type = “h”, this is a
scalar representing the level to interpolate too, i.e., 500 to interpolate to
500 hPa; or 2000 to interpolate to 2 km.
For plot_type = “v”: This can be
a pivot point though which a line is drawn – in this case a single x/y point (2
values) is required. Or this can be a set
of x/y points (4 values),
indicating start x/y and end x/y locations for the cross-section.
angle: Set to 0., for plot_type = “h”, or for plot_type = “v” when start and end locations of cross-section
were supplied in loc_param.
If a single pivot point was supplied in loc_param, angle
is the angle of the line that will pass through the pivot point. Where: 0. is
SN, and 90. is WE.
res: Set to False for plot_type = “h”, or for plot_type = “v” when a single pivot point is supplied. Set to True if start and end locations is supplied.
function wrf_user_intrp2d (var2d, loc_param, angle, res)
This function interpolates a 2D field along a given line.
var2d: Is the 2D field to interpolate.
loc_param: Is an array holding either 2 or
4 values.
This can be a pivot point though which a line is drawn – in this case a single
x/y point (2 values) is required.
Or this can be a set of x/y points (4 values), indicating start x/y and end x/y locations for the
cross-section.
angle: Set to 0 when start and end
locations of the line were supplied in loc_param.
If a single pivot point was supplied in loc_param, angle
is the angle of the line that will pass through the pivot point. Where: 0. is
SN, and 90. is WE.
res: Set to False when a single pivot point is supplied. Set to True if start and end locations is supplied.
function wrf_user_latlon_to_ij (nc_file, lats, lons)
Usage: loc = wrf_user_latlon_to_ij (a, 40., 100.)
Usage: loc =
wrf_user_latlon_to_ij (a, (/40., 50./), (/100., 120./) )
Convert a lon/lat location to the nearest x/y location. Note: no interpolation is done, only the closest grid point will be returned.
lats/lons can be scalars or arrays.
loc(:,0) is the y (SN) location, and loc(:,1) the x (WE) location.
Adding diagnostics using FORTRAN code
It is possible to link your favorite FORTRAN diagnostics routines to NCL. It is easier to use FORTRAN 77 code, but NCL does recognize basic FORTRAN 90 code.
Let’s use a routine that calculated temperature (K) from theta and pressure.
|
FORTRAN 90 routine called myTK.f90 |
|
subroutine compute_tk (tk, pressure, theta, nx, ny, nz)
!! Variables
integer :: nx, ny, nz real, dimension (nx,ny,nz) :: tk, pressure, theta !! Local Variables
integer :: i, j, k |
For simple routines like this, it is easiest to re-write the routine into a FORTRAN 77 routine.
|
FORTRAN 77 routine called myTK.f |
|
subroutine compute_tk
(tk, pressure, theta, nx, ny, nz)
C Variables integer nx, ny, nz real tk(nx,ny,nz) , pressure(nx,ny,nz), theta(nx,ny,nz) C Local Variables integer i, j, k DO k=1,nz ENDDO return |
Add the markers NCLFORTSTART and NCLEND to the subroutine as indicated below. Note, that local variables are outside these block markers.
|
FORTRAN 77 routine called myTK.f, with NCL markers
added |
|
C NCLFORTSTART subroutine compute_tk
(tk, pressure, theta, nx, ny, nz)
C Variables integer nx, ny, nz real tk(nx,ny,nz) , pressure(nx,ny,nz), theta(nx,ny,nz) C NCLEND C Local Variables integer i, j, k DO k=1,nz ENDDO return |
Now compile this code using the NCL script WRAPIT.
WRAPIT
myTK.f
NOTE: If WRAPIT cannot be found, make sure the environment variable NCARG_ROOT has been set correctly.
If the subroutine compiles successfully, a new library will be created, called myTK.so. This library can be linked to an NCL script to calculate TK. See how this is done in the example below:
|
load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_code.ncl" load
"$NCARG_ROOT/lib/ncarg/nclscripts/wrf/WRFUserARW.ncl”
begin
t
= wrf_user_getvar (a,”T”,5) p = wrf_user_getvar
(a,”pressure”,5) dim
= dimsizes(t) tk
= new( (/ dim(0), dim(1), dim(2) /), float) myTK
:: compute_tk (tk, p, theta, dim(2), dim(1), dim(0)) end |
Want to use the FORTRAN 90 program? It is possible to do so
by providing an interface block for your FORTRAN 90 program. Your FORTRAN 90
program may also not contain any of the following features:
-
pointers or structures as arguments,
-
missing/optional arguments,
-
keyword arguments, or
-
if the procedure is recursive.
|
Interface block for FORTRAN 90 code, called myTK90.stub |
|
C NCLFORTSTART subroutine compute_tk (tk, pressure, theta, nx, ny, nz) integer nx, ny, nz real tk(nx,ny,nz) , pressure(nx,ny,nz), theta(nx,ny,nz) C NCLEND |
Now compile this code using the NCL script WRAPIT.
WRAPIT
myTK90.stub myTK.f90
NOTE: You may need to copy the WRAPIT script to a locate location and edit it to point to a FORTRAN 90 compiler.
If the subroutine compiles successfully, a new library will be created, called myTK90.so (note the change in name from the FORTRAN 77 library). This library can similarly be linked to an NCL script to calculate TK. See how this is done in the example below:
|
load "$NCARG_ROOT/lib/ncarg/nclscripts/csm/gsn_code.ncl" load
"$NCARG_ROOT/lib/ncarg/nclscripts/wrf/WRFUserARW.ncl”
begin
t
= wrf_user_getvar (a,”T”,5) p = wrf_user_getvar
(a,”pressure”,5) dim
= dimsizes(t) tk
= new( (/ dim(0), dim(1), dim(2) /), float)
myTK90 ::
compute_tk (tk, p, theta, dim(2), dim(1), dim(0)) end |
RIP4
RIP (which stands for Read/Interpolate/Plot)
is a Fortran program that invokes NCAR Graphics routines for the purpose of
visualizing output from gridded meteorological data sets, primarily from
mesoscale numerical models. It was originally designed for
sigma-coordinate-level output from the PSU/NCAR Mesoscale Model (MM4/MM5), but
was generalized in April 2003 to handle data sets with any vertical coordinate,
and in particular, output from the Weather Research and Forecast (WRF) modeling
system. It can also be used to visualize model input or analyses on model
grids. It has been under continuous development since 1991, primarily by
Mark Stoelinga at both NCAR and the University of Washington.
The RIP users' guide (http://www2.mmm.ucar.edu/wrf/users/docs/ripug.htm) is essential reading.
Code history
Version 4.0: reads WRF-ARW real output files
Version 4.1: reads idealized WRF-ARW datasets
Version 4.2: reads all the files produced by WPS
Version 4.3: reads files produced by WRF-NMM model
(This document will only concentrate on running RIP4 for WRF-ARW. For
details on running RIP4 for WRF-NMM, see the WRF-NMM User’s Guide:
http://www.dtcenter.org/wrf-nmm/users/docs/user_guide/WPS/index.php)
Necessary software
RIP4 only
requires low level NCAR Graphics libraries. These libraries have been merged
with the NCL libraries since the release of NCL version 5 (http://www.ncl.ucar.edu/), so if you
don’t already have NCAR Graphics installed on your computer, install NCL
version 5.
Obtain the code from the WRF-ARW user’s web site:
http://www2.mmm.ucar.edu/wrf/users/download/get_source.html
Unzip and untar the RIP4 tar file. The tar file contains the following
directories and files:
- CHANGES, a text file that logs changes to the RIP tar file.
- Doc/, a directory that contains documentation of RIP, most notably the Users' Guide (ripug).
- Makefile, the top-level make file used to compile and link RIP.
- README, a text file containing basic information on running RIP.
- color.tbl, a file that contains a table defining the colors you want to have available for RIP plots.
- eta_micro_lookup.dat, a file that contains "look-up" table data for the Ferrier microphysics scheme.
- psadilookup.dat, a file that contains "look-up" table data for obtaining temperature on a pseudoadiabat.
- sample_infiles/, a directory that contains sample user input files for RIP and related programs.
- src/, a directory that contains all of the source
code files for RIP, RIPDP, and several other utility programs.
- stationlist, a file containing observing station location
information.
Environment Variables
An important environment variable for the RIP system is RIP_ROOT.
RIP_ROOT should be assigned the path name of the directory where all your RIP
program and utility files (color.tbl, stationlist, lookup tables, etc.) reside.
Typically (for cshrc shell):
setenv
RIP_ROOT /my-path/RIP4
The RIP_ROOT environment variable can also be overwritten with the variable rip_root in the RIP user input file (UIF).
A second environment variable you need to set is NCARG_ROOT.
Typically (for cshrc shell):
setenv
NCARG_ROOT /usr/local/ncarg ! for NCARG V4
setenv NCARG_ROOT /usr/local/ncl ! for NCL V5
Compiling RIP and associated programs
Typing "make" will produce a list of available compile options (the list shown below is just a sample of what is available):
|
make dec make linux make intel make sun make sgi make ibm make cray make clean make clobber |
To Run on
DEC_ALPHA To Run on LINUX
with PGI compiler To Run on LINUX
with INTEL compiler To Run on SUN To Run on SGI To Run on IBM
SP2 To Run on
NCAR's Cray to remove
object files to remove
object files and executables |
Pick the compiler option for the machine you are working on
and type:
"make machine"
e.g. make linux
will compile the code for a Linux computer running PGI compiler.
After a successful compilation, the following new files
should be created.
|
rip |
RIP post-processing program. |
|
ripcomp |
This program reads in two rip data files and compares their contents. |
|
ripdp_mm5 |
RIP Data Preparation program for MM5 data |
|
ripdp_wrfarw |
RIP Data Preparation program for WRF data |
|
ripinterp |
This program reads in model output (in rip-format files) from a coarse domain and from a fine domain, and creates a new file which has the data from the coarse domain file interpolated (bi-linearly) to the fine domain. The header and data dimensions of the new file will be that of the fine domain, and the case name used in the file name will be the same as that of the fine domain file that was read in. |
|
ripshow |
This program reads in a rip data file and prints out the contents of the header record. |
|
showtraj |
Sometimes, you may want to examine the contents of a trajectory position file. Since it is a binary file, the trajectory position file cannot simply be printed out. showtraj, reads the trajectory position file and prints out its contents in a readable form. When you run showtraj, it prompts you for the name of the trajectory position file to be printed out. |
|
tabdiag |
If fields are specified in the plot specification table for a trajectory calculation run, then RIP produces a .diag file that contains values of those fields along the trajectories. This file is an unformatted Fortran file; so another program is required to view the diagnostics. tabdiag serves this purpose. |
|
upscale |
This program reads in model output (in rip-format files) from a coarse domain and from a fine domain, and replaces the coarse data with fine data at overlapping points. Any refinement ratio is allowed, and the fine domain borders do not have to coincide with coarse domain grid points. |
Preparing data with RIPDP
RIP does not ingest model output files directly. First, a preprocessing step
must be executed that converts the model output data files to RIP-format data
files. The primary difference between these two types of files is that model
output data files typically contain all times and all variables in a single
file (or a few files), whereas RIP data has each variable at each time in a
separate file. The preprocessing step involves use of the program RIPDP (which
stands for RIP Data Preparation). RIPDP reads in a model
output file (or files), and separates out each variable at each time.
Running RIPDP
The program has the following usage:
ripdp_XXX [-n namelist_file] model-data-set-name [basic|all]
data_file_1 data_file_2 data_file_3 ...
In the above, the "XXX" refers to "mm5",
"wrfarw", or "wrfnmm".
The argument model-data-set-name can be any string you choose, that
uniquely defines this model output data set
The use of the namelist file is optional. The most important
information in the namelist, is the times you want to process.
As this step will create a large number of extra files,
creating a new directory to place these files in, will enable you to manage the
files easier (mkdir RIPDP).
e.g.
ripdp_wrfarw RIPDP/arw all wrfout_d01_*
The RIP user input file
Once the RIP data has been created with RIPDP, the next step is to prepare the user input file (UIF) for RIP (see Chapter 4 of the RIP users’ guide for details). This file is a text file, which tells RIP what plots you want and how they should be plotted. A sample UIF, called rip_sample.in, is provided in the RIP tar file. This sample can serve as a template for the many UIFs that you will eventually create.
A UIF is divided into two main sections. The first section specifies various general parameters about the set up of RIP, in a namelist format (userin - which control the general input specifications; and trajcalc - which control the creation of trajectories). The second section is the plot specification section, which is used to specify which plots will be generated.
namelist: userin
|
Variable |
Value |
Description |
|
idotitle |
1 |
Control first part of title. |
|
title |
‘auto’ |
Define your own title, or allow RIP to generate one. |
|
titlecolor |
‘def.foreground’ |
Control color of the title. |
|
iinittime |
1 |
Print initial date and time (in UTC) on plot. |
|
ifcsttime |
1 |
Print forecast lead-time (in hours) on plot. |
|
ivalidtime |
1 |
Print valid date and time (in both UTC and local time) on plot. |
|
inearesth |
0 |
This allows you to have the hour portion of the initial and valid time be specified with two digits, rounded to the nearest hour, rather than the standard 4-digit HHMM specification. |
|
timezone |
-7.0 |
Specifies the offset from Greenwich time. |
|
iusdaylightrule |
1 |
Flag to determine if US daylight saving should be applied. |
|
ptimes |
9.0E+09 |
Times to process. |
|
ptimeunits |
‘h’ |
Time units. This can be ‘h’ (hours), ‘m’ (minutes), or ‘s’ (seconds). Only valid with ptimes. |
|
iptimes |
99999999 |
Times to process. This is an integer array that specifies desired times for RIP to plot, but in the form of 8-digit "mdate" times (i.e. YYMMDDHH). Either ptimes or iptimes can be used, but not both. You can plot all available times, by omitting both ptimes and iptimes from the namelist, or by setting the first value negative. |
|
tacc |
1.0 |
Time tolerance in seconds. |
|
flmin, flmax, fbmin, ftmax |
.05, .95, |
Left, right, |
|
ntextq |
0 |
Text quality specifier (0=high; 1=medium; 2=low). |
|
ntextcd |
0 |
Text font specifier [0=complex (Times); 1=duplex (Helvetica)]. |
|
fcoffset |
0.0 |
This is an optional parameter you can use to "tell" RIP that you consider the start of the forecast to be different from what is indicated by the forecast time recorded in the model output. Examples: fcoffset=12 means you consider hour 12 in the model output to be the beginning of the true forecast. |
|
idotser |
0 |
Generate time series output files (no plots) only an ASCII file that can be used as input to a plotting program. |
|
idescriptive |
1 |
Use more descriptive plot titles. |
|
icgmsplit |
0 |
Split metacode into several files. |
|
maxfld |
10 |
Reserve memory for RIP. |
|
ittrajcalc |
0 |
Generate trajectory output files (use namelist trajcalc when this is set). |
|
imakev5d |
0 |
Generate output for Vis5D |
|
ncarg_type |
‘cgm’ |
Output type required. Options are ‘cgm’ (default), ‘ps’, ‘pdf’, ‘pdfL’, ‘x11’. Where ‘pdf’ is portrait and ‘pdfL’ is landscape. |
|
istopmiss |
1 |
This switch determines the behavior for RIP when a user-requested field is not available. The default is to stop. Setting the switch to 0 tells RIP to ignore the missing field and to continue plotting. |
|
rip_root |
‘/dev/null’ |
Overwrite the environment variable RIP_ROOT. |
Plot Specification Table
The second part of the RIP UIF consists of the Plot Specification Table. The
PST provides all of the user control over particular aspects of individual
frames and overlays.
The basic structure of the PST is as follows:
· The first line of the PST is a line of consecutive equal signs. This line as well as the next two lines is ignored by RIP, it is simply a banner that says this is the start of the PST section.
· After that there are several groups of one or more lines separated by a full line of equal signs. Each group of lines is a frame specification group (FSG), and it describes what will be plotted in a single frame of metacode. Each FSG must end with a full line of equal signs, so that RIP can determine where individual frames starts and ends.
·
Each line within a FGS is referred to as a plot
specification line (PSL). A FSG that consists of three PSL lines will result in
a single metacode frame with three overlaid plots.
|
Example of a frame specification groups (FSG's): ============================================== feld=tmc; ptyp=hc; vcor=p; levs=850; > cint=2; cmth=fill;
cosq=-32,light.violet,-24,
16,orange,24,brown,32,light.gray feld=ght; ptyp=hc; cint=30; linw=2
feld=uuu,vvv; ptyp=hv; vcmx=-1;
colr=white; intv=5 feld=map; ptyp=hb feld=tic; ptyp=hb _=============================================== |
This FSG will generate 5 frames to
create a single plot (as shown below):
· Temperature in degrees C (feld=tmc). This will be plotted as a horizontal contour plot (ptyp=hc), on pressure levels (vcor=p). The data will be interpolated to 850 hPa. The contour intervals are set to 2 (cint=2), and shaded plots (cmth=fill) will be generated with a color range from light violet to light gray.
· Geopotential heights (feld=ght) will also be plotted as a horizontal contour plot. This time the contour intervals will be 30 (cint=30), and contour lines, with a line width of 2 (linw=2) will be used.
· Wind vectors (feld=uuu,vvv), plotted as barbs (vcmax=-1).
· A map background will be displayed (feld=map), and
· Tic marks will be placed on the plot (feld=tic).
Running RIP
Each execution of RIP requires three basic things: a RIP executable, a model data set and a user input file (UIF). The syntax for the executable, rip, is as follows:
rip [-f] model-data-set-name rip-execution-name
In the above, model-data-set-name is the same model-data-set-name that was used in creating the RIP data set with the program ripdp.
rip-execution-name is the unique name for this RIP execution, and it also defines the name of the UIF that RIP will look for.
The –f option causes the standard output (i.e., the textual print out) from RIP to be written to a file called rip-execution-name.out. Without the –f option, the standard output is sent to the screen.
e.g. rip -f RIPDP/arw
rip_sample
If this is successful, the following files will be created:
rip_sample.TYPE -
metacode file with requested plots
rip_sample.out -
log file (if –f used) ; view this file if a problem occurred
The default output TYPE is ‘cgm’, metacode file. To view these, use the command ‘idt’.
e.g.
idt rip_sample.cgm
For high quality images, create pdf or ps images directly (ncarg_type
= pdf / ps).
See the Tools section at the end of this chapter for more information concerning other types of graphical formats and conversions between graphical formats.
Examples of plots created for both idealized and real cases
are available from:
http://www2.mmm.ucar.edu/wrf/users/graphics/RIP4/RIP4.htm
ARWpost
The ARWpost package reads in WRF-ARW model data and creates output in either GrADS or Vis5D format.
The converter can read in WPS geogrid and metgrid data, and WRF-ARW input and output files.
The package makes use of the WRF IO API. The netCDF format has been tested extensively. GRIB1 format has been tested, but not as extensively. BINARY data cannot be read at the moment.
Necessary software
GrADS software - you can download and install GrADS from http://grads/iges.org/grads. The GrADS software is not needed to compile and run
ARWpost.
Vis5D software (http://www.ssec.wisc.edu/~billh/vis5d.html)
Vis5D libraries must be installed to compile and run the ARWpost code, when creating Vis5D input data. If Vis5D files are not being created, these libraries are NOT needed to compile and run ARWpost.
Obtain the ARWpost TAR file from the WRF Download page (http://www2.mmm.ucar.edu/wrf/users/download/get_source.html)
WRFV3 must be installed and available somewhere, as ARWpost
makes use of the common IO API libraries from WRFV3.
Unzip and untar the ARWpost tar file.
The tar file contains the following directories and files:
- README, a text file containing basic information on running ARWpost.
- arch/,
directory containing configure and
compilation control.
- clean,
a script to clean compiled code.
- compile, a script to compile the code.
- configure, a script to configure the compilation for your
system.
- namelist.ARWpost,
namelist to control the running of the
code.
- src/, directory containing all source code.
- scripts/, directory containing some grads sample
scripts.
- gribinfo.txt
& gribmap.txt, files
needed to process GRIB1 data. Do not edit these files.
- util/, a directory containing some utilities.
Environment Variables
Set the environment variable NETCDF to the location where your netCDF libraries are installed. Typically (for cshrc shell):
setenv
NETCDF /usr/local/netcdf
Configure ARWpost
WRFV3 must be compiled and available on your system.
Type:
./configure
You will see a list of options for your computer (below
is an example for a Linux machine):
Will use NETCDF in dir:
/usr/local/netcdf-pgi
-----------------------------------------------------------
Please select from among the following supported platforms.
1. PC Linux i486 i586 i686, PGI compiler (no vis5d)
2. PC Linux i486 i586 i686, PGI compiler (vis5d)
3. PC Linux i486 i586 i686, Intel compiler (no vis5d)
4. PC Linux i486 i586 i686, Intel compiler (vis5d)
Enter selection [1-4]
Make sure the netCDF path is correct.
Pick compile options for your machine (if you do not have Vis5D, or if you do not plan on using it, pick an option without Vis5D libraries).
Compile ARWpost
If your WRFV3 code is NOT compiled under ../WRFV3, edit configure.arwp, and set "WRF_DIR" to the correct location of your WRFV3 code.
Type:
./compile
If successful, the executable ARWpost.exe will be created.
Edit the namelist.ARWpost file
Set input and output file names and fields to process (&io)
|
Variable |
Value |
Description |
|
|
||
|
start_date; end_date |
- |
Start and end dates to process. |
|
interval_seconds |
0 |
Interval in seconds between data to process. If data is available every hour, and this is set to every 3 hours, the code will skip past data not required. |
|
tacc |
0 |
Time tolerance in seconds. |
|
debug_level |
0 |
Set higher to debugging is required. |
|
|
||
|
io_form_input |
- |
2=netCDF, 5=GRIB1 |
|
input_root_name |
./ |
Path and root name of files to use as input. All files starting with the root name will be processed. Wild characters are allowed.
|
|
output_root_name |
./ |
Output root name. When converting data to GrADS, output_root_name.ctl and output_root_name.dat will be created. For Vis5D, output_root_name.v5d will be created.
|
|
output_title |
Title as in WRF file |
Use to overwrite title used in GrADS .ctl file. |
|
mercator_defs |
.False. |
Set to true if mercator plots are distorted. |
|
output_type |
‘grads’ |
Options are ‘grads’ or ‘v5d’ |
|
split_output |
.False. |
Use if you want to split our GrADS output files into a number of smaller files (a common .ctl file will be used for all .dat files). |
|
frames_per_outfile |
1 |
If split_output is
.True., how many time periods are required per output (.dat) file. |
|
plot |
‘all’ |
Which fields to process. ‘list’ – only fields as listed in the ‘fields’ variable. ‘all_list’ – all fields in WRF file and all fields listed
in the ‘fields’ variable. |
|
fields |
- |
Fields to plot. Only used if ‘list’ was used in the ‘plot’ variable. |
|
|
||
|
interp_method |
0 |
0 - sigma levels, -1 - code defined "nice" height levels, 1 - user defined height or pressure levels |
|
interp_levels |
- |
Only used if interp_method=1
|
Available diagnostics:
cape - 3d cape
cin - 3d cin
mcape - maximum cape
mcin - maximum cin
clfr - low/middle
and high cloud fraction
dbz - 3d reflectivity
max_dbz - maximum reflectivity
height - model height in km
lcl - lifting
condensation level
lfc - level of free convection
pressure - full model pressure
in hPa
rh - relative humidity
rh2 - 2m relative humidity
theta - potential temperature
tc - temperature in degrees C
tk - temperature in degrees K
td - dew point temperature in
degrees C
td2 - 2m dew point temperature
in degrees C
slp - sea level pressure
umet and vmet - winds rotated to earth coordinates
u10m and v10m - 10m winds rotated to earth coordinates
wdir - wind direction
wspd - wind speed coordinates
wd10 - 10m wind direction
ws10 - 10m wind speed
Run ARWpost
Type:
./ARWpost.exe
This will create output_root_name.dat and output_root_name.ctl files if creating GrADS input, and output_root_name.v5d, if creating Vis5D input.
NOW YOU ARE READY TO VIEW THE OUTPUT
GrADS
For general information about working with GrADS, view the GrADS home page: http://grads.iges.org/grads/
To help users get started a number of GrADS scripts have been provided:
· The scripts are all available in the scripts/ directory.
· The scripts provided are only examples of the type of plots one can generate with GrADS data.
· The user will need to modify these scripts to suit their data (e.g., if you did not specify 0.25 km and 2 km as levels to interpolate to when you run the "bwave" data through the converter, the "bwave.gs" script will not display any plots, since it will specifically look for these to levels).
·
Scripts must be copied to the location of the input
data.
|
GENERAL SCRIPTS |
|
|
|
|
|
cbar.gs |
Plot color bar on shaded plots (from GrADS home page) |
|
rgbset.gs |
Some extra colors (Users can add/change colors from color number 20 to 99) |
|
skew.gs |
Program to plot a skewT |
|
plot_all.gs |
Once you have opened a GrADS window, all one needs to do is run this script. It will automatically find all .ctl files in the current directory and list them so one can pick which file to open. Then the script will loop through all available fields and plot the ones a user requests. |
|
SCRIPTS FOR REAL DATA |
|
|
|
|
|
real_surf.gs |
Plot some surface data |
|
plevels.gs |
Plot some pressure level fields |
|
rain.gs |
Plot total rainfall |
|
cross_z.gs |
Need z level data as input |
|
zlevels.gs |
Plot some height level fields |
|
input.gs |
Need WRF INPUT data on height levels |
|
SCRIPTS FOR IDEALIZED DATA |
|
|
|
|
|
bwave.gs |
Need height level data as input |
|
grav2d.gs |
Need normal model level data |
|
hill2d.gs |
Need normal model level data |
|
qss.gs |
Need height level data as input. |
|
sqx.gs |
Need normal model level data a input |
|
sqy.gs |
Need normal model level data a input |
Examples of plots created for both idealized and real cases
are available from:
http://www2.mmm.ucar.edu/wrf/users/graphics/ARWpost/ARWpost.htm
Trouble Shooting
The code executes correctly, but you get "NaN"
or "Undefined Grid" for
all fields
when displaying the data.
Look in the .ctl file.
a) If the second line is:
options byteswapped
Remove this line from your .ctl file and try to display the data again.
If this SOLVES the problem, you need to remove the -Dbytesw
option from configure.arwp
b) If the line below does NOT appear in your .ctl file:
options byteswapped
ADD this line as the second line in the .ctl file.
Try to display the data again.
If this SOLVES the problem, you need to ADD the -Dbytesw
option for configure.arwp
The line "options byteswapped" is often needed on some computers (DEC alpha as an example). It is also often needed if you run the converter on one computer and use another to display the data.
Vis5D
For general information about working with Vis5D, view the Vis5D home page: http://www.ssec.wisc.edu/~billh/vis5d.html
WPP
The NCEP WRF Postprocessor was designed to interpolate both
WRF-ARW and WRF-NMM output from their native grids to National Weather Service
(NWS) standard levels (pressure, height, etc.) and standard output grids (AWIPS, Lambert Conformal,
polar-stereographic, etc.) in NWS and World
Meteorological Organization (WMO) GRIB1 format. This package also provides an
option to output fields on the model’s native vertical levels.
The adaptation of the original WRF Postprocessor package and
User’s Guide (by Mike Baldwin of NSSL/CIMMS and Hui-Ya Chuang of NCEP/EMC) was
done by Lígia Bernardet (NOAA/ESRL/DTC) in collaboration with Dusan Jovic
(NCEP/EMC), Robert Rozumalski (COMET), Wesley Ebisuzaki (NWS/HQTR), and Louisa
Nance (NCAR/DTC). Upgrades to WRF Postprocessor versions 2.2 and higher were
performed by Hui-Ya Chuang and Dusan Jovic (NCEP/EMC).
This document will mainly deal with running the WPP package
for the WRF-ARW modeling system. For details on running the package for the
WRF-NMM system, please refer to the WRF-NMM User’s Guide (http://www.dtcenter.org/wrf-nmm/users/docs/user_guide/WPS/index.php).
Necessary software
The WRF Postprocessor requires the same Fortran and C
compilers used to build the WRF model.
In addition to the netCDF library, the WRF I/O API libraries, which are
included in the WRF model tar file, are also required.
The WRF Postprocessor has some visualization scripts
included to create graphics using either GrADS (http://grads.iges.org/home.html)
or GEMPAK (http://my.unidata.ucar.edu/content/software/gempak/index.html). These packages are not part of the WPP installation and
would need to be installed.
The WRF Postprocessor package can be downloaded from: http://www.dtcenter.org/wrf-nmm/users/downloads/
Once the tar file is obtained, gunzip and untar the file.
tar
–xvf wrfpostproc_v3.0.tar.gz
This command will create a directory called WPPV3. Under the
main directory, there are five subdirectories:
- sorc/, contains source codes for wrfpost, ndate, and copygb.
- scripts/, contains sample running scripts
run_wrfpost: run wrfpost and copygb.
run_wrfpostandgempak: run wrfpost, copygb, and GEMPAK to plot various
fields.
run_wrfpostandgrads: run wrfpost, copygb, and GrADS to plot various
fields.
run_wrfpost_frames: run wrfpost and copygb on a single wrfout file containing
multiple forecast times.
- lib/, contains source code subdirectories for the WRF Postprocessor
libraries and is the directory where the WRF Postprocessor compiled
libraries will reside.
w3lib: Library for coding and decoding data in GRIB
format. (Note:
The version of this library included in this package is Endian independent and
can be used on LINUX and IBM systems.)
iplib: General interpolation library (see lib/iplib/iplib.doc)
splib: Spectral transform library (see lib/splib/splib.doc)
wrfmpi_stubs: Contains some C and FORTRAN codes to generate the libmpi.a library. It supports MPI
implementation for LINUX applications.
- parm/, contains the parameter files, which can be
modified by the user to control how the post processing is performed.
- exec/, location of executables after compilation.
Building the WPP Code
Type configure, and provide the required info. For example:
./configure
Please select from
the following supported platforms.
1. LINUX (PC)
2. AIX (IBM)
Enter selection
[1-2]: 1
Enter your NETCDF
path: /usr/local/netcdf-pgi
Enter your WRF model
source code path: /home/user/WRFV3
"YOU HAVE
SELECTED YOUR PLATFORM TO BE:" LINUX
To modify the default compiler options, edit the appropriate
platform specific makefile (i.e. makefile_linux or makefile_ibm) and repeat the configure process.
From the WPPV3
directory, type:
make >& compile_wpp.log &
This command should create four WRF Postprocessor libraries
in lib/ (libmpi.a,
libsp.a, libip.a, and
libw3.a) and three
WRF Postprocessor executables in exec/ (wrfpost.exe, ndate.exe, and copygb.exe).
Note: The makefile included in the tar file
currently only contains the setup for single processor compilation of wrfpost for LINUX. Those users wanting to implement the
parallel capability of this portion of the package will need to modify the
compile options for wrfpost in the makefile.
WPP Functionalities
The WRF Postprocessor v3.0,
· is compatible with WRF version 2.2 and higher.
· can be used to post-process both WRF-ARW and WRF-NMM forecasts.
· can ingest WRF history files (wrfout*) in two formats: netCDF and binary.
The WRF Postprocessor is divided into two parts, wrfpost and copygb:
wrfpost
· Interpolates the forecasts from the model’s native vertical coordinate to NWS standard output levels (pressure, height, etc.) and computes mean sea level pressure. If the requested field is on a model’s native level, then no vertical interpolation is performed.
·
Computes diagnostic output quantities.
A list of available fields is shown in Table 1.
· Outputs the results in NWS and WMO standard GRIB1 format (for GRIB documentation, see http://www.nco.ncep.noaa.gov/pmb/docs/).
· De-staggers the WRF-ARW forecasts from a C-grid to an A-grid.
· Outputs two navigation files, copygb_nav.txt and copygb_hwrf.txt (these are ONLY used for WRF-NMM).
copygb
· Since wrfpost de-staggers WRF-ARW from a C-grid to an A-grid, WRF-ARW data can be displayed directly without going through copygb.
· No de-staggering is applied when posting WRF-NMM forecasts. Therefore, the posted WRF-NMM output is still on the staggered native E-grid and must go through copygb to be interpolated to a regular non-staggered grid.
· copygb is mainly used by WRF-NMM - see the WRF-NMM User’s Guide (http://www.dtcenter.org/wrf-nmm/users/docs/user_guide/WPS/index.php).
An additional utility called ndate is distributed with the WRF
Postprocessor tar-file. This utility is used to format the dates of the
forecasts to be posted for ingestion by the codes.
Computational Aspects and Supported Platforms
The WRF Postprocessor v3.0 has been tested on IBM and LINUX
platforms. For LINUX, the Portland Group (PG) compiler has been used.
Only wrfpost has been parallelized, because it requires several
3-dimensional arrays for the computations. When running wrfpost on more than one processor, the
last processor will be designated as an I/O node, while the rest of the
processors are designated as computational nodes.
Setting up the WRF model to interface with the WRF
Postprocessor
The wrfpost program is currently set up to read a large number of
fields from the WRF model history (wrfout) files. This configuration stems from NCEP's need to generate all of
its required operational products. The program is configured such that is will
run successfully if an expected input field is missing from the WRF history
file as long as this field is not required to produce a requested output field.
If the pre-requisites for a requested output field are missing from the WRF
history file, wrfpost will abort at run time.
Take care not to remove fields from the wrfout files, which
may be needed for diagnostical purposes by the WPP package. For example, if
fields on isobaric surfaces are requested, but the pressure fields on model
surfaces (PB and P) are not available in
the history file, wrfpost will abort at run time. In general the default fields available
in the wrfout files are sufficient to run WPP.
Note: For WRF-ARW, the accumulated precipitation fields (RAINC and RAINNC) are run total accumulations, whereas the WRF-NMM accumulated precipitation fields (CUPREC and ACPREC) are zeroed every 6 hours.
Control File Overview
The user interacts with wrfpost through the control file, parm/wrf_cntrl.parm. The control file is composed of
a header and a body. The header specifies the
output file information. The body allows the user to select which fields and
levels to process.
The header of the wrf_cntrl.parm file contains the following variables:
· KGTYPE: defines output grid type, which should always be 255.
·
IMDLTY: identifies the process ID for AWIPS.
· DATSET: defines the prefix used for the output file name. Currently set to “WRFPRS”.
The body of the wrf_cntrl.parm file is composed of a series of
line pairs, for example:
(PRESS ON MDL SFCS ) SCAL=( 3.0)
L=(11000 00000 00000
00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000)
where,
·
The first line specifies the field (e.g. PRESS) to process, the level type a user is interested in
(e.g. ON MDL SFCS), and the
degree of accuracy to be retained in the GRIB output (SCAL=3.0).
A list of all possible output fields for wrfpost is provided in Table
1. This table provides the full name of the variable in the first column
and an abbreviated name in the second column. The abbreviated names are used in
the control file. Note that the variable names also contain the type of level
on which they are output. For instance, temperature is available on “model
surface” and “pressure surface”.
· The second line specifies the levels on which the variable is to be processed.
Controlling which fields wrfpost outputs
To output a field, the body of the control file needs to
contain an entry for the appropriate field and output for this field must be
turned on for at least one level (see “Controlling which levels wrfpost
outputs”). If an entry for a particular
field is not yet available in the control file, two lines may be added to the
control file with the appropriate entries for that field.
Controlling which levels wrfpost outputs
The second line of each pair determines which levels wrfpost will output. Output on a given
level is turned off by a “0” or turned on by a “1”.
· For isobaric output, 47 levels are possible, from 2 to 1013 hPa (8 levels above 75 mb and then every 25 mb from 75 to 1000mb). The complete list of levels is specified in sorc/wrfpost/POSTDATA.f
· For model-level output, all model levels are possible, from the highest to the lowest.
·
When using the Noah LSM the soil layers
are 0-10 cm, 10-40 cm, 40-100 cm, and 100-200 cm.
When using the RUC LSM the soil levels are 0 cm, 5 cm, 20 cm, 40 cm, 160 cm and 300 cm. For the RUC LSM it is
also necessary to turn on two additional output levels in wrf_cntrl.param so that 6 output levels are processed.
·
For PBL layer averages, the levels correspond to 6
layers with a thickness of 30 hPa each.
· For flight level, the levels are 914 m, 1524 m, 1829 m, 2134 m, 2743 m, 3658 m, and 6000 m.
· For AGL RADAR Reflectivity, the levels are 4000 and 1000 m.
· For surface or shelter-level output, only the first position of the line can be turned on.
For example, the sample control file parm/wrf_cntrl.parm has the following entry for
surface dew point temperature:
(SURFACE DEWPOINT ) SCAL=(-4.0)
L=(00000
00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000)
Based on this entry, surface dew point temperature will not be output by wrfpost. To add this field to the output,
modify the entry to read:
(SURFACE
DEWPOINT ) SCAL=(-4.0)
L=(10000 00000 00000 00000 00000 00000 00000 00000 00000
00000 00000 00000 00000 00000)
Running WPP
Four scripts for running the WRF Postprocessor package are
included in the tar file:
run_wrfpost
run_wrfpostandgrads
run_wrfpostandgempak
run_wrfpost_frames
Before running any of the above listed scripts, perform
the following instructions:
1. cd to your DOMAINPATH directory.
2. Make the
following directories. The first will hold the WRF Postprocessor results. The
second is where you will place your copy of the wrf_cntrl.parm file.
mkdir
postprd
mkdir parm
3. Copy the
default WPPV3/parm/wrf_cntrl.parm to
your working. Edit the wrf_cntrl.parm file to reflect the fields and levels you want wrfpost to output.
4. Copy the
script (WPPV3/scripts/run_wrfpost*) of
your choice to the postprd/.
5. Edit the run
script as outlined below.
Once these directories are set up and the edits outlined
above are completed, the scripts can be run interactively from the postprd directory by simply typing the script name on the
command line.
Overview of the WPP run scripts
Note: It is recommended that the user refer to the script
while reading this overview.
1. Set up
environmental variables:
TOP_DIR: top level directory for source
codes (WPPV3 and WRFV3)
DOMAINPATH: top level directory of WRF model
run
Note:
The scripts are configured such that wrfpost expects the WRF history files (wrfout* files) to be in subdirectory wrfprd, the wrf_cntrl.parm file to be in the subdirectory parm and the postprocessor working directory to be a
subdirectory called postprd under
DOMAINPATH.
2. Specify
dynamic core being run (“NMM” or “ARW”)
3. Specify the
forecast cycles to be post-processed:
startdate: YYYYMMDDHH of forecast cycle
fhr:
first forecast hour
lastfhr:
last forecast hour
incrementhr: increment (in hours) between forecast files
4. Define the
location of the post-processor executables.
5. Link the
microphysical table ${WRFPATH}/run/ETAMP_DATA and the control file ../parm/wrf_control.parm to the working directory.
6. Set up how
many domains will be post-processed:
For runs with a single domain, use
“for domain d01”.
For runs with multiple domains, use “for domain d01 d02 .. dnn”
7. Create
namelist itag that will be read in by wrfpost.exe from stdin (unit 5). This namelist contains 4 lines:
i. Name
of the WRF output file to be posted.
ii. Format of
WRF model output (netCDF or binary).
iii. Forecast valid
time (not model start time) in WRF format.
iv. Model name (NMM or
ARW).
8. Run wrfpost and check for errors. The execution command in the
distributed scripts is for a single processor wrfpost.exe < itag
> outpost. To run wrfpost on multiple processors, the command line should be:
mpirun -np N wrfpost.exe <
itag > outpost (for LINUX-MPI systems)
mpirun.lsf wrfpost.exe <
itag > outpost (for IBM)
If scripts run_wrfpostandgrads or run_wrfpostandgempak
are used, additional steps are taken to create image files (see Visualization
section below).
Upon a successful run, wrfpost will generate the output file WRFPRS_dnn.hh (linked to wrfpr_dnn.hh), in the post-processor working
directory, where “nn” is the
domain ID and “hh” the forecast
hour. In addition, the script run_wrfpostandgrads will produce a suite of gif images named variablehh_dnn_GrADS.gif, and the script run_wrfpostandgempak will produce a suite of gif images named variable_dnn_hh.gif.
If the run did not complete successfully, a log file in the
post-processor working directory called wrfpost_dnn.hh.out, where “nn” is the domain ID and “hh”
is the forecast hour, may be consulted for further information.
Visualization
GEMPAK
The GEMPAK utility nagrib is able to decode GRIB files whose navigation is on any non-staggered
grid. Hence, GEMPAK is able to decode GRIB files generated by WPP and plot
horizontal fields or vertical cross sections.
A sample script named run_wrfpostandgempak, which is included in the scripts directory of the tar file, can be used to run wrfpost and plot the following fields using GEMPAK:
_ Sfcmap_dnn_hh.gif: mean SLP and 6 hourly
precipitation
_ PrecipType_dnn_hh.gif: precipitation type (just snow and
rain)
_ 850mbRH_dnn_hh.gif: 850 mb relative humidity
_ 850mbTempandWind_dnn_hh.gif: 850 mb temperature and wind
vectors
_ 500mbHandVort_dnn_hh.gif: 500 mb geopotential height and
vorticity
_ 250mbWindandH_dnn_hh.gif: 250 mb wind speed isotacs and
geopotential height
This script can be modified to customize fields for output.
GEMPAK has an online users guide at http://my.unidata.ucar.edu/content/software/gempak/index.html
In order to use the script run_wrfpostandgempak, it is necessary to set the environment variable GEMEXEC to the path of the GEMPAK
executables. For example,
setenv
GEMEXEC /usr/local/gempak/bin
GrADS
The GrADS utilities grib2ctl.pl and gribmap are able to decode GRIB files whose navigation is on any non-staggered
grid. These utilities and instructions on how to use them to generate GrADS
control files are available from: http://www.cpc.ncep.noaa.gov/products/wesley/grib2ctl.html.
The GrADS package is available from: http://grads.iges.org/grads/grads.html.
GrADS has an online Users’ Guide at: http://grads.iges.org/grads/gadoc/.
A list of basic commands for GrADS can be found at: http://grads.iges.org/grads/gadoc/reference_card.pdf.
A sample script named run_wrfpostandgrads, which is included in the scripts directory of WPP, can be used to run wrfpost and plot the following fields using GrADS:
_ Sfcmaphh_dnn_GRADS.gif: mean SLP and 6-hour accumulated
precipitation.
_ 850mbRHhh_dnn_GRADS.gif: 850 mb relative humidity
_ 850mbTempandWindhh_dnn_GRADS.gif: 850 mb temperature and wind
vectors
_ 500mbHandVorthh_dnn_GRADS.gif: 500 mb geopotential heights and
absolute vorticity
_ 250mbWindandHhh_dnn_GRADS.gif: 250 mb wind speed isotacs and
geopotential heights
In order to use the script run_wrfpostandgrads, it is necessary to:
0. Set
environmental variable GADDIR to the
path of the GrADS fonts and auxiliary files. For example,
setenv GADDIR /usr/local/grads/data
1. Add the
location of the GrADS executables to the PATH. For example,
setenv
PATH /usr/local/grads/bin:$PATH
2. Link script cbar.gs to the post-processor working directory. (This
script is provided in WPP, and the run_wrfpostandgrads script makes a link from
scripts/ to postprd/.) To generate the
above plots, GrADS script cbar.gs
is invoked. This script can also be obtained from the GrADS library of scripts
at: http://grads.iges.org/grads/gadoc/library.html
Fields produced by the WRF Postprocessor
Table 1 lists basic and derived fields that are currently
produced by wrfpost. The abbreviated
names listed in the second column describe how the fields should be entered in
the control file (wrf_cntrl.parm).
|
Table 1: Fields
produced by wrfpost
(column 1), abbreviated names used in wrfpost control file (column 2), corresponding GRIB
identification number for the field (column 3), and corresponding GRIB
identification number for the vertical coordinate (column 4). |
|||
|
Field name |
Name in control file |
Grib ID |
Vertical level |
|
Radar reflectivity on model surface |
RADAR REFL MDL SFCS |
211 |
109 |
|
Pressure on model surface |
PRESS ON MDL SFCS |
1 |
109 |
|
Height on model surface |
HEIGHT ON MDL SFCS |
7 |
109 |
|
Temperature on model surface |
TEMP ON MDL SFCS |
11 |
109 |
|
Potential temperature on model surface |
POT TEMP ON MDL SFCS |
13 |
109 |
|
Dew point temperature on model surface |
DWPT TEMP ON MDL SFC |
17 |
109 |
|
Specific humidity on model surface |
SPEC HUM ON MDL SFCS |
51 |
109 |
|
Relative humidity on model surface |
REL HUM ON MDL SFCS |
52 |
109 |
|
Moisture convergence on model
surface |
MST CNVG ON MDL SFCS |
135 |
109 |
|
U component wind on model surface |
U WIND ON MDL SFCS |
33 |
109 |
|
V component wind on model surface |
V WIND ON MDL SFCS |
34 |
109 |
|
Cloud water on model surface |
CLD WTR ON MDL SFCS |
153 |
109 |
|
Cloud ice on model surface |
CLD ICE ON MDL SFCS |
58 |
109 |
|
Rain on model surface |
RAIN ON MDL SFCS |
170 |
109 |
|
Snow on model surface |
SNOW ON MDL SFCS |
171 |
109 |
|
Cloud fraction on model surface |
CLD FRAC ON MDL SFCS |
71 |
109 |
|
Omega on model surface |
OMEGA ON MDL SFCS |
39 |
109 |
|
Absolute vorticity on model surface |
ABS VORT ON MDL SFCS |
41 |
109 |
|
Geostrophic streamfunction on model surface |
STRMFUNC ON MDL SFCS |
35 |
109 |
|
Turbulent kinetic energy on model surface |
TRBLNT KE ON MDL SFC |
158 |
109 |
|
Richardson number on model surface |
RCHDSN NO ON MDL SFC |
254 |
109 |
|
Master length scale on model surface |
MASTER LENGTH SCALE |
226 |
109 |
|
Asymptotic length scale on model surface |
ASYMPT MSTR LEN SCL |
227 |
109 |
|
Radar reflectivity on pressure surface |
RADAR REFL ON P SFCS |
211 |
100 |
|
Height on pressure surface |
HEIGHT OF PRESS SFCS |
7 |
100 |
|
Temperature on pressure surface |
TEMP ON PRESS SFCS |
11 |
100 |
|
Potential temperature on pressure surface |
POT TEMP ON P SFCS |
13 |
100 |
|
Dew point temperature on pressure surface |
DWPT TEMP ON P SFCS |
17 |
100 |
|
Specific humidity on pressure surface |
SPEC HUM ON P SFCS |
51 |
100 |
|
Relative humidity on pressure surface |
REL HUMID ON P SFCS |
52 |
100 |
|
Moisture convergence on
pressure surface |
MST CNVG ON P SFCS |
135 |
100 |
|
U component wind on pressure surface |
U WIND ON PRESS SFCS |
33 |
100 |
|
V component wind on pressure surface |
V WIND ON PRESS SFCS |
34 |
100 |
|
Omega on pressure surface |
OMEGA ON PRESS SFCS |
39 |
100 |
|
Absolute vorticity on pressure surface |
ABS VORT ON P SFCS |
41 |
100 |
|
Geostrophic streamfunction on pressure surface |
STRMFUNC ON P SFCS |
35 |
100 |
|
Turbulent kinetic energy on pressure surface |
TRBLNT KE ON P SFCS |
158 |
100 |
|
Cloud water on pressure surface |
CLOUD WATR ON P SFCS |
153 |
100 |
|
Cloud ice on pressure surface |
CLOUD ICE ON P SFCS |
58 |
100 |
|
Rain on pressure surface |
RAIN ON P SFCS |
170 |
100 |
|
Snow water on pressure surface |
SNOW ON P SFCS |
171 |
100 |
|
Total condensate on pressure
surface |
CONDENSATE ON P SFCS |
135 |
100 |
|
Mesinger (Membrane) sea level pressure |
MESINGER MEAN SLP |
130 |
102 |
|
Shuell sea level pressure |
SHUELL MEAN SLP |
2 |
102 |
|
2 M pressure |
SHELTER PRESSURE |
1 |
105 |
|
2 M temperature |
SHELTER TEMPERATURE |
11 |
105 |
|
2 M specific humidity |
SHELTER SPEC HUMID |
51 |
105 |
|
2 M dew point temperature |
SHELTER DEWPOINT |
17 |
105 |
|
2 M RH |
SHELTER REL HUMID |
52 |
105 |
|
10 M u component wind |
U WIND AT ANEMOM HT |
33 |
105 |
|
10 M v component wind |
V WIND AT ANEMOM HT |
34 |
105 |
|
10 M potential temperature |
POT TEMP AT 10 M |
13 |
105 |
|
10 M specific humidity |
SPEC HUM AT 10 M |
51 |
105 |
|
Surface pressure |
SURFACE PRESSURE |
1 |
1 |
|
Terrain height |
SURFACE HEIGHT |
7 |
1 |
|
Skin potential temperature |
SURFACE POT TEMP |
13 |
1 |
|
Skin specific humidity |
SURFACE SPEC HUMID |
51 |
1 |
|
Skin dew point temperature |
SURFACE DEWPOINT |
17 |
1 |
|
Skin Relative humidity |
SURFACE REL HUMID |
52 |
1 |
|
Skin temperature |
SFC (SKIN) TEMPRATUR |
11 |
1 |
|
Soil temperature at the bottom of soil layers |
BOTTOM SOIL TEMP |
85 |
111 |
|
Soil temperature in between each of soil layers |
SOIL TEMPERATURE |
85 |
112 |
|
Soil moisture in between each of soil layers |
SOIL MOISTURE |
144 |
112 |
|
Snow water equivalent |
SNOW WATER EQUIVALNT |
65 |
1 |
|
Snow cover in percentage |
PERCENT SNOW COVER |
238 |
1 |
|
Heat exchange coeff at surface |
SFC EXCHANGE COEF |
208 |
1 |
|
Vegetation cover |
GREEN VEG COVER |
87 |
1 |
|
Soil moisture availability |
SOIL MOISTURE AVAIL |
207 |
112 |
|
Ground heat flux - instantaneous |
INST GROUND HEAT FLX |
155 |
1 |
|
Lifted index—surface based |
LIFTED INDEX—SURFCE |
131 |
101 |
|
Lifted index—best |
LIFTED INDEX—BEST |
132 |
116 |
|
Lifted index—from boundary layer |
LIFTED INDEX—BNDLYR |
24 |
116 |
|
CAPE |
CNVCT AVBL POT ENRGY |
157 |
1 |
|
CIN |
CNVCT INHIBITION |
156 |
1 |
|
Column integrated precipitable water |
PRECIPITABLE WATER |
54 |
200 |
|
Column integrated cloud water |
TOTAL COLUMN CLD WTR |
136 |
200 |
|
Column integrated cloud ice |
TOTAL COLUMN CLD ICE |
137 |
200 |
|
Column integrated rain |
TOTAL COLUMN RAIN |
138 |
200 |
|
Column integrated snow |
TOTAL COLUMN SNOW |
139 |
200 |
|
Column integrated total condensate |
TOTAL COL CONDENSATE |
140 |
200 |
|
Helicity |
STORM REL HELICITY |
190 |
106 |
|
U component storm motion |
U COMP STORM MOTION |
196 |
106 |
|
V component storm motion |
V COMP STORM MOTION |
197 |
106 |
|
Accumulated total precipitation |
ACM TOTAL PRECIP |
61 |
1 |
|
Accumulated convective precipitation |
ACM CONVCTIVE PRECIP |
63 |
1 |
|
Accumulated grid-scale precipitation |
ACM GRD SCALE PRECIP |
62 |
1 |
|
Accumulated snowfall |
ACM SNOWFALL |
65 |
1 |
|
Accumulated total snow melt |
ACM SNOW TOTAL MELT |
99 |
1 |
|
Precipitation type (4 types) - instantaneous |
INSTANT PRECIP TYPE |
140 |
1 |
|
Precipitation rate - instantaneous |
INSTANT PRECIP RATE |
59 |
1 |
|
Composite radar reflectivity |
COMPOSITE RADAR REFL |
212 |
200 |
|
Low level cloud fraction |
LOW CLOUD FRACTION |
73 |
214 |
|
Mid level cloud fraction |
MID CLOUD FRACTION |
74 |
224 |
|
High level cloud fraction |
HIGH CLOUD FRACTION |
75 |
234 |
|
Total cloud fraction |
TOTAL CLD FRACTION |
71 |
200 |
|
Time-averaged total cloud fraction |
AVG TOTAL CLD FRAC |
71 |
200 |
|
Time-averaged stratospheric cloud fraction |
AVG STRAT CLD FRAC |
213 |
200 |
|
Time-averaged convective cloud fraction |
AVG CNVCT CLD FRAC |
72 |
200 |
|
Cloud bottom pressure |
CLOUD BOT PRESSURE |
1 |
2 |
|
Cloud top pressure |
CLOUD TOP PRESSURE |
1 |
3 |
|
Cloud bottom height (above MSL) |
CLOUD BOTTOM HEIGHT |
7 |
2 |
|
Cloud top height (above MSL) |
CLOUD TOP HEIGHT |
7 |
3 |
|
Convective cloud bottom pressure |
CONV CLOUD BOT PRESS |
1 |
242 |
|
Convective cloud top pressure |
CONV CLOUD TOP PRESS |
1 |
243 |
|
Shallow convective cloud bottom pressure |
SHAL CU CLD BOT PRES |
1 |
248 |
|
Shallow convective cloud top pressure |
SHAL CU CLD TOP PRES |
1 |
249 |
|
Deep convective cloud bottom pressure |
DEEP CU CLD BOT PRES |
1 |
251 |
|
Deep convective cloud top pressure |
DEEP CU CLD TOP PRES |
1 |
252 |
|
Grid scale cloud bottom pressure |
GRID CLOUD BOT PRESS |
1 |
206 |
|
Grid scale cloud top pressure |
GRID CLOUD TOP PRESS |
1 |
207 |
|
Convective cloud fraction |
CONV CLOUD FRACTION |
72 |
200 |
|
Convective cloud efficiency |
CU CLOUD EFFICIENCY |
134 |
200 |
|
Above-ground height of LCL |
LCL AGL HEIGHT |
7 |
5 |
|
Pressure of LCL |
LCL PRESSURE |
1 |
5 |
|
Cloud top temperature |
CLOUD TOP TEMPS |
11 |
3 |
|
Temperature tendency from radiative fluxes |
RADFLX CNVG TMP TNDY |
216 |
109 |
|
Temperature tendency from shortwave radiative flux |
SW RAD TEMP TNDY |
250 |
109 |
|
Temperature tendency from longwave radiative flux |
LW RAD TEMP TNDY |
251 |
109 |
|
Outgoing surface shortwave radiation - instantaneous |
INSTN OUT SFC SW RAD |
211 |
1 |
|
Outgoing surface longwave radiation - instantaneous |
INSTN OUT SFC LW RAD |
212 |
1 |
|
Incoming surface shortwave radiation - time-averaged |
AVE INCMG SFC SW RAD |
204 |
1 |
|
Incoming surface longwave radiation - time-averaged |
AVE INCMG SFC LW RAD |
205 |
1 |
|
Outgoing surface shortwave radiation - time-averaged |
AVE OUTGO SFC SW RAD |
211 |
1 |
|
Outgoing surface longwave radiation - time-averaged |
AVE OUTGO SFC LW RAD |
212 |
1 |
|
Outgoing model top shortwave radiation -
time-averaged |
AVE OUTGO TOA SW RAD |
211 |
8 |
|
Outgoing model top longwave radiation -
time-averaged |
AVE OUTGO TOA LW RAD |
212 |
8 |
|
Incoming surface shortwave radiation - instantaneous |
INSTN INC SFC SW RAD |
204 |
1 |
|
Incoming surface longwave radiation - instantaneous |
INSTN INC SFC LW RAD |
205 |
1 |
|
Roughness length |
ROUGHNESS LENGTH |
83 |
1 |
|
Friction velocity |
FRICTION VELOCITY |
253 |
1 |
|
Surface drag coefficient |
SFC DRAG COEFFICIENT |
252 |
1 |
|
Surface u wind stress |
SFC U WIND STRESS |
124 |
1 |
|
Surface v wind stress |
SFC V WIND STRESS |
125 |
1 |
|
Surface sensible heat flux - time-averaged |
AVE SFC SENHEAT FX |
122 |
1 |
|
Ground heat flux - time-averaged |
AVE GROUND HEAT FX |
155 |
1 |
|
Surface latent heat flux - time-averaged |
AVE SFC LATHEAT FX |
121 |
1 |
|
Surface momentum flux - time-averaged |
AVE SFC MOMENTUM FX |
172 |
1 |
|
Accumulated surface evaporation |
ACC SFC EVAPORATION |
57 |
1 |
|
Surface sensible heat flux - instantaneous |
INST SFC SENHEAT FX |
122 |
1 |
|
Surface latent heat flux -_ instantaneous |
INST SFC LATHEAT FX |
121 |
1 |
|
Latitude |
LATITUDE |
176 |
1 |
|
Longitude |
LONGITUDE |
177 |
1 |
|
Land sea mask (land=1, sea=0) |
LAND SEA MASK |
81 |
1 |
|
Sea ice mask |
SEA ICE MASK |
91 |
1 |
|
Surface midday albedo |
SFC MIDDAY ALBEDO |
84 |
1 |
|
Sea surface temperature |
SEA SFC TEMPERATURE |
80 |
1 |
|
Press at tropopause |
PRESS AT TROPOPAUSE |
1 |
7 |
|
Temperature at tropopause |
TEMP AT TROPOPAUSE |
11 |
7 |
|
Potential temperature at tropopause |
POTENTL TEMP AT TROP |
13 |
7 |
|
U wind at tropopause |
U WIND AT TROPOPAUSE |
33 |
7 |
|
V wind at tropopause |
V WIND AT TROPOPAUSE |
34 |
7 |
|
Wind shear at tropopause |
SHEAR AT TROPOPAUSE |
136 |
7 |
|
Height at tropopause |
HEIGHT AT TROPOPAUSE |
7 |
7 |
|
Temperature at flight levels |
TEMP AT FD HEIGHTS |
11 |
103 |
|
U wind at flight levels |
U WIND AT FD HEIGHTS |
33 |
103 |
|
V wind at flight levels |
V WIND AT FD HEIGHTS |
34 |
103 |
|
Freezing level height (above mean sea level) |
HEIGHT OF FRZ LVL |
7 |
4 |
|
Freezing level RH |
REL HUMID AT FRZ LVL |
52 |
4 |
|
Highest freezing level height |
HIGHEST FREEZE LVL |
7 |
204 |
|
Pressure in boundary layer (30 mb mean) |
PRESS IN BNDRY LYR |
1 |
116 |
|
Temperature in boundary layer (30 mb mean) |
TEMP IN BNDRY LYR |
11 |
116 |
|
Potential temperature in boundary layers (30 mb
mean) |
POT TMP IN BNDRY LYR |
13 |
116 |
|
Dew point temperature in boundary layer (30 mb
mean) |
DWPT IN BNDRY LYR |
17 |
116 |
|
Specific humidity in boundary layer (30 mb mean) |
SPC HUM IN BNDRY LYR |
51 |
116 |
|
RH in boundary layer (30 mb mean) |
REL HUM IN BNDRY LYR |
52 |
116 |
|
Moisture convergence in boundary layer (30 mb
mean) |
MST CNV IN BNDRY LYR |
135 |
116 |
|
Precipitable water in boundary layer (30 mb mean) |
P WATER IN BNDRY LYR |
54 |
116 |
|
U wind in boundary layer (30 mb mean) |
U WIND IN BNDRY LYR |
33 |
116 |
|
V wind in boundary layer (30 mb mean) ________________________ |
V WIND IN BNDRY LYR________ |
34 |
116 |
|
Omega in boundary layer (30 mb mean) |
OMEGA IN BNDRY LYR |
39 |
116 |
|
Visibility |
VISIBILITY |
20 |
1 |
|
Vegetation type |
VEGETATION TYPE |
225 |
1 |
|
Soil type |
SOIL TYPE |
224 |
1 |
|
Canopy conductance |
CANOPY CONDUCTANCE |
181 |
1 |
|
PBL height |
PBL HEIGHT |
221 |
1 |
|
Slope type |
SLOPE TYPE |
222 |
1 |
|
Snow depth |
SNOW DEPTH |
66 |
1 |
|
Liquid soil moisture |
LIQUID SOIL MOISTURE |
160 |
112 |
|
Snow free albedo |
SNOW FREE ALBEDO |
170 |
1 |
|
Maximum snow albedo |
MAXIMUM SNOW ALBEDO |
159 |
1 |
|
Canopy water evaporation |
CANOPY WATER EVAP |
200 |
1 |
|
Direct soil evaporation |
DIRECT SOIL EVAP |
199 |
1 |
|
Plant transpiration |
PLANT TRANSPIRATION |
210 |
1 |
|
Snow sublimation |
SNOW SUBLIMATION |
198 |
1 |
|
Air dry soil moisture |
AIR DRY SOIL MOIST |
231 |
1 |
|
Soil moist porosity |
SOIL MOIST POROSITY |
240 |
1 |
|
Minimum stomatal resistance |
MIN STOMATAL RESIST |
203 |
1 |
|
Number of root layers |
NO OF ROOT LAYERS |
171 |
1 |
|
Soil moist wilting point |
SOIL MOIST WILT PT |
219 |
1 |
|
Soil moist reference |
SOIL MOIST REFERENCE |
230 |
1 |
|
Canopy conductance - solar component |
CANOPY COND SOLAR |
246 |
1 |
|
Canopy conductance - temperature component |
CANOPY COND TEMP |
247 |
1 |
|
Canopy conductance - humidity component |
CANOPY COND HUMID |
248 |
1 |
|
Canopy conductance - soil component |
CANOPY COND SOILM |
249 |
1 |
|
Potential evaporation |
POTENTIAL EVAP |
145 |
1 |
|
Heat diffusivity on sigma surface |
DIFFUSION H RATE S S |
182 |
107 |
|
Surface wind gust |
SFC WIND GUST |
180 |
1 |
|
Convective precipitation rate |
CONV PRECIP RATE |
214 |
1 |
|
Radar reflectivity at certain above ground heights |
RADAR REFL AGL |
211 |
105 |
VAPOR
VAPOR is the Visualization
and Analysis Platform for Ocean, Atmosphere, and Solar Researchers. VAPOR was developed at NCAR to provide interactive
visualization and analysis of numerically simulated fluid dynamics. With the latest (1.2) version, VAPOR
now supports visualization of WRF-ARW simulation output.
Basic capabilities of VAPOR with WRF-ARW output
·
Direct Volume rendering (DVR)
Any 3D variable in the WRF data can
be viewed as a density. Users
control transparency and color to view temperature, water vapor, clouds,
etc. in 3D.
·
Flow
- Draw 2D and 3D streamlines and
flow arrows, showing the wind motion and direction, and how wind changes in
time.
- Path tracing (unsteady flow)
enables visualization of trajectories that particles take over time. Users control when and where the
particles are released.
·
Isosurfaces
The isosurfaces of variables are
displayed interactively. Users can
control iso-values, color and transparency of the isosurfaces.
·
Contour planes and Probes
3D variables can be intersected
with arbitrarily oriented planes.
Contour planes can be interactively positioned. Users can interactively pinpoint the
values of a variable and establish seed points for flow integration.
·
Animation
Control the time-stepping of the
data, for interactive replaying and for recording animated sequences.
·
Terrain rendering
The ground surface can be
represented as a colored surface or can display a terrain image for
geo-referencing.
VAPOR requirements
VAPOR is supported on Linux, Mac, Irix, and Windows. VAPOR
works best with a recent graphics card (say 1-2 years old). The advanced features of VAPOR perform
best with nVidia or ATI graphics accelerators.
VAPOR is installed on NCAR visualization systems. Users with UCAR accounts can connect
their (windows or Linux) desktops to the NCAR visualization systems using NCAR’s
remote graphics service, and run VAPOR remotely. Instructions for using this are at: http://www.cisl.ucar.edu/hss/dasg/services/docs/VAPOR.shtml. Contact dasg@ucar.edu for assistance.
VAPOR support resources
The VAPOR website: http://www.vapor.ucar.edu includes software, documentation, example data, and
links to other resources.
The VAPOR sourceforge website (http://sourceforge.net/projects/vapor) enables users to post bugs, request features,
download software, etc.
Users of VAPOR on NCAR visualization systems should contact dasg@ucar.edu
for support.
Questions, problems, bugs etc. should be reported to vapor@ucar.edu.
VAPOR development priorities are established by the VAPOR
steering committee, a group of turbulence researchers who are interested in
improving the ability to analyze and visualize time-varying simulation
results. Post a feature request to
the VAPOR sourceforge website, or e-mail vapor@ucar.edu if you have requests or suggestions about improving
VAPOR capabilities.
How to use VAPOR with WRF-ARW data
1. Install
VAPOR
VAPOR installers for Windows,
Macintosh and Linux are available on the VAPOR download page, http://www.vapor.ucar.edu/download. You will be asked to agree to the terms of a BSD
open source license. For most
users, a binary installation is fine.
Installation instructions are provided at the top of the VAPOR
documentation page, http://www.vapor.ucar.edu/doc.
After VAPOR is installed, it is
necessary to perform user environment setup on Unix or Mac, before executing
any VAPOR software. These setup
instructions are provided on the VAPOR binary install documentation page, http://www.vapor.ucar.edu/doc/binary-install/index.shtml.
2. Convert
WRF output data to VAPOR
VAPOR datasets consist of (1) a
metadata file (file type .vdf) that describes an entire VAPOR data collection,
and (2) a directory of multi-resolution data files where the actual data is
stored. The metadata file is
created by the command wrfvdfcreate, and
the multi-resolution data files are written by the command wrf2vdf. The
simplest way to create a VAPOR data collection is as follows:
First issue the command:
wrfvdfcreate
wrf_files metadata_file.vdf
where: wrf_files is a list
of one or more wrf output files that you want to use.
metadata_file.vdf is the name that you will use for your metadata
file.
For example:
wrfvdfcreate
wrfout_d02_2006-10-25_18_00_00 wrfout.vdf
Then issue the command:
wrf2vdf
metadata_file.vdf wrf_files
using the same arguments (in
reversed order) as you used with wrfvdfcreate. Note that wrf2vdf does most of the work, and may take a few minutes to
convert a large WRF dataset.
After issuing the above commands,
all of the 3D variables in the specified WRF output files will be converted,
for all the time steps in the files.
If you desire more control over the conversion process, there are many
additional options that you can provide to wrfvdfcreate and wrf2vdf. Type the command with
the argument “-help” to get a short-listing of the command usage. All data conversion options are detailed
in section 1 of http://www.vapor.ucar.edu/doc/WRFsupport.pdf. Some
of the options include:
- Calculation of derived variables
such as vertical vorticity, temperature in Kelvin, normalized pressure, wind
velocity.
- Overriding default volume
dimensions and/or spatial extents.
- Converting only a subset of the
WRF output time steps
- Converting a specific collection
of variables.
3. Visualize
the WRF data
From the command line, issue the command
“vaporgui”, or double-click the VAPOR desktop icon (on Windows or Mac). This will launch the VAPOR user
interface. From the Data menu,
choose “Load a dataset into default session”, and select the metadata file that
you associated with your converted WRF data.
To visualize the data, select a
renderer tab (DVR, Iso, Flow, or Probe), and then, at the top of that tab,
check the box labeled “Instance:1”, to enable that renderer. For example, the above image combines
volume, flow and isosurface visualization with a terrain image.
There are many capabilities in
VAPOR to support visualization of WRF data. Several resources are available to help users quickly get
the information they need to obtain the most useful visualizations:
-The Georgia Weather Case Study (http://www.vapor.ucar.edu/doc/GeorgiaCaseStudy.pdf) provides a step-by-step tutorial, showing how to
use most of the VAPOR features that are useful in WRF visualization.
- To understand the meaning or
function of an element in the VAPOR user interface:
Tool tips: Place
the cursor over a widget for a couple of seconds and a one-sentence description
is provided.
Context-sensitive help: From
the Help menu, click on “?Explain This”, and then click with the left mouse
button on a widget, to get a longer technical explanation of the functionality.
- Complete documentation of all
capabilities of the VAPOR user interface is provided in the VAPOR User
Interface Reference Manual (http://www.vapor.ucar.edu/doc/ReferenceManual.pdf).
- The VAPOR Quick Start Guide (http://www.vapor.ucar.edu/doc/QuickstartGuide.pdf) provides a step-by-step tutorial for using VAPOR on
turbulence data. The Quick Start
Guide does not discuss the WRF-specific capabilities of VAPOR.
- The WRF-specific features of
VAPOR are described in detail in section 2 of the document “Vapor Support
for converting and visualizing WRF datasets”
(http://www.vapor.ucar.edu/doc/WRFsupport.pdf).
Utility:
read_wrf_nc
This utility allows a user to look at a WRF netCDF file at a glance.
What
is the difference between this utility and the netCDF utility ncdump?
· This utility has a large number of options, to allow a user to look at the specific part of the netCDF file in question.
· The utility is written in Fortran 90, which will allow users to add options.
·
This
utility can be used for both WRF-ARW and WRF-NMM cores.
It can be used for geogrid, metgrid and wrf input / output files.
Only 3 basic diagnostics are available, pressure / height / tk, these can be
activated with the -diag option (these are only available for wrfout files)
Obtain the read_wrf_nc utility from the WRF Download page (http://www2.mmm.ucar.edu/wrf/users/download/get_source.html)
Compile
The
code should run on any machine with a netCDF library (If you port the code
to a different machine, please forward the compile flags to wrfhelp@ucar.edu)
To compile the code, use the compile flags at the top of the utility.
e.g., for a LINUX machine you
need to type:
pgf90 read_wrf_nc.f -L/usr/local/netcdf/lib
-lnetcdf -lm -I/usr/local/netcdf/include
-Mfree -o read_wrf_nc
If
successful, this will create the executable: read_wrf_nc
Run
./read_wrf_nc wrf_data_file_name
[-options]
options : [-h / help] [-att] [-m] [-M z] [-s]
[-S x y z] [-v VAR] [-V VAR] [-w VAR]
[-t t1 [t2]] [-times]
[-ts xy X Y VAR VAR ....]
[-ts ll lat lon VAR VAR
....]
[-lev z] [-rot] [-diag]
[-EditData VAR]
Options: (Note: options [-att] ; [-t] and [-diag] can be used with other options) |
|
|
-h / help |
Print help information. |
|
-att |
Print global attributes. |
|
-m |
Print list of fields available for each time, plus the min and max values for each field. |
|
-M z |
Print list of fields available for each time, plus the min
and max values for each field. |
|
-s |
Print list of fields available for each time, plus a
sample value for each field. |
|
-S x y z |
Print list of fields available for each time, plus a
sample value for each field. |
|
-t t1 [t2] |
Apply options only to times t1 to t2.
|
|
-times |
Print only the times in the file. |
|
-ts |
Generate time series output. A full vertical profile for each variable will be created. -ts xy
X Y VAR VAR ….. will generate time series output for all VAR’s at location X/Y -ts ll lat lon VAR VAR ….. will generate time series output for all VAR’s at x/y location nearest to lat/lon |
|
-lev z |
Work only with option –ts |
|
-rot |
Work only with option –ts Will rotate winds to earth coordinates |
|
-diag |
Add if you want to see output for the diagnostics temperature (K), full model pressure and model height (tk, pressure, height) |
|
-v VAR |
Print basic information about field VAR. |
|
-V VAR |
Print basic information about field VAR, and dump the full field out to the screen. |
|
-w VAR |
Write the full field out to a file VAR.out |
|
|
|
|
|
Default Options are [-att –s] |
SPECIAL option:
-EditData VAR This option allows a user to read a WRF netCDF file, change a specific field and write it BACK into the WRF netCDF file. This option will CHANGE your CURRENT WRF netCDF file so TAKE CARE when using this option. ONLY one field at a time can be changed. So if you need 3 fields changed, you will need to run this program 3 times, each with a different "VAR" IF you have multiple times in your WRF netCDF file – by default ALL times
for variable "VAR" WILL be changed. If you only want to change
one time period, also use the “-t” option. HOW TO USE THIS OPTION: Make a COPY of your WRF netCDF file before using this option
EDIT the subroutine USER_CODE ADD an IF-statement block
for the variable you want to change. This is to prevent a variable getting
overwritten by mistake.
Compile and run program |
|
Utility: iowrf
This utility allows a user to do some basic manipulation on WRF-ARW netCDF files.
· The utility allows a user to thin the data; de-stagger the data; or extract a box from the data file.
Obtain the iowrf utility from the WRF
Download page (http://www2.mmm.ucar.edu/wrf/users/download/get_source.html)
Compile
The
code should run on any machine with a netCDF library (If you port the code
to a different machine, please forward the compile flags to wrfhelp@ucar.edu)
To compile the code, use the compile flags at the top of the utility.
e.g., for a LINUX machine you
need to type:
pgf90 iowrf.f -L/usr/local/netcdf/lib -lnetcdf
-lm -I/usr/local/netcdf/include -Mfree -o iowrf
If
successful, this will create the executable: iowrf
Run
./iowrf
wrf_data_file_name
[-options]
options : [-h / help] [-thina X] [-thin X]
[-box {}] [-A] [-64bit]
|
-thina X |
Thin the data with a ratio of 1:X |
|
-thin X |
Thin the data with a ratio of 1:X No averaging will be done |
|
-box {} |
Extract a box from the data file. X/Y/Z can be controlled independently. e.g., -box x 10 30 y 10 30 z 5 15 -box x 10 30 z 5 15 -box y 10 30 -box z 5 15 |
|
-A |
De-stagger the data – no thinning will take place |
|
-64bit |
Allow large files (> 2GB) to be read / write |
Utility: p_interp
This utility interpolates WRF-ARW netCDF output files to user specified pressure levels.
Obtain the p_interp utility from the
WRF Download page (http://www2.mmm.ucar.edu/wrf/users/download/get_source.html)
Compile
The
code should run on any machine with a netCDF library (If you port the code
to a different machine, please forward the compile flags to wrfhelp@ucar.edu)
To compile the code, use the compile flags at the top of the utility.
e.g., for a LINUX machine you
need to type:
pgf90 p_interp.F90 -L/usr/local/netcdf/lib
-lnetcdf -lm -I/usr/local/netcdf/include
-Mfree -o p_interp
If
successful, this will create the executable: p_interp
Run
Edit the associated namelist.pinterp file (see namelist options below), and run
./p_interp
|
&io |
|
|
input_root_name |
Path and file name(s) of wrfout files. |
|
process |
Indicate which fields to process. ‘list’ of fields as indicated in ‘fields’ |
|
fields |
List of fields to process. |
|
debug |
Switch debug more on/off. |
|
-64bit |
Allow large files (> 2GB) to be read / write. |
|
&interp_in |
|
|
interp_levels |
List of pressure levels to interpolate data to |
|
extrapolate |
0 - set values below ground and above model top to missing values (default) 1 - extrapolate below ground, and set above model top to model top values |
|
interp_method |
1 - linear in p interpolation (default) 2 - linear in log p interpolation |
|
unstagger_grid |
Set to .True. so unstagger the data on output |
Tools
Below is a list of tools that are freely available that can be used very successfully to manipulate model data (both WRF model data as well as other GRIB and netCDF datasets).
Converting Graphics
ImageMagick
ImageMagick is a software suite to create, edit, and compose bitmap images. It can read, convert and write images in a variety of formats (over 100) including DPX, EXR, GIF, JPEG, JPEG-2000, PDF, PhotoCD, PNG, Postscript, SVG, and TIFF. Use ImageMagick to translate, flip, mirror, rotate, scale, shear and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses and B_zier curves.
The software package is freely available from, http://www.imagemagick.org. Download and installation instructions are also available from this site.
Examples of converting data with ImageMagick software:
convert
file.pdf file.png
convert file.png file.bmp
convert file.pdf file.gif
convert file.ras file.png
ImageMagick cannot convert ncgm (NCAR Graphics) file format to other file formats.
Converting ncgm (NCAR Graphics) file format
NCAR Graphics has tools to convert ncgm files to raster file formats. Once files are in raster file format, ImageMagick can be used to translate the files into other formats.
For ncgm files containing a single frame, use ctrans.
ctrans -d sun file.ncgm
file.ras
For ncgm files containing multiple
frames, first use med (metafile frame editor) and then ctrans. med will create multiple single frame files called medxxx.ncgm
med -e '1,$ split $' file.ncgm
ctrans -d sun_ med001.ncgm > med001.ras
Design WRF model domains
WPS/util/plotgrids.exe, can be used to display model domains before WPS/geogrid.exe is run.
This utility reads the domain setup from namelist.wps and creates an ncgm file that can be viewed with the NCAR Graphics command “idt”, e.g.,
idt gmeta
Read more about this utility in Chapter 3 of this Users Guide.
Display ungrib (intermediate) files
WPS/util/plotfmt.exe, can be used to display intermediate files created by WPS/ungrib.exe.
If
you have created intermediate files manually, it is a very good practice to use
this utility to display the data in your files first before running
WPS/metgrid/exe.
Note: If you plan on manually
creating intermediate files, refer to http://www2.mmm.ucar.edu/wrf/OnLineTutorial/WPS/IM_files.htm
for detailed information about the file formats and sample programs.
This utility reads intermediate files and creates an ncgm file that can be viewed with the NCAR Graphics command “idt”, e.g.,
idt gmeta
Read more about this utility in Chapter 3 of this Users Guide.
netCDF data
netCDF stands for network Common Data Form.
Most
of the information below can be used for WRF netCDF data as well as other
netCDF datasets.
netCDF is one of the current supported data formats chosen for WRF I/O API.
Advantages
of using netCDF?
Most graphical packages support netCDF file formats
netCDF files are platform-independent (big-endian / little-endian)
A lot of software already exists which can be used to process/manipulate netCDF data
Documentation:
http://www.unidata.ucar.edu/ (General netCDF documentation)
http://www.unidata.ucar.edu/software/netcdf/fguide.pdf (NETCDF User’s Guide for FORTRAN)
Utilities:
ncdump
Part of the netCDF libraries. Reads a netCDF file and prints information about the dataset. e.g.
ncdump –h file (print header information)
ncdump –v VAR file (print header information and the
full field VAR)
ncdump –v Times file (a handy way to see how many
times are available in a WRF output file)
ncview
Display
netCDF data graphically. No overlays, no maps and no manipulation of data
possible.
http://meteora.ucsd.edu/~pierce/ncview_home_page.html
ncBrowse
Display
netCDF data graphically. Some overlays, maps and manipulation of data are
possible.
http://www.epic.noaa.gov/java/ncBrowse/
A utility to display basic information about WRF netCDF files.
A utility to do some basic file manipulation on WRF-ARW netCDF files.
A utility to interpolate WRF-ARW netCDF output files to user specified pressure levels.
netCDF
operators
Stand
alone programs to, which can be used to manipulate data (performing grid point
averaging / file differencing / file ‘appending’). Examples of the available
operators are ncdiff, ncrcat, ncra, and ncks.
ncdiff
Difference two file, e.g.
ncdiff input1.nc input2.nc output.nc
ncrcat
Write specified variables / times to a new file, e.g.
ncrcat -v RAINNC wrfout* RAINNC.nc
ncrcat -d Time,0,231 –v RAINNC wrfout* RAINNC.nc
ncra
Average variables and write to a new file, e.g.
ncra -v OLR wrfout* OLR.nc
ncks (nc kitchen sink)
Combination of NCO tools all in one (handy: one tool for multiple operations).
GRIB data
Documentation
http://dss.ucar.edu/docs/formats/grib/gribdoc/ (Guide to GRIB 1)
http://www.nco.ncep.noaa.gov/pmb/docs/grib2/grib2_doc.shtml
(Guide to GRIB2)
http://www.nco.ncep.noaa.gov/pmb/docs/grib2/GRIB2_parmeter_conversion_table.html
(GRIB2 - GRIB1 parameter conversion table)
GRIB
codes
It
is important to understand the GRIB codes to know which fields are available in
your dataset. For instance, NCEP uses the GRIB1 code 33 for the U-component of
the wind, and 34 for the V-component. Other centers may use different codes,
so always obtain the GRIB codes from the center you get your data from.
GRIB2
uses 3 codes for each field - product, category and parameter.
We would most often be interested in product 0 (Meteorological products). Category refers to the type of field, e.g., category 0 is
temperature, category 1 is moisture and category 2 is momentum. Parameter is the field number.
So whereas GRIB1 only uses code 33 for the U-component of the wind, GRIB2 will use 0,2,2, for the U-component, and 0,2,3 for the V-component.
Display
GRIB header/field information
GRIB1
data
WPS/util/g1print.exe
wgrib
(http://www.cpc.ncep.noaa.gov/products/wesley/wgrib.html)
GRIB2
data
WPS/util/g2print.exe
wgrib2 (http://www.cpc.ncep.noaa.gov/products/wesley/wgrib2/)
Convert
GRIB1 data to netCDF format
ncl_grib2nc
(http://www.ncl.ucar.edu/Document/Tools)
Model Verification
MET is designed to be a highly
configurable, state-of-the-art suite of verification tools. It was developed
using output from the Weather Research and Forecasting (WRF) modeling system
but may be applied to the output of other modeling systems as well.
MET provides a variety of
verification techniques, including:
- Standard
verification scores comparing gridded model data to point-based
observations
- Standard
verification scores comparing gridded model data to gridded observations
- Object-based
verification method comparing gridded model data to gridded observations
http://www.dtcenter.org/met/users/index.php