issue_comments

I updated my example above to show that the chunking over the last dimension is ridiculously slow.

Sorry for the confusion, I had an obvious mistake in my timing experiment above (forgot to do the actual computations...).

The dimension order does make a difference:

```python import dask as da import xarray as xr

d = xr.DataArray(da.array.zeros((1000, 721, 1440), chunks=(10, 721, 1440)), dims=('z', 'y', 'x')) d.to_netcdf('da.nc') # 8.3 Gb

with xr.open_dataarray('da.nc', chunks={'z':10}) as d: %timeit d.sum().load() 3.94 s ± 95.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

with xr.open_dataarray('da.nc', chunks={'y':10}) as d: %timeit d.sum().load() 4.15 s ± 316 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

with xr.open_dataarray('da.nc', chunks={'x':10}) as d: %timeit d.sum().load() 1min 54s ± 1.43 s per loop (mean ± std. dev. of 7 runs, 1 loop each)

with xr.open_dataarray('da.nc', chunks={'y':10, 'x':10}) as d: %timeit d.sum().load() 2min 23s ± 215 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) ```

Those chunksizes are the opposite of what I was expecting...

chunksizes in encoding are ignored in your case, dask still uses your user provided encoding.

Can you still try to chunk along one dimension only? i.e. chunks={'time':200}

[EDIT]: forgot the load ...

<s> forget my comment about chunks - I thought this would make a difference but it's actually the opposite (to my surprise): </s>

Out of curiosity: - why do you chunk over lats and lons rather than time? The order of dimensions in your dataarray suggest that chunking over time could be more efficient - can you show the output of ds.mtpr and ds.mtpr.encoding ?