按维度名称提取netcdf4变量切片

Question

I have a netCDF file with 4 dimensions. I want to extract a slice from the netCDF file by giving the name of one of the dimensions

I know how to do this by position. Eg

from netCDF4 import Dataset
hndl_nc = Dataset(path_to_nc)

# Access by slice
hndl_nc.variables['name_variable'][:,5,:,:]

Given that I know the names of the dimensions, say A , B , C , D . How do I access by dimension name instead of position?

Answer 1

You can use xarray 's indexing capabilities to access netcdf data by dimension name.

import xarray as xr
ds = xr.open_dataset('./foo.nc')
var = ds['name_variable']
# Slice var by Dimension "A" between values 0 and 5
var_slice = var.sel(A=slice(0,5))

Answer 2

It seems the closest current solution is

np.take(nc4_variable[:],dim_ids,axis=dim)

or

nc4_variable[:].take(dim_ids,axis=dim)

where dim_ids is a list or tuple of your slices, and dim is the dimension along which you want to slice. Unfortunately, this seems to load the entire dataset first, and there doesn't seem to be a way around that; the [:] is necessary. Neglecting it in the first method loads data without adjustments from the add_offset , _FillValue , etc. parameters; neglecting it in the second method yields an error.

Testing with %timeit in Ipython confirms major differences between normal slicing and the np.take method.

Hope someone comes up with a more complete answer to this; would be very useful for diverse datasets.

Answer 3

So, I might have come up with something that could qualify as a " solution ".

numpy arrays can evidently be indexed with a singleton list of iterables, eg

a = np.reshape(range(0,16),(4,4),order='F')
a = a[ [[0,1], [1]] ]

returns a equal to array([4,5]) . Another example would be [[range(3),[1 2],3]] . These singleton lists are unfurled in the manner of *subscripts , as if you had directly queried a[[0,1],1] instead of a[ [[0,1],1] ] .

So, if you are able to query the position and length of each dimension in your netCDF variable (pretty easy with nc_fid[var].dimension and nc_fid[var].shape ), then you can simply permute a list according to the location of each dimension. For example, if you have data of shape time by lon by lat, and you want all longitudes, all latitudes, and time index t=5 , you can use something like

order_want = ['lon', 'lat', 'time'] # must figure out dimension names a priori
nlon = nc_fid[var].shape[nc_fid[var].dimensions.index('lon')]
nlat = nc_fid[var].shape[nc_fid[var].dimensions.index('lat')]
ids = [ range(0,nlon), range(0,nlat), 5 ]
ids_permute = [order_want.index(n) for n in nc_fid[var].dimensions] 
ids_query = [l[i] for l,i in zip(ids,ids_permute)]

sliced_data = nc_fid[var][list_query]

This requires no a priori knowledge of the dimension position, and does not require loading all dimensions of the variable.

Note that after some %timeit testing in IPython, it appears there is some special delay for all-integer indexing, eg list_query = [0,0,0,0] will take 80ms whereas list_query = [range(1),0,0,0] or even list_query = [[0,1,2,3,4,5],0,0,0] will take 1ms . Very mysterious; anyway, evidently you should try to make sure list_query is not just a list of integers.