Adding info on how to see Backends

Author: erikvansebille

docs/user_guide/examples/explanation_performance.md

@@ -2,12 +2,18 @@
 
 In many Parcels simulations, the bottle-neck in terms of performance is the retrieval of the hydrodynamic field data from disk. This is especially true for simulations with a relatively small number of particles, where the time spent on retrieving the fields can be much larger than the time spent on computing the particle trajectories.
 
-In this tutorial, we will show how to squeeze performance in Parcels by using a few different techniques. Which technique works best for your case depends on the amount of field data you have and how you can store it on disk.
+In this tutorial, we will show how to squeeze performance in Parcels by using a few different Parcels Backends. Which Backend works best for your case depends on the amount of field data you have and how you can store it on disk.
 
-## Option 1: explicitly load the full FieldSet into memory
+```{note}
+You can check which Backend Parcels is using by calling `fieldset.describe()`. The last column shows the Backend that is used for each Field.
+```
+
+## Option 1: load the full FieldSet into memory
 
 **Best for: small Datasets (less than a few GB)**
 
+_Uses Parcels Backend: Numpy_
+
 For relatively small Datasets (less than a few GB), it is possible to load the entire FieldSet into memory. This can be done by calling the `load()` method on the `xarray.Dataset` object:
 
 ```{code-cell}
@@ -22,10 +28,12 @@ This will make Parcels use `numpy` functions in the interpolation routines, whic
 | ---------------------------------- | ------------------------------------------------------ |
 | Very fast and simple to implement. | Will only work if the entire Dataset fits into memory. |
 
-## Option 2: use cached zarr files
+## Option 2: use (cached) zarr files
 
 **Best for: large Datasets (more than a few GB) and particles distributed over a small part of the domain**
 
+_Uses Parcels Backend: Zarr_
+
 If your Dataset is too large to fit into memory, but your particles are only distributed over a small part of the domain, it could be efficient to use cached zarr files. This can be done by using the (experimental) `zarr.CacheStore` in combination with the `parcels.open_raw_zarr()` function. This will make Parcels only load the chunks that are needed for the particles, and cache these chunks in memory for future use.
 
 ```{code-cell}
@@ -49,7 +57,9 @@ ds = parcels.open_raw_zarr(store)
 In our performance testing, we have found that using zarr files saved without any compression can be considerably faster than using compressed zarr files. However, we are working on an upstream fix in to make caching compressed zarr files faster, so this may change in the future.
 ```
 
-## Option 3: use `fieldset.to_windowed_arrays()`
+## Option 3: use Windowed Arrays
+
+_Uses Parcels Backend: WindowedArray_
 
 **Best for: large Datasets (more than a few GB) and particles distributed over the entire domain**
 
@@ -72,6 +82,8 @@ fieldset.to_windowed_arrays()
 
 **Best for: large Datasets (more than a few GB) and small ParticleSets (less than a few hundred particles)**
 
+_Uses Parcels Backend: Dask_
+
 If your Dataset is so large that it doesn't fit into memory, and you have very few particles, you can use Dask to perform the interpolation operations. In this case, you don't have to do any special setup, as Parcels will automatically use Dask if the `xarray.Dataset` is a Dask array.
 
 ### Advantages and disadvantages