fmdtools 2.4.0__tar.gz → 2.5.1__tar.gz

{fmdtools-2.4.0 → fmdtools-2.5.1}/LICENSE

@@ -1,4 +1,4 @@
-fmdtools version 2.4.0
+fmdtools version 2.5.1
 ---------------------------
                                  Apache License
                            Version 2.0, January 2004

{fmdtools-2.4.0 → fmdtools-2.5.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fmdtools
-Version: 2.4.0
+Version: 2.5.1
 Summary: System resilience modelling, simulation, and assessment in Python
 Author: fmdtools Developers
 Maintainer-email: Daniel Hulse <daniel.e.hulse@nasa.gov>
-License: fmdtools version 2.4.0
+License: fmdtools version 2.5.1
         ---------------------------
                                          Apache License
                                    Version 2.0, January 2004
@@ -250,7 +250,7 @@ Requires-Dist: tqdm
 Requires-Dist: networkx
 Requires-Dist: numpy>=2.0
 Requires-Dist: matplotlib>=3.7.0
-Requires-Dist: pandas[all]>=2.2.0
+Requires-Dist: pandas[output-formatting,plot]>=2.2.0
 Requires-Dist: ordered-set
 Requires-Dist: dill
 Requires-Dist: recordclass==0.24
@@ -306,8 +306,8 @@ The fmdtools library provides the computational support needed to perform a simu
 
 <img align="left" width="100" height="100" src="/docs-source/figures/powerpoint/flexible.svg">
 
-### Flexible Modelling Paradigm
-Models in fmdtools use a consistent and composable representation of system structure and behavior. Whether you want to model a simple component, a complex system-of-systems, or both, fmdtools can help.
+### Flexible, AI-Ready Modelling Paradigm
+Models in fmdtools use a straightforward and composable code-based representation of system structure and behavior. Since fmdtools models are based on open-source Python, models can be readily generated from your AI of choice with the right prompting. Whether you want to model a simple component, a complex system-of-systems, or both, fmdtools can help.
 
 <img align="left" width="100" height="100" src="/docs-source/figures/powerpoint/powerful.svg">
 
@@ -394,7 +394,7 @@ More guidance on development installations is provided in [How to Contribute](ht
 Note that this version reflects the latest version on the ``main`` git branch along with any local changes. To use a particular version of ``fmdtools`` in the context of a development install you can checkout the tag corresponding to the version you want, e.g.:
 
 ```
-   git checkout v2.4.0
+   git checkout v2.5.1
 ```
 
 
@@ -490,10 +490,24 @@ Once fmdtools is installed, use the following to get acquainted with how to use
 
 - Explore more [examples](https://nasa.github.io/fmdtools/examples/Examples.html) of particular use-cases by going through the [examples folder](https://github.com/nasa/fmdtools/tree/main/examples)
 
-- Read about contributions and model development best practices by perusing the [Development Guide](https://nasa.github.io/fmdtools/docs-source/Development%20Guide.html#).
+- Read about contributions and model development best practices by perusing the [Development Guide](https://nasa.github.io/fmdtools/docs-source/development-guide.html).
 
 - Explore the searchable [module reference](https://nasa.github.io/fmdtools/docs-source/fmdtools.html) for syntax and usage documentation.
 
+### AI/LLM Tips
+
+Decent (but **very imperfect**) results can be achieved using LLMs for model development using the prompt:
+
+```prompt
+You are an experienced software engineer learning a new Python library for the first time. Make an fmdtools simulation of racecar using the latest syntax from `https://github.com/nasa/fmdtools/tree/v2.5.1` for all modeling (`fmdtools.define`), simulation (`fmdtools.sim`), and analysis (`fmdtools.analyze`) classes. The output should be a bare bones but well-commented .py file with simple behaviors for each class and a small script at the bottom leveraging the built-in capabilities in the `fmdtools.analyze` package instead of directly using external libraries like matplotlib. As you are going, explain the structure of each class, the usage of each function call and how they each leverage the correct fmdtools v2.5.1 syntax.
+```
+
+The important aspects of this prompt are specifying the URL and version--otherwise the LLM is likely to hallucinate usage or recall an earlier version of fmdtools. Do not expect perfect output from this--you may have to spend some time identifying the problems so they can be fixed!
+
+For somewhat better results, we recommend using an on-machine coding "agent" such as OpenCode/Claude Code/Codex.
+
+More elaborate prompts can be found in our [AGENTS.md](AGENTS.md) and repository skills at `.agents/skills`.
+
 ## Contributions
 fmdtools is developed primarily by researchers at NASA Ames Research Center. External contributions are welcome under a Contributor License Agreement:
 
@@ -527,12 +541,12 @@ To cite fmdtools in general, you may cite our explanatory publication:
 To cite a particular version of the fmdtools, you may use:
 
 ```
-@software{nasa2025fmdtools,
+@software{nasa2026fmdtools,
   author = {{NASA}},
   title = {fmdtools},
   url = {https://github.com/nasa/fmdtools},
-  version = {2.4.0},
-  date = {2026-5-29},
+  version = {2.5.1},
+  date = {2026-9-22},
 }
 ```
 

{fmdtools-2.4.0 → fmdtools-2.5.1}/README.md

@@ -35,8 +35,8 @@ The fmdtools library provides the computational support needed to perform a simu
 
 <img align="left" width="100" height="100" src="/docs-source/figures/powerpoint/flexible.svg">
 
-### Flexible Modelling Paradigm
-Models in fmdtools use a consistent and composable representation of system structure and behavior. Whether you want to model a simple component, a complex system-of-systems, or both, fmdtools can help.
+### Flexible, AI-Ready Modelling Paradigm
+Models in fmdtools use a straightforward and composable code-based representation of system structure and behavior. Since fmdtools models are based on open-source Python, models can be readily generated from your AI of choice with the right prompting. Whether you want to model a simple component, a complex system-of-systems, or both, fmdtools can help.
 
 <img align="left" width="100" height="100" src="/docs-source/figures/powerpoint/powerful.svg">
 
@@ -123,7 +123,7 @@ More guidance on development installations is provided in [How to Contribute](ht
 Note that this version reflects the latest version on the ``main`` git branch along with any local changes. To use a particular version of ``fmdtools`` in the context of a development install you can checkout the tag corresponding to the version you want, e.g.:
 
 ```
-   git checkout v2.4.0
+   git checkout v2.5.1
 ```
 
 
@@ -219,10 +219,24 @@ Once fmdtools is installed, use the following to get acquainted with how to use
 
 - Explore more [examples](https://nasa.github.io/fmdtools/examples/Examples.html) of particular use-cases by going through the [examples folder](https://github.com/nasa/fmdtools/tree/main/examples)
 
-- Read about contributions and model development best practices by perusing the [Development Guide](https://nasa.github.io/fmdtools/docs-source/Development%20Guide.html#).
+- Read about contributions and model development best practices by perusing the [Development Guide](https://nasa.github.io/fmdtools/docs-source/development-guide.html).
 
 - Explore the searchable [module reference](https://nasa.github.io/fmdtools/docs-source/fmdtools.html) for syntax and usage documentation.
 
+### AI/LLM Tips
+
+Decent (but **very imperfect**) results can be achieved using LLMs for model development using the prompt:
+
+```prompt
+You are an experienced software engineer learning a new Python library for the first time. Make an fmdtools simulation of racecar using the latest syntax from `https://github.com/nasa/fmdtools/tree/v2.5.1` for all modeling (`fmdtools.define`), simulation (`fmdtools.sim`), and analysis (`fmdtools.analyze`) classes. The output should be a bare bones but well-commented .py file with simple behaviors for each class and a small script at the bottom leveraging the built-in capabilities in the `fmdtools.analyze` package instead of directly using external libraries like matplotlib. As you are going, explain the structure of each class, the usage of each function call and how they each leverage the correct fmdtools v2.5.1 syntax.
+```
+
+The important aspects of this prompt are specifying the URL and version--otherwise the LLM is likely to hallucinate usage or recall an earlier version of fmdtools. Do not expect perfect output from this--you may have to spend some time identifying the problems so they can be fixed!
+
+For somewhat better results, we recommend using an on-machine coding "agent" such as OpenCode/Claude Code/Codex.
+
+More elaborate prompts can be found in our [AGENTS.md](AGENTS.md) and repository skills at `.agents/skills`.
+
 ## Contributions
 fmdtools is developed primarily by researchers at NASA Ames Research Center. External contributions are welcome under a Contributor License Agreement:
 
@@ -256,12 +270,12 @@ To cite fmdtools in general, you may cite our explanatory publication:
 To cite a particular version of the fmdtools, you may use:
 
 ```
-@software{nasa2025fmdtools,
+@software{nasa2026fmdtools,
   author = {{NASA}},
   title = {fmdtools},
   url = {https://github.com/nasa/fmdtools},
-  version = {2.4.0},
-  date = {2026-5-29},
+  version = {2.5.1},
+  date = {2026-9-22},
 }
 ```
 

{fmdtools-2.4.0 → fmdtools-2.5.1}/examples/airspacelib/__init__.py

@@ -18,5 +18,6 @@ specific language governing permissions and limitations under the License.
 import fmdtools_examples.airspacelib.base as base
 import  fmdtools_examples.airspacelib.contingency_management as contingency_management
 import  fmdtools_examples.airspacelib.wildfire_response as wildfire_response
+import fmdtools_examples.airspacelib.water_rescue as water_rescue
 
-__all__ = ['base', 'contingency_management', 'wildfire_response']
+__all__ = ['base', 'contingency_management', 'wildfire_response', 'water_rescue']

{fmdtools-2.4.0 → fmdtools-2.5.1}/examples/airspacelib/base/aircraftarchitecture.py

@@ -32,7 +32,8 @@ from fmdtools_examples.airspacelib.base.arch.holdpayload import HoldPayload
 
 class AircraftArchParameter(Parameter):
     """Overall Parameter Defining the AircraftArchitecture."""
-
+    startpt: tuple = (0.0, 0.0)
+    endpt: tuple = (25.0, 25.0)
     flightplan: tuple = ((0.0, 0.0), (25.0, 25.0))
     height: float = 25.0
 

{fmdtools-2.4.0 → fmdtools-2.5.1}/examples/airspacelib/base/arch/controlflight.py

@@ -20,6 +20,7 @@ specific language governing permissions and limitations under the License.
 from fmdtools.define.block.function import Function
 from fmdtools.define.container.state import State
 from fmdtools.define.container.mode import Mode
+from fmdtools.define.pathplan import PathPlannerBase
 
 from fmdtools_examples.airspacelib.base.arch.flows import Trajectories, Force, Electricity
 from fmdtools_examples.airspacelib.base.arch.flows import AircraftEnvironment
@@ -120,6 +121,8 @@ class ControlFlight(Function):
         """Add the desired trajectory local flow to the Function."""
         self.perc_traj = self.trajectories.create_local("perc_traj")
         self.des_traj = self.trajectories.create_local("des_traj")
+        # self.planner = PathPlannerBase()
+        # self.planner.init_environment(self.environment)
 
     def static_behavior(self):
         """
@@ -197,6 +200,12 @@ class ControlFlight(Function):
             newgoal = self.des_traj.s.get_loc()
         self.des_traj.s.assign(newgoal, 'goal_x', 'goal_y', 'goal_z')
 
+    # def run_planner(self, start, goal, algorithm, **kwargs):
+    #     path = self.planner.compute_path(start, goal, planner=algorithm, **kwargs)
+    #     self.s.flightplan = self.planner.s.flightplan
+    #     self.s.pt = self.planner.s.pt
+    #     return path
+
 
 if __name__ == "__main__":
     import doctest

fmdtools-2.5.1/examples/airspacelib/water_rescue/__init__.py

@@ -0,0 +1,23 @@
+"""
+Water rescue model.
+
+Copyright © 2024, United States Government, as represented by the Administrator
+of the National Aeronautics and Space Administration. All rights reserved.
+
+The "Fault Model Design tools - fmdtools version 2" software is licensed
+under the Apache License, Version 2.0 (the "License"); you may not use this
+file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE/2.0. 
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""
+
+import fmdtools_examples.airspacelib.water_rescue.model_environment as model_environment
+import fmdtools_examples.airspacelib.water_rescue.model_responder as model_responder
+import fmdtools_examples.airspacelib.water_rescue.model_drone as model_drone
+import fmdtools_examples.airspacelib.water_rescue.model_main as model_main
+
+__all__ = ['model_environment', 'model_responder', 'model_drone', 'model_main']

fmdtools-2.5.1/examples/airspacelib/water_rescue/model_drone.py

@@ -0,0 +1,138 @@
+"""
+Patrol drone model for the water-rescue simulation.
+
+The drone flies a zigzag patrol path along the shoreline. When it spots a
+distressed swimmer within its viewing radius, it switches to rescue mode,
+alerts the responder, flies to the victim, and drops a buoy before returning
+to patrol.
+
+Copyright © 2024, United States Government, as represented by the Administrator
+of the National Aeronautics and Space Administration. All rights reserved.
+
+The “"Fault Model Design tools - fmdtools version 2"” software is licensed
+under the Apache License, Version 2.0 (the "License"); you may not use this
+file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0. 
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""
+from fmdtools_examples.airspacelib.base.aircraft import BaseAircraft
+from fmdtools_examples.airspacelib.base.state import AircraftState
+from fmdtools_examples.airspacelib.water_rescue.model_environment import BeachEnvironment
+from fmdtools.define.container.mode import Mode
+import numpy as np
+
+
+# Patrol path construction
+# The shoreline runs along the x-axis (y=0 is the shore).
+# The drone sweeps between two offshore bands: 100ft ~ 30m, 200ft ~ 60m.
+near_shore = 150   # inner band, 150ft offshore
+far_shore = 270    # outer band, 270ft offshore
+
+# extent of the beach along the x-axis
+x_min = -50
+x_max = 1900
+
+# Build a zigzag path: alternate between the near and far bands while
+# stepping 100 units along the beach each waypoint.
+zigzag_path = []
+x_positions = np.arange(x_min, x_max+100, 100)
+
+for i, x in enumerate(x_positions):
+    if i % 2 == 0:
+        zigzag_path.append((x, near_shore))
+    else:
+        zigzag_path.append((x, far_shore))
+
+
+class BeachAircraftModes(Mode):
+    """Drone operating modes: patrolling the shore or rescuing a swimmer."""
+    opermodes = ("patrol", "rescue")
+    mode: str = "patrol"
+
+
+class BeachAircraftState(AircraftState):
+    """State of the drone: position, path progress, and rescue bookkeeping."""
+    victim_spotted: bool = False   # whether a victim has been detected
+    flight_path: list = zigzag_path  # patrol waypoints to cycle through
+    patrol_idx: int = 0            # index of the current patrol waypoint
+    rescue_idx: int = 0            # index along the rescue path
+    time_arrived: float = -1.0     # sim time the drone reached the victim (-1 = not yet)
+    location: tuple = (0, 0)       # current (x, y) position
+
+
+class BeachAircraft(BaseAircraft):
+    """Aircraft that spots struggling swimmers and notifies responders."""
+    container_m = BeachAircraftModes
+    container_s = BeachAircraftState
+    flow_environment = BeachEnvironment
+
+    def init_block(self, **kwargs):
+        """Set initial aircraft location to its assigned base."""
+        self.s.x = self.environment.c.p.base_locations[self.p.base][0]
+        self.s.y = self.environment.c.p.base_locations[self.p.base][1]
+
+    def set_rescue_goal(self):
+        """Switch to rescue mode, alert the responder, and target the victim."""
+        self.m.set_mode("rescue")
+        self.send_rescue_alert()
+        # fall back to the first configured rescue location if none recorded
+        victim = getattr(self.environment.c, "person_location",
+                         self.environment.c.p.rescue_locations[0])
+        self.s.assign(victim, "goal_x", "goal_y")
+
+    def fly_patrol(self):
+        """Fly toward the current patrol waypoint; advance to the next on arrival."""
+        self.m.set_mode("patrol")
+        waypoint = self.s.flight_path[self.s.patrol_idx]
+        self.s.assign(waypoint, "goal_x", "goal_y")
+        self.fly_to_goal()
+        if self.indicate_at_goal():
+            # loop back to the start of the path after the last waypoint
+            self.s.patrol_idx = (self.s.patrol_idx + 1) % len(self.s.flight_path)
+
+    def fly_rescue(self):
+        """Fly to the victim; on arrival drop a buoy and return to patrol."""
+        victim = getattr(self.environment.c, "person_location",
+                         self.environment.c.p.rescue_locations[0])
+        self.s.assign(victim, "goal_x", "goal_y")
+
+        self.fly_to_goal()
+
+        self.s.location = self.s.get_loc()
+
+        if self.indicate_at_goal():
+            # record first arrival time
+            if self.s.time_arrived < 0:
+                self.s.time_arrived = self.t.time
+
+            # drop the buoy: victim now floats and no longer needs the drone
+            self.environment.c.set_pts([victim], "with_buoy", True)
+            self.environment.c.set_pts([victim], "person_to_rescue", False)
+            self.m.set_mode("patrol")
+
+    def send_rescue_alert(self):
+        """Raise the shared rescue flag so the responder knows to act."""
+        self.environment.c.s.rescue = True
+
+    def dynamic_behavior(self):
+        """
+        Per-timestep behavior.
+
+        If in patrol, the drone checks the area around it with check_vicinity,
+        which returns whether the closest distressed person is within viewing
+        radius (and their location).
+
+        If a person needs rescue, the drone switches to rescue mode and flies
+        to the person to drop the buoy, then returns to patrol.
+        """
+        if self.m.in_mode("patrol"):
+            self.fly_patrol()
+            in_range, _ = self.environment.c.check_vicinity(self.s.get_loc())
+            if in_range:
+                self.set_rescue_goal()
+        elif self.m.in_mode("rescue"):
+            self.fly_rescue()

fmdtools-2.5.1/examples/airspacelib/water_rescue/model_environment.py

@@ -0,0 +1,170 @@
+"""
+Beach environment model for the water-rescue simulation.
+
+Defines the beach/water grid, where distressed swimmers appear, and the
+"swimmer behavior" function that counts down distress and survival timers.
+
+Copyright © 2024, United States Government, as represented by the Administrator
+of the National Aeronautics and Space Administration. All rights reserved.
+
+The “"Fault Model Design tools - fmdtools version 2"” software is licensed
+under the Apache License, Version 2.0 (the "License"); you may not use this
+file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0. 
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""
+from fmdtools.define.object.coords import Coords, CoordsParam
+from fmdtools.define.environment import Environment
+from fmdtools.define.block.function import Function
+from fmdtools.define.container.state import State
+import numpy as np
+
+
+class BeachMapParam(CoordsParam):
+    """Parameters defining the size and layout of the beach grid."""
+    x_size: int = 20                # width of grid (number of tiles)
+    y_size: int = 5                 # length of grid (number of tiles)
+    blocksize: float = 100          # 100 meters per tile
+    base_locations: tuple = ((400.0, 0.0), (1600.0, 0.0))  # points where drones launch from
+    rescue_locations: tuple = ((1000.0, 300.0),)           # points where people need rescue
+    num_distress: int = 1           # how many swimmers will go into distress
+    time_to_reach: float = 10.0     # expected time for responder to reach a victim
+    vicinity_radius: float = 200.0  # default detection radius for check_vicinity()
+
+
+class BeachBehaviorState(State):
+    """Shared state used to communicate rescue alerts between functions."""
+    time_to_reach: int = 30   # time budget for reaching a victim
+    rescue: bool = False      # set True when a victim has been spotted (rescue alert)
+
+
+class BeachMap(Coords):
+    """
+    Grid representation of the beach.
+
+    Each tile carries per-point states (survival rate, timers, rescue status)
+    and features marking what type of terrain it is (beach, water, base, etc.).
+    """
+    container_p = BeachMapParam
+    container_s = BeachBehaviorState
+
+    # states for every point in environment
+    state_survival_rate = (float, 1)          # likelihood the victim survives
+    state_person_to_rescue = (bool, False)    # True once a swimmer at this point is in distress
+    point_person_location = (0, 0)            # location of the (first) distressed swimmer
+    state_with_buoy = (bool, False)           # True after the drone drops a buoy at this point
+    state_rescued = (bool, False)             # True once the responder completes the rescue
+    state_distress_timer = (float, 100.0)     # countdown until the swimmer shows distress
+    state_survival_timer = (float, 300.0)     # countdown until a distressed swimmer dies
+    state_dead = (bool, False)                # True if the survival timer ran out
+
+    # terrain features
+    feature_beach = (bool, False)             # sandy area (y between 0 and blocksize)
+    feature_water = (bool, False)             # open water (y beyond 2*blocksize)
+    feature_base = (bool, False)              # drone launch points
+    feature_rescue_location = (bool, False)   # designated victim locations
+
+    def init_properties(self, *args, **kwargs):
+        """Lay out the map: mark bases, victim points, beach strip, and water."""
+        self.set_pts(self.p.base_locations, "base", True)
+        self.set_pts(self.p.rescue_locations, "person_to_rescue", False)
+        b = self.p.blocksize
+        self.set_range("beach", True, ymin=0, ymax=b)   # first row of tiles is sand
+        self.set_range("water", True, ymin=b * 2)       # everything past 2 tiles is water
+
+        # record the first victim's location for easy lookup by other functions
+        victim_pts = self.p.rescue_locations[:self.p.num_distress]
+        if victim_pts:
+            self.person_location = victim_pts[0]
+
+    def check_vicinity(self, point, radius=None):
+        """
+        Check whether any distressed swimmer is within radius of point.
+
+        Returns
+        -------
+        (in_range, closest_pt) : tuple
+            in_range : True if the nearest active victim is within radius.
+            closest_pt : location of that victim, or None if no one is in distress.
+        """
+        if radius is None:
+            radius = self.p.vicinity_radius
+
+        # gather only victims currently flagged as needing rescue
+        active = []
+        for pt in self.p.rescue_locations:
+            if self.get(pt[0], pt[1], "person_to_rescue"):
+                active.append(pt)
+        if not active:
+            return (False, None)
+
+        # find the closest active victim and test it against the radius
+        pts = np.array(active)
+        dists = np.hypot(pts[:, 0] - point[0], pts[:, 1] - point[1])
+        i = int(np.argmin(dists))
+        return (dists[i] <= radius, tuple(pts[i]))
+
+
+class BeachEnvironment(Environment):
+    """Environment flow wrapping the BeachMap grid, shared by all functions."""
+    coords_c = BeachMap
+
+
+class BeachBehavior(Function):
+    """
+    Simulates swimmer behavior over time.
+
+    Counts down each swimmer's distress timer; once it hits zero the swimmer
+    is flagged as needing rescue. From then on, a survival timer counts down —
+    slower if a buoy has been dropped — and the swimmer dies if it reaches zero.
+    """
+    container_s = BeachBehaviorState
+    flow_environment = BeachEnvironment
+
+    def dynamic_behavior(self):
+        env = self.environment.c
+
+        # distress phase: count down until each swimmer starts struggling
+        for pt in env.p.rescue_locations:
+            rescued = env.get(pt[0], pt[1], "rescued")
+            if rescued:
+                continue  # skip already rescued victims
+            timer = env.get(pt[0], pt[1], "distress_timer")
+            print(f"timer: {timer}, person_to_rescue: {env.get(pt[0], pt[1], 'person_to_rescue')}")
+            if timer > 0:
+                env.set(pt[0], pt[1], "distress_timer", timer - self.t.dt)
+            elif not env.get(pt[0], pt[1], "with_buoy"):
+                # timer expired and no buoy yet -> flag swimmer as needing rescue
+                env.set_pts([pt], "person_to_rescue", True)
+
+        # survival phase: distressed swimmer's survival timer counts down
+        victim = env.p.rescue_locations[0]
+        if env.get(victim[0], victim[1], "distress_timer") <= 0 \
+                and not env.get(victim[0], victim[1], "rescued") \
+                and not env.get(victim[0], victim[1], "dead"):
+            timer = env.get(victim[0], victim[1], "survival_timer")
+            if env.get(victim[0], victim[1], "with_buoy"):
+                timer -= self.t.dt * 0.1  # buoy slows the countdown 10x
+            else:
+                timer -= self.t.dt
+            if timer <= 0:
+                # survival time ran out -> victim dies
+                timer = 0.0
+                env.set_pts([victim], "dead", True)
+            env.set(victim[0], victim[1], "survival_timer", timer)
+
+
+# Colors used when plotting the map states/features in simulation visuals
+sim_properties = {
+    'beach':            {'color': 'sandybrown'},
+    'water':            {'color': 'steelblue'},
+    'person_to_rescue': {'color': 'red'},
+    'base':             {'color': 'black'},
+    'with_buoy':        {'color': 'yellow'},
+    'rescued':          {'color': 'green'},
+    'dead':             {'color': 'purple'},
+}

fmdtools-2.5.1/examples/airspacelib/water_rescue/model_main.py

@@ -0,0 +1,33 @@
+"""
+Top-level model for the water-rescue simulation.
+
+Wires together the shared beach environment with the three functions:
+the lifeguard responder, the swimmer behavior, and the patrol drone.
+
+Copyright © 2024, United States Government, as represented by the Administrator
+of the National Aeronautics and Space Administration. All rights reserved.
+
+The “"Fault Model Design tools - fmdtools version 2"” software is licensed
+under the Apache License, Version 2.0 (the "License"); you may not use this
+file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0. 
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+"""
+from fmdtools_examples.airspacelib.water_rescue.model_environment import BeachEnvironment, BeachBehavior
+from fmdtools_examples.airspacelib.water_rescue.model_responder import Responder
+from fmdtools_examples.airspacelib.water_rescue.model_drone import BeachAircraft
+from fmdtools.define.architecture.function import FunctionArchitecture
+
+
+class Beach(FunctionArchitecture):
+    """Function architecture connecting all functions through the environment flow."""
+
+    def init_architecture(self, **kwargs):
+        self.add_flow("environment", BeachEnvironment)
+        self.add_fxn("responder", Responder, "environment")
+        self.add_fxn("swimmers", BeachBehavior, "environment")
+        self.add_fxn("beach_aircraft", BeachAircraft, "environment")