.ipynb .pdf

repository open issue suggest edit

Binder JupyterHub

On this page

Py-ART Gridding

---

Overview

Within this notebook, we will cover:

1. What is gridding and why is it important?

2. An overview of gridding with Py-ART

3. Test out a different gridding routine

4. Apply Gridding to a Selection of Files

Prerequisites

Concepts	Importance	Notes
Py-ART Basics	Helpful	Basic features
Intro to Cartopy	Helpful	Basic features
Matplotlib Basics	Helpful	Basic plotting
NumPy Basics	Helpful	Basic arrays

• Time to learn: 15 minutes

---

Imports

import os
from pathlib import Path
import glob
import warnings

import cartopy.crs as ccrs
import matplotlib.pyplot as plt


import pyart
from pyart.testing import get_test_data
import xarray as xr

warnings.filterwarnings('ignore')

What is gridding and why is it important?

Antenna vs. Cartesian Coordinates

Radar data, by default, is stored in a polar (or antenna) coordinate system, with the data coordinates stored as an angle (ranging from 0 to 360 degrees with 0 == North), and a radius from the radar, and an elevation which is the angle between the ground and the ground.

This format can be challenging to plot, since it is scan/radar specific. Also, it can make comparing with model data, which is on a lat/lon grid, challenging since one would need to transform the model daa cartesian coordinates to polar/antenna coordiantes.

Fortunately, PyART has a variety of gridding routines, which can be used to grid your data to a Cartesian grid. Once it is in this new grid, one can easily slice/dice the dataset, and compare to other data sources.

Why is Gridding Important?

Gridding is essential to combining multiple data sources (ex. multiple radars), and comparing to other data sources (ex. model data). There are also decisions that are made during the gridding process that have a large impact on the regridded data - for example:

• What resolution should my grid be?

• Which interpolation routine should I use?

• How smooth should my interpolated data be?

While there is not always a right or wrong answer, it is important to understand the options available, and document which routine you used with your data! Also - experiment with different options and choose the best for your use case!

An overview of gridding with Py-ART

Let’s dig into the regridding process with PyART!

Read in and Visualize a Test Dataset

Let’s start with the same file used in the previous notebook (PyART Basics), which is a radar file from Northern Oklahoma.

file = "../../data/uah-armor/RAW_NA_000_125_20080411182229"
radar = pyart.io.read(file)

Let’s plot up quick look of reflectivity, at the lowest elevation scan (closest to the ground)

fig = plt.figure(figsize=[12, 12])
display = pyart.graph.RadarDisplay(radar)
display.plot_ppi('reflectivity',
                 cmap='pyart_HomeyerRainbow')

As mentioned before, the dataset is currently in the antenna coordinate system measured as distance from the radar

Setup our Gridding Routine with pyart.map.grid_from_radars()

Py-ART has the Grid object which has characteristics similar to that of the Radar object, except that the data are stored in Cartesian coordinates instead of the radar’s antenna coordinates.

pyart.core.Grid?

Init signature:
pyart.core.Grid(
    time,
    fields,
    metadata,
    origin_latitude,
    origin_longitude,
    origin_altitude,
    x,
    y,
    z,
    projection=None,
    radar_latitude=None,
    radar_longitude=None,
    radar_altitude=None,
    radar_time=None,
    radar_name=None,
)
Docstring:     
A class for storing rectilinear gridded radar data in Cartesian coordinate.

Refer to the attribute section for information on the parameters.

To create a Grid object using legacy parameters present in Py-ART version
1.5 and before, use :py:func:`from_legacy_parameters`,
grid = Grid.from_legacy_parameters(fields, axes, metadata).

Attributes
----------
time : dict
    Time of the grid.
fields : dict of dicts
    Moments from radars or other variables.
metadata : dict
    Metadata describing the grid.
origin_longitude, origin_latitude, origin_altitude : dict
    Geographic coordinate of the origin of the grid.
x, y, z : dict, 1D
    Distance from the grid origin for each Cartesian coordinate axis in a
    one dimensional array. Defines the spacing along the three grid axes
    which is repeated throughout the grid, making a rectilinear grid.
nx, ny, nz : int
    Number of grid points along the given Cartesian dimension.
projection : dic or str
    Projection parameters defining the map projection used to transform
    from Cartesian to geographic coordinates. None will use the default
    dictionary with the 'proj' key set to 'pyart_aeqd' indicating that
    the native Py-ART azimuthal equidistant projection is used. Other
    values should specify a valid pyproj.Proj projparams dictionary or
    string. The special key '_include_lon_0_lat_0' is removed when
    interpreting this dictionary. If this key is present and set to True,
    which is required when proj='pyart_aeqd', then the radar longitude and
    latitude will be added to the dictionary as 'lon_0' and 'lat_0'.
    Use the :py:func:`get_projparams` method to retrieve a copy of this
    attribute dictionary with this special key evaluated.
radar_longitude, radar_latitude, radar_altitude : dict or None, optional
    Geographic location of the radars which make up the grid.
radar_time : dict or None, optional
    Start of collection for the radar which make up the grid.
radar_name : dict or None, optional
    Names of the radars which make up the grid.
nradar : int
    Number of radars whose data was used to make the grid.
projection_proj : Proj
    pyproj.Proj instance for the projection specified by the projection
    attribute. If the 'pyart_aeqd' projection is specified accessing this
    attribute will raise a ValueError.
point_x, point_y, point_z : LazyLoadDict
    The Cartesian locations of all grid points from the origin in the
    three Cartesian coordinates. The three dimensional data arrays
    contained these attributes are calculated from the x, y, and z
    attributes. If these attributes are changed use :py:func:
    `init_point_x_y_z` to reset the attributes.
point_longitude, point_latitude : LazyLoadDict
    Geographic location of each grid point. The projection parameter(s)
    defined in the `projection` attribute are used to perform an inverse
    map projection from the Cartesian grid point locations relative to
    the grid origin. If these attributes are changed use
    :py:func:`init_point_longitude_latitude` to reset the attributes.
point_altitude : LazyLoadDict
    The altitude of each grid point as calculated from the altitude of the
    grid origin and the Cartesian z location of each grid point.  If this
    attribute is changed use :py:func:`init_point_altitude` to reset the
    attribute.
Init docstring: Initalize object.
File:           /srv/conda/envs/notebook/lib/python3.9/site-packages/pyart/core/grid.py
Type:           type
Subclasses:     

We can transform our data into this grid object, from the radars, using pyart.map.grid_from_radars().

Beforing gridding our data, we need to make a decision about the desired grid resolution and extent. For example, one might imagine a grid configuration of:

• Grid extent/limits

  • 20 km in the x-direction (north/south)

  • 20 km in the y-direction (west/east)

  • 15 km in the z-direction (vertical)

• 500 m spatial resolution

The pyart.map.grid_from_radars() function takes the grid shape and grid limits as input, with the order (z, y, x).

Let’s setup our configuration, setting our grid extent first, with the distance measured in meters

z_grid_limits = (0.,15_000.)
y_grid_limits = (-150_000.,150_000.)
x_grid_limits = (-150_000.,150_000.)

Now that we have our grid limits, we can set our desired resolution (again, in meters)

grid_resolution = 500

Let’s compute our grid shape - using the extent and resolution to compute the number of grid points in each direction.

def compute_number_of_points(extent, resolution):
    return int((extent[1] - extent[0])/resolution)

Now that we have a helper function to compute this, let’s apply it to our vertical dimension

z_grid_points = compute_number_of_points(z_grid_limits, grid_resolution)
z_grid_points

30

We can apply this to the horizontal (x, y) dimensions as well.

x_grid_points = compute_number_of_points(x_grid_limits, grid_resolution)
y_grid_points = compute_number_of_points(y_grid_limits, grid_resolution)

print(z_grid_points,
      y_grid_points,
      x_grid_points)

30 600 600

Use our configuration to grid the data!

Now that we have the grid shape and grid limits, let’s grid up our radar!

grid = pyart.map.grid_from_radars(radar,
                                  grid_shape=(z_grid_points,
                                              y_grid_points,
                                              x_grid_points),
                                  grid_limits=(z_grid_limits,
                                               y_grid_limits,
                                               x_grid_limits),
                                  fields=['reflectivity'],
                                  gridding_algo='map_gates_to_grid',
                                  h_factor=0.,
                                  nb=0.6,
                                  bsp=1.,
                                  min_radius=200.
                                 )
grid

<pyart.core.grid.Grid at 0x7f1f460430a0>

We now have a pyart.core.Grid object!

Plot up the Grid Object

Plot a horizontal view of the data

We can use the GridMapDisplay from pyart.graph to visualize our regridded data, starting with a horizontal view (slice along a single vertical level)

display = pyart.graph.GridMapDisplay(grid)
display.plot_grid('reflectivity',
                  level=2,
                  vmin=-20,
                  vmax=60,
                  cmap='pyart_HomeyerRainbow')

Plot a Latitudinal Slice

We can also slice through a single latitude or longitude!

display.plot_latitude_slice('reflectivity',
                            lat=35.1,
                            vmin=-20,
                            vmax=60,
                            cmap='pyart_HomeyerRainbow')
plt.xlim([-20, 20]);

Plot with Xarray

Another neat feature of the Grid object is that we can transform it to an xarray.Dataset!

ds = grid.to_xarray()
ds

<xarray.Dataset>
Dimensions:       (time: 1, z: 30, y: 600, x: 600)
Coordinates:
  * time          (time) object 2008-04-11 18:22:42
  * z             (z) float64 0.0 517.2 1.034e+03 ... 1.448e+04 1.5e+04
    lat           (y, x) float64 33.29 33.29 33.29 33.29 ... 35.98 35.98 35.98
    lon           (y, x) float64 -88.39 -88.38 -88.37 ... -85.12 -85.11 -85.1
  * y             (y) float64 -1.5e+05 -1.495e+05 ... 1.495e+05 1.5e+05
  * x             (x) float64 -1.5e+05 -1.495e+05 ... 1.495e+05 1.5e+05
Data variables:
    reflectivity  (time, z, y, x) float32 nan nan nan nan ... nan nan nan nan
    ROI           (time, z, y, x) float32 2.222e+03 2.218e+03 ... 2.972e+03

xarray.Dataset

• Dimensions:
  • time: 1
  • z: 30
  • y: 600
  • x: 600
• Coordinates: (6)
  • time
    (time)
    object
    2008-04-11 18:22:42

    array([cftime.DatetimeGregorian(2008, 4, 11, 18, 22, 42, 0, has_year_zero=False)],
          dtype=object)

  • z
    (z)
    float64
    0.0 517.2 ... 1.448e+04 1.5e+04

    standard_name :

    projection_z_coordinate

    long_name :

    Z distance on the projection plane from the origin

    axis :

    Z

    units :

    m

    positive :

    up

    array([    0.      ,   517.241379,  1034.482759,  1551.724138,  2068.965517,
            2586.206897,  3103.448276,  3620.689655,  4137.931034,  4655.172414,
            5172.413793,  5689.655172,  6206.896552,  6724.137931,  7241.37931 ,
            7758.62069 ,  8275.862069,  8793.103448,  9310.344828,  9827.586207,
           10344.827586, 10862.068966, 11379.310345, 11896.551724, 12413.793103,
           12931.034483, 13448.275862, 13965.517241, 14482.758621, 15000.      ])

  • lat
    (y, x)
    float64
    33.29 33.29 33.29 ... 35.98 35.98

    long_name :

    latitude of grid cell center

    units :

    degree_N

    standard_name :

    Latitude

    array([[33.28654042, 33.28661159, 33.28668252, ..., 33.28668252,
            33.28661159, 33.28654042],
           [33.29104357, 33.29111474, 33.29118568, ..., 33.29118568,
            33.29111474, 33.29104357],
           [33.29554672, 33.2956179 , 33.29568884, ..., 33.29568884,
            33.2956179 , 33.29554672],
           ...,
           [35.97489386, 35.97496906, 35.97504401, ..., 35.97504401,
            35.97496906, 35.97489386],
           [35.97939692, 35.97947212, 35.97954708, ..., 35.97954708,
            35.97947212, 35.97939692],
           [35.98389998, 35.98397519, 35.98405015, ..., 35.98405015,
            35.98397519, 35.98389998]])

  • lon
    (y, x)
    float64
    -88.39 -88.38 ... -85.11 -85.1

    long_name :

    longitude of grid cell center

    units :

    degree_E

    standard_name :

    Longitude

    array([[-88.38515411, -88.37976717, -88.37438022, ..., -85.16861967,
            -85.16323272, -85.15784577],
           [-88.3852384 , -88.37985118, -88.37446395, ..., -85.16853594,
            -85.16314871, -85.15776148],
           [-88.38532271, -88.37993521, -88.37454769, ..., -85.16845219,
            -85.16306468, -85.15767718],
           ...,
           [-88.43833334, -88.43276899, -88.42720464, ..., -85.11579524,
            -85.11023089, -85.10466655],
           [-88.43842744, -88.43286279, -88.42729812, ..., -85.11570177,
            -85.1101371 , -85.10457244],
           [-88.43852156, -88.43295659, -88.42739161, ..., -85.11560827,
            -85.11004329, -85.10447832]])

  • y
    (y)
    float64
    -1.5e+05 -1.495e+05 ... 1.5e+05

    standard_name :

    projection_y_coordinate

    long_name :

    Y distance on the projection plane from the origin

    axis :

    Y

    units :

    m

    array([-150000.      , -149499.165275, -148998.330551, ...,  148998.330551,
            149499.165275,  150000.      ])

  • x
    (x)
    float64
    -1.5e+05 -1.495e+05 ... 1.5e+05

    standard_name :

    projection_x_coordinate

    long_name :

    X distance on the projection plane from the origin

    axis :

    X

    units :

    m

    array([-150000.      , -149499.165275, -148998.330551, ...,  148998.330551,
            149499.165275,  150000.      ])

• Data variables: (2)
  • reflectivity
    (time, z, y, x)
    float32
    nan nan nan nan ... nan nan nan nan

    units :

    dBZ

    standard_name :

    equivalent_reflectivity_factor

    long_name :

    Reflectivity

    coordinates :

    elevation azimuth range

    _FillValue :

    -9999.0

    array([[[[nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             ...,
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan]],
    
            [[nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             ...,
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan]],
    
            [[nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             ...,
    ...
             ...,
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan]],
    
            [[nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             ...,
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan]],
    
            [[nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             ...,
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan],
             [nan, nan, nan, ..., nan, nan, nan]]]], dtype=float32)

  • ROI
    (time, z, y, x)
    float32
    2.222e+03 2.218e+03 ... 2.972e+03

    standard_name :

    radius_of_influence

    long_name :

    Radius of influence for mapping

    units :

    m

    least_significant_digit :

    1

    _FillValue :

    -9999.0

    array([[[[2221.5227, 2217.8171, 2214.1177, ..., 2214.1174, 2217.817 ,
              2221.5227],
             [2217.8171, 2214.1052, 2210.3997, ..., 2210.3994, 2214.1052,
              2217.8171],
             [2214.1177, 2210.3997, 2206.6877, ..., 2206.6877, 2210.3997,
              2214.1177],
             ...,
             [2214.1174, 2210.3994, 2206.6877, ..., 2206.6875, 2210.3994,
              2214.1174],
             [2217.817 , 2214.1052, 2210.3997, ..., 2210.3994, 2214.105 ,
              2217.817 ],
             [2221.5227, 2217.8171, 2214.1177, ..., 2214.1174, 2217.817 ,
              2221.5227]],
    
            [[2247.3848, 2243.6792, 2239.9797, ..., 2239.9795, 2243.679 ,
              2247.3848],
             [2243.6792, 2239.9673, 2236.2617, ..., 2236.2615, 2239.9673,
              2243.6792],
             [2239.9797, 2236.2617, 2232.5498, ..., 2232.5498, 2236.2617,
              2239.9797],
    ...
             [2938.2554, 2934.5374, 2930.8257, ..., 2930.8254, 2934.5374,
              2938.2554],
             [2941.9548, 2938.2432, 2934.5376, ..., 2934.5374, 2938.243 ,
              2941.9548],
             [2945.6606, 2941.955 , 2938.2556, ..., 2938.2554, 2941.9548,
              2945.6606]],
    
            [[2971.5227, 2967.8171, 2964.1177, ..., 2964.1174, 2967.817 ,
              2971.5227],
             [2967.8171, 2964.1052, 2960.3997, ..., 2960.3994, 2964.1052,
              2967.8171],
             [2964.1177, 2960.3997, 2956.6877, ..., 2956.6877, 2960.3997,
              2964.1177],
             ...,
             [2964.1174, 2960.3994, 2956.6877, ..., 2956.6875, 2960.3994,
              2964.1174],
             [2967.817 , 2964.1052, 2960.3997, ..., 2960.3994, 2964.105 ,
              2967.817 ],
             [2971.5227, 2967.8171, 2964.1177, ..., 2964.1174, 2967.817 ,
              2971.5227]]]], dtype=float32)

• Indexes: (4)
  • time
    PandasIndex

    PandasIndex(CFTimeIndex([2008-04-11 18:22:42],
                dtype='object', length=1, calendar='standard', freq=None))

  • z
    PandasIndex

    PandasIndex(Index([               0.0,  517.2413793103449, 1034.4827586206898,
           1551.7241379310346, 2068.9655172413795, 2586.2068965517246,
           3103.4482758620693,  3620.689655172414,  4137.931034482759,
            4655.172413793104,  5172.413793103449, 5689.6551724137935,
            6206.896551724139,  6724.137931034484,  7241.379310344828,
            7758.620689655173,  8275.862068965518,  8793.103448275862,
            9310.344827586208,  9827.586206896553, 10344.827586206899,
           10862.068965517243, 11379.310344827587, 11896.551724137933,
           12413.793103448277, 12931.034482758621, 13448.275862068967,
           13965.517241379312, 14482.758620689656,            15000.0],
          dtype='float64', name='z'))

  • y
    PandasIndex

    PandasIndex(Index([          -150000.0,  -149499.1652754591,  -148998.3305509182,
            -148497.4958263773,  -147996.6611018364, -147495.82637729548,
            -146994.9916527546,  -146494.1569282137, -145993.32220367278,
           -145492.48747913187,
           ...
             145492.4874791319,  145993.32220367278,  146494.15692821366,
             146994.9916527546,  147495.82637729548,  147996.66110183642,
             148497.4958263773,  148998.33055091818,  149499.16527545912,
                      150000.0],
          dtype='float64', name='y', length=600))

  • x
    PandasIndex

    PandasIndex(Index([          -150000.0,  -149499.1652754591,  -148998.3305509182,
            -148497.4958263773,  -147996.6611018364, -147495.82637729548,
            -146994.9916527546,  -146494.1569282137, -145993.32220367278,
           -145492.48747913187,
           ...
             145492.4874791319,  145993.32220367278,  146494.15692821366,
             146994.9916527546,  147495.82637729548,  147996.66110183642,
             148497.4958263773,  148998.33055091818,  149499.16527545912,
                      150000.0],
          dtype='float64', name='x', length=600))

• Attributes: (0)

Now, our plotting routine is a one-liner, starting with the horizontal slice:

ds.isel(z=2).reflectivity.plot(cmap='pyart_HomeyerRainbow',
                               vmin=-20,
                               vmax=60);

And a vertical slice at a given y dimension (latitude)

ds.sel(y=-3000,
       method='nearest').reflectivity.plot(cmap='pyart_HomeyerRainbow',
                                           vmin=-20,
                                           vmax=60);

Try a Different Gridding Technique

nearest_grid = pyart.map.grid_from_radars(radar,
                                  grid_shape=(z_grid_points,
                                              y_grid_points,
                                              x_grid_points),
                                  grid_limits=(z_grid_limits,
                                               y_grid_limits,
                                               x_grid_limits),
                                  fields=['reflectivity'],
                                  weighting_function='Nearest',
                                  nb=0.6,
                                  bsp=1.,
                                  min_radius=200.
                                 )

display.plot_latitude_slice('reflectivity',
                            lat=35.1,
                            vmin=-20,
                            vmax=60,
                            cmap='pyart_HomeyerRainbow')
plt.xlim([-20, 20]);

display = pyart.graph.GridMapDisplay(nearest_grid)
display.plot_latitude_slice('reflectivity',
                            lat=35.1,
                            vmin=-20,
                            vmax=60,
                            cmap='pyart_HomeyerRainbow')
plt.xlim([-20, 20]);

Apply Gridding to a Selection of Files

We would like to apply our gridding transformation to an entire list of files, that will enable tracking in future notebooks (ex. tobac). We need to:

• Setup a function to grid our data (including saving it to disk)

• Provide a list of files to grid

def grid_radar_data(infile, outdir, grid_resolution=500):
    """
    Parameters
    ==========
    infile: string, path to file to be gridded
    outdir: string, path to directory to save to
    grid_resolution: int, desired resolution of field in meters
    
    Returns
    =======
    print statement with saved file
    """
    
    # Read the data
    radar = pyart.io.read(infile)
    
    # Configure the bounds + compute points
    z_grid_limits = (0.,15_000.)
    y_grid_limits = (-150_000.,150_000.)
    x_grid_limits = (-150_000.,150_000.)
    x_grid_points = compute_number_of_points(x_grid_limits, grid_resolution)
    y_grid_points = compute_number_of_points(y_grid_limits, grid_resolution)
    z_grid_points = compute_number_of_points(z_grid_limits, grid_resolution)
    
    
    # Grid the radar data
    grid = pyart.map.grid_from_radars(radar,
                                  grid_shape=(z_grid_points,
                                              y_grid_points,
                                              x_grid_points),
                                  grid_limits=(z_grid_limits,
                                               y_grid_limits,
                                               x_grid_limits),
                                  fields=['reflectivity'],
                                  weighting_function='Nearest',
                                  nb=0.6,
                                  bsp=1.,
                                  min_radius=200.
                                 )
    
    infile_path = Path(infile)
    
    outfile = f"{outdir}/{infile_path.stem}.nc"
    
    # Save to disk
    grid.to_xarray().to_netcdf(outfile, mode='w')
    print(f"Done gridding + saving {outfile}")
    return outfile

import fsspec

fs = fsspec.filesystem("https")

files = ["RAW_NA_000_125_20080411181219",
         "RAW_NA_000_125_20080411181722",
         "RAW_NA_000_125_20080411182229",
         "RAW_NA_000_125_20080411182732",
         "RAW_NA_000_125_20080411183259",
         "RAW_NA_000_125_20080411183827",
         "RAW_NA_000_125_20080411184409",
         "RAW_NA_000_125_20080411184937",
         "RAW_NA_000_125_20080411185504",
         "RAW_NA_000_125_20080411190016",
         "RAW_NA_000_125_20080411190525",
         "RAW_NA_000_125_20080411191031",
         "RAW_NA_000_125_20080411191548",
         "RAW_NA_000_125_20080411192104",
         "RAW_NA_000_125_20080411192613",
         "RAW_NA_000_125_20080411193127",
         "RAW_NA_000_125_20080411193638",
         "RAW_NA_000_125_20080411194151",
         "RAW_NA_000_125_20080411194703",
         "RAW_NA_000_125_20080411195218",
         "RAW_NA_000_125_20080411195728",
         "RAW_NA_000_125_20080411200416",
         "RAW_NA_000_125_20080411200945",
         "RAW_NA_000_125_20080411201520",
         "RAW_NA_000_125_20080411202047"
        ]

import urllib.request
import glob

def download_file(file, outdir='../../data/uah-armor/'):
    urllib.request.urlretrieve(f"https://github.com/openradar/open-radar-data/raw/main/data/{file}", f"{outdir}{file}")
    return f"{outdir}{file}"

downloaded_files = [download_file(file) for file in files]

gridded_data = [grid_radar_data(file,
                                "../../data/uah-armor/gridded") for file in downloaded_files]
    

Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411181219.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411181722.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411182229.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411182732.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411183259.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411183827.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411184409.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411184937.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411185504.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411190016.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411190525.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411191031.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411191548.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411192104.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411192613.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411193127.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411193638.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411194151.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411194703.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411195218.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411195728.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411200416.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411200945.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411201520.nc
Done gridding + saving ../../data/uah-armor/gridded/RAW_NA_000_125_20080411202047.nc

Read in the Gridded Data and Plot It

Now that we have our output, we can read all of it into the same xarray.Dataset, and visualize our data!

ds = xr.open_mfdataset(gridded_data).squeeze()

ds.reflectivity.isel(z=2).plot(x='x',
                               y='y',
                               col='time',
                               vmin=-20,
                               vmax=70,
                               cmap='pyart_ChaseSpectral',
                               col_wrap=5);

---

Summary

Within this notebook, we covered the basics of gridding radar data using pyart, including:

• What we mean by gridding and why is it matters

• Configuring your gridding routine

• Visualize gridded radar data

What’s Next

In the next few notebooks, we walk through applying data cleaning methods, and advanced visualization methods!

Resources and References

Py-ART essentials links:

• Landing page

• Examples

• Source Code

• Mailing list

• Issue Tracker

previous

Py-ART Corrections

next

Pyrad Tutorial