What happened: The example of plotting data using pcolormesh has some spurious lines:

What you expected to happen: No spurious lines.

Minimal Complete Verifiable Example:

```python %matplotlib inline import numpy as np import pandas as pd import xarray as xr import cartopy.crs as ccrs from matplotlib import pyplot as plt

ds = xr.tutorial.open_dataset('rasm').load()

plt.figure(figsize=(14,6))

ax = plt.axes(projection=ccrs.PlateCarree()) ax.set_global()

ds.Tair[0].plot.pcolormesh(ax=ax, transform=ccrs.PlateCarree(), x='xc', y='yc', shading='auto', add_colorbar=False)

ax.coastlines() ax.set_ylim([0,90]); ```

Anything else we need to know?: pcolormesh doc

Environment:

What happened?

I got different results when I tried to plot 2D data test.npy.zip using matplotlib and xarray.

matplotlib

xarray

What did you expect to happen?

Same plot.

Minimal Complete Verifiable Example

```Python import numpy as np import xarray as xr import matplotlib.pyplot as plt

test = np.load('test.npy')

plt.imshow(test, vmin=0, vmax=200) plt.colorbar()

xr.DataArray(test).plot.imshow(vmin=0, vmax=200) ```

MVCE confirmation

• [X] Minimal example — the example is as focused as reasonably possible to demonstrate the underlying issue in xarray.
• [X] Complete example — the example is self-contained, including all data and the text of any traceback.
• [X] Verifiable example — the example copy & pastes into an IPython prompt or Binder notebook, returning the result.
• [X] New issue — a search of GitHub Issues suggests this is not a duplicate.
• [X] Recent environment — the issue occurs with the latest version of xarray and its dependencies.

Relevant log output

No response

Anything else we need to know?

No response

Environment

Is your feature request related to a problem?

Sometimes, the mask used in .where(mask) may have nan values. In the current stage, xarray just neglects them. But, it also makes sense that users want to mask data with nan values.

Describe the solution you'd like

This option can be achieved by adding skipna=bool.

if skipna=False, the nan values in mask will be replaced by 0:mask.fillna(0). By default, it's skipna=True which is current function.

Describe alternatives you've considered

No response

Additional context

No response

The 3D array has three dims: z, y and x. The 2D array has two dims: y and x. When I try to concatenate them by expanding the 2D array with z dim, there's something wrong in _dataset_concat

MCVE Code Sample

```python import xarray as xr import numpy as np

x = 2 y = 4 z = 3 data = np.arange(xyz).reshape(z, x, y)

3d array with coords

a = xr.DataArray(data, dims=['z', 'y', 'x'], coords={'z': np.arange(z)})

2d array without coords

b = xr.DataArray(np.arange(xy).reshape(x, y)1.5, dims=['y', 'x'])

expand 2d to 3d

b = b.expand_dims('z')

concat

comb = xr.concat([a, b], dim='z') ```

Expected Output

Same as np.concatenate: concat_array = np.concatenate((a, b)) comb = xr.DataArray(concat_array, dims={'z', 'y', 'x'})

``` <xarray.DataArray (z: 4, x: 2, y: 4)> array([[[ 0. , 1. , 2. , 3. ], [ 4. , 5. , 6. , 7. ]],

   [[ 8. ,  9. , 10. , 11. ],
    [12. , 13. , 14. , 15. ]],

   [[16. , 17. , 18. , 19. ],
    [20. , 21. , 22. , 23. ]],

   [[ 0. ,  1.5,  3. ,  4.5],
    [ 6. ,  7.5,  9. , 10.5]]])

Dimensions without coordinates: z, x, y ```

Problem Description

comb = xr.concat([a, b], dim='z') File "E:\miniconda3\envs\satpy\lib\site-packages\xarray\core\concat.py", line 135, in concat return f(objs, dim, data_vars, coords, compat, positions, fill_value, join) File "E:\miniconda3\envs\satpy\lib\site-packages\xarray\core\concat.py", line 455, in _dataarray_concat join=join, File "E:\miniconda3\envs\satpy\lib\site-packages\xarray\core\concat.py", line 395, in _dataset_concat raise ValueError("%r is not present in all datasets." % k) ValueError: 'z' is not present in all datasets.

As suggested by @dcherian, assigning the coordinate label by changing b = b.expand_dims('z') to b = b.expand_dims(z=[3]) makes it work.

Versions

When DataArray is masked by .where(), the type is converted to float64.

But, if we need to use the DataArray ouput from .where() in .isel(), the dtype should be int. (#3949 )

MCVE Code Sample

```python import numpy as np import xarray as xr

val_arr = xr.DataArray(np.arange(27).reshape(3, 3, 3), dims=['z', 'y', 'x'])

z_indices = xr.DataArray(np.array([[1, 0, 2], [0, 0, 1], [-2222, 0, 1]]), dims=['y', 'x'])

fill_value = -2222 sub = z_indices.where(z_indices != fill_value) indexed_array = val_arr.isel(z=sub) ```

Expected Output

array([[ 1, 0, 2], [ 0, 0, 1], [nan, 0, 1]])

Problem Description

File "E:\miniconda3\envs\satpy\lib\site-packages\xarray\core\indexing.py", line 446, in __init__ f"invalid indexer array, does not have integer dtype: {k!r}" TypeError: invalid indexer array, does not have integer dtype: array([[ 1., 0., 2.], [ 0., 0., 1.], [nan, 0., 1.]])

Currently, pandas supports NaN values. Is this possible for xarray? or another method around?

Sometimes we have one attribute called ancillary_variables which is a list containing several strings. It would be useful to decode them.

MCVE Code Sample

```python import numpy as np import xarray as xr import pandas as pd

temp = 15 + 8 * np.random.randn(2, 2, 3) precip = 10 * np.random.rand(2, 2, 3)

temp = xr.DataArray(temp, dims=['x', 'y', 'time']) precip = xr.DataArray(precip, dims=['x', 'y', 'time'])

lon = [[-99.83, -99.32], [-99.79, -99.23]] lat = [[42.25, 42.21], [42.63, 42.59]]

temp.attrs['ancillary_variables'] = ['precip'] precip.attrs['ancillary_variables'] = ['temp']

ds = xr.Dataset({'temperature': temp, 'precipitation': precip}, coords={'lon': (['x', 'y'], lon), 'lat': (['x', 'y'], lat), 'time': pd.date_range('2014-09-06', periods=3), 'reference_time': pd.Timestamp('2014-09-05')})

ds.to_netcdf('test_ancillary_variables.nc', engine='netcdf4')

ds_new = xr.open_dataset('test_ancillary_variables.nc', decode_cf=True) print(ds_new['temperature']) ```

Expected Output

...... Attributes: ancillary_variables: [<xarray.DataArray (x: 2, y: 2, time: 3)> ......... ]

Versions

.sortby() only supports sorting DataArray by coords values. I'm trying to sort one DataArray (cld) by data values along one dim and sort another DataArray (pair) by the same order.

MCVE Code Sample

```python import xarray as xr import numpy as np

x = 4 y = 2 z = 4 data = np.arange(xyz).reshape(z, y, x)

3d array with coords

cld_1 = xr.DataArray(data, dims=['z', 'y', 'x'], coords={'z': np.arange(z)})

2d array without coords

cld_2 = xr.DataArray(np.arange(xy).reshape(y, x)1.5+1, dims=['y', 'x'])

expand 2d to 3d

cld_2 = cld_2.expand_dims(z=[4])

concat

cld = xr.concat([cld_1, cld_2], dim='z')

paired array

pair = cld.copy(data=np.arange(xy(z+1)).reshape(z+1, y, x))

print(cld) print(pair) ```

Output

``` <xarray.DataArray (z: 5, y: 2, x: 4)> array([[[ 0. , 1. , 2. , 3. ], [ 4. , 5. , 6. , 7. ]],

   [[ 8. ,  9. , 10. , 11. ],
    [12. , 13. , 14. , 15. ]],

   [[16. , 17. , 18. , 19. ],
    [20. , 21. , 22. , 23. ]],

   [[24. , 25. , 26. , 27. ],
    [28. , 29. , 30. , 31. ]],

   [[ 1. ,  2.5,  4. ,  5.5],
    [ 7. ,  8.5, 10. , 11.5]]])

Coordinates: * z (z) int64 0 1 2 3 4 Dimensions without coordinates: y, x

<xarray.DataArray (z: 5, y: 2, x: 4)> array([[[ 0, 1, 2, 3], [ 4, 5, 6, 7]],

   [[ 8,  9, 10, 11],
    [12, 13, 14, 15]],

   [[16, 17, 18, 19],
    [20, 21, 22, 23]],

   [[24, 25, 26, 27],
    [28, 29, 30, 31]],

   [[32, 33, 34, 35],
    [36, 37, 38, 39]]])

Coordinates: * z (z) int64 0 1 2 3 4 Dimensions without coordinates: y, x ```

Problem Description

I've tried argsort(): cld.argsort(axis=0), but the result is wrong: ``` <xarray.DataArray (z: 5, y: 2, x: 4)> array([[[0, 0, 0, 0], [0, 0, 0, 0]],

   [[4, 4, 4, 4],
    [4, 4, 4, 4]],

   [[1, 1, 1, 1],
    [1, 1, 1, 1]],

   [[2, 2, 2, 2],
    [2, 2, 2, 2]],

   [[3, 3, 3, 3],
    [3, 3, 3, 3]]], dtype=int64)

Coordinates: * z (z) int64 0 1 2 3 4 Dimensions without coordinates: y, x ```

What happened?

I'm trying to interpolate multi-dimensional data. But, it doesn't work with extrapolating.

What did you expect to happen?

No response

Minimal Complete Verifiable Example

```python import xarray as xr import numpy as np

da = xr.DataArray( np.sin(0.3 * np.arange(20).reshape(5, 4)), [("x", np.arange(5)), ("y", [0.1, 0.2, 0.3, 0.4])], ) x = xr.DataArray([-0.5, 1.5, 2.5], dims="z")

y = xr.DataArray([0.15, 0.25, 0.35], dims="z")

da.interp(x=x, y=y, kwargs={"fill_value": "extrapolate"}) ```

Relevant log output

```python

ValueError Traceback (most recent call last) Input In [2], in <module> 8 x = xr.DataArray([-0.5, 1.5, 2.5], dims="z") 10 y = xr.DataArray([0.15, 0.25, 0.35], dims="z") ---> 12 da.interp(x=x, y=y, kwargs={"fill_value": "extrapolate"})

File ~/miniconda3/lib/python3.9/site-packages/xarray/core/dataarray.py:1742, in DataArray.interp(self, coords, method, assume_sorted, kwargs, coords_kwargs) 1737 if self.dtype.kind not in "uifc": 1738 raise TypeError( 1739 "interp only works for a numeric type array. " 1740 "Given {}.".format(self.dtype) 1741 ) -> 1742 ds = self._to_temp_dataset().interp( 1743 coords, 1744 method=method, 1745 kwargs=kwargs, 1746 assume_sorted=assume_sorted, 1747 coords_kwargs, 1748 ) 1749 return self._from_temp_dataset(ds)

File ~/miniconda3/lib/python3.9/site-packages/xarray/core/dataset.py:3192, in Dataset.interp(self, coords, method, assume_sorted, kwargs, method_non_numeric, coords_kwargs) 3189 if dtype_kind in "uifc": 3190 # For normal number types do the interpolation: 3191 var_indexers = {k: v for k, v in use_indexers.items() if k in var.dims} -> 3192 variables[name] = missing.interp(var, var_indexers, method, kwargs) 3193 elif dtype_kind in "ObU" and (use_indexers.keys() & var.dims): 3194 # For types that we do not understand do stepwise 3195 # interpolation to avoid modifying the elements. (...) 3198 # this loop there might be some duplicate code that slows it 3199 # down, therefore collect these signals and run it later: 3200 to_reindex[name] = var

File ~/miniconda3/lib/python3.9/site-packages/xarray/core/missing.py:640, in interp(var, indexes_coords, method, *kwargs) 638 original_dims = broadcast_dims + dims 639 new_dims = broadcast_dims + list(destination[0].dims) --> 640 interped = interp_func( 641 var.transpose(original_dims).data, x, destination, method, kwargs 642 ) 644 result = Variable(new_dims, interped, attrs=var.attrs) 646 # dimension of the output array

File ~/miniconda3/lib/python3.9/site-packages/xarray/core/missing.py:765, in interp_func(var, x, new_x, method, kwargs) 749 meta = var._meta 751 return da.blockwise( 752 _dask_aware_interpnd, 753 out_ind, (...) 762 align_arrays=False, 763 ) --> 765 return _interpnd(var, x, new_x, func, kwargs)

File ~/miniconda3/lib/python3.9/site-packages/xarray/core/missing.py:789, in _interpnd(var, x, new_x, func, kwargs) 787 # stack new_x to 1 vector, with reshape 788 xi = np.stack([x1.values.ravel() for x1 in new_x], axis=-1) --> 789 rslt = func(x, var, xi, **kwargs) 790 # move back the interpolation axes to the last position 791 rslt = rslt.transpose(range(-rslt.ndim + 1, 1))

File ~/miniconda3/lib/python3.9/site-packages/scipy/interpolate/interpolate.py:2703, in interpn(points, values, xi, method, bounds_error, fill_value) 2701 # perform interpolation 2702 if method == "linear": -> 2703 interp = RegularGridInterpolator(points, values, method="linear", 2704 bounds_error=bounds_error, 2705 fill_value=fill_value) 2706 return interp(xi) 2707 elif method == "nearest":

File ~/miniconda3/lib/python3.9/site-packages/scipy/interpolate/interpolate.py:2469, in RegularGridInterpolator.init(self, points, values, method, bounds_error, fill_value) 2465 fill_value_dtype = np.asarray(fill_value).dtype 2466 if (hasattr(values, 'dtype') and not 2467 np.can_cast(fill_value_dtype, values.dtype, 2468 casting='same_kind')): -> 2469 raise ValueError("fill_value must be either 'None' or " 2470 "of a type compatible with values") 2472 for i, p in enumerate(points): 2473 if not np.all(np.diff(p) > 0.):

ValueError: fill_value must be either 'None' or of a type compatible with values ```

Anything else we need to know?

I've also tried da.interp(x=x, kwargs={"fill_value": "extrapolate"}).interp(y=y), but I got this error: ```

KeyError Traceback (most recent call last) Input In [4], in <module> 10 y = xr.DataArray([0.15, 0.25, 0.35], dims="z") 12 # da.interp(x=x, y=y, kwargs={"fill_value": "extrapolate"}) ---> 13 da.interp(x=x, kwargs={"fill_value": "extrapolate"}).interp(y=y)

File ~/miniconda3/lib/python3.9/site-packages/xarray/core/dataarray.py:1742, in DataArray.interp(self, coords, method, assume_sorted, kwargs, coords_kwargs) 1737 if self.dtype.kind not in "uifc": 1738 raise TypeError( 1739 "interp only works for a numeric type array. " 1740 "Given {}.".format(self.dtype) 1741 ) -> 1742 ds = self._to_temp_dataset().interp( 1743 coords, 1744 method=method, 1745 kwargs=kwargs, 1746 assume_sorted=assume_sorted, 1747 coords_kwargs, 1748 ) 1749 return self._from_temp_dataset(ds)

File ~/miniconda3/lib/python3.9/site-packages/xarray/core/dataset.py:3130, in Dataset.interp(self, coords, method, assume_sorted, kwargs, method_non_numeric, *coords_kwargs) 3121 if coords: 3122 # This avoids broadcasting over coordinates that are both in 3123 # the original array AND in the indexing array. It essentially 3124 # forces interpolation along the shared coordinates. 3125 sdims = ( 3126 set(self.dims) 3127 .intersection([set(nx.dims) for nx in indexers.values()]) 3128 .difference(coords.keys()) 3129 ) -> 3130 indexers.update({d: self.variables[d] for d in sdims}) 3132 obj = self if assume_sorted else self.sortby([k for k in coords]) 3134 def maybe_variable(obj, k): 3135 # workaround to get variable for dimension without coordinate.

File ~/miniconda3/lib/python3.9/site-packages/xarray/core/dataset.py:3130, in <dictcomp>(.0) 3121 if coords: 3122 # This avoids broadcasting over coordinates that are both in 3123 # the original array AND in the indexing array. It essentially 3124 # forces interpolation along the shared coordinates. 3125 sdims = ( 3126 set(self.dims) 3127 .intersection(*[set(nx.dims) for nx in indexers.values()]) 3128 .difference(coords.keys()) 3129 ) -> 3130 indexers.update({d: self.variables[d] for d in sdims}) 3132 obj = self if assume_sorted else self.sortby([k for k in coords]) 3134 def maybe_variable(obj, k): 3135 # workaround to get variable for dimension without coordinate.

File ~/miniconda3/lib/python3.9/site-packages/xarray/core/utils.py:459, in Frozen.getitem(self, key) 458 def getitem(self, key: K) -> V: --> 459 return self.mapping[key]

KeyError: 'z' ```

Environment

```python INSTALLED VERSIONS

commit: None python: 3.9.7 | packaged by conda-forge | (default, Sep 29 2021, 19:20:46) [GCC 9.4.0] python-bits: 64 OS: Linux OS-release: 5.11.0-40-generic machine: x86_64 processor: x86_64 byteorder: little LC_ALL: None LANG: en_US.UTF-8 LOCALE: ('en_US', 'UTF-8') libhdf5: 1.12.1 libnetcdf: 4.8.1

xarray: 0.20.2 pandas: 1.3.5 numpy: 1.19.5 scipy: 1.7.3 netCDF4: 1.5.8 pydap: None h5netcdf: None h5py: 3.6.0 Nio: None zarr: 2.10.3 cftime: 1.5.1.1 nc_time_axis: None PseudoNetCDF: None rasterio: 1.2.10 cfgrib: None iris: None bottleneck: None dask: 2021.12.0 distributed: 2021.12.0 matplotlib: 3.5.1 cartopy: 0.20.2 seaborn: None numbagg: None fsspec: 2022.01.0 cupy: None pint: 0.18 sparse: None setuptools: 59.8.0 pip: 21.3.1 conda: 4.11.0 pytest: None IPython: 8.0.0 sphinx: None ```

What happened:

The uint data type variables are read as float64 instead of the correct uint type.

Minimal Complete Verifiable Example:

```python import xarray as xr

print(xr.open_dataset('test_save.nc')['processing_quality_flags'].dtype) ```

Anything else we need to know?:

The sample data is attached here. The output of ncdump -h test_save.nc: netcdf test_save { dimensions: y = 3246 ; x = 450 ; variables: float longitude(y, x) ; longitude:_FillValue = NaNf ; longitude:name = "longitude" ; longitude:standard_name = "longitude" ; longitude:units = "degrees_east" ; float latitude(y, x) ; latitude:_FillValue = NaNf ; latitude:name = "latitude" ; latitude:standard_name = "latitude" ; latitude:units = "degrees_north" ; uint processing_quality_flags(y, x) ; processing_quality_flags:_FillValue = 4294967295U ; processing_quality_flags:comment = "Flags indicating conditions that affect quality of the retrieval." ; processing_quality_flags:end_time = "2019-07-02 05:00:24" ; processing_quality_flags:file_key = "PRODUCT/SUPPORT_DATA/DETAILED_RESULTS/processing_quality_flags" ; processing_quality_flags:file_type = "tropomi_l2" ; processing_quality_flags:flag_masks = 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 256U, 512U, 1024U, 2048U, 4096U, 8192U, 16384U, 32768U, 65536U, 131072U, 262144U, 524288U, 1048576U, 2097152U, 4194304U, 8388608U, 16777216U, 33554432U, 67108864U, 134217728U, 268435456U, 536870912U ; processing_quality_flags:flag_meanings = "success radiance_missing irradiance_missing input_spectrum_missing reflectance_range_error ler_range_error snr_range_error sza_range_error vza_range_error lut_range_error ozone_range_error wavelength_offset_error initialization_error memory_error assertion_error io_error numerical_error lut_error ISRF_error convergence_error cloud_filter_convergence_error max_iteration_convergence_error aot_lower_boundary_convergence_error other_boundary_convergence_error geolocation_error ch4_noscat_zero_error h2o_noscat_zero_error max_optical_thickness_error aerosol_boundary_error boundary_hit_error chi2_error svd_error dfs_error radiative_transfer_error optimal_estimation_error profile_error cloud_error model_error number_of_input_data_points_too_low_error cloud_pressure_spread_too_low_error cloud_too_low_level_error generic_range_error generic_exception input_spectrum_alignment_error abort_error wrong_input_type_error wavelength_calibration_error coregistration_error slant_column_density_error airmass_factor_error vertical_column_density_error signal_to_noise_ratio_error configuration_error key_error saturation_error max_num_outlier_exceeded_error solar_eclipse_filter cloud_filter altitude_consistency_filter altitude_roughness_filter sun_glint_filter mixed_surface_type_filter snow_ice_filter aai_filter cloud_fraction_fresco_filter aai_scene_albedo_filter small_pixel_radiance_std_filter cloud_fraction_viirs_filter cirrus_reflectance_viirs_filter cf_viirs_swir_ifov_filter cf_viirs_swir_ofova_filter cf_viirs_swir_ofovb_filter cf_viirs_swir_ofovc_filter cf_viirs_nir_ifov_filter cf_viirs_nir_ofova_filter cf_viirs_nir_ofovb_filter cf_viirs_nir_ofovc_filter refl_cirrus_viirs_swir_filter refl_cirrus_viirs_nir_filter diff_refl_cirrus_viirs_filter ch4_noscat_ratio_filter ch4_noscat_ratio_std_filter h2o_noscat_ratio_filter h2o_noscat_ratio_std_filter diff_psurf_fresco_ecmwf_filter psurf_fresco_stdv_filter ocean_filter time_range_filter pixel_or_scanline_index_filter geographic_region_filter input_spectrum_warning wavelength_calibration_warning extrapolation_warning sun_glint_warning south_atlantic_anomaly_warning sun_glint_correction snow_ice_warning cloud_warning AAI_warning pixel_level_input_data_missing data_range_warning low_cloud_fraction_warning altitude_consistency_warning signal_to_noise_ratio_warning deconvolution_warning so2_volcanic_origin_likely_warning so2_volcanic_origin_certain_warning interpolation_warning saturation_warning high_sza_warning cloud_retrieval_warning cloud_inhomogeneity_warning" ; processing_quality_flags:flag_values = 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 16U, 17U, 18U, 19U, 20U, 21U, 22U, 23U, 24U, 25U, 26U, 27U, 28U, 29U, 30U, 31U, 32U, 33U, 34U, 35U, 36U, 37U, 38U, 39U, 40U, 41U, 42U, 43U, 44U, 45U, 46U, 47U, 48U, 49U, 50U, 51U, 52U, 53U, 54U, 55U, 64U, 65U, 66U, 67U, 68U, 69U, 70U, 71U, 72U, 73U, 74U, 75U, 76U, 77U, 78U, 79U, 80U, 81U, 82U, 83U, 84U, 85U, 86U, 87U, 88U, 89U, 90U, 91U, 92U, 93U, 94U, 95U, 96U, 97U, 256U, 512U, 1024U, 2048U, 4096U, 8192U, 16384U, 32768U, 65536U, 131072U, 262144U, 524288U, 1048576U, 2097152U, 4194304U, 8388608U, 16777216U, 33554432U, 67108864U, 134217728U, 268435456U, 536870912U ; processing_quality_flags:long_name = "Processing quality flags" ; processing_quality_flags:modifiers = "" ; processing_quality_flags:platform_shortname = "S5P" ; processing_quality_flags:reader = "tropomi_l2" ; processing_quality_flags:sensor = "tropomi" ; processing_quality_flags:start_time = "2019-07-02 03:18:54" ; processing_quality_flags:coordinates = "latitude longitude" ; }

Note that I can't reproduce it using this example: ``` import numpy as np import xarray as xr

da = xr.DataArray(np.array([1,2,3], dtype='uint')).rename('test_array') da.to_netcdf("test.nc", engine='netcdf4') with xr.open_dataset('test.nc') as ds: print(ds['test_array'].dtype)

uint64 ```

Environment:

What happened:

I have a NetCDF file that has groups like this:

--/PRODUCT/ --/PRODUCT/SUPPORT_DATA/DETAILED_RESULTS .....

Screenshots

When I read the variable named air_mass_factor_clear inside /PRODUCT/SUPPORT_DATA/DETAILED_RESULTS, the coordinates are missing. But, it works for variable named nitrogendioxide_tropospheric_column in the /PRODUCT/ group.

What you expected to happen:

Coordinates of variables in subgroups are loaded.

Minimal Complete Verifiable Example:

python xr.open_dataset('./201908/S5P_PAL__L2__NO2____20190811T022605_20190811T040734_09459_01_020301_20211110T023157.nc', group='PRODUCT/')['nitrogendioxide_tropospheric_column']

python xr.open_dataset('./201908/S5P_PAL__L2__NO2____20190811T022605_20190811T040734_09459_01_020301_20211110T023157.nc', group='PRODUCT/SUPPORT_DATA/DETAILED_RESULTS/')['air_mass_factor_clear']

Environment:

The Groupby example focuses on lat_bin. Then the xc in the groupby_bins function should be yc.

MCVE Code Sample

```python

Your code here

import xarray as xr

airtemps = xr.tutorial.open_dataset('air_temperature') air = airtemps.air - 273.15 air2d = air.isel(time=500) air2d.plot.pcolormesh(add_colorbar=True, add_labels=True, cbar_kwargs=dict(orientation='horizontal', pad=0.15, shrink=1, label='Temperature ($^{\circ}$C)')) ```

Expected Output

Problem Description

Is it possible to change the label size and ticks label size of colorbar? size and labelsize don't work in cbar_kwargs.

Output of xr.show_versions()

What happened:

I'm using apply_ufunc to apply np.minimum.reduceat() function, which is much quicker than groupby_bins().min(). However, the length of bin is different from the input data. As a result, this causes the length error.

Minimal Complete Verifiable Example:

```python import numpy as np import xarray as xr

data = xr.DataArray(np.arange(10), dims=['x']) dask_data = data.chunk({'x': -1}) bins_reduceat = np.linspace(0, 9, 10).astype('int')

def reduceat_np(data, bins): return np.minimum.reduceat(data, bins)

res = xr.apply_ufunc(reduceat_np, dask_data, bins_reduceat[:5], dask="parallelized", output_dtypes=[data.dtype], dask_gufunc_kwargs={'allow_rechunk': True},

                )

res.compute() ```

Error: `` ~/new/miniconda3/envs/pyresample_min/lib/python3.8/site-packages/dask/array/gufunc.py in apply_gufunc(func, signature, *args, **kwargs) 392 #### Check that the arrays have same length for same dimensions or dimension1393 if set(sizes) | {1} != {1, max(sizes)}: --> 394 raise ValueError( 395 "Dimension'{}'` with different lengths in arrays".format(dim) 396 )

ValueError: Dimension '__loopdim0__' with different lengths in arrays ```

Anything else we need to know?:

It works well if the data and bin have the same length.

Environment:

Although groupby_bins supports setting bins as int, it doesn't support manually setting the range.

Here's an example:

``` from scipy.stats import binned_statistic import numpy as np import xarray as xr

--- scipy method ---

x = np.arange(500) values = x*50 statistics, _, _ = binned_statistic(x, values, statistic='min', bins=500, range=(0, 500))

--- xarray method ---

x = xr.DataArray(x) values = xr.DataArray(values) x.groupby_bins('dim_0', bins=500).min() ```

I can set range=(0, 500) in binned_statistic, how can I get the same result using groupby_bins? Is it suitable to add this new feature? I have also posted a similar question on StackOverflow.

What happened: interpolate_na doesn't support extrapolation

What you expected to happen: Support extrapolation.

Minimal Complete Verifiable Example:

```python import xarray as xr import numpy as np

x = xr.DataArray( [[0, 1, np.nan, np.nan, 2, np.nan, np.nan]], dims=['y', 'x'], coords={"x": xr.Variable("x", [0, 1, 1.1, 1.8, 2, 4, 5]), 'y': xr.Variable("y", [0])}, )

x = x.interpolate_na(dim="x", method="linear", use_coordinate="x") print(x) ```

The output is: array([[0. , 1. , 1.1, 1.8, 2. , nan, nan]])

It should be this array after extrapolation: array([[0. , 1. , 1.1, 1.8, 2. , 4, 5]])

Environment:

It's impossible to concatenate two arrays on same named dimensions with different sizes.

MCVE Code Sample

```python import xarray as xr import pandas as pd

a = xr.DataArray([0], dims=['x']) b = xr.DataArray([1, 2, 3], dims=['x']) a = a.expand_dims("time") b = b.expand_dims("time") a.coords["time"] = pd.DatetimeIndex(['2020-02-14 05:25:10']) b.coords["time"] = pd.DatetimeIndex(['2020-02-14 05:25:10']) c = xr.concat([a, b], dim='time') print(c) ```

Expected Output

[[0], [1, 2, 3]]

Problem Description

File "C:\Users\Xin\Desktop\test_github.py", line 10, in <module> c = xr.concat([a, b], dim='time') File "E:\miniconda3\envs\satpy\lib\site-packages\xarray\core\concat.py", line 135, in concat return f(objs, dim, data_vars, coords, compat, positions, fill_value, join) File "E:\miniconda3\envs\satpy\lib\site-packages\xarray\core\concat.py", line 455, in _dataarray_concat join=join, File "E:\miniconda3\envs\satpy\lib\site-packages\xarray\core\concat.py", line 319, in _dataset_concat *datasets, join=join, copy=False, exclude=[dim], fill_value=fill_value File "E:\miniconda3\envs\satpy\lib\site-packages\xarray\core\alignment.py", line 327, in align % (dim, sizes) ValueError: arguments without labels along dimension 'x' cannot be aligned because they have different dimension sizes: {1, 3}

Versions

This is copied from a question on stackoverflow.

I have a ndarray of shape(z,y,x) containing values. I am trying to index this array with another ndarray of shape(y,x) that contains the z-index of the value I am interested in. How do I have to index val_arr with z_indices to get the values at the desired z-axis position?

MCVE Code Sample

```python import numpy as np val_arr = np.arange(27).reshape(3, 3, 3)

z_indices = np.array([[1, 0, 2], [0, 0, 1], [2, 0, 1]])

index_array = z_indices.choose(val_arr) print(index_array) ```

xarray version

```python import numpy as np import xarray as xr

val_arr = xr.DataArray(np.arange(27).reshape(3, 3, 3), dims=['z', 'y', 'x'])

z_indices = xr.DataArray(np.array([[1, 0, 2], [0, 0, 1], [2, 0, 1]]), dims=['y', 'x'])

index_array = np.choose(z_indices, val_arr) print(index_array) ```

Expected Output

<xarray.DataArray (y: 3, x: 3)> array([[ 9, 1, 20], [ 3, 4, 14], [24, 7, 17]]) Dimensions without coordinates: y, x

Problem Description

Is this feature of choose supported in xarray?

I have three arrays: 1. a: input array 2. sindex: the array containing the start index for summation 3. eindex: the array containing the end index for summation

MCVE Code Sample

```python import xarray as xr data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])

input array

a = xr.DataArray(data, dims=['x', 'y'])

start_index array

sindex = xr.DataArray(np.array([0, 0, 1, 1]), dims=['x'])

end_index array

eindex = xr.DataArray(np.array([0, 1, 2, 2]), dims=['x'])

empty array for saving summation

sum_a = xr.DataArray(np.empty((a.shape[0], 1)), dims=['x', 'y'])

for x in a.x: # sum values from sindex to eindex at row x sum_a[x] = a[x, sindex[x].values:eindex[x].values+1].sum()

print(sum_a) ```

Expected Output

<xarray.DataArray (x: 4, y: 1)> array([[ 1.], [ 9.], [17.], [23.]]) Dimensions without coordinates: x, y

Problem Description

Is it necessary to use xr.apply_ufunc? or any other good method?

I have two data:

1. 3D data with z(height) levels
2. 3D pressure data which are at the same levels

Then, I want to interpolate the first 3D data to another 3D pressure data. I have to iterate through x, y and interpolate the data by pressure levels.

This is too slow when the 3D array is large. Is there a more efficient and easier method to accomplish this?

MCVE Code Sample

```python import xarray as xr import numpy as np

x = 10 y = 10 z = 4 data = np.arange(xyz).reshape((x, y, z))

bottom_up data

bottom_up = xr.DataArray(data, coords={'x': np.arange(x), 'y': np.arange(y), 'z': np.arange(z)}, dims=['x', 'y', 'z'] )

corresponding pressure data

pressure = xr.DataArray(data+1, coords={'x': np.arange(x), 'y': np.arange(y), 'z': np.arange(z)}, dims=['x', 'y', 'z'] )

pressure levels which data are interpolated to

interp_p = xr.DataArray(data[:, :, :-2]+0.5, coords={'x': np.arange(x), 'y': np.arange(y), 'z': np.arange(z-2)}, dims=['x', 'y', 'z'])

empty DataArray where interpolated values are saved

output = interp_p.copy(data=np.full_like(interp_p, np.nan))

iterate through x and y

for x in bottom_up.x: for y in bottom_up.y: # replace bottom_up with pressure bottom_up = bottom_up.assign_coords(z=(pressure[x, y, :]).values) # interpolate data to interpolated pressure levels output[x, y, :] = bottom_up[x, y, :].interp(z=interp_p[x, y, :], kwargs={'fill_value': 'extrapolate'} ) print(output) ```

MCVE Code Sample

```python import numpy as np import xarray as xr tstr='2019-07-25_00:00:00' Times = xr.DataArray(np.array([" ".join(tstr).split()], dtype = 'S1'), dims = ['Time', 'DateStrLen']) ds = xr.Dataset({'Times':Times}) ds.to_netcdf('test.nc', format='NETCDF4',encoding={'Times': {'zlib':True, 'complevel':5}}, unlimited_dims={'Time':True})

```

Expected Output

Because I want to use the nc file as the input of WRF model, I just need Time and DateStrLen two dimensions.

ncdump -h test.nc:

``` netcdf test { dimensions: Time = UNLIMITED ; // (1 currently) DateStrLen = 19 ; variables: char Times(Time, DateStrLen) ; }

`` Although it's possible to set the exactchar_dim_nametoTimelike #2895, but I need the unlimitedTime` dimension as the first one.

Problem Description

This is the actual output of ncdump -h test.nc: netcdf test { dimensions: Time = UNLIMITED ; // (1 currently) DateStrLen = 19 ; string1 = 1 ; variables: char Times(Time, DateStrLen, string1) ; }

Output of xr.show_versions()

MCVE Code Sample

```python from datetime impo

rt datetime import xarray as xr import os

def read_data(f, composition, west, east, north, south): # read data ds = xr.open_dataset(f, group='PRODUCT') # subset to region index = ((ds.longitude > west) & (ds.longitude < east)) ds = ds.where(index) # read composition data = ds[composition][0,:,:] data_units = data.units # read time t = ds['time_utc'] st = datetime.strptime(str(t.min(skipna=True).values), '%Y-%m-%dT%H:%M:%S.%fZ') et = datetime.strptime(str(t.max(skipna=True).values), '%Y-%m-%dT%H:%M:%S.%fZ')

# read lon and lat
lon = data.coords['longitude']
lat = data.coords['latitude']

return lon, lat, data, data_units, st, et

datadir = '/xin/data/TROPOMI/GZ/bug' os.chdir(datadir) west = 112.5; east = 114.5; north = 24; south = 22.5;

f = 'S5P_NRTI_L2__O3_____20190825T053303_20190825T053803_09659_01_010107_20190825T061441.nc' lon, lat, data, data_units, st, et = read_data(f, 'ozone_total_vertical_column', west, east, north, south) ```

Problem Description

You can download the data from google drive. I get errors shown in details, even using skipna=True.

Output of xr.show_versions()

Code Sample

```python import xarray as xr from netCDF4 import Dataset

rootgrp = Dataset("test.nc", "w", format="NETCDF4") fcstgrp = rootgrp.createGroup("forecasts")

lat = rootgrp.createDimension("lat", 73) lon = rootgrp.createDimension("lon", 144) latitudes = rootgrp.createVariable("lat","f4",("lat",)) longitudes = rootgrp.createVariable("lon","f4",("lon",))

temp = rootgrp.createVariable("temp","f4",("lat","lon",)) ftemp = rootgrp.createVariable("/forecasts/temp","f4","lat","lon",) rootgrp.close()

ds = xr.open_dataset('test.nc') print (ds['temp']) print (ds['/forecasts/temp']) ```

Problem description

The temp variable in the / group can be accessed successfully, but temp in the /forecasts group not. It says: KeyError: '/forecasts/temp'

Output of xr.show_versions()

Code Sample

```python import xarray as xr import numpy as np from netCDF4 import Dataset

temp = np.random.randn(2, 2, 3) precip = np.random.rand(2, 2, 3) lon = [[-99.83, -99.32], [-99.79, -99.23]] lat = [[42.25, 42.21], [42.63, 42.59]]

attrs = {'units': 'hours since 2015-01-01'} ds_1 = xr.Dataset({'temperature': (['x', 'y', 'time'], temp)}, coords={'lon': (['x', 'y'], lon), 'lat': (['x', 'y'], lat), 'time': ('time', [100, 101, 102], attrs)})

ds_2 = xr.Dataset({'temperature': (['x', 'y', 'time'], temp+1)}, coords={'lon': (['x', 'y'], lon), 'lat': (['x', 'y'], lat), 'time': ('time', [200, 201, 202], attrs)})

ds_1.to_netcdf('ds1.nc') ds_2.to_netcdf('ds2.nc')

ds = xr.open_mfdataset('ds*.nc') ds.to_netcdf('merge.nc')

with xr.open_dataset('merge.nc') as f: print (f,'\n') print ('---------------------------')

ds_1 = Dataset('ds1.nc') print ('keys of ds_1:') print (ds_1.variables.keys(),'\n') print ('time of ds_1:') print (ds_1.variables['time'],'\n') print ('---------------------------')

merge = Dataset('merge.nc') print ('keys of merge:') print (merge.variables.keys(),'\n') print ('time of merge:') print (merge.variables['time'],'\n')

```

Problem description

As time is the coordinate in xarray.Dataset, it's variable in netCDF4. When netCDF4 is used to read time of merged file , the units is hours since 2015-01-05 04:00:00. I want to keep the attributes of time as hours since 2015-01-01.

Output of all print()

``` <xarray.Dataset> Dimensions: (time: 6, x: 2, y: 2) Coordinates: lon (x, y) float64 ... lat (x, y) float64 ... * time (time) datetime64[ns] 2015-01-05T04:00:00 ... Dimensions without coordinates: x, y Data variables: temperature (x, y, time) float64 ...

keys of ds_1: odict_keys(['temperature', 'lon', 'lat', 'time'])

time of ds_1: <class 'netCDF4._netCDF4.Variable'> int64 time(time) units: hours since 2015-01-01 unlimited dimensions: current shape = (3,) filling on, default _FillValue of -9223372036854775806 used

keys of merge: odict_keys(['lon', 'lat', 'temperature', 'time'])

time of merge: <class 'netCDF4._netCDF4.Variable'> int64 time(time) units: hours since 2015-01-05 04:00:00 calendar: proleptic_gregorian unlimited dimensions: current shape = (6,) filling on, default _FillValue of -9223372036854775806 used ```