Ytukyg

What is the best way to determine which coordinates of an xarray dataArray object contain longitude, latitude and time?

A typical dataArray might look like this:

<xarray.Dataset>

Dimensions:    (ensemble: 9, lat: 224, lon: 464, time: 12054)

Coordinates:

  * lat        (lat) float64 25.06 25.19 25.31 25.44 ... 52.56 52.69 52.81 52.94

  * lon        (lon) float64 -124.9 -124.8 -124.7 ... -67.31 -67.19 -67.06

  * time       (time) datetime64[ns] 1980-01-01 1980-01-02 ... 2012-12-31

Dimensions without coordinates: ensemble

Data variables:

    elevation  (lat, lon) float64 dask.array<shape=(224, 464), chunksize=(224, 464)>

    temp       (ensemble, time, lat, lon) float64 dask.array<shape=(9, 12054, 224, 464), chunksize=(1, 287, 224, 464)>

One approach could be to loop through the variables identified by the variable coords, like temp.coords, looking for the standard_name attributes of time, longitude, and latitude. But many datasets don't seem to include standard_name attributes for all variables.

I guess another approach be to search over the units attributes and try to identify if they have appropriate units attributes (e.g. degrees_east or degrees_west for longitude, etc).

Is there a better way?

The MetPy package includes some helpers for systematic coordinate identification like this. You can see the basics of how this works in the xarray with MetPy tutorial. For example, if you want the time coordinate of a DataArray called temp (assuming it came from a dataset that has been parsed by MetPy), you would simply call:

temp.metpy.time

This is done internally by parsing the coordinate metadata according to the CF conventions.

Here's a short example:

import xarray as xr

import metpy.calc as mpcalc



ds = xr.tutorial.load_dataset('air_temperature')

ds = ds.metpy.parse_cf()



x,y,t = ds['air'].metpy.coordinates('x','y','time')



print([coord.name for coord in (x, y, t)])

which produces:

['lon', 'lat', 'time']

You can probably do something similar to the code below with xarray filter_by:

def x_axis(nc):

    xnames = ['longitude', 'grid_longitude', 'projection_x_coordinate']

    xunits = [

        'degrees_east',

        'degree_east',

        'degree_E',

        'degrees_E',

        'degreeE',

        'degreesE',

    ]

    xvars = list(set(

        nc.get_variables_by_attributes(

            axis=lambda x: x and str(x).lower() == 'x'

        ) +

        nc.get_variables_by_attributes(

            standard_name=lambda x: x and str(x).lower() in xnames

        ) +

        nc.get_variables_by_attributes(

            units=lambda x: x and str(x).lower() in xunits

        )

    ))

    return xvars

I think we should lean heavily on CF conventions. They exist precisely for this reason. So I would recommend separating this problem into two parts:

• Fixing non-CF-complaint datasets (perhaps a small library for this purpose would make sense--it could contain the logic to translate common variable names into appropriate standard_name attributes)


• Parsing CF-complaint datasets (can leverage standard_name attributes)

If you are looking for just the special coords that act as indexes, then you can iterate over the ds.indexes and do some string parsing on their names. Something like:

ds = xr.tutorial.load_dataset('air_temperature')

ds.lat.attrs.pop('standard_name')



for k in ds.indexes.keys():

    v = ds[k]

    sn = v.attrs.get('standard_name')

    if not sn:

        if 'lon' in k:

            v.attrs.update(standard_name='longitude')

            continue

        if 'lat' in k:

            v.attrs.update(standard_name='latitude')

            continue

        if 'time' in k or k in ['day', 't', 'month', 'year']:

            v.attrs.update(standard_name='time')