•   almost 2 years ago

Automating Life Safety Assessments (Process Automation)

Several months ago a few approaches were revealed for automated generation of fire egress paths. This leads me to wonder if there is a way to build tools for automating all sorts of life safety and code considerations:
- fire egress path of travel
- means of egress/type count
- adequate sizing of means of egress check
- ideal fire extinguisher placement
- corridor width compliance
- light/ventilation area calculations & compliance
- BOMA calculations
- others?

The process can widely vary depending on which of these you are tackling. I think assembling a team of multiple Revit users with some Dynamo knowledge would help to simultaneously explore each task/tool. Towards the end a add-in specialist could be brought in to build a toolkit for managing multiple task executions on a comprehensive suite.

- familiarity with Revit models
- Dynamo expertise
- C# and Revit API knowledge
- previous research examples...

Fire Exit Risk Assessment with Revit and Dynamo - Dieter Vermeulen

Automated Fire Egress - Colin McCrone

- tools that can be run on a sample model to demonstrate functionality
- clear delineation between a conforming design and one that does not meet requirements
- consideration of user experience and how tool would be implemented to less experienced users ("easy button")

- learn about various life safety considerations
- gain a deeper understanding of how these tasks are typically executed using Revit
- develop a working concept using Dynamo or other means
- have each team member walk away from the experience with at least one new skill


  •   •   almost 2 years ago

    I've love to get involved with something like this as it always comes up at the last minute of that SD or DD exercise and takes awhile. I think it would be a great opportunity to learn and produce some really useful stuff. If there is a team already forming for this sign me up, and if not but others are interested let me know so we can get together.

  •   •   almost 2 years ago

    two possible approaches (although I do not know much about building evacuation codes):

    A. Graph and space.
    1) Getting data: Get all wall, door, stair and space data per floor
    (I think space is the one that is revit rooms automatically, and the one that has volumes)
    2) Finding optimal exit Paths
    2.1) Do some projection/intersection of doors and spaces and transform into a graph of rooms.
    2.2) set the space which contain a stair as target nodes.
    2.3) DFS from each space-node to a target node, while indexing number of times each node is used during a shortest path solution. This gives the flow of people calmly exiting the building, and how often any space appears in that path.
    3) Geometry
    3.1) Hertel-Mehlhorn algorithm or Triangulation followed by some merge-reduce operation to turn the geometry of each space into convex hulls (we need this to account for corridor bends and whatnot). Each convex hull is a line of site to an exit sign, and should give a center=line for exit route.
    4) Linework
    4.1) embed geometric nodes into the Space-graph as sub-nodes. Direction of travel through each node can be found with adjacent of space. For each sub-node create evacuation path line in physical geometry.
    4.2) for outermost leaf nodes (rooms that open to a corridor), lines may need to be adjusted to be perpendiular to hallway space using door geometry (which is embedded in graph as links) or some-such, or may not be shown at all.
    5) Signage - For each convex hull node that is also an evacuation path node, a sign is needed (think bends in the hallway). The exact placement requires some heuristic, probably related to the evacuation line geometry, but this seems solvable.
    6) Fire Extinguishers - some rule to place them along the exit pathway geometry, according to whatever the code is. Intersect those distances with borders of space node geometry.
    *If in step 1 space data is not available, generate convex hulls from the wall data, or discretize the model bounds and do some space filling approach to get the space graph.

    B. Simulated Agents.
    1) Getting data: Get all wall, door, stair and space data per floor.
    1.1) remove door geometry (2d) from wall geometry. Now you have a maze.
    2) Path Simulation:
    2.1) Create some agents that of a discrete size run can run around in space (probs move this all to pygame). Maybe the Agents have a few biases, like wanting to move to larger/longer space. Add goals for them at stairs. They can be added randomly around the space.
    2.2) Run that a bunch of times, while keeping track of paths.
    2.3) The Paths can be some combination of average and reduce with the constraint that no reduced path can intersect a wall, until paths form exit routes. (this should converge eventually).
    3) Signage Simulation:
    3.1) Add a constraint to the agents that on each timestep they can look around for an exit sign. If they can see one, they will be biased to run towards it. (agent's fov can be set according to max distance between exit signs from code).
    3.2) Add an optimizer to the simulation that minimizes time for agents to reach exit spaces.
    3.3) Optimize signage locations with monte carlo simulations.

    Approach A Pros:
    -more computationally efficient. (and steps 2 and 3 can be parallel)
    Approach A Cons:
    -very heuristic.
    -does not seem general enough.

    Approach B Pros:
    -does not depend on heuristics/true to what it is simulating
    -Assumptions can be added to simulation parameters fairly flexibly.
    Approach B Cons:
    -may be too intensive (but this can be mitigated in a production version by giving the overall simulator a Q function of signs given walls to learn, so it will get efficient after a few thousands runs.
    -may be difficult to trouble shoot if does not converge.
    -extra dependencies, or external to Revit (idk if you can add pygame to revit python)

  •   •   almost 2 years ago

    Interesting idea on the simulation stuff. I'm not sure the Horton-Mandel method is correct as we often need to follow the room's axis aligned travel path or the exterior walls of the space to account for furniture and smoke, but admittedly I haven't seen that in action so maybe it's ideal.

    Im a dynamo junky, so my thoughts on the egress path are tailored to that workflow.

    1) Find the door sequence from each occupiable space (I.E. is not a closet) to each room called stair or a discharge door using a door sequence node or a similar method.

    2) For every room that isn't entered into by another room, get the perimeter boundaries as a closed polycurve and split them at the door leading out of the space. Offset the polycurve 1 unit into the center and get the curves which make it up. Reverse the list of curves and get the lengths of the ordered list and the reversed list, and use some logic to find the furthest point from the exit door and the shorter direction around the room. Create a single Model Element (adaptive component? maybe don't go into the model yet and just use a class in a Python node?) at these curves and write the total length to a parameter.

    3) Do a similar exercise for the room(s) containing the next two doors in the sequence, but split the room boundaries by both doors, and then get the length of the two polycurves, discarding the longer as the shorter is the correct route here. In addition to the length of this line, total the length of this line and the total length from the previous room, writing that into a parameter in the component as well.

    4) When you reach the stair get the longest total travel distance.

    The math is fairly straightforward so this feels 'doable,' but there are several complications not yet discussed, which is what makes this seemingly simple exercise so complex: only go to the closer of the two stairs; documenting common travel path; leveraging the effort to produce total occupants at any given egress component and checking the required width; verifying all spaces with over 50 occupants have two means (even if one is backtracking a bit); checking door swing direction; many others.

  •   •   almost 2 years ago

    Love this idea, and I'm very intrigued by the agent approach proposed by psavine.
    I'm sure we can find path finding algorithms to use, but transforming the rivet model into a format suitable for path-finding will be its own obstacle.

Comments are closed.