slim4.particles3d

Classes

class slim4.particles3d.ParticleArrays3d

slim4::particles::ParticleArrays This class holds the particle data for 23 particles. It is designed to be used with the Tracker2d class, and to be able to store a large number of particles efficiently on the GPU. It also provides methods to add, remove and sort particles, as well as to compute the concentration field on the mesh. The particles are stored in a structure of arrays format, with the position of the particles in local coordinates (xi, eta, z) within each triangle, and the triangle indices and boundary types of the particles. The class also allows to store additional scalar attributes for the particles, which can be used to compute the concentration field or to export the particles. The class also keeps track of the random seed used for the random number generator, which is used for the random walk of the particles.

Properties

random_seed: int — random seed

mesh: slim3d.Mesh — mesh

size: int — size

Constructor

__init__(mesh, attr_names=[], initial_capacity=0, random_seed=0)

Create a new slim4::particles3d::ParticleArrays3d with the given capacity

Parameters

mesh: slim3d.Mesh — The 3D mesh

attr_names: List[str] — additional scalar attributes

initial_capacity: int — capacity

random_seed: int — random_seed (if 0 time will be used)

Methods

add_particles(position, z, attrs={})

Add particles to the slim4::particles3d::ParticleArrays3d

Parameters

position: NDArray[np.float64] — The 3D position of the particles (3, n_particles)

z: NDArray[np.float64] — The vertical mesh coordinate

attrs: Dict[str,NDArray[np.float64]] — additional scalar attributes

Returns

n_added: int — the number of particles added

static create_xdmf(fname)

Create a new xdmf export for the particles

Parameters

fname: str — The name of the xdmf file to create (without extension)

append_to_xdmf(fname, t, fields=[])

Append the particles to an existing xdmf export

Parameters

fname: str — The name of the xdmf file to append to (without extension)

t: float — The time to export

fields: List[str] — The fields to export (if empty, all fields will be exported). Defaults fields are ‘tri’, ‘bndtype’, ‘layer’ and ‘deletion_time’

sort()

Sort the particles by triangle, and putting the deleted particles at the end (for better performance)

remove_inactive()

Remove inactive particles (settled, leaving, etc.) from the slim4::particles3d::ParticleArrays3d. This also sorts the particles.

Returns

removed: ParticleArrays3d — the removed particles

get_position()

Get the 3D position of the particles

Returns

xyz: NDArray[np.float64] — The 3D position of the particles (3, n_particles)

get_concentration(attr_name, z)

Compute the volumetric concentration field on the 3D mesh. Each prism receives the sum of particle values divided by the prism volume (m^-3 or kg/m^3).

Parameters

attr_name: str — Name of the attribute to accumulate; use ‘count’ for particle count

z: slim.ScalarArrayDevice — Current vertical coordinates of the mesh nodes (shape: 1, 6, n_prisms)

Returns

concentration: slim.ScalarArrayDeviceMPI — Volumetric concentration per prism (n_prisms)

get_triangle()

Get the triangle indices of the particles

Returns

tri: NDArray[np.int32] — The triangle indices of the particles (n_particles)

get_layer()

Get the layer indices of the particles

Returns

layer: NDArray[np.int32] — The layer indices of the particles (n_particles)

get_bndtype()

Get the bndtype flag

Returns

bndtype: NDArray[np.int32] — The bndtype flag of the particles (n_particles)

get_deletion_time()

Get the deletion time of the deleted particles

Returns

deletion_time: NDArray[np.float64] — The deletion time of the deleted particles (n_particles)

get_attr(name)

Get the attribute of the particles

Parameters

name: str — The name of the attribute

Returns

attr: NDArray[np.float64] — The attribute of the particles (n_particles)

get_attribute_names()

Get the names of the attributes of the particles

Returns

names: List[str] — The names of the attributes of the particles

eval_data_gpu(mesh, z, data, t)

Evaluate the data at time t

Parameters

mesh: slim3d.Mesh — the 3d mesh

z: slim.Data — the z coordinates of the 3d mesh

data: slim.Data — The data to evaluate

t: float — The time to evaluate the data at

Returns

evaluated_data: slim.ScalarArrayDevice — The evaluated data GPU readable

eval_data(mesh, z, data, t)

Evaluate the data at time t

Parameters

mesh: slim3d.Mesh — the 3d mesh

z: slim.Data — the z coordinates of the 3d mesh

data: slim.Data — The data to evaluate

t: float — The time to evaluate the data at

Returns

evaluated_data: NDArray[np.float64] — The evaluated data

class slim4.particles3d.Tracker3d

doc

Constructor

__init__(mesh, z, uvw, kh, kv, kh_formula='direct')

Create new 3D tracker

Parameters

mesh: slim3d.Mesh — 3D mesh

z: slim.Data — z coordinate of the mesh on one timestep

uvw: slim.Data — velocity field

kh: slim.Data — horizontal diffusivity

kv: slim.Data — vertical diffusivity

kh_formula: slim2d.HorizontalDiffusivityFormula | str — horizontal diffusivity formula

Methods

set_boundary(tag, type)

Set open boundaries for the tracker

Parameters

tag: str — The boundary tag

type: particles.ParticleBoundaryType | str — The type of boundary

move(p_array, t, dt)

Move particles

Parameters

p_array: ParticleArrays3d — particle arrays

t: float — time

dt: float — time diff between

Returns

end_t: float — the new time after moving the particles

add_particles(p_array, px, t, attrs={})

doc

Parameters

p_array: ParticleArrays3d — p_array

px: NDArray[np.float64] — px

t: float — time

attrs: Dict[str,NDArray[np.float64]] — additional scalar attributes

Returns

n_added: int — the number of particles added

class slim4.particles3d.SedimentsQuasi3d

Quasi-3D Lagrangian tracker for cohesive or non-cohesive sediment particles in a 2D hydrodynamic framework. Each particle carries individual grain properties (diameter, settling velocity, density ratio, erodibility), enabling polydisperse sediment transport simulations. The vertical dimension is resolved analytically: particles are assigned a depth position within the water column based on local flow conditions and settling dynamics, without requiring a full 3D mesh for advection. Typical workflow: 1. create() — instantiate with hydrodynamic fields 2. add_particles() — inject particles with per-grain attributes 3. move() / resuspend_sediments() / update_depth_position() — advance each time step 4. get_suspension_concentrations() / get_settlement_concentrations() — post-process

Constructor

__init__(mesh, uv, eta, bathy, rho_water, kh, kh_formula='direct')

Create new 2D tracker

Parameters

mesh: slim2d.Mesh — 2D mesh

uv: slim.Data — velocity field (u, v)

eta: slim.Data — sea surface elevation

bathy: slim.Data — bathymetry

rho_water: float — water density

kh: slim.Data — horizontal diffusivity

kh_formula: slim2d.HorizontalDiffusivityFormula | str — horizontal diffusivity formula

Methods

set_boundary(tag, type)

Set open boundaries for the tracker

Parameters

tag: str — The boundary tag

type: particles.ParticleBoundaryType | str — The type of boundary

add_particles(p_array, px, attrs)

doc

Parameters

p_array: particles2d.ParticleArrays2d — p_array

px: NDArray[np.float64] — px

attrs: Dict[str,NDArray[np.float64]] — { mass: the particle mass (kg), depth: the particle position along the z axis (depth = h > 0 at the bottom and depth = -eta at the surface) (m), D: the particle diameter (m), w_s: th eparticle settling velocity, positive downward (m/s), density_ratio: the density ratio between the grain and the water, u_crit: the critical velocity to trigger resuspension (m/s), dry_sedimentation_density: the dry sedimentation density (kg/m**3), erodibility: the erodibility used to compute the erosion flux (= erodibility *(tau/tau_crit-1)**power), power: the power used to compute the erosion flux (= erodibility *(tau/tau_crit-1)**power), … }

Returns

n_added: int — the number of particles added

move(p_array, t, dt, k_s)

Move particles

Parameters

p_array: particles2d.ParticleArrays2d — particle arrays

t: float — time

dt: float — time diff between

k_s: float — form roughness height (=3*D90)

update_depth_position(parray, t, dt, mesh, k_s)

doc

Parameters

parray: particles2d.ParticleArrays2d — parray of the particles in suspension

t: float — time

dt: float — time step

mesh: slim2d.Mesh — mesh

k_s: float — form roughness height = 3* D90

resuspend_sediments(parray, t, dt, mesh, k_s)

doc

Parameters

parray: particles2d.ParticleArrays2d — parray of the settled particles

t: float — time

dt: float — time step

mesh: slim2d.Mesh — mesh

k_s: float — form roughness height

get_concentration_3D(p_array, attr_name, mesh3D, z_0, t)

Get the a 3D continuous map of the concentratin (kg/m**3)

Parameters

p_array: particles2d.ParticleArrays2d — p_array

attr_name: str — The name of the attribute to sum (if ‘count’ the number of particles is used)

mesh3D: slim3d.Mesh — The 3D mesh on which the concentration is computed

z_0: slim.ScalarArrayDevice — The z coordinates of the nodes in the 3D mesh

t: float — The time of the computation

Returns

concentration: slim.ScalarArrayDeviceMPI — P0 array with the concentration of particles on each prism (n_prims)

z: slim.ScalarArrayDeviceMPI — P1 array with the updated z coordinates of the mesh (1,6,n_prisms)

get_suspension_concentrations(parray, attr_name, t, dt, by_area)

Get the 2D position of the particles

Parameters

parray: particles2d.ParticleArrays2d — parray of the suspended particles

attr_name: str — The name of the attribute to sum (if ‘count’ the number of particles is used)

t: float — The time of the computation

dt: float — time step

by_area: bool — = true Compute the concentration by squared meters

Returns

concentration_whole_water_column: slim.ScalarArrayDevice — P0 array with the concentration of particles in the total water column on each element (in kg/m**3)

concentration_main_water_column: slim.ScalarArrayDevice — P0 array with the concentration of particles in the main water column on each element (in kg/m**3)

concentration_nearbed: slim.ScalarArrayDevice — P0 array with the concentration of particles in the nearbed layer on each element (in kg/m**3) (n_triangles)

get_settlement_concentrations(parray, attr_name, by_area)

Get the 2D position of the particles

Parameters

parray: particles2d.ParticleArrays2d — parray of the suspended particles

attr_name: str — The name of the attribute to sum (if ‘count’ the number of particles is used)

by_area: bool — = true Compute the concentration by squared meters

Returns

settlement: slim.ScalarArrayDevice — P0 array with the mass per squared meters of settled particles

settlement_thickness: slim.ScalarArrayDevice — P0 array with the thickness of the settled particle layer (n_triangles)

class slim4.particles3d.SedimentsMixtureQuasi3d

Quasi-3D Lagrangian tracker for a sediment mixture described by its grain-size distribution statistics, rather than per-particle grain properties. All particles share the same statistical grain properties (D50, D90), which characterise the sediment mixture as a whole. Settling velocity and critical shear stress are derived internally from D50 using empirical relationships (e.g. van Rijn), and the roughness height is set to k_s = 3 * D90. This approach is appropriate when the sediment can be treated as a uniform mixture — e.g. for reach-scale dredging plumes or background fine-sediment transport — and individual grain-class resolution is not required. Compared to SedimentsQuasi3d: - No per-particle D, w_s, or density_ratio attributes - D50 and D90 are set once at construction (or via setters) - Settling velocity, Shields threshold, and roughness are computed from the mixture statistics Typical workflow: 1. create() — instantiate with hydrodynamic fields and mixture statistics (D50, D90, rho_s) 2. add_particles() — inject particles with mass and depth position only 3. move() / resuspend_sediments() / update_depth_position() — advance each time step 4. get_suspension_concentrations() / get_settlement_concentrations() — post-process

Constructor

__init__(mesh, uv, eta, bathy, rho_water, rho_sediment, D50, D90, kh, kh_formula='direct')

Create new 2D tracker

Parameters

mesh: slim2d.Mesh — 2D mesh

uv: slim.Data — velocity field (u, v)

eta: slim.Data — sea surface elevation

bathy: slim.Data — bathymetry

rho_water: float — water density

rho_sediment: float — sediment density

D50: float — Grain size at which 50% of the sediment is finer (m).

D90: float — Grain size at which 90% of the sediment is finer (m).

kh: slim.Data — horizontal diffusivity

kh_formula: slim2d.HorizontalDiffusivityFormula | str — horizontal diffusivity formula

Methods

set_boundary(tag, type)

Set open boundaries for the tracker

Parameters

tag: str — The boundary tag

type: particles.ParticleBoundaryType | str — The type of boundary

move(p_array, t, dt, k_s)

Move particles

Parameters

p_array: particles2d.ParticleArrays2d — particle arrays

t: float — time

dt: float — time diff between

k_s: float — form roughness height (=3*D90)

add_particles(p_array, px, attrs)

doc

Parameters

p_array: particles2d.ParticleArrays2d — p_array

px: NDArray[np.float64] — px

attrs: Dict[str,NDArray[np.float64]] — { mass: the particle mass (kg), depth: the particle position along the z axis (depth = h > 0 at the bottom and depth = -eta at the surface) (m), }

Returns

n_added: int — the number of particles added

update_depth_position(parray, t, dt, mesh, k_s)

doc

Parameters

parray: particles2d.ParticleArrays2d — parray of the particles in suspension

t: float — time

dt: float — time step

mesh: slim2d.Mesh — mesh

k_s: float — form roughness height = 3* D90

resuspend_sediments(parray, t, dt, mesh, k_s)

doc

Parameters

parray: particles2d.ParticleArrays2d — parray of the settled particles

t: float — time

dt: float — time step

mesh: slim2d.Mesh — mesh

k_s: float — form roughness height

get_concentration_3D(p_array, attr_name, mesh3D, z_0, t)

Get the a 3D continuous map of the concentratin (kg/m**3)

Parameters

p_array: particles2d.ParticleArrays2d — p_array

attr_name: str — The name of the attribute to sum (if ‘count’ the number of particles is used)

mesh3D: slim3d.Mesh — The 3D mesh on which the concentration is computed

z_0: slim.ScalarArrayDevice — The z coordinates of the nodes in the 3D mesh

t: float — The time of the computation

Returns

concentration: slim.ScalarArrayDeviceMPI — P0 array with the concentration of particles on each prism (n_prims)

z: slim.ScalarArrayDeviceMPI — P1 array with the updated z coordinates of the mesh (1,6,n_prisms)

get_suspension_concentrations(parray, attr_name, t, dt, by_area)

Get the 2D position of the particles

Parameters

parray: particles2d.ParticleArrays2d — parray of the suspended particles

attr_name: str — The name of the attribute to sum (if ‘count’ the number of particles is used)

t: float — The time of the computation

dt: float — time step

by_area: bool — = true Compute the concentration by squared meters

Returns

concentration_whole_water_column: slim.ScalarArrayDevice — P0 array with the concentration of particles in the total water column on each element (in kg/m**3)

concentration_main_water_column: slim.ScalarArrayDevice — P0 array with the concentration of particles in the main water column on each element (in kg/m**3)

concentration_nearbed: slim.ScalarArrayDevice — P0 array with the concentration of particles in the nearbed layer on each element (in kg/m**3) (n_triangles)

get_settlement_concentration(parray, attr_name, by_area)

Get the 2D position of the particles

Parameters

parray: particles2d.ParticleArrays2d — parray of the suspended particles

attr_name: str — The name of the attribute to sum (if ‘count’ the number of particles is used)

by_area: bool — = true Compute the concentration by squared meters

Returns

settlement: slim.ScalarArrayDevice — P0 array with the concentration of settled particles (n_triangles)

class slim4.particles3d.ConnectivityArray

doc

Properties

nnz: int — numner of non-zero entries

size: int — number of reefs

Constructor

__init__(size, initial_capacity=0)

Create a new slim4::particles3d::ParticleArrays3d with the given capacity

Parameters

size: int — number of reefs

initial_capacity: int — initial capacity of the array

Methods

get_entries()

Get the entries of the connectivity array

Returns

pfrom: NDArray[np.int32] — pfrom

pto: NDArray[np.int32] — pto

mass: NDArray[np.float64] — mass

update(pfrom, pto, pmass)

Adds the entries to the connectivity array

Parameters

pfrom: slim.IdxArrayDevice — pfrom

pto: slim.IdxArrayDevice — pto

pmass: slim.ScalarArrayDevice — mass

class slim4.particles3d.Particle3dCorals

doc

Constructor

__init__(mesh, z, uvw, kh, kv, kh_formula='direct')

Create new 3D tracker

Parameters

mesh: slim3d.Mesh — 3D mesh

z: slim.Data — z coordinate of the mesh on one timestep

uvw: slim.Data — velocity field

kh: slim.Data — horizontal diffusivity

kv: slim.Data — vertical diffusivity

kh_formula: slim2d.HorizontalDiffusivityFormula | str — horizontal diffusivity formula

Methods

set_boundary(tag, type)

Set open boundaries for the tracker

Parameters

tag: str — The boundary tag

type: particles.ParticleBoundaryType | str — The type of boundary

move(p_array, t, dt)

Move particles

Parameters

p_array: ParticleArrays3d — particle arrays

t: float — time

dt: float — time diff between

Returns

end_t: float — the new time after moving the particles

add_particles(p_array, px, t, attrs={})

doc

Parameters

p_array: ParticleArrays3d — p_array

px: NDArray[np.float64] — px

t: float — time

attrs: Dict[str,NDArray[np.float64]] — additional scalar attributes

Returns

n_added: int — the number of particles added

update_biological_state(p_array, t, dt, tc, a, b, u, v)

Parameters

p_array: ParticleArrays3d — p_array

t: float — time

dt: float — time step

tc: float — minimum time to competence (hours)

a: float — competence acquisition rate (hours^-1)

b: float — competence loss rate (hours^-1)

u: float — mortality rate (hours^-1)

v: float — Weibull shape parameter (dimensionless)

update_biological_state_discrete(p_array, t)

Parameters

p_array: ParticleArrays3d — p_array

t: float — time

update_biological_state_discrete2(p_array, t)

Parameters

p_array: ParticleArrays3d — p_array

t: float — time

update_physical_state(p_array, t, rho, nu_v, times, rho_p, diameter)

Update the physical state of the particles

Parameters

p_array: ParticleArrays3d — p_array

t: float — time

rho: slim.Data — density field (kg/m3)

nu_v: slim.Data — vertical viscosity field (m2/s)

times: NDArray[np.float64] — list of times to evaluate the physical state

rho_p: NDArray[np.float64] — list of particle densities (kg/m3)

diameter: NDArray[np.float64] — list of particle diameters (m)

update_physical_state_discrete(p_array, t, swimspeed, rho, nu_v, times, rho_p, diameter)

Update the physical state of the particles

Parameters

p_array: ParticleArrays3d — p_array

t: float — time

swimspeed: float — downwards swimming speed (m/s) during competent phase

rho: slim.Data — density field (kg/m3)

nu_v: slim.Data — vertical viscosity field (m2/s)

times: NDArray[np.float64] — list of times to evaluate the physical state

rho_p: NDArray[np.float64] — list of particle densities (kg/m3)

diameter: NDArray[np.float64] — list of particle diameters (m)

update_physical_state_discrete2(p_array, t, tides, eta, eta_corr)

Update the physical state of the particles

Parameters

p_array: ParticleArrays3d — p_array

t: float — time

tides: bool — boolean indicating if tidal synchrony is activated

eta: slim.Data — Sea surface elevation (m)

eta_corr: float — Correction term for eta (m)

update_physical_state_discrete2_NT(p_array, t, tides)

Update the physical state of the particles without tidal synchrony and eta correction

Parameters

p_array: ParticleArrays3d — p_array

t: float — time

tides: bool — boolean indicating if tidal synchrony is activated

settle_particles(p_array, reef_map, cm_array, t, dt, z_dist, gamma)

Evaluate the data at time t

Parameters

p_array: ParticleArrays3d — p_array

reef_map: slim.Data — reef map data to evaluate

cm_array: ConnectivityArray — connectivity map array

t: float — The time to evaluate the data at

dt: float — The time step

z_dist: float — vertical distance for particles to settle (m)

gamma: float — deposition rate (h-1)

settle_particles_discrete(p_array, reef_map, cm_array, t, dt, z_dist, gamma)

Evaluate the data at time t

Parameters

p_array: ParticleArrays3d — p_array

reef_map: slim.Data — reef map data to evaluate

cm_array: ConnectivityArray — connectivity map array

t: float — The time to evaluate the data at

dt: float — The time step

z_dist: float — vertical distance for particles to settle (m)

gamma: float — deposition rate (h-1)

settle_particles_discrete2(p_array, reef_map, cm_array, t, dt, z_dist, cues)

Evaluate the data at time t

Parameters

p_array: ParticleArrays3d — p_array

reef_map: slim.Data — reef map data to evaluate

cm_array: ConnectivityArray — connectivity map array

t: float — The time to evaluate the data at

dt: float — The time step

z_dist: float — vertical distance for particles to settle (m)

cues: bool — boolean indicating if settlement cues are activated

class slim4.particles3d.Particle3dSediments

doc

Constructor

__init__(mesh, z, uvw, kh, kv, kh_formula='direct')

Create new 3D tracker

Parameters

mesh: slim3d.Mesh — 3D mesh

z: slim.Data — z coordinate of the mesh on one timestep

uvw: slim.Data — velocity field

kh: slim.Data — horizontal diffusivity

kv: slim.Data — vertical diffusivity

kh_formula: slim2d.HorizontalDiffusivityFormula | str — horizontal diffusivity formula

Methods

set_boundary(tag, type)

Set open boundaries for the tracker

Parameters

tag: str — The boundary tag

type: particles.ParticleBoundaryType | str — The type of boundary

move(p_array, t, dt)

Move particles

Parameters

p_array: ParticleArrays3d — particle arrays

t: float — time

dt: float — time diff between

Returns

end_t: float — the new time after moving the particles

add_particles(p_array, px, t, attrs={})

doc

Parameters

p_array: ParticleArrays3d — p_array

px: NDArray[np.float64] — px

t: float — time

attrs: Dict[str,NDArray[np.float64]] — additional scalar attributes

Returns

n_added: int — the number of particles added

settle_sediments(parray, t, z_tolerance)

doc

Parameters

parray: ParticleArrays3d — parray

t: float — time

z_tolerance: float — z_tolerance

class slim4.particles3d.SeagrassFateArray

doc

Properties

nnz: int — numner of non-zero entries

n_rows: int — number of seagrass patches

n_cols: int — number of fate categories

Constructor

__init__(n_rows, n_cols, initial_capacity=0)

Create a new slim4::particles3d::SeagrassFateArray with the given capacity

Parameters

n_rows: int — number of seagrass patches

n_cols: int — number of fate categories

initial_capacity: int — initial capacity of the array

Methods

get_entries()

Get the entries of the connectivity array

Returns

pfrom: NDArray[np.int32] — pfrom

pto: NDArray[np.int32] — pto

weight: NDArray[np.float64] — weight

update(pfrom, pto, pweight)

Adds the entries to the array

Parameters

pfrom: slim.IdxArrayDevice — pfrom

pto: slim.IdxArrayDevice — pto

pweight: slim.ScalarArrayDevice — weight

class slim4.particles3d.Particle3dSeagrass

doc

Constructor

__init__(mesh, z, uvw, kh, kv, wind, kh_formula='direct')

Create new 3D tracker

Parameters

mesh: slim3d.Mesh — 3D mesh

z: slim.Data — z coordinate of the mesh on one timestep

uvw: slim.Data — velocity field

kh: slim.Data — horizontal diffusivity

kv: slim.Data — vertical diffusivity

wind: slim.Data — wind speed

kh_formula: slim2d.HorizontalDiffusivityFormula | str — horizontal diffusivity formula

Methods

set_boundary(tag, type)

Set open boundaries for the tracker

Parameters

tag: str — The boundary tag

type: particles.ParticleBoundaryType | str — The type of boundary

move(p_array, t, dt)

Move particles

Parameters

p_array: ParticleArrays3d — particle arrays

t: float — time

dt: float — time diff between

Returns

end_t: float — the new time after moving the particles

add_particles(p_array, px, t, attrs={})

doc

Parameters

p_array: ParticleArrays3d — p_array

px: NDArray[np.float64] — px

t: float — time

attrs: Dict[str,NDArray[np.float64]] — additional scalar attributes

Returns

n_added: int — the number of particles added

set_physical_attributes(p_array, t, eta, surf_threshold, deep_threshold, deposition_threshold)

Adjust vertical velocity and boolean attributes

Parameters

p_array: ParticleArrays3d — particle arrays

t: float — time

eta: slim.Data — sea surface elevation

surf_threshold: float — distance threshold for considering a particle to be at the surface

deep_threshold: float — distance threshold for considering a particle to be in deep water

deposition_threshold: float — distance threshold for considering a particle to be near the bottom

decompose(p_array, t, dt, t_exp, tfactor, z_exp, zfactor)

Update particle mass as a function of time and depth

Parameters

p_array: ParticleArrays3d — particle arrays

t: float — time

dt: float — time step

t_exp: bool — exponential decay with time (linear if False)

tfactor: float — decomposition factor with time (s-1)

z_exp: bool — exponential decay with depth (linear if False)

zfactor: float — depth-dependence of the decomposition factor (m-1)

update_deposition_clock(p_array, t, dt, resuspension_speed, deposition_time)

Update the deposition clock for particles near the bottom

Parameters

p_array: ParticleArrays3d — particle arrays

t: float — time

dt: float — time step

resuspension_speed: float — speed at which the deposition clock is restarted due to resuspension (m/s)

deposition_time: float — time required for a particle to be considered settled if it is near the bottom (s)

update_fate_arrays(p_array, t, sgn_array, sgm_array)

Update fate arrays based on the attributes of the particles at the time of deletion

Parameters

p_array: ParticleArrays3d — particle arrays

t: float — time

sgn_array: SeagrassFateArray — fate array for number of particles

sgm_array: SeagrassFateArray — fate array for mass of particles