{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tutorial on how to 'delay' the start of particle advection"
]
},
{
"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 conatant 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."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline\n",
"from parcels import FieldSet, ParticleSet, JITParticle, plotTrajectoriesFile\n",
"from parcels import AdvectionRK4\n",
"import numpy as np\n",
"from datetime import timedelta as delta"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"First import a `FieldSet` (from the Peninsula example, in this case)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"fieldset = FieldSet.from_parcels('Peninsula_data/peninsula', allow_time_extrapolation = True)"
]
},
{
"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"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Assigning each particle its own `time` ###"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The simplest way to delaye the start of a particle is to use the `time` argument for each particle"
]
},
{
"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",
"time = np.arange(0, npart) * delta(hours=1).total_seconds() # release every particle one hour later\n",
"\n",
"pset = ParticleSet(fieldset=fieldset, pclass=JITParticle, lon=lon, lat=lat, time=time)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Then we can execute the `pset` as usual"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"INFO: Compiled JITParticleAdvectionRK4 ==> /var/folders/r2/8593q8z93kd7t4j9kbb_f7p00000gr/T/parcels-504/5fba5501ea36ea205605260b5254062f.so\n",
"100% (86400.0 of 86400.0) |##############| Elapsed Time: 0:00:00 Time: 0:00:00\n"
]
}
],
"source": [
"output_file = pset.ParticleFile(name=\"DelayParticle_time\", outputdt=delta(hours=1))\n",
"pset.execute(AdvectionRK4, runtime=delta(hours=24), dt=delta(minutes=5),\n",
" output_file=output_file)"
]
},
{
"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."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
""
],
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plotTrajectoriesFile('DelayParticle_time.nc', mode='movie2d_notebook')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Using the `repeatdt` argument ###"
]
},
{
"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."
]
},
{
"cell_type": "code",
"execution_count": 6,
"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 3 hours\n",
"\n",
"pset = ParticleSet(fieldset=fieldset, pclass=JITParticle, lon=lon, lat=lat, repeatdt=repeatdt)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we again define an output file and execute the `pset` as usual."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"INFO: Compiled JITParticleAdvectionRK4 ==> /var/folders/r2/8593q8z93kd7t4j9kbb_f7p00000gr/T/parcels-504/694933c823154d73a884aab64a89b625.so\n",
"100% (86400.0 of 86400.0) |##############| Elapsed Time: 0:00:02 Time: 0:00:02\n"
]
}
],
"source": [
"output_file = pset.ParticleFile(name=\"DelayParticle_releasedt\", outputdt=delta(hours=1))\n",
"pset.execute(AdvectionRK4, runtime=delta(hours=24), dt=delta(minutes=5),\n",
" output_file=output_file)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And we get an animation where a new particle is released every 3 hours from each start location"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
""
],
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plotTrajectoriesFile('DelayParticle_releasedt.nc', mode='movie2d_notebook')"
]
},
{
"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"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"INFO: Compiled JITParticleAdvectionRK4 ==> /var/folders/r2/8593q8z93kd7t4j9kbb_f7p00000gr/T/parcels-504/aca27122514704372f3f6e56d1ca8af6.so\n",
"100% (28800.0 of 28800.0) |##############| Elapsed Time: 0:00:00 Time: 0:00:00\n",
"100% (54000.0 of 54000.0) |##############| Elapsed Time: 0:00:00 Time: 0:00:00\n"
]
},
{
"data": {
"text/html": [
""
],
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pset = ParticleSet(fieldset=fieldset, pclass=JITParticle, lon=lon, lat=lat, repeatdt=repeatdt)\n",
"output_file = pset.ParticleFile(name=\"DelayParticle_releasedt_9hrs\", outputdt=delta(hours=1))\n",
"\n",
"# first run for 3 * 3 hrs\n",
"pset.execute(AdvectionRK4, runtime=delta(hours=9), dt=delta(minutes=5),\n",
" output_file=output_file)\n",
"\n",
"# now stop the repeated release\n",
"pset.repeatdt = None\n",
"\n",
"# now continue running for the remaining 15 hours\n",
"pset.execute(AdvectionRK4, runtime=delta(hours=15), dt=delta(minutes=5),\n",
" output_file=output_file)\n",
"\n",
"plotTrajectoriesFile('DelayParticle_releasedt_9hrs.nc', mode='movie2d_notebook')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 2",
"language": "python",
"name": "python2"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 2
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython2",
"version": "2.7.15"
}
},
"nbformat": 4,
"nbformat_minor": 1
}