Parcels

1. It fixes some Issues with dask chunking, particularly in 3D simulations (738, 740 and 731)
2. It adds a von Mises distribution to `parcels.random` (725)

And numerous smaller bugfixes.

1) It fixes some serious issues with memory usage for field chunking (see 668, 703 and 711), which have now been addressed in 719
2) Fixing xarray compatibility (716)
3) Fixing a bug in cartopy.quiver (714)
4) New kernels to compute density (688)

And various other minor bug fixes

1. It fixes a serious bug on some systems with floating point accuracy, that could lead to incorrect output files (see 670 and solution at 672). For this reason, all users are encouraged to use this new version v2.1.2 instead of v2.1.1.
2. It also fixes a smaller bug (676) with the `timestamps` argument in `Field.from_netcdf()`

1. Parcels has a parallel MPI version! While working on multiple processors, the particles are spread over the processors for an efficient integration. (625). See https://oceanparcels.org#parallel_install for instructions on how to install.
2. For an efficient loading of the `Fieldset`, the `Field` objects are now loaded by chunks, controlled by the parameter `field_chunksize` (632). This results in lower memory usage and faster simulation. It is also a fundamental part of the parallel implementation, since for low number of particles per processor, the computation time is dominated by the loading of the data. A more efficient parallel version will be dynamically balancing the particles between the processors such to minimise the number of chunks loaded per processor. See [this document](https://nbviewer.jupyter.org/github/OceanParcels/parcels/blob/master/parcels/examples/documentation_MPI.ipynb) for further background on the implementation.
3. An efficient writing of the particleset. For a quicker export of the data, particles are now dumped into npy files during simulation. The pickles are gathered into one single file at the end of the simulation. (614)
4. A proper management of `particle.dt` modified by the kernel. If the kernel modifies `particle.dt`, the kernel will automatically be restarted with the updated `dt`. If you want to simply updates the `dt` for next kernel call, use `particle.update_next_dt(new_dt)`. (657)
5. New particles can now be added to the `ParticleSet` only via a temporary `ParticleSet` object. This enables a proper control of the `particle.id` in parallel (629)
6. `Field.gradient()` function is not available anymore. This functionality was providing spurious results on curvilinear grids and was conflicting with the use of chunked fields. Users can still obtain easily an accurate field gradient (see example proposed in 633)
7. Using the `time_periodic` flag in `FieldSet` creation now requires the length of the period (659)
8. Numerous bug fixes


Note that Parcels v2.1.0 is the last version to officially support Python 2.7. While all functionalities currently work with both Python 2 and 3, new development and code dependencies will progressively lead to incompatibility with Python 2. We strongly advice the users to switch to Python 3.

Parcels v2.0.0 builds on previous versions v2.0.0.beta and v2.0.0.beta2. It's the release which is fully described in the paper [The Parcels v2.0 Lagrangian framework: new field interpolation schemes](https://doi.org/10.5194/gmd-2018-339), by Delandmeter and van Sebille, 2019, GMD.

The major changes of v2.0.0 compared to v1.1.1 are

1) The order of arguments for `Field` interpolation has changed. This is now `field[time, depth, lat, lon]`, which is consistent with the dimension order in which data is stored in the `field.data` numpy array (503 and 276).

2) The `dt` argument has been dropped from Kernel definitions, so that the only arguments allowed in a Kernel are `def kernelfunc(fieldset, particle, time)` (503)

3) Interpolation for C-grids is now done in a fluxes framework, instead of a velocity framework (499 and 494).

4) Interpolation for B-grids (573)

5) Support for `np.float64` accuracy of particle locations. This can be set using the `lonlatdepth_dtype` argument in ParticleSet construction. Default is `np.float64` for C-grids, and `np.float32` for all other grids (552 and 557)

Note also a number of other minor development: