Skip Navigation Links www.nws.noaa.gov 
NOAA logo - Click to go to the NOAA home page National Weather Service   NWS logo - Click to go to the NWS home page
Climate Prediction Center
 
 

 
About Us
   Our Mission
   Who We Are

Contact Us
   CPC Information
   CPC Web Team

 
HOME > Monitoring_and_Data > Oceanic and Atmospheric Data > Reanalysis: Atmospheric Data > wgrib2-new_grid
 

wgrib2: -new_grid

Introduction

The -new_grid option interpolates the fields into a new grid like a grib2 version of copygb. The default interpolation is bilinear but that can be changed using the -new_grid_interpolation option. This option uses scalar and vector interpolation as appropriate. In order for the vector interpolation to work, the vector quantities must be in a (U,V) order. For example: Z200, U200, V200, Z500, U500, V500 is good. If the data are not in (U,V) order, the inventory can be sorted into (U,V) order and the inventory can then be used to control the order of processing. If the vector quanties are not in (U,V) order, the vector quantites will not be interpolated. (See example 3 for converting the file into a (U,V) order.)

The option is not part of the default configuration. The interpolation code is written in fortran and combining fortran and C code can require some work. (gcc/gfortran and clang/gfortran are already handled by the makefile.) Getting the C and Fortran code to cooperate requires some system-specific knowledge and may not be possible in all cases. Consequently you are on your own in getting the -new_grid option installed.

Usage

-new_grid_winds W -new_grid A B C outfile
    W = earth or grid
        earth means that the U wind goes eastward
        grid means that U wind goes from grid (i,j) to (i+1,j)
          which is not eastward in a Lambert-conformal or polar stereographic grids
    A, B, C are the output grid description
    outfile is an output file.  The grib2 interpolated records are written in outfile

Examples

  wgrib2 IN.grb -set_grib_type same -new_grid_winds earth -new_grid latlon 100:10:1 30:20:1 OUT.grb
    Interpolates from IN.grb to OUT.grb
    Uses the same grib packing as in the input file
    Makes a 10x20, 1x1 degree lat-lon grid, lower left corner: 100E 30N


  wgrib2 IN.grb -set_grib_type same -new_grid_winds earth -new_grid ncep grid 221 OUT.grb
    Interpolates from IN.grb to OUT.grb
    Uses the same grib packing as in the input file
    Interpolates to NCEP grid 221.

 In this example, U and V are not in the required order.

    wgrib2 201201.A | sed -e 's/:UGRD:/:UGRDa:/' -e 's/:VGRD:/:UGRDb:/'  | \
    sort -t: -k3,3 -k5,8 -k4,4 | \
    wgrib2 201201.A -i -new_grid_winds earth -new_grid ncep grid 2 201201.A.grd2

    The first line creates an inventory with new variable names: UGRD -> UGRDa and VGRD -> UGRDb
    The second line sorts the inventory so that UGRDb follows UGRDB.
    The third line regrids the file, with the order of processing controlled by the inventory.

Grid description format

-new_grid ncep grid I outfile                                   	  I = 2,3,98,126-129,170,173,221,230,241,249
                                                                            (NCEP grid defintions)
									  T62,T126,T170,T190,T254,T382,T574,T1148,T1534
									    (NCEP Gaussian grids definitions)
                                                                          Want more ncep grids?  Modify ncep_grids.c

-new_grid latlon lon0:nlon:dlon lat0:nlat:dlat outfile		  	  lat-lon grid
									  lat0, lon0 = degrees of lat/lon for 1st grid point 
									  nlon = number of longitudes
									  nlat = number of latitudes
									  dlon = grid cell size in degrees of longitude
									  dlat = grid cell size in degrees of latitude

-new_grid lambert:lov:latin1:latin2:lad lon0:nx:dx lat0:ny:dy outfile	  Lambert conic conformal
-new_grid lambert:lov:latin1:latin2 lon0:nx:dx lat0:ny:dy outfile         lad = latin2
-new_grid lambert:lov:latin1 lon0:nx:dx lat0:ny:dy outfile                latin2 = latini lad = latin1
									  lov = longitude (degrees) where y axis is parallel to meridian
									  latin1 = first latitude from pole which cuts the secant cone
									  latin2 = second latitude from pole which cuts the secant cone
									  lad = latitude (degrees) where dx and dy are specified
									  lat0, lon0 = degrees of lat/lon for 1st grid point 
									  nx = number of grid points in X direction
									  ny = number of grid points in Y direction
									  dx = grid cell size in meters in x direction
									  dy = grid cell size in meters in y direction
                                                                          note: if latin2 >= 0, the north pole is on proj plane
                                                                                if latin2 < 0, the south pole is on proj plane

-new_grid lambertc:lov:latin1:latin2:lad lonc:nx:dx latc:ny:dy outfile    Lambert conic conformal with centered position
-new_grid lambertc:lov:latin1:latin2 lonc:nx:dx latc:ny:dy outfile        like lambert except lonc and latc replace lon0 and lat0
-new_grid lambertc:lov:latin1 lonc:nx:dx latc:ny:dy outfile               latc, lonc = degrees of lat/lon for center of the grid


-new_grid nps:lov:lad lon0:nx:dx lat0:ny:dy outfile                       north polar stereographic
-new_grid sps:lov:lad lon0:nx:dx lat0:ny:dy outfile			  south polar stereographic
									  lov = longitude (degrees) where y axis is parallel to meridian
									  lad = latitude (degrees) where dx and dy are specified
                                                                            note: grib1 uses lad = 60N (nps) or 60S (sps)
                                                                            lad must be 60 (nps) or -60 (sps) (library limitation)
									  lat0, lon0 = degrees of lat/lon for 1st grid point 
									  nx = number of grid points in X direction
									  ny = number of grid points in Y direction
									  dx = grid cell distance meters in x direction at lad
									  dy = grid cell distance meters in y direction at lad


-new_grid gaussian lon0:nx:dlon lat0:ny outfile                           global Gaussian grids
                                                                          lat0, lon0 = degrees of lat/lon for 1st grid point
                                                                          note: lon1 = -lon0, lat1 = lat0 + (nx-1)*dlon;
									  nx = number of grid points in X direction
									  ny = number of grid points in Y direction
                                                                             ny must be even
                                                                          dlon = degrees of longitude between adjacent grid points


-new_grid mercator:lad lon0:nx:dx:lonn lat0:ny:dy:latn outfile            lad = latitude (degrees) where dx and dy are specified
                                                                          lat0, lon0 = degrees of lat/lon for 1st grid point
                                                                          latn, lonn = degrees of lat/lon for last grid point
                                                                          nx = number of grid points in X direction
                                                                          ny = number of grid points in Y direction
                                                                          dx = grid cell distance in meters in x direction at lad
                                                                          dy = grid cell distance in meters in y direction at lad

                                                                          note: the mercator grid description is over specified
                                                                          User must make sure (nx,dy) is consistent with lonn
                                                                          as well as (ny,dy) is consistent with latn


lambert, nps, sps, mercator only support we:sn ordering
latlon, gaussian only support we:sn and we:ns ordering

Type of Interpolation

The IPOLATES library supports a number of interpolation schemes including bilinear (default), bicubic, neighbor and budget. The wgrib2 was tested with the spectral interpolation but that option was removed because it greatly increased the code size for a minor option. The interpolation method can be selected by using the -new_grid_interpolation option before the -new_grid option. Some of the interpolation options need numeric parameters which are set by the -new_grid_ipopt option. IPOPT is defined in the IPOLATES library documentation.

You can use different interpolations for different variables. For example, a bilinear interpolation of soil or vegetation type is meaningless. So nearest neighbor interpolation is used instead.

    wgrib2 IN.grb -new_grid_winds earth \
      -new_grid_interpolation bilinear \
      -if ":(VGTYP|SOTYP):" -new_grid_interpolation neighbor -fi \
      -new_grid latlon 0:360:1 90:181:-1 OUT.grb

   line 2: set default interpolation to bilinear
   line 3: if VGTYP or SOTYP then set the interpolation to nearest neighbor
   line 4: do the interpolation

Winds

Before you do an interpolation, you need to define the wind directions. Most people want the the V winds to be in the direction of the North Pole. With a verbose wgrib2 inventory, you will seee winds(N/S). However, some meteorologists want the V winds to go from grid point (i,j) to (i,j+1). The corresponding wgrib2 notation is "winds(grid)". See the -new_grid_winds option for more details.

Changes from copygb

  1. copygb default vectors: UGRD/VGRD
  2. wgrib2 default vectors: UGRD/VGRD, VUCSH/VVCSH,UFLX/VFLX, UGUST/VGUST",USTM/VSTM,VDFUA/VDFVA, UOGRD/VOGRD
  3. copygb can have vectors in any order
  4. wgrib2 must have V follow U for vectors pairs
  5. copygb has bilinear, bicubic, nearest neighbor, budget and spectral interpoltions
  6. wgrib2 has bilinear, bicubic, and nearest neighbor and budget interpoltions (missing spectral)
  7. copygb uses fixed Earth's radius
  8. wgrib2 uses Earth's radius based on grib message
  9. wgrib2 doesn't have merging, mapthreshold or map files
  10. copygb by default, ignores the binary scaling and preserves decimal scaling
  11. wgrib2 by default, preserves binary and decimal scaling

Installation

1) set USE_IPOLATES to 1 in the makefile
2) environment variable $FC must be set to the fortran90 compiler, ex. export FC=gfortran
3) If $FC is not gfortran, openf95, or xlf_r, then
      modify the makefile for the new fortran compiler
      modify New_grid.c for the new fortran compiler
      Note: icc and pgc are incompatible with the jasper library and are not supported
4) now you are ready to make

Quilting tiles - Merging files

Yes, it can be done using -new_grid, -bin, -import_bin -rpn, and the -grib_out options. No, I haven't done it.

Limitations

The IPOLATES library is used in operations at NCEP but it has limitations. Grids used by NCEP get supported and others don't. The library has a grib1 interface, so new features of grib2 are not supported and the precision of the grid parameters are limited to the grib1 values. For example, latitude and longitude values are limited to millidegrees instead of microdegrees
  1. not all grid types are supported by IPOLATES
  2. only common grids are supported by the wgrib2 "wrapper" for IPOLATES
  3. latitude, longitude values are in millidegrees (affects interpolation)
  4. only grib1 scan order are supported (i.e., WE:SN and WE:NS)
  5. NDFD/Glahn scan order are not supported (i.e., WE|EW:SN)
  6. Earth is assumed to be spherical
  7. The fixed radius limitation of IPOLATES has been circumvented.
  8. interpolation library only uses degrees to the nearest milli-degree
  9. Lambert conformal: LatD must follow grib1 conventions
  10. Polar Stereographic: LatD must be 60 latitude (grib1 convention)

NDFD work arounds

NDFD files are written in an order which is not supported by the IPOLATES library. The NDFD files come in (WE|EW):SN order. Which means the odd rows are in WE order and the even rows are EW order. The rows go from south to north. The solution is to convert the grid to WE:SN order is

  1. for data in input=WE|EW:SN scan order (wgrib2 IN -scan)
  2. read data, change order scan order of data, change flag table 3.4, save data
  3. wgrib2 IN.grb -rpn alt_x_scan -set table_3.4 64 -grib_out OUT.grb

A variation of the previous trick can be used to put data in to (WE|EW):SN packing.

See also: -new_grid_interpolation, -new_grid_winds, -new_grid_vectors, -lola, -bin, -import_bin, -rpn, -grib_out,


NOAA/ National Weather Service
National Centers for Environmental Prediction
Climate Prediction Center
5830 University Research Court
College Park, Maryland 20740
Climate Prediction Center Web Team
Page last modified: Sep 11, 2014
Disclaimer Privacy Policy