issue_comments

Is there hope for groupby working on multi-indexed DataArrays again in the future? We -- and from the issue history it looks like others too -- are currently pinning xarray<2022.6 even though we would love to use newer versions.

This error occurs in versions 2022.6 through 2022.11. The code worked fine in previous versions, e.g. in 2022.3.0 it executes as expected. Related: https://github.com/pydata/xarray/issues/6836.

still relevant

Any updates on this by any chance? (now that there seems to be progress on #1603)

I think the issue stems from this line of code. Removing it leads to the desired MultiIndex. But I'm not sure if it leads to downstream issues, e.g selecting over coord1 then seems to also squeeze that dimension. Perhaps @benbovy and @jhamman can chime in as the owners of that line.

I would expect the dimension to become a MultiIndex with a single coordinate:

<xarray.DataArray (dim: 1)> array([0]) Coordinates: * dim MultiIndex coord (dim) int64 0

When there is more than one coordinate that is what happens, but not when there is only a single coordinate.

Sorry I missed a line in the issue, added it now. You're right about the .sel -- since it does not operate on dimension levels by default, I manually set the index: d.set_index(append=True, inplace=True, dim=['coord']). However, this now gets rid of the coordinate: <xarray.DataArray (dim: 1)> array([0]) Coordinates: * dim (dim) int64 0 and thus d.sel(coord=0) does not work because the coord has been discarded.

I posted a manual solution to the multi-dimensional grouping in the stackoverflow thread. Hopefully, .sel can be made more efficient though, it's such an everyday method.

I built a manual solution in the stackoverflow thread. Maybe this helps someone.

Thanks @max-sixty, the checks per call make sense, although I still find 0.5 ms insane for a single-value lookup (python dict-indexing takes about a 50th to index every single item in the array).

The reason I'm looking into this is actually multi-dimensional grouping (#2438) which is unfortunately not implemented (the above code is essentially a step towards trying to implement that). Is there a way of vectorizing these calls with that in mind? I.e. apply a method for each group.

Thanks @shoyer, Your comment helped me realize that at least part of the "horribly slow" probably stems from a DataArray with MultiIndex. The above code sample takes 5-6 seconds for 1000 b values. When stacking the DataArray beforehand with d = d.stack(adim=['a'], bdim=['b']), it takes around 14 seconds. However, both of these are unfortunately very slow compared to indexing in e.g. numpy or pandas.