scikit-complexity 0.2.0__py3-none-any.whl

skcomplex/models/engineering/processes/_systems.py

@@ -0,0 +1,316 @@
+"""Process systems: stocks of grain, waste, food, and water that engineered systems move between holders."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+
+from ....core.system import System
+from ....specs import ObservableSpec
+from ..._catalog import register_model
+from ._irrigation_scheme import IrrigationSchemeElement
+from ._relief_pipeline import ReliefPipelineElement
+from ._rice_mill import BRAN_SHARE, HUSK_SHARE, RiceMillElement
+from ._waste_system import WasteSystemElement
+
+INITIAL_COLLECTION_SHARE = 0.75
+
+
+@register_model(
+    field='engineering/processes',
+    tags=('agriculture', 'milling', 'stocks and flows', 'system dynamics', 'ode'),
+    references=('Bala et al. 2017',),
+    defaults={'until': 120.0, 'dt': 0.25},
+    observables=lambda system: [
+        ObservableSpec('procurement', RiceMillElement._procurement, element='mill'),
+        ObservableSpec('indicated_milling', RiceMillElement._indicated_milling, element='mill'),
+        ObservableSpec('milling', RiceMillElement._milling, element='mill'),
+    ],
+)
+def rice_milling(
+    *,
+    harvest: float = 2000.0,
+    seasonality: float = 0.8,
+    procurement_delay: float = 1.0,
+    outturn: float = 0.65,
+    capacity: float = 2000.0,
+    expansion_time: float = 12.0,
+) -> System:
+    """Return a rice milling system, a mill that buys paddy, mills it into rice and by-products, and sells them.
+
+    Paddy arrives from the farms through a third-order procurement delay, at a rate that follows the harvest season
+    around its mean. The mill processes its paddy stock in a month, as far as its milling capacity allows, and splits
+    the milled paddy by mass into rice, the outturn, husk, bran, and milling losses. Rice, husk, and bran leave their
+    inventories for the market at a fixed coverage. The capacity adjusts to the smoothed indicated milling rate, so in
+    the harvest season the capacity lags and paddy accumulates, and in the lean season the capacity idles. Grain is
+    conserved, every change of the paddy, rice, husk, and bran stocks is a flow, and over a year the milled paddy and
+    the rice sales match the mean harvest and its outturn. The structure follows the rice milling case of Bala,
+    Arshad and Noh (2017), with illustrative parameters in tonnes and months, since the case data are specific to
+    their study.
+
+    Args:
+        harvest:
+            The mean paddy procurement in tonnes per month.
+
+        seasonality:
+            The relative amplitude of the yearly harvest cycle.
+
+        procurement_delay:
+            The average time for purchased paddy to reach the mill, in months.
+
+        outturn:
+            The fraction of the milled paddy that becomes rice.
+
+        capacity:
+            The initial milling capacity in tonnes of paddy per month.
+
+        expansion_time:
+            The time for the capacity to adjust to the perceived milling rate, in months.
+
+    Returns:
+        system:
+            The model, with the grain stocks `mill.paddy`, `mill.rice`, `mill.husk`, and `mill.bran` in tonnes, the
+            capacity `mill.capacity`, and the flows `mill.paddy_purchases`, `mill.milled_rice`, `mill.husk_output`,
+            `mill.bran_output`, `mill.milling_losses`, `mill.rice_sales`, `mill.husk_sales`, and `mill.bran_sales` in
+            tonnes per month, over months. The observables of the model are `mill.procurement`,
+            `mill.indicated_milling`, and `mill.milling`.
+
+    Examples:
+        >>> from skcomplex.models.engineering.processes import rice_milling
+        >>> rice_milling(capacity=1500.0).elements[0].capacity
+        1500.0
+    """
+    mill = RiceMillElement(
+        'mill',
+        paddy=harvest,
+        rice=outturn * harvest,
+        husk=HUSK_SHARE * harvest,
+        bran=BRAN_SHARE * harvest,
+        capacity=capacity,
+        harvest=harvest,
+        seasonality=seasonality,
+        procurement_delay=procurement_delay,
+        outturn=outturn,
+        expansion_time=expansion_time,
+    )
+    return System(elements=[mill])
+
+
+@register_model(
+    field='engineering/processes',
+    tags=('waste management', 'urban', 'stocks and flows', 'system dynamics', 'ode'),
+    references=('Bala et al. 2017',),
+    defaults={'until': 40.0, 'dt': 0.1},
+    observables=lambda system: [
+        ObservableSpec('generation', WasteSystemElement._generation, element='city'),
+        ObservableSpec('collection', WasteSystemElement._collection, element='city'),
+        ObservableSpec('acceptance', WasteSystemElement._acceptance, element='city'),
+    ],
+)
+def solid_waste(
+    population: float = 1e6,
+    *,
+    growth_rate: float = 0.02,
+    per_capita: float = 0.2,
+    recycling_share: float = 0.2,
+    composting_share: float = 0.3,
+    landfill_capacity: float = 2e6,
+) -> System:
+    """Return a solid waste system, the waste of a growing city collected, recycled, composted, and landfilled.
+
+    The population grows exponentially and generates waste in proportion to its size. The waste waits uncollected
+    until the collection, limited by a collection capacity that the city expands towards the generation with a delay,
+    removes it. The collected waste is recycled, composted, or sent to the landfill in fixed shares. Recycled material
+    and compost leave for industry and farms. The landfill accepts waste until it nears its capacity, and a table
+    function then turns the residual waste to open dumping. Waste is conserved, so the landfill fills up to its
+    capacity and dumping takes over. The structure follows the solid waste management case of Bala, Arshad and Noh
+    (2017), with illustrative parameters in tonnes and years for a city of a million people.
+
+    Args:
+        population:
+            The initial population.
+
+        growth_rate:
+            The yearly growth rate of the population.
+
+        per_capita:
+            The waste generated per person, in tonnes per year.
+
+        recycling_share:
+            The share of the collected waste that is recycled.
+
+        composting_share:
+            The share of the collected waste that is composted.
+
+        landfill_capacity:
+            The capacity of the landfill in tonnes.
+
+    Returns:
+        system:
+            The model, with the population `city.population`, the waste stocks `city.uncollected`, `city.recycled`,
+            `city.composted`, `city.landfill`, and `city.dumped` in tonnes, the capacity `city.collection_capacity`,
+            and the flows `city.population_growth`, `city.waste_generation`, `city.recycling`, `city.composting`,
+            `city.landfilling`, `city.dumping`, `city.recycled_sales`, and `city.compost_sales` per year, over years.
+            The observables of the model are `city.generation`, `city.collection`, and `city.acceptance`.
+
+    Examples:
+        >>> from skcomplex.models.engineering.processes import solid_waste
+        >>> solid_waste(landfill_capacity=1e6).elements[0].landfill_capacity
+        1000000.0
+    """
+    city = WasteSystemElement(
+        'city',
+        population=population,
+        collection_capacity=INITIAL_COLLECTION_SHARE * per_capita * population,
+        growth_rate=growth_rate,
+        per_capita=per_capita,
+        recycling_share=recycling_share,
+        composting_share=composting_share,
+        landfill_capacity=landfill_capacity,
+    )
+    return System(elements=[city])
+
+
+@register_model(
+    field='engineering/processes',
+    tags=('humanitarian logistics', 'supply chain', 'stocks and flows', 'system dynamics', 'ode'),
+    references=('Bala et al. 2017',),
+    defaults={'until': 120.0, 'dt': 0.5},
+    observables=lambda system: [
+        ObservableSpec('need', ReliefPipelineElement._need, element='relief'),
+        ObservableSpec('shipments', ReliefPipelineElement._shipments, element='relief'),
+    ],
+)
+def food_relief(
+    affected: float = 1e5,
+    *,
+    ration: float = 5e-4,
+    onset: float = 10.0,
+    shipping_delay: float = 14.0,
+    cover: float = 7.0,
+    stock_time: float = 7.0,
+) -> System:
+    """Return a food relief system, a pipeline that ships food to a warehouse and distributes it to people in need.
+
+    A disaster at `onset` leaves `affected` people who need a daily ration. The relief agency ships food at the need
+    plus corrections that close the gaps between the warehouse stock and its desired cover of the need, and between
+    the food in transit and the need over the shipping delay. Shipped food enters the pipeline and arrives at the
+    warehouse through a third-order material delay. The warehouse distributes the need while its stock lasts. Food is
+    conserved, so almost nothing reaches the people in the first days after the disaster, and the gap closes as the
+    pipeline fills. The structure follows the relief food example of Bala, Arshad and Noh (2017, Section 4.11), with
+    illustrative parameters in tonnes and days.
+
+    Args:
+        affected:
+            The number of people in need after the disaster.
+
+        ration:
+            The daily ration in tonnes per person.
+
+        onset:
+            The day of the disaster.
+
+        shipping_delay:
+            The average time from shipping to arrival, in days.
+
+        cover:
+            The desired warehouse stock in days of need.
+
+        stock_time:
+            The time to correct the warehouse stock, in days.
+
+    Returns:
+        system:
+            The model, with the food stocks `relief.in_transit` and `relief.warehouse` in tonnes, and the flows
+            `relief.shipping`, `relief.arrivals`, and `relief.distribution` in tonnes per day, over days. The
+            observables of the model are `relief.need` and `relief.shipments`.
+
+    Examples:
+        >>> from skcomplex.models.engineering.processes import food_relief
+        >>> food_relief(shipping_delay=7.0).elements[0].shipping_delay
+        7.0
+    """
+    relief = ReliefPipelineElement(
+        'relief',
+        affected=affected,
+        ration=ration,
+        onset=onset,
+        shipping_delay=shipping_delay,
+        cover=cover,
+        stock_time=stock_time,
+    )
+    return System(elements=[relief])
+
+
+@register_model(
+    field='engineering/processes',
+    tags=('water resources', 'agriculture', 'stocks and flows', 'system dynamics', 'ode'),
+    references=('Bala et al. 2017',),
+    defaults={'until': 730.0, 'dt': 1.0},
+    observables=lambda system: [
+        ObservableSpec('demand', IrrigationSchemeElement._demand, element='scheme'),
+        ObservableSpec('release', IrrigationSchemeElement._reservoir_release, element='scheme'),
+        ObservableSpec('pumping', IrrigationSchemeElement._pumping, element='scheme'),
+    ],
+)
+def irrigation(
+    *,
+    river_inflow: float = 0.5,
+    seasonality: float = 0.9,
+    reservoir_capacity: float = 80.0,
+    potential_et: float = 0.4,
+    canal_loss: float = 0.2,
+    pump_capacity: float = 0.2,
+) -> System:
+    """Return an irrigation system, a reservoir and an aquifer that keep the root zone of the crops supplied.
+
+    A river fills the reservoir with a yearly cycle, and the reservoir loses water to evaporation and spills above its
+    capacity. The irrigation demand is the potential crop evapotranspiration plus the refill of the root zone towards
+    a target fraction of its field capacity. The reservoir releases the demand grossed up for the canal losses, as far
+    as its stock allows, and the losses seep into the aquifer. When the release falls short, the farmers pump the
+    unmet demand from the aquifer up to the pump capacity. The crops draw water from the root zone at the potential
+    rate scaled by a water-stress table, and the root zone percolates to the aquifer, which drains as baseflow. Water
+    is conserved, so in the dry season the reservoir falls, the pumping rises, and the aquifer is drawn down. The
+    structure follows the irrigation example of Bala, Arshad and Noh (2017, Section 4.11), with illustrative
+    parameters in millions of cubic metres and days.
+
+    Args:
+        river_inflow:
+            The mean river inflow to the reservoir, per day.
+
+        seasonality:
+            The relative amplitude of the yearly inflow cycle.
+
+        reservoir_capacity:
+            The capacity of the reservoir.
+
+        potential_et:
+            The crop water requirement, the potential evapotranspiration of the irrigated area per day.
+
+        canal_loss:
+            The fraction of the release lost from the canals to the aquifer.
+
+        pump_capacity:
+            The largest groundwater pumping per day.
+
+    Returns:
+        system:
+            The model, with the water stocks `scheme.reservoir`, `scheme.soil`, and `scheme.groundwater`, and the
+            flows `scheme.inflow`, `scheme.evaporation`, `scheme.spill`, `scheme.irrigation`, `scheme.seepage`,
+            `scheme.groundwater_pumping`, `scheme.crop_water`, `scheme.percolation`, and `scheme.baseflow` per day,
+            over days. The observables of the model are `scheme.demand`, `scheme.release`, and `scheme.pumping`.
+
+    Examples:
+        >>> from skcomplex.models.engineering.processes import irrigation
+        >>> irrigation(pump_capacity=0.0).elements[0].pump_capacity
+        0.0
+    """
+    scheme = IrrigationSchemeElement(
+        'scheme',
+        river_inflow=river_inflow,
+        seasonality=seasonality,
+        reservoir_capacity=reservoir_capacity,
+        potential_et=potential_et,
+        canal_loss=canal_loss,
+        pump_capacity=pump_capacity,
+    )
+    return System(elements=[scheme])

skcomplex/models/engineering/processes/_tub.py

@@ -0,0 +1,42 @@
+"""Tub of water, a stock filled by a faucet that opens after five minutes and emptied by a drain."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from types import SimpleNamespace
+from typing import Annotated
+
+from sage.all__sagemath_symbolics import oo
+from sage.sets.real_set import RealSet
+
+from ....core.elements import Element
+from ....core.laws import BaseLaw, Sink, Source, TransferLaw
+from ....core.laws.utils import step, where
+from ....specs import ParameterSpec, StateSpec, VisualSpec
+
+INFLOW_START = 5.0
+
+
+class TubElement(Element):
+    """Tub of water, a stock filled by a faucet that opens after five minutes and emptied by a drain."""
+
+    def __init__(
+        self,
+        label: str,
+        visual: VisualSpec | None = None,
+        *,
+        water: Annotated[object, StateSpec(domain=RealSet.closed_open(0, oo), quantity='water')] = 50.0,
+        inflow: Annotated[object, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 5.0,
+        outflow: Annotated[object, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 5.0,
+    ) -> None:
+        super().__init__(label, visual=visual)
+        self.water = water
+        self.inflow = inflow
+        self.outflow = outflow
+
+    def _get_laws(self, s: SimpleNamespace) -> list[BaseLaw]:
+        """Return the faucet and drain flows of the tub."""
+        return [
+            TransferLaw(Source(), s.water, s.inflow * step(s.t, INFLOW_START), label='faucet'),
+            TransferLaw(s.water, Sink(), where(s.water > 0, s.outflow, 0), label='drain'),
+        ]

skcomplex/models/engineering/processes/_waste_system.py

@@ -0,0 +1,101 @@
+"""Solid waste system of a growing city that collects, recycles, composts, and landfills its waste."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from types import SimpleNamespace
+from typing import Annotated
+
+from sage.all__sagemath_symbolics import Expression, oo
+from sage.sets.real_set import RealSet
+
+from ....core.elements import Element
+from ....core.laws import BaseLaw, RateLaw, Sink, Source, TransferLaw
+from ....core.laws.utils import lookup, minimum
+from ....specs import ParameterSpec, StateSpec, VisualSpec
+
+LANDFILL_ACCEPTANCE = ((0.0, 1.0), (0.9, 1.0), (1.0, 0.0))
+
+
+class WasteSystemElement(Element):
+    """Solid waste system of a growing city that collects, recycles, composts, and landfills its waste."""
+
+    def __init__(
+        self,
+        label: str,
+        visual: VisualSpec | None = None,
+        *,
+        population: Annotated[object, StateSpec(domain=RealSet.closed_open(0, oo), quantity='people')] = 1000000.0,
+        uncollected: Annotated[object, StateSpec(domain=RealSet.closed_open(0, oo), quantity='waste')] = 0.0,
+        recycled: Annotated[object, StateSpec(domain=RealSet.closed_open(0, oo), quantity='waste')] = 0.0,
+        composted: Annotated[object, StateSpec(domain=RealSet.closed_open(0, oo), quantity='waste')] = 0.0,
+        landfill: Annotated[object, StateSpec(domain=RealSet.closed_open(0, oo), quantity='waste')] = 0.0,
+        dumped: Annotated[object, StateSpec(domain=RealSet.closed_open(0, oo), quantity='waste')] = 0.0,
+        collection_capacity: Annotated[object, StateSpec(domain=RealSet.closed_open(0, oo))] = 150000.0,
+        growth_rate: Annotated[object, ParameterSpec()] = 0.02,
+        per_capita: Annotated[object, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 0.2,
+        collection_time: Annotated[object, ParameterSpec(domain=RealSet.open(0, oo))] = 0.05,
+        recycling_share: Annotated[object, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 0.2,
+        composting_share: Annotated[object, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 0.3,
+        landfill_capacity: Annotated[object, ParameterSpec(domain=RealSet.open(0, oo))] = 2000000.0,
+        recycling_time: Annotated[object, ParameterSpec(domain=RealSet.open(0, oo))] = 0.25,
+        composting_time: Annotated[object, ParameterSpec(domain=RealSet.open(0, oo))] = 0.5,
+        capacity_time: Annotated[object, ParameterSpec(domain=RealSet.open(0, oo))] = 3.0,
+    ) -> None:
+        super().__init__(label, visual=visual)
+        self.population = population
+        self.uncollected = uncollected
+        self.recycled = recycled
+        self.composted = composted
+        self.landfill = landfill
+        self.dumped = dumped
+        self.collection_capacity = collection_capacity
+        self.growth_rate = growth_rate
+        self.per_capita = per_capita
+        self.collection_time = collection_time
+        self.recycling_share = recycling_share
+        self.composting_share = composting_share
+        self.landfill_capacity = landfill_capacity
+        self.recycling_time = recycling_time
+        self.composting_time = composting_time
+        self.capacity_time = capacity_time
+
+    def _get_laws(self, s: SimpleNamespace) -> list[BaseLaw]:
+        """Return the flows of waste through the city and the adjustment of its collection capacity."""
+        return WasteSystemElement._waste_laws(s)
+
+    @staticmethod
+    def _generation(s: SimpleNamespace) -> Expression:
+        """Return the generation of waste by the population."""
+        return s.per_capita * s.population
+
+    @staticmethod
+    def _collection(s: SimpleNamespace) -> Expression:
+        """Return the collection of waste, limited by the collection capacity."""
+        return minimum(s.uncollected / s.collection_time, s.collection_capacity)
+
+    @staticmethod
+    def _acceptance(s: SimpleNamespace) -> Expression:
+        """Return the share of the residual waste that the landfill accepts as it fills."""
+        return lookup(s.landfill / s.landfill_capacity, LANDFILL_ACCEPTANCE)
+
+    @staticmethod
+    def _waste_laws(s: SimpleNamespace) -> list[BaseLaw]:
+        """Return the generation, collection, treatment, and disposal of the solid waste of a growing city."""
+        generation, collection, acceptance = (
+            WasteSystemElement._generation(s),
+            WasteSystemElement._collection(s),
+            WasteSystemElement._acceptance(s),
+        )
+        residual = (1 - s.recycling_share - s.composting_share) * collection
+        return [
+            TransferLaw(Source('births'), s.population, s.growth_rate * s.population, label='population_growth'),
+            TransferLaw(Source('households'), s.uncollected, generation, label='waste_generation'),
+            TransferLaw(s.uncollected, s.recycled, s.recycling_share * collection, label='recycling'),
+            TransferLaw(s.uncollected, s.composted, s.composting_share * collection, label='composting'),
+            TransferLaw(s.uncollected, s.landfill, acceptance * residual, label='landfilling'),
+            TransferLaw(s.uncollected, s.dumped, (1 - acceptance) * residual, label='dumping'),
+            TransferLaw(s.recycled, Sink('industry'), s.recycled / s.recycling_time, label='recycled_sales'),
+            TransferLaw(s.composted, Sink('farms'), s.composted / s.composting_time, label='compost_sales'),
+            RateLaw(s.collection_capacity, (generation - s.collection_capacity) / s.capacity_time),
+        ]

skcomplex/models/engineering/robotics/__init__.py

@@ -0,0 +1,12 @@
+"""Robotics: autonomous robots and robot swarms."""
+
+from ._light_sensitive_robot import LightSensitiveRobotElement
+from ._robots import light_seeking_robots, swarmtaxis
+from ._swarm_robot import SwarmRobotElement
+
+__all__: list[str] = [
+    'LightSensitiveRobotElement',
+    'SwarmRobotElement',
+    'light_seeking_robots',
+    'swarmtaxis',
+]

skcomplex/models/engineering/robotics/_light_sensitive_robot.py

@@ -0,0 +1,125 @@
+"""Robot in a Gaussian light field that slows down in light, reacting to the light it measured a delay ago."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from types import SimpleNamespace
+from typing import Annotated
+
+from sage.all__sagemath_symbolics import Expression, cos, exp, oo, sin, sqrt
+from sage.sets.real_set import RealSet
+
+from ....core.elements import Element
+from ....core.laws import BaseLaw, BoundaryLaw, NoiseLaw, RateLaw
+from ....core.laws.utils import delayed, where
+from ....specs import ParameterSpec, StateSpec, VisualSpec
+
+
+class LightSensitiveRobotElement(Element):
+    """Robot in a Gaussian light field that slows down in light, reacting to the light it measured a delay ago.
+
+    The robot moves at the speed `v = V_inf + (V0 - V_inf) exp(-I(t - delay))` in the direction `phi`, which diffuses
+    with time scale `tau`, `dphi = sqrt(2 / tau) dW`. The light is `I(x, y) = I0 exp(-(x^2 + y^2) / r0^2)`, and a wall
+    at radius `R` reflects the robot back into a circular well.
+
+    Args:
+        label:
+            The label of the robot or the group.
+
+        visual:
+            How the element is drawn, or `None` for `default_visual_`.
+
+        x:
+            The initial horizontal position.
+
+        y:
+            The initial vertical position.
+
+        phi:
+            The initial direction of motion.
+
+        V0:
+            The speed in the dark.
+
+        V_inf:
+            The speed in strong light.
+
+        I0:
+            The intensity at the centre of the light.
+
+        r0:
+            The width of the light.
+
+        tau:
+            The time scale of rotational diffusion.
+
+        R:
+            The radius of the well.
+
+        delay:
+            The sensory delay, 0 for a robot that reacts to the light it measures now.
+
+    Examples:
+        >>> from skcomplex.models.engineering.robotics import LightSensitiveRobotElement
+        >>> LightSensitiveRobotElement('robot', delay=5.0).delay
+        5.0
+    """
+
+    def __init__(
+        self,
+        label: str,
+        visual: VisualSpec | None = None,
+        *,
+        x: Annotated[float, StateSpec(role='position')] = 0.0,
+        y: Annotated[float, StateSpec(role='position')] = 0.0,
+        phi: Annotated[float, StateSpec(role='direction')] = 0.0,
+        V0: Annotated[float, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 1.0,
+        V_inf: Annotated[float, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 0.1,
+        I0: Annotated[float, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 1.0,
+        r0: Annotated[float, ParameterSpec(domain=RealSet.open(0, oo))] = 1.0,
+        tau: Annotated[float, ParameterSpec(domain=RealSet.open(0, oo))] = 1.0,
+        R: Annotated[float, ParameterSpec(domain=RealSet.open(0, oo))] = 2.0,
+        delay: float = 0.0,
+    ) -> None:
+        super().__init__(label, visual=visual)
+        self.x = x
+        self.y = y
+        self.phi = phi
+        self.V0 = V0
+        self.V_inf = V_inf
+        self.I0 = I0
+        self.r0 = r0
+        self.tau = tau
+        self.R = R
+        self.delay = delay
+
+    def _get_laws(self, s: SimpleNamespace) -> list[BaseLaw]:
+        """Return the motion at the light-dependent speed, the rotational noise, and the reflecting wall.
+
+        Args:
+            s:
+                The namespace of the symbols the laws can use.
+
+        Returns:
+            laws:
+                The laws of the component.
+        """
+        sensed = (
+            LightSensitiveRobotElement._light(s, delayed(s.x, self.delay), delayed(s.y, self.delay))
+            if self.delay
+            else LightSensitiveRobotElement._light(s, s.x, s.y)
+        )
+        speed = s.V_inf + (s.V0 - s.V_inf) * exp(-sensed)
+        reach = where(sqrt(s.x**2 + s.y**2) > s.R, sqrt(s.x**2 + s.y**2), s.R)
+        return [
+            RateLaw(s.x, speed * cos(s.phi)),
+            RateLaw(s.y, speed * sin(s.phi)),
+            NoiseLaw(s.phi, sqrt(2 / s.tau)),
+            BoundaryLaw(s.x, s.x * s.R / reach),
+            BoundaryLaw(s.y, s.y * s.R / reach),
+        ]
+
+    @staticmethod
+    def _light(s: SimpleNamespace, x: Expression, y: Expression) -> Expression:
+        """Return the Gaussian light intensity `I0 exp(-(x^2 + y^2) / r0^2)` at a point."""
+        return s.I0 * exp(-(x**2 + y**2) / s.r0**2)