{
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# Delayed starts\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"In many applications, it is needed to 'delay' the start of particle advection. For example because particles need to be released at different times throughout an experiment. Or because particles need to be released at a constant rate from the same set of locations.\n",
"\n",
"This tutorial will show how this can be done. We start with importing the relevant modules.\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from datetime import timedelta as delta\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",
"from parcels import (\n",
" AdvectionRK4,\n",
" FieldSet,\n",
" JITParticle,\n",
" ParticleFile,\n",
" ParticleSet,\n",
" Variable,\n",
" download_example_dataset,\n",
")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"First import a `FieldSet` (from the Peninsula example, in this case)\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"example_dataset_folder = download_example_dataset(\"Peninsula_data\")\n",
"fieldset = FieldSet.from_parcels(\n",
" f\"{example_dataset_folder}/peninsula\", allow_time_extrapolation=True\n",
")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now, there are two ways to delay the start of particles. Either by defining the whole `ParticleSet` at initialisation and giving each particle its own `time`. Or by using the `repeatdt` argument. We will show both options here\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Assigning each particle its own `time`\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"The simplest way to delaye the start of a particle is to use the `time` argument for each particle\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"npart = 10 # number of particles to be released\n",
"lon = 3e3 * np.ones(npart)\n",
"lat = np.linspace(3e3, 45e3, npart, dtype=np.float32)\n",
"\n",
"# release every particle one hour later\n",
"time = np.arange(0, npart) * delta(hours=1).total_seconds()\n",
"\n",
"pset = ParticleSet(fieldset=fieldset, pclass=JITParticle, lon=lon, lat=lat, time=time)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Then we can execute the `pset` as usual\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"INFO: Output files are stored in DelayParticle_time.zarr.\n",
"100%|██████████| 86400.0/86400.0 [00:02<00:00, 35968.90it/s]\n"
]
}
],
"source": [
"output_file = pset.ParticleFile(name=\"DelayParticle_time.zarr\", outputdt=delta(hours=1))\n",
"\n",
"pset.execute(\n",
" AdvectionRK4, runtime=delta(hours=24), dt=delta(minutes=5), output_file=output_file\n",
")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"And then finally, we can show a movie of the particles. Note that the southern-most particles start to move first.\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"%%capture\n",
"\n",
"ds = xr.open_zarr(\"DelayParticle_time.zarr\")\n",
"\n",
"fig = plt.figure(figsize=(7, 5), constrained_layout=True)\n",
"ax = fig.add_subplot()\n",
"\n",
"ax.set_ylabel(\"Meridional distance [m]\")\n",
"ax.set_xlabel(\"Zonal distance [m]\")\n",
"ax.set_xlim(0, 9e4)\n",
"ax.set_ylim(0, 5e4)\n",
"\n",
"timerange = np.unique(ds[\"time\"].values[np.isfinite(ds[\"time\"])])\n",
"\n",
"# Indices of the data where time = 0\n",
"time_id = np.where(ds[\"time\"] == timerange[0])\n",
"\n",
"sc = ax.scatter(ds[\"lon\"].values[time_id], ds[\"lat\"].values[time_id])\n",
"\n",
"t = str(timerange[0].astype(\"timedelta64[h]\"))\n",
"title = ax.set_title(f\"Particles at t = {t}\")\n",
"\n",
"\n",
"def animate(i):\n",
" t = str(timerange[i].astype(\"timedelta64[h]\"))\n",
" title.set_text(f\"Particles at t = {t}\")\n",
"\n",
" time_id = np.where(ds[\"time\"] == timerange[i])\n",
" sc.set_offsets(np.c_[ds[\"lon\"].values[time_id], ds[\"lat\"].values[time_id]])\n",
"\n",
"\n",
"anim = FuncAnimation(fig, animate, frames=len(timerange), interval=100)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"
\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"HTML(anim.to_jshtml())"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Using the `repeatdt` argument\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"The second method to delay the start of particle releases is to use the `repeatdt` argument when constructing a `ParticleSet`. This is especially useful if you want to repeatedly release particles from the same set of locations.\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"npart = 10 # number of particles to be released\n",
"lon = 3e3 * np.ones(npart)\n",
"lat = np.linspace(3e3, 45e3, npart, dtype=np.float32)\n",
"repeatdt = delta(hours=3) # release from the same set of locations every 3h\n",
"\n",
"pset = ParticleSet(\n",
" fieldset=fieldset, pclass=JITParticle, lon=lon, lat=lat, repeatdt=repeatdt\n",
")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we again define an output file and execute the `pset` as usual.\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"INFO: Output files are stored in DelayParticle_releasedt.zarr.\n",
" 0%| | 0/86400.0 [00:00\n",
"\n",
"\n",
"\n",
"\n",
"
\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"HTML(anim.to_jshtml())"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that, if you want to if you want to at some point stop the repeatdt, the easiest implementation is to use two calls to `pset.execute()`. For example, if in the above example you only want four releases of the pset, you could do the following\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"INFO: Output files are stored in DelayParticle_releasedt_9hrs.zarr.\n",
" 0%| | 0/32400.0 [00:00\n",
"\n",
"\n",
"\n",
"\n",
"
\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"HTML(anim.to_jshtml())"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Synced `time` in the output file\n",
"\n",
"Note that, because the `outputdt` variable controls the JIT-loop, all particles are written _at the same time_, even when they start at a non-multiple of `outputdt`.\n",
"\n",
"For example, if your particles start at `time=[0, 1, 2]` and `outputdt=2`, then the times written (for `dt=1` and `endtime=4`) will be\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 0 2 4]\n",
" [ 2 4 'NaT']\n",
" [ 2 4 'NaT']]\n"
]
}
],
"source": [
"outtime_expected = np.array(\n",
" [[0, 2, 4], [2, 4, np.datetime64(\"NaT\")], [2, 4, np.datetime64(\"NaT\")]],\n",
" dtype=\"timedelta64[s]\",\n",
")\n",
"print(outtime_expected)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"INFO: Output files are stored in DelayParticle_nonmatchingtime.zarr.\n",
"100%|██████████| 4.0/4.0 [00:00<00:00, 57.38it/s]\n"
]
}
],
"source": [
"outfilepath = \"DelayParticle_nonmatchingtime.zarr\"\n",
"\n",
"pset = ParticleSet(\n",
" fieldset=fieldset, pclass=JITParticle, lat=[3e3] * 3, lon=[3e3] * 3, time=[0, 1, 2]\n",
")\n",
"\n",
"output_file = pset.ParticleFile(name=outfilepath, outputdt=2)\n",
"pset.execute(\n",
" AdvectionRK4,\n",
" endtime=4,\n",
" dt=1,\n",
" output_file=output_file,\n",
")\n",
"\n",
"# Note that we also need to write the final time to the file\n",
"output_file.write_latest_locations(pset, 4)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"And indeed, the `time` values in the NetCDF output file are as expected\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 0 2 4]\n",
" [ 2 4 'NaT']\n",
" [ 2 4 'NaT']]\n"
]
}
],
"source": [
"outtime_infile = xr.open_zarr(outfilepath).time.values[:]\n",
"print(outtime_infile.astype(\"timedelta64[s]\"))\n",
"\n",
"assert (\n",
" outtime_expected[np.isfinite(outtime_expected)]\n",
" == outtime_infile[np.isfinite(outtime_infile)]\n",
").all()"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Now, for some applications, this behavior may be undesirable; for example when particles need to be analyzed at a same age (instead of at a same time). In that case, we recommend either changing `outputdt` so that it is a common divisor of all start times; or doing multiple Parcels runs with subsets of the original `ParticleSet` (e.g., in the example above, one run with the Particles that start at `time=[0, 2]` and one with the Particle at `time=[1]`). In that case, you will get two files:\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"INFO: Output files are stored in DelayParticle_nonmatchingtime.zarr.\n",
"100%|██████████| 4.0/4.0 [00:00<00:00, 65.51it/s]\n",
"[[ 0 2 4]\n",
" [ 2 4 'NaT']]\n",
"INFO: Output files are stored in DelayParticle_nonmatchingtime.zarr.\n",
"100%|██████████| 3.0/3.0 [00:00<00:00, 95.96it/s]\n",
"[[1 3 4]]\n"
]
}
],
"source": [
"for times in [[0, 2], [1]]:\n",
" pset = ParticleSet(\n",
" fieldset=fieldset,\n",
" pclass=JITParticle,\n",
" lat=[3e3] * len(times),\n",
" lon=[3e3] * len(times),\n",
" time=times,\n",
" )\n",
" output_file = pset.ParticleFile(name=outfilepath, outputdt=2)\n",
" pset.execute(\n",
" AdvectionRK4,\n",
" endtime=4,\n",
" dt=1,\n",
" output_file=output_file,\n",
" )\n",
" # Note that we also need to write the final time to the file\n",
" output_file.write_latest_locations(pset, 4)\n",
" print(xr.open_zarr(outfilepath).time.values[:].astype(\"timedelta64[s]\"))"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Adding new particles to a ParticleSet during runtime\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"In the examples above, all particles were defined at the start of the simulation. There are use-cases, though, where it is important to be able to add particles 'on-the-fly', during the runtime of a Parcels simulation.\n",
"\n",
"Unfortuantely, Parcels does not (yet) support adding new particles _within_ a `Kernel`. A workaround is to temporarily leave the `execution()` call to add particles via the `ParticleSet.add()` method, before continuing with `execution()`.\n",
"\n",
"See the example below, where we add 'mass' to a particle each timestep, based on a probablistic condition, and then split the particle once its 'mass' is larger than 5\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n",
"INFO: Output files are stored in growingparticles.zarr.\n"
]
}
],
"source": [
"GrowingParticle = JITParticle.add_variables(\n",
" [\n",
" Variable(\"mass\", initial=0),\n",
" Variable(\"splittime\", initial=-1),\n",
" Variable(\"splitmass\", initial=0),\n",
" ]\n",
")\n",
"\n",
"\n",
"def GrowParticles(particle, fieldset, time):\n",
" # 25% chance per timestep for particle to grow\n",
" if ParcelsRandom.random() < 0.25:\n",
" particle.mass += 1.0\n",
" if (particle.mass >= 5.0) and (particle.splittime < 0):\n",
" particle.splittime = time\n",
" particle.splitmass = particle.mass / 2.0\n",
" particle.mass = particle.mass / 2.0\n",
"\n",
"\n",
"pset = ParticleSet(fieldset=fieldset, pclass=GrowingParticle, lon=0, lat=0)\n",
"outfile = ParticleFile(\"growingparticles.zarr\", pset, outputdt=1)\n",
"\n",
"for t in range(40):\n",
" pset.execute(\n",
" GrowParticles, runtime=1, dt=1, output_file=outfile, verbose_progress=False\n",
" )\n",
" for p in pset:\n",
" if p.splittime > 0:\n",
" pset.add(\n",
" ParticleSet(\n",
" fieldset=fieldset,\n",
" pclass=GrowingParticle,\n",
" lon=0,\n",
" lat=0,\n",
" time=p.splittime,\n",
" mass=p.splitmass,\n",
" )\n",
" )\n",
" p.splittime = -1 # reset splittime"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"The 'trick' is that we place the `pset.execute()` call in a for-loop, so that we leave the JIT-mode and can add Particles to the ParticleSet.\n",
"\n",
"Indeed, if we plot the mass of particles as a function of time, we see that new particles are created every time a particle reaches a mass of 5.\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"ds = xr.open_zarr(\"growingparticles.zarr\")\n",
"plt.plot(ds.time.values[:].astype(\"timedelta64[s]\").T, ds.mass.T)\n",
"plt.grid()\n",
"plt.xlabel(\"Time\")\n",
"plt.ylabel(\"Particle 'mass'\")\n",
"plt.show()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.6"
}
},
"nbformat": 4,
"nbformat_minor": 1
}