A multi-agent system for generating bridge design models driven by a large model

Abstract

This invention discloses a multi-agent system for generating trestle bridge design models driven by a large model, relating to the intersection of BIM and AI technologies. The system workflow includes: after user input, the system automatically verifies parameters such as span combinations and total bridge deck length, and derives the number of steel pipe piles by calculating the number of pier rows and columns; the architect agent uses a hierarchical layout algorithm combined with a default value table to derive component coordinates; the programmer agent generates modeling code according to priority rules and handles issues such as missing parameters and family library mismatches through an error self-correction strategy. The system integrates a long-term / short-term memory mechanism to achieve design parameter traceability and closed-loop optimization of the modeling process, significantly improving the design efficiency and automation level of complex trestle bridge structures.

Description

Technical Field

[0001] This invention belongs to the field of BIM and AI interdisciplinary technology, specifically involving a multi-agent system for generating bridge design models driven by a large model. Background Technology

[0002] In the field of modern architectural engineering, the design and construction of trestle bridges and bridges place higher demands on precision, efficiency, and intelligence. Traditional design methods rely on designers manually calculating parameters, drawing blueprints, and making repeated adjustments, resulting in low efficiency, error-proneness, and difficulty in adapting to complex working conditions. Although Building Information Modeling (BIM) technology is widely used in 3D modeling, its level of automation is limited, especially when dealing with complex structures such as trestle bridges. Users still need professional knowledge to complete tasks such as parameter input, component layout, and conflict detection. In addition, traditional design tools lack the ability to intelligently parse natural language commands, leading to a significant gap between the design process and user needs.

[0003] The shortcomings of existing technologies include:

[0004] Insufficient parameter verification and conflict detection: The design of trestle bridges involves key parameters such as span, bridge deck length, and Bailey panel length. Traditional methods require manual verification of the logical relationship between parameters. If parameters conflict or are invalid, they need to be manually adjusted or re-entered, which is time-consuming and prone to overlooking potential problems.

[0005] Layout planning relies on experience: The layout of trestle components must follow strict structural rules. Traditional design relies on the designer's experience and judgment, making it difficult to achieve rapid iteration and adaptive optimization. For example, the coordinate calculation of the main longitudinal beam needs to be combined with the geometric center and elevation changes of the steel pipe piles. Manual derivation is prone to introducing errors.

[0006] The modeling process is inefficient and relies heavily on specialized skills: While BIM tools such as Revit can generate 3D models, their operation is cumbersome, requiring manual execution of each component and lacking the ability to directly respond to natural language commands. Designers need to be proficient in the Revit API and programming logic to achieve automated modeling of complex structures, which presents a high barrier to entry.

[0007] Insufficient error correction and fault tolerance: When traditional design tools encounter problems such as missing parameters, missing family library components, or location conflicts, they usually only prompt errors but cannot automatically correct them, requiring repeated user intervention and affecting design continuity.

[0008] In recent years, artificial intelligence technology, especially intelligent agent systems based on large language models, has shown significant potential in the construction field. Multi-agent technology, through distributed collaboration mechanisms, can simulate the decision-making process of human experts, automating tasks such as parameter verification, layout planning, and modeling. Examples include LLM agents, the integration of BIM and AI, and optimized memory mechanisms. This system, through deep integration of LLM agents and Revit plugins, achieves end-to-end automation from natural language input to 3D model generation, significantly improving the efficiency, accuracy, and intelligence of trestle design, and providing innovative solutions for rapid design and iteration in complex engineering scenarios. Summary of the Invention

[0009] To overcome the shortcomings and deficiencies of the existing technology, the present invention adopts the following technical solution:

[0010] A multi-agent system for generating bridge design models driven by a large model, including an LLM agent module and a Revit plugin module;

[0011] LLM agent module: includes tool library, requirements analyst agent, architect agent and programmer agent;

[0012] Tool library: Contains a set of modeling functions based on Revit API, covering the generation logic of 14 types of components such as piers, horizontal bracing, diagonal bracing, main longitudinal beams, Bailey panels, support frames, bridge decks, guardrail crossbars, and guardrail posts, used to create trestle and bridge structural components;

[0013] Demand Analyst Intelligent Agent: Used to verify the design parameters in the text instructions provided by the user. The verification parameters include span, bridge deck length, and Bailey panel length. It verifies the conflicts between them and adjusts them automatically. If a conflict of parameters that cannot be adjusted automatically is found, it will prompt the user to re-enter the instructions.

[0014] Architect agent: an engine for layout planning and parameter filling;

[0015] Programmer intelligent agent: used for code generation and execution controller;

[0016] Revit plugin module: includes UI interaction interface, code execution engine and component reader;

[0017] UI / UX interface: Supports natural language command input and 3D preview;

[0018] Code execution engine: Communicates with the agent via a RESTful API;

[0019] Component reader: Real-time synchronization of Revit family library metadata;

[0020] The agent possesses long short-term memory (LSM) capabilities. The LSM module stores important information about components, including their ID, location, and size. The SSM module stores information about errors in tool execution. The agent combines information from both LSM and SSM to select the next action to take.

[0021] Preferably, the system workflow is as follows:

[0022] S1: The demand analyst intelligent agent parses natural language instructions and executes parameter conflict detection for span verification algorithm, total bridge deck length calculation and steel pipe pile number derivation;

[0023] S2: The architect agent generates a bridge layout based on rule-based reasoning and parameter filling, determines the positional dependencies of components and the rules for arranging repetitive structures, and automatically uses default values ​​or adaptive calculation methods to determine parameters that are not explicitly specified.

[0024] S3: The programmer agent calls library functions based on the layout and generates modeling code according to priority control logic;

[0025] S4: The code execution engine injects code and implements a self-correcting error strategy.

[0026] Preferably, the span modularization adjustment algorithm is as follows:

[0027] When the span is a single span, calculate whether the span is divisible by the length of the Bailey panel. If the span is not divisible by the length of the Bailey panel, adjust accordingly. The rounding direction is downwards;

[0028] When the span is a combination span of [A×B+C], perform the following operations on A and B respectively:

[0029]

[0030] Non-standard values ​​are allowed for the first and last spans C, but the minimum structural stress must be ≥ 1.5m; otherwise, an error will be reported.

[0031] Preferably, adaptive layout planning includes:

[0032] The location of each component depends on the spatial coordinates of its supporting object; if there are repeated structures, they are generated according to the standard of "two stakes above and below each stake"; finally, the component's structured description, including name, coordinates, and orientation, is automatically derived using regular expressions; for parameters that are not explicitly specified, default values ​​or adaptive calculation methods are automatically used to determine the parameters.

[0033] It also includes the following:

[0034] Calculation of the number of main longitudinal beams: Quantity = Total number of steel pipe piles ÷ 2;

[0035] Determining the coordinates of the main longitudinal beam: Obtaining the maximum elevation h of the top of the steel pipe pile. max Minimum elevation h of the top of the steel pipe pile min Calculate the median offset The Z-axis coordinate of the main longitudinal beam is the pile top elevation + Δh, with precision control at the millimeter level; the axis of the main longitudinal beam is parallel to the center line of the bridge deck, with an allowable angular deviation of less than or equal to 0.5°;

[0036] Repeating structure generation rules: Steel tie beams are generated according to "two beams above and below each pile", and channel steel is arranged according to transverse / longitudinal classification.

[0037] Preferably, the priority control table includes:

[0038] Substructure generation sequence: steel pipe piles → main longitudinal beams → transverse steel tie beams → longitudinal steel tie beams → channel steel;

[0039] Superstructure generation sequence: Bailey panel → support frame → bridge deck → guardrail post → guardrail crossbar;

[0040] Execution constraint principles: integrity verification > quantity matching > function mapping > generation order > format specification.

[0041] Preferably, the memory module includes:

[0042] Long-term memory: Stores JSON structured data containing component IDs, spatial coordinates, and size parameters;

[0043] Short-term memory pool: Records the error logs of the last 20 API calls, including error type, timestamp, and fix actions;

[0044] Error self-correction strategies include: retrieving the most recent valid value when a parameter is missing, switching to a similar type when a family is not found, and retrying with a 50mm offset when there is a position conflict.

[0045] Preferably, the component reader of the Revit plug-in module executes every 5 minutes:

[0046] Call FilteredElementCollector.OfClass(FamilySymbol) to scan the current document;

[0047] Extract family name, type name, and parameter list to update the utility library function dictionary;

[0048] CRC32 checksum ensures metadata consistency.

[0049] Preferably, the total length of the bridge deck is calculated as follows: When the user-specified total length conflicts with the calculated value, it will be forcibly overridden to 1.05 times the user-specified value; the calculation rule for the number of steel pipe piles is as follows: the number of rows of steel pipe piles arranged transversely along the bridge deck is fixed at 2 rows, and the number of columns = the total span + 1.

[0050] Preferably, the modeling code generation includes:

[0051] Unit conversion: Convert the user-input millimeter value to the feet unit required by Revit API. The conversion formula is: feet = millimeter value ÷ 304.8;

[0052] Transaction control: The atomicity of modeling operations is guaranteed through Transaction.Start() / Commit();

[0053] Exception handling: Use a try-except block to catch FamilySymbolNotFoundException and trigger memory retrieval.

[0054] In summary, due to the adoption of the above technical solution, the beneficial effects of the present invention are:

[0055] 1. The requirement analyst intelligent agent of this invention achieves automated conflict detection and intelligent correction of user input parameters through preset span verification algorithms, total bridge deck length calculation rules, and steel pipe pile quantity derivation logic. For parameters not explicitly specified, the system automatically fills them in through default value rules or adaptive algorithms, which reduces user input costs and ensures the engineering feasibility of design parameters through the rule engine.

[0056] 2. This invention utilizes a programmer-based intelligent agent to generate structured layout designs based on an architect-based intelligent agent. Through a pre-defined process control table and priority determination principles (completeness priority, quantity priority, etc.), it achieves automated generation and execution of modeling code. Furthermore, the code output adheres to strict format constraints (one line of code + numbered suffix), avoiding redundant symbols, and the generated model files possess high readability and traceability.

[0057] 3. This invention constructs a closed-loop feedback mechanism through a long short-term memory module: the long-term memory stores key information such as the ID, location, and size of the component, providing historical valid value retrieval for scenarios where parameters are missing; the short-term memory captures tool execution errors (such as family not found or location conflict) in real time, triggering an automatic correction strategy. This self-correction capability makes the system more adaptable in complex engineering environments, significantly reducing manual debugging costs, and is especially suitable for bridge design scenarios with multiple version iterations, ensuring the continuity of the modeling process and the accuracy of the model. Attached Figure Description

[0058] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0059] Figure 1 This invention illustrates a block diagram of a multi-agent system for generating a bridge design model driven by a large model.

[0060] Figure 2 A flowchart of the invention is shown;

[0061] Figure 3 The flowchart of the memory module execution of the present invention is shown. Detailed Implementation

[0062] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0063] Furthermore, the described features, structures, or characteristics can be combined in any suitable manner in one or more exemplary embodiments. Numerous specific details are provided in the following description to give a full understanding of exemplary embodiments of this disclosure. However, those skilled in the art will recognize that the technical solutions of this disclosure can be practiced with one or more of the specific details omitted, or other methods, components, steps, etc., can be employed. In other instances, well-known structures, methods, implementations, or operations are not shown or described in detail to avoid obscuring various aspects of this disclosure.

[0064] Example 1:

[0065] See Figure 1 As shown in this embodiment, a multi-agent system for generating bridge design models driven by a large model includes an LLM agent module and a Revit plugin module.

[0066] LLM agent module: includes tool library, requirements analyst agent, architect agent, and programmer agent.

[0067] Tool Library: Contains a set of modeling functions based on Revit API, covering the generation logic of 14 types of components such as piers (steel pipe piles), horizontal bracing (steel tie beams), diagonal bracing (channel steel), main longitudinal beams, Bailey panels, support frames, bridge decks, guardrail crossbars, and guardrail posts, used to create trestle and bridge structural components.

[0068] The requirements analyst intelligent agent is used to verify the design parameters in the text instructions provided by the user. Verification parameters include span, bridge deck length, and Bailey panel length. It verifies conflicts between these parameters and automatically adjusts them. If a conflicting parameter that cannot be automatically adjusted is found (such as an invalid instruction with a negative span), it prompts the user to re-enter the instruction.

[0069] Architect agent: an engine for layout planning and parameter filling.

[0070] Programmer agent: Reads the bridge layout design of the architect agent, plans the modeling task based on the currently available components, and calls the tool library to execute the modeling task.

[0071] Revit plugin modules include a UI interface, a code execution engine, and a component reader.

[0072] UI / UX: Supports natural language command input and 3D preview.

[0073] Code execution engine: Communicates with the agent via RESTful API.

[0074] Component Reader: Real-time synchronization of Revit family library metadata.

[0075] See Figure 2 As shown in this embodiment, a multi-agent system for generating bridge design models driven by a large model has the following workflow:

[0076] Step 1: User command parsing and parameter verification.

[0077] Extract natural language commands entered by the user in the Revit plugin interface (such as "generate a steel trestle bridge with a span of 6×9m");

[0078] The demand analyst agent performs parameter conflict detection: span verification algorithm; total bridge deck length calculation; and steel pipe pile number derivation.

[0079] The procedure for checking parameter conflicts is as follows:

[0080] 1) Verification of steel pipe pile span:

[0081] If the span is provided directly: calculate whether the span is divisible by the length of the Bailey panel. If not, adjust accordingly. The rounding direction is downwards.

[0082] If the span (or a combination of spans) is provided, but the span form is [A×B+C]: this means the first and last spans are both C, with an intermediate span A of length B. Calculate whether spans B and C are both divisible by the length of the Bailey panel. If not, then...

[0083] Non-standard values ​​are allowed for the first and last spans C (to adapt to boundary conditions), but the minimum structural stress must be met (e.g., C≥1.5m), otherwise an error will be reported.

[0084] 2) Calculation of total bridge deck length:

[0085] The sum of the spans of each span is the total length of the bridge deck (the spans of the first and last spans are not necessarily equal). In this case, even if the user explicitly specifies the total length of the bridge deck in the instructions, it will be overwritten.

[0086] 3) The calculation rule for the number of steel pipe piles is as follows: the number of rows of steel pipe piles arranged transversely along the bridge deck is fixed at 2, and the number of columns = the total span + 1.

[0087] Step 2: Adaptive layout planning.

[0088] Based on verified user instructions, the architect agent generates a trestle or bridge layout design using a hierarchical layout algorithm based on rule reasoning and parameter filling. The automatic reasoning mechanism first determines the spatial coordinates of each component's location, which depends on its supporting object (such as steel pipe piles, main longitudinal beams, etc.). If repetitive structures (such as steel tie beams, channel steel) are involved, the design is generated based on the standard of "two piles above and below each pile". Finally, the structured descriptions of component names, coordinates, and orientations are automatically derived using rule expressions.

[0089] For parameters that are not explicitly specified, default values ​​or adaptive calculation methods are automatically used to determine the parameters. The default value table for specified parameters is as follows:

[0090]

[0091] Taking the main longitudinal beam layout as an example, its adaptive layout calculation formula is: Quantity = Total number of steel pipe piles ÷ 2; Each main longitudinal beam is erected in the middle position of the two columns of steel pipe piles in the first row; the coordinates of the main longitudinal beam are derived as follows: Obtain the median offset. h max h is the maximum elevation of the top of the steel pipe pile; min The minimum elevation of the top of the steel pipe pile is specified; the center point of the main longitudinal beam is located at the geometric center of the two rows of steel pipe piles, and the Z-axis coordinate is equal to the pile top elevation plus Δh, with precision control at the millimeter level; the axis of the main longitudinal beam is parallel to the center line of the bridge deck, with an allowable angular deviation of ≤0.5°.

[0092] The layout of trestle bridges or bridges shall be designed according to the following rules:

[0093] 1) Overall structure: including the width and length of the trestle or bridge.

[0094] 2) Substructure:

[0095] Bridge piers: The row spacing and column spacing are calculated based on the span (or a combination of spans) and the length and width of the bridge deck, and the dimensions can be set.

[0096] Main longitudinal beam: It is centrally mounted on a pair of piers and its dimensions can be set.

[0097] Diagonal bracing / horizontal bracing: generated between the steel pipe piles at the head and tail of the trestle.

[0098] 3) Superstructure:

[0099] Bailey panels: These are installed on the main longitudinal beams. The number of panels is calculated based on the length and width of the bridge deck. If the number is not divisible, it is rounded up. The spacing between each row of Bailey panels can be set.

[0100] Support frame: erected between the Bailey panels.

[0101] 4) Bridge deck accessories:

[0102] Bridge deck: Erected on Bailey panels, the quantity is calculated based on the overall dimensions of the bridge deck and the dimensions of the bridge deck panels. If the dimensions are not divisible, they are rounded up. The dimensions can be set.

[0103] Guardrail crossbars: Located on both sides of the bridge deck, two on each side, with the length of the crossbars being the same as the total length of the bridge deck.

[0104] Guardrail posts: located at the junction of the bridge deck panels on both sides of the bridge.

[0105] Step 3: Modeling code generation and execution.

[0106] The programmer agent reads the bridge layout design from the architect agent, plans the modeling task based on the currently available components, and calls the tool library to execute the modeling task.

[0107] The flow control table for the programmer's intelligent agent calling functions is shown below:

[0108]

[0109]

[0110] The corresponding priority determination principles are as follows:

[0111] Completeness first: Any parameter, even if it is a default value, must be explicitly filled in; leaving it blank is considered an error.

[0112] Quantity priority: Strictly adhere to the quantities / combinations given in the design plan; no increases or decreases are permitted.

[0113] Function mapping priority: First, search for the most directly corresponding function in the tool library. If it does not exist, then try the general function; otherwise, report an error.

[0114] Position / order priority: Generated sequentially according to layout order (row → column → hierarchy) to maintain readability and traceability.

[0115] Formatting constraints take precedence: The final output must not contain any extra symbols (such as ````), and must be called line by line with the suffix "| number".

[0116] The agent possesses long short-term memory (LSTM) capabilities. The long-term memory module stores important information about components, such as their IDs, locations, and dimensions. Below is an example of data from the long-term memory: {'code':200,'family_instance_id':351808,'message':'Main longitudinal beam-2HN500×200mm successfully created','family':'Steel pipe pile 1-Ф630×10mm','location_point':(36000,4500,250),'parameters':{'length':21000}}

[0117] The short-term memory module stores information about execution errors. The agent then combines information from both long-term and short-term memory to select the next action to take. The execution flow of the memory module is as follows: Figure 3 As shown.

[0118] Step 4: Modeling Execution and Feedback.

[0119] S41, the code execution engine dynamically injects code through the Revit API.

[0120] The Transaction mechanism is used to ensure the atomicity of operations.

[0121] Exceptions are captured in real time and written to the short-term memory.

[0122] S42, Error self-correction strategy.

[0123] Missing parameter: Retrieve the most recent valid value from long memory.

[0124] Family not found: Automatically switch to a similar family type (e.g., Ф630×10mm → Ф600×12mm).

[0125] Position conflict: Retry insertion with a 50mm offset.

[0126] The beneficial effects of this embodiment are as follows: the system achieves automatic parameter verification and dynamic adjustment through intelligent agent collaboration, and combined with the Revit plugin, it supports natural language interaction and real-time 3D preview, which significantly improves the efficiency and accuracy of trestle design, reduces human error, optimizes the multi-component modeling process, and enables non-professional users to efficiently generate professional-grade bridge models.

[0127] The above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the scope of the technology disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.

[0128] The preferred embodiments of the present invention disclosed above are merely illustrative of the invention. These preferred embodiments do not exhaustively describe all details, nor do they limit the invention to specific implementations. Clearly, many modifications and variations can be made based on the content of this specification. This specification selects and specifically describes these embodiments to better explain the principles and practical applications of the invention, thereby enabling those skilled in the art to better understand and utilize the invention. The invention is limited only by the claims and their full scope and equivalents.

Claims

1. A multi-agent system for generating bridge design models driven by a large model, characterized in that, The system includes an LLM agent module and a Revit plugin module; LLM agent module: includes tool library, requirements analyst agent, architect agent and programmer agent; Demand Analyst Intelligent Agent: Used to verify the design parameters in the text instructions provided by the user. The verification parameters include span, bridge deck length, Bailey panel length, and conflict between parameters and automatic adjustment. If a parameter conflict that cannot be automatically adjusted is found, feedback is sent to ask the user to re-enter the instructions. Architect agent: an engine for layout planning and parameter filling; Programmer intelligent agent: used for code generation and execution controller; Revit plugin module: includes UI interaction interface, code execution engine and component reader; The agent possesses long short-term memory (LSM) capabilities. The LSM module stores important information about components, including their ID, location, and size. The SSM module stores information about errors in tool execution. The agent combines information from both LSM and SSM to select the next action to take.

2. The multi-agent system for generating bridge design models driven by a large model according to claim 1, characterized in that, The system workflow is as follows: S1: The demand analyst intelligent agent parses natural language instructions and executes parameter conflict detection for span verification algorithm, total bridge deck length calculation and steel pipe pile number derivation; S2: The architect agent generates a bridge layout based on rule-based reasoning and parameter filling, determines the positional dependencies of components and the rules for arranging repetitive structures, and automatically uses default values ​​or adaptive calculation methods to determine parameters that are not explicitly specified. S3: The programmer agent calls library functions based on the layout and generates modeling code according to priority control logic; S4: The code execution engine injects code and implements a self-correcting error strategy.

3. The multi-agent system for generating bridge design models driven by a large model according to claim 2, characterized in that, The specific algorithm for modulo adjustment of span is as follows: When the span is a single span, calculate whether the span is divisible by the length of the Bailey panel. If the span is not divisible by the length of the Bailey panel, adjust accordingly. The rounding direction is downwards; When the span is a combination span of [A×B+C], perform the following operations on A and B respectively: ； ； Non-standard values ​​are allowed for the first and last spans C, but C ≥ 1.5m must be met, otherwise an error will be reported.

4. The multi-agent system for generating bridge design models driven by a large model according to claim 2, characterized in that, The layout plan includes: The location of each component depends on the spatial coordinates of its supporting object; if there are repetitive structures, they are generated according to the standard of "two stakes above and below each stake"; finally, the component's structured description, including name, coordinates, and orientation, is automatically derived using regular expressions; for parameters that are not explicitly specified, default values ​​or adaptive calculation methods are automatically used to determine the parameters. It also includes the following: Calculation of the number of main longitudinal beams: Quantity = Total number of steel pipe piles ÷ 2; Determining the coordinates of the main longitudinal beam: Obtaining the maximum elevation of the top of the steel pipe pile. Minimum elevation of the top of the steel pipe pile Calculate the median offset The Z-axis coordinate of the main longitudinal beam is the pile top elevation. The precision control is at the millimeter level; the axis of the main longitudinal beam is parallel to the centerline of the bridge deck, and the allowable angular deviation is less than or equal to... ; Repeating structure generation rules: Steel tie beams are generated according to "two beams above and below each pile", and channel steel is arranged according to transverse / longitudinal classification.

5. A multi-agent system for generating bridge design models driven by a large model, as described in claim 2, is characterized in that... The priority control table includes: Substructure generation sequence: steel pipe piles → main longitudinal beams → transverse steel tie beams → longitudinal steel tie beams → channel steel; Superstructure generation sequence: Bailey panel → support frame → bridge deck → guardrail post → guardrail crossbar; Execution constraint principles: integrity verification > quantity matching > function mapping > generation order > format specification.

6. The multi-agent system for generating bridge design models driven by a large model according to claim 1, characterized in that, The memory module includes: Long-term memory: Stores JSON structured data containing component IDs, spatial coordinates, and size parameters; Short-term memory pool: Records the error logs of the last 20 API calls, including error type, timestamp, and fix actions; Error self-correction strategies include: retrieving the most recent valid value when a parameter is missing, switching to a similar type when a family is not found, and retrying with a 50mm offset when there is a position conflict.

7. A multi-agent system for generating bridge design models driven by a large model, as described in claim 2, is characterized in that... The component reader for the Revit plug-in module executes every 5 minutes: Call FilteredElementCollector.OfClass(FamilySymbol) to scan the current document; Extract family name, type name, and parameter list to update the utility library function dictionary; CRC32 checksum ensures metadata consistency.

8. A multi-agent system for generating bridge design models driven by a large model, as described in claim 2, is characterized in that... The total length of the bridge deck is calculated as follows: ; The index number for the span, starting from 1; The total number of spans; where when the user-specified total length conflicts with the calculated value, it is forcibly overridden to be 1.05 times the user-specified value; the calculation rule for the number of steel pipe piles is: the number of rows of steel pipe piles arranged transversely along the bridge deck is fixed at 2 rows, and the number of columns = total spans + 1.

9. A multi-agent system for generating bridge design models driven by a large model, as described in claim 2, is characterized in that... The modeling code generation includes: Unit conversion: Converts user-inputted millimeter values ​​to feet units required by Revit API. The conversion formula is: feet = millimeter value ÷ 304.8; Transaction control: The atomicity of modeling operations is guaranteed through Transaction.Start() / Commit(); Exception handling: Use a try-except block to catch FamilySymbolNotFoundException and trigger memory retrieval.

Images