issue_comments

@observingClouds I think a fill_value arg in sel as in reindex is still warranted. Although reindex as @dcherian suggested works for cases the dims match the target dims, in cases where the dims don't match, e.g., in the examples of sel: https://xarray.pydata.org/en/stable/generated/xarray.DataArray.sel.html. It'd cause error: ValueError: Indexer has dimensions ('points',) that are different from that to be indexed along x

I think the original scope of this issue is still valid. I also would expect that indices that are not within the tolerance would simply be dropped. While it might be nice in some situations, I don't really think that specifying a fill value is needed in order to accomplish this.

The issue I'm facing with reindex is that it doesn't really scale as well as sel does, significantly reducing the amount of data I can handle. I would like to humbly suggest that there still might be interest in seeing this functionality.

Unfortunately the testing logs from #4996 have expired so it's not clear why the tests failed for this PR before it was closed.

Example using nearest & tolerance with reindex & sel when dims don't match based on the example in sel:

```python import numpy import xarray

da = xarray.DataArray( numpy.arange(25).reshape(5, 5), coords={"x": numpy.arange(5), "y": numpy.arange(5)}, dims=("x", "y"), ) tgt_x = numpy.linspace(0, 4, num=5) + 0.5 tgt_y = numpy.linspace(0, 4, num=5) + 0.5 da = da.reindex( x=tgt_x, y=tgt_y, method="nearest", tolerance=0.2, fill_value=numpy.nan ).sel( x=xarray.DataArray(tgt_x, dims="points"), y=xarray.DataArray(tgt_y, dims="points"), ) Output: <xarray.DataArray (points: 5)> array([nan, nan, nan, nan, nan]) Coordinates: x (points) float64 0.5 1.5 2.5 3.5 4.5 y (points) float64 0.5 1.5 2.5 3.5 4.5 Dimensions without coordinates: points `` Side note: I don't think it makes sense to addfill_valuetoselas it would require adding new coordinates that didn't exist previously. Callingreindex` first makes that more clear in my opinion.

Thanks @dcherian, this is doing the job. I'll close this issue as there seems to be no need to implement this into the sel method.

Actually does reindex do what you want, the returned coordinate labels will be what you provide.

```

ds.reindex(lat=[5,15,40], method="nearest", tolerance=5, fill_value=-999) <xarray.DataArray (lat: 2)> array([1, 2, -999]) Coordinates: * lat (lat) int64 5 15 40 ```

in using a fill_value is that the indexing has to modify the data ( insert e.g. -999) and also 'invent' a new coordinate point ( here 40).

This seems totally doable though.

One fill_value might not fit to all data arrays

In quite a few functions, fill_value can be a dict mapping variable name to a value so this is workable.

Let's see what others think.

Introducing a fill_value seems like a good idea, such that the size of the output does not change compared to the intended selection. Choosing the original/requested coordinate as a label for the missing datapoint seems to be a valid choice because this position has been checked for valid data nearby without success. I would suggest, that the fill_value should then be automatically determined from the _FillValue, the datatype and only at last requires the fill_value to be set.

However, the shortcoming that I see in using a fill_value is that the indexing has to modify the data ( insert e.g. -999) and also 'invent' a new coordinate point ( here 40). This gets reasonably complex, when applying to a dataset with DataArrays of different types, e.g. ```python import numpy as np import xarray as xr

ds = xr.Dataset() ds['data1'] = xr.DataArray(np.array([1,2,3,4,5], dtype=int), dims=["lat"], coords={'lat':[10,20,30,50,60]}) ds['data2'] = xr.DataArray(np.array([1,2,3,4,5], dtype=float), dims=["lat"], coords={'lat':[10,20,30,50,60]}) `` Onefill_valuemight not fit to all data arrays being it because of the datatype or the actual data. E.g.-999might be a goodfill_value` for one DataArray but a valid datapoint in another one.

```

ds.sel(lat=[5,15,40], method="nearest", tolerance=5) <xarray.DataArray (lat: 2)> array([1, 2]) Coordinates: * lat (lat) int64 10 20 ```

This is a very surprising result, you've asked for values at three points but received two back.

The following (specifying fill_value) seems like better behaviour to me but how do you choose the coordinate label (here I picked 40 since that was provided to sel) ```

ds.sel(lat=[5,15,40], method="nearest", tolerance=5, fill_value=-999) <xarray.DataArray (lat: 2)> array([1, 2, -999]) Coordinates: * lat (lat) int64 10 20 40 ```