Merge branch 'v4-dev' into structure_overview

Author: reint-fischer

docs/getting_started/tutorial_output.ipynb

@@ -549,15 +549,9 @@
     "\n",
     "# Create animation\n",
     "anim = FuncAnimation(fig, animate, frames=nframes, interval=100)\n",
+    "plt.close(fig)\n",
     "anim"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

docs/user_guide/examples/explanation_kernelloop.md

@@ -78,12 +78,11 @@ Now we define a wind kernel that uses a forward Euler method to apply the wind f
 
 ```{code-cell}
 def wind_kernel(particles, fieldset):
-    dt_float = particles.dt / np.timedelta64(1, 's')
     particles.dlon += (
-        fieldset.UWind[particles] * dt_float
+        fieldset.UWind[particles] * particles.dt
     )
     particles.dlat += (
-        fieldset.VWind[particles] * dt_float
+        fieldset.VWind[particles] * particles.dt
     )
 ```
 

docs/user_guide/examples/tutorial_Argofloats.ipynb

@@ -30,54 +30,44 @@
     "driftdepth = 1000  # maximum depth in m\n",
     "maxdepth = 2000  # maximum depth in m\n",
     "vertical_speed = 0.10  # sink and rise speed in m/s\n",
-    "cycletime = (\n",
-    "    10 * 86400\n",
-    ")  # total time of cycle in seconds  # TODO update to \"timedelta64[s]\"\n",
+    "cycletime = 10 * 86400  # total time of cycle in seconds\n",
     "drifttime = 9 * 86400  # time of deep drift in seconds\n",
     "\n",
     "\n",
     "def ArgoPhase1(particles, fieldset):\n",
-    "    dt = particles.dt / np.timedelta64(1, \"s\")  # convert dt to seconds\n",
-    "\n",
     "    def SinkingPhase(p):\n",
     "        \"\"\"Phase 0: Sinking with vertical_speed until depth is driftdepth\"\"\"\n",
-    "        p.dz += vertical_speed * dt\n",
+    "        p.dz += vertical_speed * particles.dt\n",
     "        p.cycle_phase = np.where(p.z + p.dz >= driftdepth, 1, p.cycle_phase)\n",
     "        p.dz = np.where(p.z + p.dz >= driftdepth, driftdepth - p.z, p.dz)\n",
     "\n",
     "    SinkingPhase(particles[particles.cycle_phase == 0])\n",
     "\n",
     "\n",
     "def ArgoPhase2(particles, fieldset):\n",
-    "    dt = particles.dt / np.timedelta64(1, \"s\")  # convert dt to seconds\n",
-    "\n",
     "    def DriftingPhase(p):\n",
     "        \"\"\"Phase 1: Drifting at depth for drifttime seconds\"\"\"\n",
-    "        p.drift_age += dt\n",
+    "        p.drift_age += particles.dt\n",
     "        p.cycle_phase = np.where(p.drift_age >= drifttime, 2, p.cycle_phase)\n",
     "        p.drift_age = np.where(p.drift_age >= drifttime, 0, p.drift_age)\n",
     "\n",
     "    DriftingPhase(particles[particles.cycle_phase == 1])\n",
     "\n",
     "\n",
     "def ArgoPhase3(particles, fieldset):\n",
-    "    dt = particles.dt / np.timedelta64(1, \"s\")  # convert dt to seconds\n",
-    "\n",
     "    def SecondSinkingPhase(p):\n",
     "        \"\"\"Phase 2: Sinking further to maxdepth\"\"\"\n",
-    "        p.dz += vertical_speed * dt\n",
+    "        p.dz += vertical_speed * particles.dt\n",
     "        p.cycle_phase = np.where(p.z + p.dz >= maxdepth, 3, p.cycle_phase)\n",
     "        p.dz = np.where(p.z + p.dz >= maxdepth, maxdepth - p.z, p.dz)\n",
     "\n",
     "    SecondSinkingPhase(particles[particles.cycle_phase == 2])\n",
     "\n",
     "\n",
     "def ArgoPhase4(particles, fieldset):\n",
-    "    dt = particles.dt / np.timedelta64(1, \"s\")  # convert dt to seconds\n",
-    "\n",
     "    def RisingPhase(p):\n",
     "        \"\"\"Phase 3: Rising with vertical_speed until at surface\"\"\"\n",
-    "        p.dz -= vertical_speed * dt\n",
+    "        p.dz -= vertical_speed * particles.dt\n",
     "        p.temp = fieldset.thetao[p.time, p.z, p.lat, p.lon]\n",
     "        p.cycle_phase = np.where(p.z + p.dz <= fieldset.mindepth, 4, p.cycle_phase)\n",
     "        p.dz = np.where(\n",
@@ -100,8 +90,7 @@
     "\n",
     "\n",
     "def ArgoPhase6(particles, fieldset):\n",
-    "    dt = particles.dt / np.timedelta64(1, \"s\")  # convert dt to seconds\n",
-    "    particles.cycle_age += dt  # update cycle_age"
+    "    particles.cycle_age += particles.dt  # update cycle_age"
    ]
   },
   {
@@ -211,11 +200,7 @@
     "x = ds_particles[\"lon\"][:].squeeze()\n",
     "y = ds_particles[\"lat\"][:].squeeze()\n",
     "z = ds_particles[\"z\"][:].squeeze()\n",
-    "time = (\n",
-    "    (ds_particles[\"time\"][:].squeeze() - fieldset.time_interval.left).astype(float)\n",
-    "    / 1e9\n",
-    "    / 86400\n",
-    ")  # convert time to days\n",
+    "time = ds_particles[\"time\"][:].squeeze()\n",
     "temp = ds_particles[\"temp\"][:].squeeze()"
    ]
   },

docs/user_guide/examples/tutorial_delaystart.ipynb

@@ -24,15 +24,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from datetime import timedelta\n",
-    "\n",
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
     "import xarray as xr\n",
-    "from IPython.display import HTML\n",
     "from matplotlib.animation import FuncAnimation\n",
     "\n",
-    "import parcels"
+    "import parcels\n",
+    "\n",
+    "# for interactive display of animations\n",
+    "plt.rcParams[\"animation.html\"] = \"jshtml\""
    ]
   },
   {
@@ -138,8 +138,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%%capture\n",
-    "\n",
     "ds_particles = xr.open_zarr(\"delayparticle_time.zarr\")\n",
     "\n",
     "fig = plt.figure(figsize=(7, 5), constrained_layout=True)\n",
@@ -173,16 +171,9 @@
     "    )\n",
     "\n",
     "\n",
-    "anim = FuncAnimation(fig, animate, frames=len(timerange), interval=100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "HTML(anim.to_jshtml())"
+    "anim = FuncAnimation(fig, animate, frames=len(timerange), interval=100)\n",
+    "plt.close()\n",
+    "anim"
    ]
   },
   {
@@ -261,13 +252,13 @@
    "outputs": [],
    "source": [
     "output_file = parcels.ParticleFile(\n",
-    "    \"delayparticle_releasedt.zarr\", outputdt=timedelta(hours=1)\n",
+    "    \"delayparticle_releasedt.zarr\", outputdt=np.timedelta64(1, \"h\")\n",
     ")\n",
     "\n",
     "pset.execute(\n",
     "    parcels.kernels.AdvectionRK4,\n",
-    "    runtime=timedelta(hours=24),\n",
-    "    dt=timedelta(minutes=5),\n",
+    "    runtime=np.timedelta64(24, \"h\"),\n",
+    "    dt=np.timedelta64(5, \"h\"),\n",
     "    output_file=output_file,\n",
     ")"
    ]
@@ -286,8 +277,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%%capture\n",
-    "\n",
     "ds_particles = xr.open_zarr(\"delayparticle_releasedt.zarr\")\n",
     "\n",
     "fig = plt.figure(figsize=(7, 5), constrained_layout=True)\n",
@@ -321,16 +310,9 @@
     "    )\n",
     "\n",
     "\n",
-    "anim = FuncAnimation(fig, animate, frames=len(timerange), interval=100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "HTML(anim.to_jshtml())"
+    "anim = FuncAnimation(fig, animate, frames=len(timerange), interval=100)\n",
+    "plt.close(fig)\n",
+    "anim"
    ]
   },
   {