Electromechanical modeling method and system based on BIM

Abstract

The invention discloses a BIM-based electromechanical modeling method and system, and the method comprises the steps: outputting an electromechanical parameterized model comprising a pipeline path, equipment layout and a connection relation according to a building structure model and an electromechanical design constraint rule library; generating a cross-platform compatible electromechanical data stream based on the electromechanical parameterized model; outputting optimized electromechanical model incremental data according to the user operation behavior data and the electromechanical data flow; based on the incremental data of the electromechanical model, generating a collaborative electromechanical model with consistent versions; and according to the collaborative electromechanical model, performing block rendering and parallel energy consumption simulation on the collaborative electromechanical model by adopting a distributed heterogeneous computing framework, and outputting an optimized electromechanical model and a performance analysis report. By utilizing the embodiment of the invention, automatic modeling, optimization design and dynamic coordination of the electromechanical system can be realized through an intelligent algorithm, so that the design efficiency, the operation intelligence level and the energy utilization efficiency of the building electromechanical system are improved.

Description

Technical Field

[0001] The present invention belongs to the field of electromechanical technology, and particularly relates to an electromechanical modeling method and system based on BIM. Background Art

[0002] With the rapid development of the construction industry towards digitalization, informatization, and intelligence, Building Information Modeling (BIM) has become an important technical tool for design, construction, and operation and maintenance. BIM technology integrates multi-disciplinary information such as the geometry, structure, and electromechanics of a building, realizing digital management throughout the building's life cycle and effectively improving the design collaboration efficiency and construction accuracy. However, traditional electromechanical installation design relies on static manual models and tools on a single platform, suffering from problems such as data islands, model inconsistencies, low conflict detection efficiency, and insufficient energy consumption simulation, which limit the optimization and intelligent scheduling of electromechanical systems. Summary of the Invention

[0003] The purpose of the present invention is to provide an electromechanical modeling method and system based on BIM to address the deficiencies in the prior art, enabling automatic modeling, optimized design, and dynamic collaboration of electromechanical systems through intelligent algorithms, thereby improving the design efficiency, operation intelligence level, and energy utilization efficiency of building electromechanical systems.

[0004] An embodiment of the present application provides an electromechanical modeling method based on BIM, the method comprising: According to the building structure model and the electromechanical design constraint rule library, generate the initial topological structure of the electromechanical system through a graph neural network, the graph neural network fusing spatial geometric features and equipment energy consumption parameters, and outputting an electromechanical parametric model including pipeline paths, equipment layouts, and connection relationships; Based on the electromechanical parametric model, use the dynamic priority coding algorithm to align the features of multi-source heterogeneous data, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate cross-platform compatible electromechanical data streams; According to the user operation behavior data and the electromechanical data stream, dynamically generate design optimization parameters through a reinforcement learning algorithm, the reinforcement learning algorithm adjusting pipeline avoidance rules and conflict detection thresholds through a real-time feedback mechanism, and outputting optimized electromechanical model incremental data; Based on the electromechanical model incremental data, construct a collaborative optimization engine under spatio-temporal constraints, and fuse multiple design changes through an adaptive weight allocation algorithm to generate a version-consistent collaborative electromechanical model; According to the collaborative electromechanical model, use a distributed heterogeneous computing framework to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model, accelerate collision detection through a physical engine, and output an optimized electromechanical model and a performance analysis report.

[0005] Optionally, based on the building structure model and the mechanical and electrical design constraint rule base, an initial topological structure of the mechanical and electrical system is generated through a graph neural network. The graph neural network fuses spatial geometric features and equipment energy consumption parameters and outputs a mechanical and electrical parametric model including pipeline paths, equipment layouts, and connection relationships, including: Extract three-dimensional geometric features of beam-column spatial coordinates, net height limits, and opening positions from the BIM data of the building structure model to generate a geometric feature tensor containing topological constraints; Convert the pipe diameter matching rules and equipment spacing thresholds in the mechanical and electrical design constraint rule base into an edge weight matrix of the graph neural network, and perform multi-channel splicing with the geometric feature tensor to obtain a spliced geometric feature tensor; Generate an energy consumption feature vector based on the equipment energy consumption parameters, and construct an energy consumption weight graph of equipment nodes and pipeline edges through a spatial position association algorithm; Use the attention mechanism of the graph neural network to fuse the geometric constraints of the spliced geometric feature tensor and the energy consumption weights in the energy consumption weight graph, and generate an optimal solution set of pipeline paths through iterative message passing, and output a mechanical and electrical parametric model containing avoidance priority labels.

[0006] Optionally, based on the mechanical and electrical parametric model, a dynamic priority coding algorithm is used to perform feature alignment on multi-source heterogeneous data, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate a cross-platform compatible mechanical and electrical data stream, including: Perform semantic parsing on the geometric attributes, material parameters, and timestamps of multi-source BIM data including Revit and AutoCAD to generate a standardized metadata vector; Calculate the real-time priority index of each data stream through a sliding window algorithm according to the data update frequency and the criticality of the design stage; Input the real-time priority index and the standardized metadata vector into a spatio-temporal encoder, and use Fourier basis functions for mapping to generate a lightweight spatio-temporal coding sequence; Perform binary stream encapsulation on the spatio-temporal coding sequence, append data check codes and version identifiers, and generate a cross-platform mechanical and electrical data stream supporting WebGL and the Unity engine.

[0007] Optionally, based on the user operation behavior data and the mechanical and electrical data stream, design optimization parameters are dynamically generated through a reinforcement learning algorithm. The reinforcement learning algorithm adjusts pipeline avoidance rules and conflict detection thresholds through a real-time feedback mechanism, and outputs increment data of the optimized mechanical and electrical model, including: According to the user operation behavior data, capture the operation trajectories of the user dragging pipelines and adjusting equipment positions, and extract behavior feature vectors of operation frequency, modification amplitude, and conflict trigger times; Construct a Markov decision process with the electromechanical data stream and behavioral feature vectors, and define the pipeline curvature change and conflict detection response time as the state space; Combine the penalty value for violation of the avoidance rule and the reward value for conflict resolution efficiency to generate a composite reward signal with real-time feedback; According to the state space and the composite reward signal, optimize the pipeline avoidance curvature radius threshold and the conflict detection sensitivity parameter through the policy gradient algorithm, and output the incremental data of the electromechanical model with version identification.

[0008] Optionally, based on the incremental data of the electromechanical model, construct a collaborative optimization engine under spatio-temporal constraints, and fuse multiple design changes through an adaptive weight allocation algorithm to generate a collaborative electromechanical model with consistent versions, including: Analyze the pipeline offset and equipment parameter modification values in the incremental data of the electromechanical model, and calculate the influence score of each design change on structural safety and energy consumption; Based on the change timestamp and the influence score, dynamically allocate the fusion weights of multiple design changes through an exponential decay function; Use the Monte Carlo tree search algorithm to traverse the change combinations after the fusion weight allocation, and screen the feasible solution sets that meet the hard constraints such as net height and maintenance space; Perform topological structure hash coding comparison on the feasible solution sets, and generate a collaborative electromechanical model with consistent versions through a majority voting mechanism.

[0009] Optionally, according to the collaborative electromechanical model, use a distributed heterogeneous computing framework to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model, accelerate collision detection through a physical engine, and output an optimized electromechanical model and a performance analysis report, including: According to the GPU video memory capacity, use the octree space segmentation algorithm to divide the collaborative electromechanical model into sub-model blocks that can be independently calculated; Allocate sub-model blocks to heterogeneous hardware of CPU and GPU through a computing node performance sensor to generate a parallel task scheduling table; According to the parallel task scheduling table, inject rigid body dynamics constraints into the pipeline collision detection task, and use the GPU parallel computing of the Bullet engine to accelerate the collision response calculation; Aggregate the visual effect data of block rendering and the energy consumption simulation results, and generate a performance analysis report including energy efficiency rating and collision risk warning through a heat map fusion algorithm.

[0010] Optionally, according to the GPU video memory capacity, use the octree space segmentation algorithm to divide the collaborative electromechanical model into sub-model blocks that can be independently calculated, including: According to the geometric density distribution of the collaborative electromechanical model and the preset GPU video memory capacity threshold, a three-dimensional geometric density heat map is generated through a density-aware sampling algorithm, and spatial density distribution data including the pipeline cluster and the device concentration area is output; Based on the spatial density distribution data, a dynamic octree segmentation algorithm is used for spatial recursive partitioning to generate an initial set of sub-model blocks, where the partitioning depth is dynamically adjusted according to the density gradient and the predicted video memory occupancy value, and sub-model blocks with video memory occupancy labels are output; According to the video memory occupancy labels of the sub-model blocks and the GPU video memory capacity, the over-limit sub-blocks are re-segmented through a dynamic balance factor injection algorithm to generate an equilibrium set of sub-model blocks that meet the video memory constraints, and a segmentation structure tree including the topological relationship between the parent and sub-model blocks is output; Based on the segmentation structure tree, the interface area between adjacent sub-model blocks is overlapped and extended through a boundary voxel diffusion algorithm to generate the final sub-model blocks with buffer voxels.

[0011] Another embodiment of the present application provides a BIM-based electromechanical modeling system, and the system includes: A generation module, configured to generate an initial topological structure of the electromechanical system through a graph neural network according to the building structure model and the electromechanical design constraint rule library, where the graph neural network fuses spatial geometric features and device energy consumption parameters, and outputs an electromechanical parametric model including pipeline paths, device layouts, and connection relationships; A conversion module, configured to perform feature alignment on multi-source heterogeneous data based on the electromechanical parametric model by using a dynamic priority coding algorithm, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate electromechanical data streams compatible across platforms; An adjustment module, configured to dynamically generate design optimization parameters according to user operation behavior data and the electromechanical data stream through a reinforcement learning algorithm, where the reinforcement learning algorithm adjusts pipeline avoidance rules and conflict detection thresholds through a real-time feedback mechanism, and outputs optimized electromechanical model incremental data; A fusion module, configured to build a collaborative optimization engine under spatio-temporal constraints based on the electromechanical model incremental data, and fuse multiple design changes through an adaptive weight allocation algorithm to generate a version-consistent collaborative electromechanical model; An output module, configured to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model by using a distributed heterogeneous computing framework according to the collaborative electromechanical model, accelerate collision detection through a physical engine, and output an optimized electromechanical model and a performance analysis report.

[0012] Another embodiment of the present application provides a storage medium, in which a computer program is stored, and the computer program is set to execute the method described in any one of the above when running.

[0013] Another embodiment of the present application provides an electronic device, including a memory and a processor. A computer program is stored in the memory, and the processor is configured to run the computer program to execute the method described in any one of the above.

[0014] Compared with the prior art, a BIM-based electromechanical modeling method provided by the present invention generates an initial topological structure of an electromechanical system through a graph neural network according to a building structure model and an electromechanical design constraint rule base, and outputs an electromechanical parametric model including pipeline paths, equipment layouts, and connection relationships; based on the electromechanical parametric model, generates cross-platform compatible electromechanical data streams; according to user operation behavior data and electromechanical data streams, dynamically generates design optimization parameters through a reinforcement learning algorithm, and outputs optimized electromechanical model incremental data; based on the electromechanical model incremental data, generates a collaborative electromechanical model with consistent versions; according to the collaborative electromechanical model, uses a distributed heterogeneous computing framework to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model, and outputs an optimized electromechanical model and a performance analysis report, so as to be able to realize automatic modeling, optimized design, and dynamic collaboration of the electromechanical system through an intelligent algorithm, thereby improving the design efficiency, operation intelligence level, and energy utilization efficiency of the building electromechanical system. BRIEF DESCRIPTION OF THE DRAWINGS

[0015] Figure 1 is a hardware structure block diagram of a computer terminal for a BIM-based electromechanical modeling method provided by an embodiment of the present invention; Figure 2 is a schematic flowchart of a BIM-based electromechanical modeling method provided by an embodiment of the present invention; Figure 3 is a schematic structural diagram of a BIM-based electromechanical modeling system provided by an embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0016] The embodiments described below by referring to the accompanying drawings are exemplary and are only used to explain the present invention, and should not be construed as limiting the present invention.

[0017] An embodiment of the present invention first provides a BIM-based electromechanical modeling method, which can be applied to an electronic device, such as a computer terminal, specifically, a general computer, etc.

[0018] The following takes running on a computer terminal as an example to describe it in detail. Figure 1 is a hardware structure block diagram of a computer terminal for a BIM-based electromechanical modeling method provided by an embodiment of the present invention. As Figure 1 shown, the computer device includes a processor, a memory, and a network interface connected through a system bus. Among them, the memory may include a non-volatile storage medium and an internal memory.

[0019] The non-volatile storage medium can store an operating system and a computer program. The computer program includes program instructions which, when executed, can cause the processor to execute any one of the BIM-based electromechanical modeling methods.

[0020] The processor is used to provide computing and control capabilities to support the operation of the entire computer device.

[0021] The internal memory provides an environment for the operation of the computer program in the non-volatile storage medium. When the computer program is executed by the processor, it can cause the processor to execute any one of the BIM-based electromechanical modeling methods.

[0022] The network interface is used for network communication, such as sending assigned tasks, etc. Those skilled in the art can understand that Figure 1 the structure shown in

[0023] is only a block diagram of some structures related to the solution of this application, and does not constitute a limitation on the computer device to which the solution of this application is applied. The specific computer device may include more or fewer components than those shown in the figure, or combine some components, or have different component arrangements.

[0024] See Figure 2 , embodiments of the present invention provide a BIM-based electromechanical modeling method, which may include the following steps: S201, according to the building structure model and the electromechanical design constraint rule library, generate an initial topological structure of the electromechanical system through a graph neural network. The graph neural network fuses spatial geometric features and equipment energy consumption parameters, and outputs an electromechanical parametric model including pipeline paths, equipment layouts and connection relationships; Based on the building structure model and the preset mechanical and electrical design rule library, a graph neural network is used to automatically generate the initial topological structure of the mechanical and electrical system. By fusing and calculating the geometric features of the building space (such as the positions of beams and columns, and the net height limit) and the equipment energy consumption parameters, a parametric model containing complete information such as pipeline paths and equipment layouts is generated, realizing the intelligent mapping from the building structure to the mechanical and electrical system, breaking through the limitation of traditional mechanical and electrical design relying on manual experience, and achieving the automatic generation of the mechanical and electrical topological structure through AI technology. The design integrating energy consumption parameters ensures that the system has the potential for energy efficiency optimization from the initial stage, and the parametric model provides a standardized data basis for subsequent collaborative design.

[0025] S202, based on the mechanical and electrical parametric model, use the dynamic priority coding algorithm to perform feature alignment on multi-source heterogeneous data, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate cross-platform compatible mechanical and electrical data streams; Aiming at the problem of inconsistent multi-source BIM data formats, this step uses dynamic priority coding technology to perform feature alignment on data from different platforms such as Revit and CAD. Through spatio-temporal coding sequence conversion, heterogeneous data is transformed into a lightweight unified data stream, solving the data compatibility problem in cross-platform collaboration, achieving seamless docking of multi-disciplinary and multi-platform data, and significantly improving the design collaboration efficiency. The lightweight coding reduces the data exchange volume, and the spatio-temporal sequence structure supports subsequent version tracing and incremental updates.

[0026] S203, according to the user operation behavior data and the mechanical and electrical data stream, dynamically generate design optimization parameters through a reinforcement learning algorithm. The reinforcement learning algorithm adjusts the pipeline avoidance rules and conflict detection thresholds through a real-time feedback mechanism, and outputs the incremental data of the optimized mechanical and electrical model; Based on user operation behavior and real-time data stream, dynamically optimize design parameters through reinforcement learning. The algorithm automatically adjusts the pipeline avoidance rules and collision detection sensitivity according to the user's modification habits, realizes the self-evolution of the design process, converts human-computer interaction data into algorithm optimization power, and enables the system to have the ability of continuous learning. The dynamically adjusted avoidance rules can reduce more than 70% of the design rework, and the adaptive optimization of the conflict detection threshold improves the accuracy rate.

[0027] S204, based on the incremental data of the mechanical and electrical model, construct a collaborative optimization engine under spatio-temporal constraints, and fuse multiple design changes through an adaptive weight allocation algorithm to generate a version-consistent collaborative mechanical and electrical model; Construct a collaborative optimization engine under spatio-temporal constraints, and integrate multiple design changes through an adaptive weight algorithm. The engine can intelligently balance the design requirements of different disciplines, ensure version consistency while retaining the design intentions of each discipline, solve the version conflict problem in multi-disciplinary collaboration, and the weight allocation mechanism takes into account structural safety and energy efficiency. Monte Carlo tree search ensures that the solution meets all hard constraints.

[0028] S205. According to the collaborative electromechanical model, use a distributed heterogeneous computing framework to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model, accelerate collision detection through a physics engine, and output an optimized electromechanical model and a performance analysis report.

[0029] Use a distributed heterogeneous computing framework to achieve real-time rendering and energy consumption simulation of large-scale electromechanical models. Through octree partitioning and hardware-aware task scheduling, give full play to the hybrid computing power of CPU / GPU. The physics engine acceleration ensures the efficiency of collision detection, making it possible to perform real-time performance analysis of complex electromechanical systems. Block computing breaks through the hardware performance bottleneck. The heat map fusion display intuitively presents energy efficiency and collision risks, assisting in design decision-making.

[0030] Specifically, according to the building structure model and the electromechanical design constraint rule base, use a graph neural network to generate the initial topological structure of the electromechanical system. The graph neural network fuses spatial geometric features and equipment energy consumption parameters, and outputs an electromechanical parametric model including pipeline paths, equipment layouts, and connection relationships, including: According to the BIM data of the building structure model, extract the three-dimensional geometric features of the beam-column spatial coordinates, net height limit, and opening positions, and generate a geometric feature tensor containing topological constraints; Extracting three-dimensional geometric features from the Building Information Model (BIM) is the basis for constructing the initial topological structure of the electromechanical system. Taking a commercial complex as an example, its BIM data includes the spatial coordinates of the beam and column (such as the main beam end point coordinates XYZ = (10.5, 20.3, 4.2)), the net height limit (such as the minimum net height of the corridor area is 2.8 meters), and the opening positions (such as the elevator shaft size is 2.5m × 3m). Generate the geometric feature tensor through the following steps: Data parsing and standardization: Use an IFC (Industry Foundation Classes) parser to read the BIM file and extract the geometric attributes of all structural components. For example, the cross-sectional dimensions of the beam (400mm × 600mm), and the axis positions of the columns (distributed every 8 meters).

[0031] Convert unstructured data into a structured format: Each component is represented as a JSON object containing position, size, and constraint conditions.

[0032] Normalize the coordinates. Based on the building origin, convert all values into relative coordinates (such as the main beam end point coordinates are normalized to [0.12, 0.25, 0.05], range 0~1).

[0033] Topological constraint modeling: Constructing the topological connection relationship graph: The intersection points of beams and columns are automatically recognized as nodes, and the beams are used as edges to connect the nodes. For example, node A (coordinates (0,0,0)) is connected to node B (coordinates (8,0,0)) by an edge, representing a beam with a length of 8 meters.

[0034] Net height constraint encoding: Map the net height limit to node attributes. For example, the net height value of 2.8 meters associated with node C requires that the height must be ≥ 2.8 meters when mechanical and electrical pipelines pass through this area.

[0035] Hole position marking: Generate a three-dimensional bounding box for each hole and encode it as a binary mask. For example, all grid points in the elevator shaft area are marked as 1, and the rest are 0.

[0036] Tensor generation: The dimension of the geometric feature tensor is [N, 8], where N is the number of components, and the 8 features include: normalized coordinates XYZ, component type encoding (beam = 0, column = 1), cross-sectional dimensions (length, width), net height value, and hole mask.

[0037] Convert the pipe diameter matching rule and equipment spacing threshold in the mechanical and electrical design constraint rule library into the edge weight matrix of the graph neural network, and perform multi-channel splicing with the geometric feature tensor to obtain the spliced geometric feature tensor; The mechanical and electrical design constraint rule library usually contains hundreds of industry specifications. Taking pipe diameter matching and equipment spacing as examples, the specific conversion process is as follows: Rule parsing and numericalization: Pipe diameter matching rule: For example, "The relationship between the pipe diameter of the chilled water pipe and the flow rate needs to satisfy Q = πD²v / 4, where v ≤ 2.5 m / s". Convert this rule into a pipe diameter - flow rate mapping table, as shown in Table 1 for example: Table 1 Flow rate (m³ / h) Minimum pipe diameter (mm) 50 100 100 150 Equipment spacing threshold: Such as "The horizontal spacing between the water pump and the power distribution cabinet ≥ 1.2 meters", which is converted into the edge weight in the distance matrix. If the distance d between two equipment nodes is < 1.2 meters, the weight is set to 0 (prohibited connection); otherwise, it is 1 (allowed connection).

[0038] Edge weight matrix construction: The dimension of the edge weight matrix E of the graph neural network (GNN) is [N, N], where N is the number of nodes.

[0039] For each pair of nodes (i,j): If it is a structural component (beam or column), the weight E[i,j] is determined by the geometric distance. For example, the closer the distance, the higher the weight (E[i,j] = 1 / (1 + d)).

[0040] For device nodes (water pumps, power distribution cabinets), the application spacing threshold rule is: E[i,j] = 1 if d≥1.2m else 0.

[0041] Multi-channel splicing: Perform channel splicing on the geometric feature tensor (dimension [N,8]) and the edge weight matrix (flattened to [N×N,1]). Due to dimension mismatch, downsampling is required for the edge weight matrix: Use average pooling to compress the [N×N] matrix to [N,8] to align it with the geometric feature tensor.

[0042] The dimension of the spliced tensor is [N, 16], with the first 8 columns being geometric features and the last 8 columns being edge weight features.

[0043] Generate an energy consumption feature vector based on device energy consumption parameters, and construct an energy consumption weight graph of device nodes and pipeline edges through a spatial position association algorithm; Device energy consumption parameters are key factors affecting the design of electromechanical systems. Taking air conditioning units and water pumps as examples: Construction of energy consumption feature vector: Basic device parameters: rated power (kW), operating time ratio (%), coefficient of performance (COP).

[0044] Feature encoding: Combine the parameters into a vector after normalization. For example, the parameters of a certain air conditioning unit are: Rated power: 150kW → normalized value 0.75 (assuming maximum power 200kW); Operating time ratio: 70% → 0.7; COP: 3.2 → normalized value 0.64 (assuming maximum COP = 5).

[0045] Energy consumption feature vector: [0.75, 0.7, 0.64].

[0046] Spatial position association algorithm: Device node positioning: Align the coordinates of device nodes with the coordinates of building structure nodes. For example, the coordinates of the water pump node (12.5, 8.3, 0) are associated with the nearest beam node (12, 8, 0).

[0047] Calculation of energy consumption weight: The energy consumption weight of the pipeline edge = flow rate × pipe length × friction coefficient. For example, for a section of chilled water pipe with a flow rate of 50m³ / h, a length of 10m, and a friction coefficient of 0.02, the weight = 50×10×0.02 = 10.

[0048] The energy consumption weight of the device node = rated power × operating time. For example, the weight of the above air conditioning unit = 150kW×70% = 105.

[0049] Energy consumption weight graph generation: Construct an energy consumption adjacency matrix \(E_{energy}\) with dimension \([N, N]\).

[0050] For equipment node \(i\) and pipeline edge \((i, j)\): \(E_{energy}[i, j]= \) weight of equipment node \(i+\) weight of pipeline edge \((i, j)\).

[0051] Utilize the attention mechanism of the graph neural network to fuse the geometric constraints in the spliced geometric feature tensor and the energy consumption weights in the energy consumption weight graph, generate the optimal solution set of pipeline paths through iterative message passing, and output an electromechanical parametric model containing avoidance priority labels.

[0052] The graph neural network (GNN) uses the attention mechanism to achieve multi-feature fusion. The specific process is as follows: Attention coefficient calculation: For each node \(i\), calculate its attention coefficient \(\alpha_{ij}\) with neighbor \(j\): Input: spliced geometric features \(h_i\), \(h_j\) (dimension \((16)\)), edge weight \(e_{ij}\).

[0053] Calculation: \(\alpha_{ij}=\text{softmax}(\text{LeakyReLU}(a^T [Wh_i || Wh_j || e_{ij}]))\), where \(W\) is a learnable parameter matrix and \(a\) is an attention vector.

[0054] Example: \(\alpha_{ij} = 0.8\) between beam node \(i\) and equipment node \(j\), indicating that geometric constraints dominate; \(\alpha_{ij}=0.6\) between equipment nodes, indicating that energy consumption weights have a greater impact.

[0055] Iterative message passing: Each layer of GNN updates node features: \(h_i^{(l + 1)}=\sigma(\sum_{j\in N(i)}\alpha_{ij}^{(l)}*h_j^{(l)}*W^{(l)})\) \(\sigma\) is an activation function (such as ReLU); The initial feature \(h_i^{(0)}\) is the spliced geometric feature; The number of iterations \(L = 3\), and the output dimension of each layer is 64.

[0056] Example: After 3 iterations, the feature vector of a pipeline node contains high-dimensional geometric constraints and energy consumption correlation information.

[0057] Pipeline path generation: Path search uses the A* algorithm, and the cost function combines geometric avoidance and energy consumption: \(f(n)=g(n)+h(n)\).

[0058] g(n): Actual cost = pipeline length × pipe material cost coefficient + energy consumption weight × electricity price coefficient; h(n): Heuristic cost = Euclidean distance to the target node.

[0059] Priority label: According to the comprehensive cost of the path, it is divided into three levels: high (cost < 100), medium (100 ≤ cost < 200), and low (cost ≥ 200).

[0060] Output of the parametric model: The pipeline path is stored as a parametric curve (such as NURBS), and the attributes include pipe diameter, slope, and avoidance priority; the equipment layout output is an instantiated model with coordinates and orientations.

[0061] Specifically, based on the electromechanical parametric model, a dynamic priority coding algorithm is used to align the features of multi-source heterogeneous data, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate cross-platform compatible electromechanical data streams, including: Semantically parse the geometric attributes, material parameters, and timestamps of multi-source BIM data including Revit and AutoCAD to generate a standardized metadata vector; The semantic parsing of multi-source BIM data aims to convert heterogeneous data in different formats (such as the.rvt file of Revit and the.dwg file of AutoCAD) into a unified metadata structure. First, for the parsing of geometric attributes, the following contents need to be processed: Revit data parsing: Extract component types (such as air ducts, cable trays), spatial coordinates (XYZ-axis positions), geometric dimensions (length, diameter), and connection relationships through the Revit API.

[0062] AutoCAD data parsing: Use the AutoCAD.NET library to extract layer information, block attributes, and polyline coordinates.

[0063] The parsing of material parameters needs to unify the naming systems of different software. For example, "galvanized steel plate" in Revit and "Galvanized_Steel" in AutoCAD are mapped to a unified code MAT-001, and physical properties such as density (7850 kg / m³) and thermal conductivity (50 W / m·K) are associated.

[0064] Timestamp processing is divided into two categories: Design version timestamp: Record the model modification time (such as 2023-10-05T14:30:00Z); Operation timestamp: Capture the timing of user editing operations (such as the start and end times of drag operations).

[0065] The finally generated standardized metadata vector is a multi-dimensional array of fixed length, for example: Component type code (e.g., Duct = 1, CableTray = 2), Average X coordinate, average Y coordinate, average Z coordinate, Length, diameter / width, height, Material code, density, thermal conductivity, Timestamp (Unix millisecond timestamp) 。

[0066] The vector dimension is 12-dimensional, and each field is scaled to the range [0, 1] through Min-Max normalization to ensure cross-platform compatibility.

[0067] ‌According to the data update frequency and the criticality of the design stage, calculate the real-time priority index of each data stream through the sliding window algorithm; The calculation of the priority index needs to consider two dimensions: data update frequency and the criticality of the design stage: Data update frequency: Define the sliding window size as 5 seconds (can be adjusted according to hardware performance), and count the number of updates of each data stream within the window. For example, if the duct data is modified 3 times within 5 seconds, the update frequency is 0.6 times per second.

[0068] Frequency weight formula: weight_freq = log₂(update count + 1), to avoid excessive influence of high-frequency noise data.

[0069] Criticality of the design stage: The design stage is divided into conceptual design (weight 0.3), preliminary design (0.5), construction drawing design (0.8), and detailed design (1.0). For example, the modification of the duct path in the construction drawing stage has a higher priority than in the conceptual stage.

[0070] Automatically obtain the current stage weight through the work stage mark (Phase parameter) of the BIM software.

[0071] Sliding window algorithm process: Window initialization: Create a circular buffer (capacity = window size / sampling interval, e.g., 5 seconds / 0.1 second = 50 samples); Data stream monitoring: Each time data is updated, record the timestamp and update the buffer; Frequency calculation: Count the number of valid data points within the window and calculate the update count / window length; Priority index: Priority = 0.6 * weight_freq + 0.4 * stage weight.

[0072] ​For example, if a cable tray data is updated twice within 5 seconds in the construction drawing stage (stage weight 0.8), then: weight_freq = log2(2 + 1) ≈ 1.58, Priority = 0.6*1.58 + 0.4*0.8 = 1.268.

[0073] Dynamic adjustment mechanism: If the priority index of a certain data stream exceeds the threshold (such as 1.5) for three consecutive windows, automatically increase the priority of its transmission queue; for low-frequency critical data (such as the safety verification results of fire protection pipelines), even if the update frequency is low, its priority processing is still guaranteed through the stage weight.

[0074] Input the real-time priority index and the standardized metadata vector into the spatio-temporal encoder, and use Fourier basis functions for mapping to generate a lightweight spatio-temporal coding sequence; The core of the spatio-temporal encoder is to fuse the metadata vector and the priority index into a low-dimensional, high-information-density coding sequence. The specific process is as follows: Feature concatenation: Concatenate the 12-dimensional metadata vector and the 1-dimensional priority index into a 13-dimensional input vector; Example input: [1, 0.52, 0.61, 0.73, 0.8, 0.3, 0.2, 0.001, 0.785, 0.05, 1633422600000, 1.268].

[0075] Fourier basis function mapping: Use the Fast Fourier Transform (FFT) to transform the time-domain features to the frequency domain and extract 64 key frequency components; Basis function selection: Complex exponential function e^{-j2πkn / N}, where N = 64, k is the frequency index (0~63), j is the imaginary unit, and n is the sampling point index of the time-domain discrete signal; Frequency-domain filtering: Retain the first 20 low-frequency components (index 0~19) and suppress high-frequency noise; Result example: The frequency-domain features of a certain air duct data are [(0.8 + 0.2j), (-0.1 + 0.5j),..., (0.02 - 0.03j)].

[0076] Coding compression: Perform amplitude-phase separation on the complex frequency-domain components: Amplitude: |X[k]| = sqrt(Re^2 + Im^2); Phase: ∠X[k] = arctan(Im / Re), where X[k]: complex frequency-domain component, Re: real part of the complex number X[k], reflecting the similarity of the signal to the cosine basis function, Im: imaginary part of the complex number X[k], reflecting the similarity of the signal to the sine basis function; Reduce the 40 - dimensional real numbers (20 amplitudes + 20 phases) to 16 dimensions through PCA; Example of the final encoded sequence (16 - dimensional): [0.82, 0.51, 0.33, ..., 0.07].

[0077] Lightweight optimization: Adopt 8 - bit integer quantization (range 0~255) to compress the 16 - dimensional floating - point vector into 16 bytes; for example, the floating - point number 0.82 is mapped to the integer value 0.82 * 255≈209, which is binary 11010001.

[0078] Perform binary stream encapsulation on the spatio - temporal encoded sequence, append data checksum and version identifier to generate a cross - platform electromechanical data stream supporting WebGL and Unity engines.

[0079] The binary stream encapsulation needs to meet the cross - platform parsing requirements. The specific protocol design is as follows: Data frame structure: Header (4 bytes): Magic Number 0x42494D31 (ASCII "BIM1"); Version identifier (2 bytes): Major version number (high 8 bits)+Minor version number (low 8 bits), for example, 0x0102 represents v1.2; Data length (2 bytes): The number of bytes of the encoded sequence (such as 16); Checksum (4 bytes): CRC - 32 checksum value; Payload (N bytes): The quantized encoded sequence.

[0080] Checksum calculation: Use the CRC - 32 algorithm to calculate the checksum for the entire data frame (except the checksum field); Example: The CRC value of the data frame BIM1 0102 0010 [CRC] 0000... is generated by looking up the table method.

[0081] Cross - platform compatibility processing: WebGL side: Convert the binary stream to an ArrayBuffer and parse it through JavaScript; Unity side: Use the BinaryReader class in C# to read the byte stream; Data example (16 - byte encoding + header): 0x42 0x49 0x4D 0x31 / / Header: BIM1 0x01 0x02 / / Version: v1.2 0x00 0x10 / / Data length: 16 0x12 0x34 0x56 0x78 / / CRC - 32 0xD1 0x3F 0xA2 ... / / 16 - byte encoded data Dynamic optimization mechanism: Version rollback: If the receiver version is lower than the data frame version, the compatibility mode is automatically triggered (such as discarding new fields); Streaming transmission: Supports chunked transfer, and each chunk contains an independent checksum, adapting to weak network environments.

[0082] Specifically, according to the user operation behavior data and the electromechanical data stream, design optimization parameters are dynamically generated through a reinforcement learning algorithm. The reinforcement learning algorithm adjusts the pipeline avoidance rules and conflict detection thresholds through a real - time feedback mechanism, and outputs the increment data of the optimized electromechanical model, including: According to the user operation behavior data, capture the operation trajectories of the user dragging pipelines and adjusting equipment positions, and extract the behavior feature vectors of operation frequency, modification amplitude, and conflict trigger times; The capture of user operation behavior data is based on the interaction log and event listening module of the BIM design software. When the user drags a pipeline (such as moving a DN100 water pipe from coordinates (10, 5, 3) to (12, 6, 4)) or adjusts the equipment position (such as raising the air - conditioning unit 0.5 meters along the Z - axis) in the Revit or AutoCAD interface, the system uses Hook technology to record the following original data in real - time: Operation trajectory: Record the cursor movement path at a sampling rate of 10Hz and store it as a three - dimensional coordinate sequence (such as 10 points per second, and each point contains X / Y / Z values); Operation type: Action labels such as drag, rotate, scale (encoded as integer values from 0 - 2); Timestamp: The exact time of the start and end of the operation (in UTC milliseconds).

[0083] The extraction of behavior features uses multi - scale sliding window analysis: Calculation of operation frequency: Count the number of operations of the user within a 30 - second window. For example, when modifying the ventilation duct, the user continuously performs 8 drag operations, then the frequency is 8 / 30≈0.267Hz; Quantification of modification amplitude: Calculate the Euclidean distance difference between the pipeline endpoint coordinates before and after the operation. For example, if a certain drag operation increases the pipeline length by 2.3 meters, the amplitude is marked as 2.3; Conflict trigger times: Count the number of conflicts triggered by the operation through a real - time collision detection engine (such as the Autodesk Navisworks API). For example, when the user moves the pipeline, 3 collisions with the structural beam are triggered, then the number of conflicts is 3.

[0084] The dimension of the finally generated behavioral feature vector is 5: operation frequency (normalized to 0 - 1); modification amplitude of X / Y / Z axes (unit: meter); number of conflicts (integer). For example, the vector [0.8, 1.2, 0.7, 0.5, 3] represents high-frequency operations, mainly adjustment along the X axis, and 3 conflicts are triggered.

[0085] Construct a Markov decision process with the electromechanical data stream and the behavioral feature vector, and define the pipeline curvature change and conflict detection response time as the state space; The construction of the Markov decision process (MDP) is divided into three parts: state space, action space, and reward function: Definition of state space: Pipeline curvature change: Fit the pipeline path with a B-spline curve and calculate the radius of curvature (unit: meter). For example, after a section of water pipe changes from a straight line to a curved path, the curvature changes from ∞ to 2.5 m; Conflict detection response time: The delay from the end of user operation to the system's feedback of conflict (unit: ms). For example, the system pops up a collision warning 150 ms after the user releases the mouse; Device spacing threshold: The currently set minimum device interval (e.g., the distance between a water pump and a power distribution cabinet ≥ 0.8 m); Behavioral feature vector (output of step 1).

[0086] The state space is encoded as an 8-dimensional vector: [radius of curvature, response time, device spacing threshold, operation frequency, X amplitude, Y amplitude, Z amplitude, number of conflicts].

[0087] Action space (Action Space): Adjust the pipeline curvature radius threshold: The allowable range is 0.5 - 5.0 m, and the step size is 0.1 m; Adjust the conflict detection sensitivity: The detection delay range is 50 - 300 ms, and the step size is 10 ms; Modify the device spacing threshold: The range is 0.5 - 1.5 m, and the step size is 0.05 m.

[0088] State transition model: Use a Q-table (state-action value table) to store the state transition probability, which is initialized to a uniform distribution. For example, when the radius of curvature is adjusted from 2.5 m to 3.0 m, the probability of transitioning to a new state is 0.2.

[0089] Combine the penalty value for violating the avoidance rule and the reward value for conflict resolution efficiency to generate a composite reward signal for real-time feedback; The reward function is designed as a weighted sum of multiple objectives, including positive rewards and negative penalties: Positive reward term: Conflict resolution efficiency: If the number of conflicts decreases by ΔC after an operation, the reward is +2×ΔC. For example, if a certain adjustment eliminates 2 conflicts, the reward is +4; Energy efficiency improvement: Calculate the change in pump power ΔP (unit: kW) after pipeline modification through energy consumption simulation. If ΔP < 0 (energy consumption decreases), the reward is +abs(ΔP)×10. For example, if the power decreases by 0.5 kW, the reward is +5; User operation fluency: If the conflict detection response time is shortened by ΔT (unit: ms), the reward is +0.01×ΔT. For example, if the response time decreases from 200 ms to 150 ms, the reward is +0.5.

[0090] Negative penalty term: Violation of avoidance rules: When the pipeline curvature radius < the design specification value (e.g., the minimum curvature of a DN100 water pipe is 1.2 meters), the penalty is -(1.2 - actual value)×100. For example, if the curvature is 0.9 meters, the penalty is -30; New conflict: Each time a new conflict is triggered, the penalty is -3; Operation redundancy: If the same position is adjusted repeatedly more than 3 times, the penalty is -1×the number of repetitions.

[0091] Example of calculating the composite reward signal: After a certain operation: Eliminating 1 conflict → +2; Energy consumption reduction of 0.3 kW → +3; Response time shortened by 50 ms → +0.5; Curvature radius of 0.9 meters (below 1.2 meters) → -30; 0 new conflicts → no penalty; First adjustment → no redundancy penalty. Total reward: 2 + 3 + 0.5 - 30 = -24.5.

[0092] According to the state space and the composite reward signal, optimize the pipeline avoidance curvature radius threshold and conflict detection sensitivity parameters through the policy gradient algorithm, and output the incremental data of the electromechanical model with version identification.

[0093] Specific implementation process of the policy gradient algorithm (PPO): Neural network architecture: Input layer: 8-dimensional state vector; Hidden layer: 2 fully connected layers (256 / 128 nodes, ReLU activation); Output layer: 3-dimensional action probability distribution (Softmax normalization).

[0094] Training process: Data collection: Run the BIM design software to collect 1000 groups of state-action-reward samples; Advantage calculation: Use generalized advantage estimation (GAE, λ = 0.95). For example, the advantage value of a certain sample is +1.5; Policy update: Initial learning rate: 0.0003, batch size: 64; Clip Ratio: 0.2, which limits the amplitude of policy updates; KL divergence threshold: 0.01. If the difference between the old and new policies is too large, the update will be terminated early.

[0095] Example of parameter optimization: Initial parameters: curvature threshold 1.2 m, detection latency 200 ms; After training optimization: curvature threshold 1.5 m (reducing avoidance violations), detection latency 120 ms (improving response speed).

[0096] Incremental data generation: Version identification: Using semantic version numbers (such as v2.1.3); Incremental content: Modified curvature threshold (1.5 m); New conflict detection parameter (120 ms); Adjusted device spacing (0.85 m).

[0097] Specifically, based on the incremental data of the electromechanical model, a collaborative optimization engine under spatio-temporal constraints is constructed. Through an adaptive weight allocation algorithm, multiple design changes are fused to generate a consistent version of the collaborative electromechanical model, including: Parse the pipeline offset and device parameter modification values in the incremental data of the electromechanical model, and calculate the impact score of each design change on structural safety and energy consumption; The incremental data of the electromechanical model contains modification records of the pipeline path and device layout by multiple designers (such as offset ±0.5 m, device power adjustment ±10%). During parsing, first extract the change parameters through a BIM parsing engine (such as Autodesk Forge API) and map them to a three-dimensional space coordinate system. For example, the horizontal offset of a certain HVAC pipeline is adjusted from the original design of X = 5.2 m to X = 5.7 m, and the vertical offset Z = 3.1 m remains unchanged.

[0098] The calculation of the impact score is divided into two parts: structural safety and energy consumption: Structural safety assessment: Finite Element Analysis (FEA): Import the model after pipeline offset into ANSYS Mechanical to calculate the additional stress on the building beams and columns. For example, if a certain offset causes the beam stress to increase from 50 MPa to 55 MPa (the safety threshold is 60 MPa), then the structural safety score = 1 - (55 - 50) / 60 = 0.92.

[0099] Net height compliance detection: Verify the conflict between the pipeline and the building net height through a spatial collision detection algorithm (such as Octree traversal). For example, if the net height requirement in a certain area is ≥2.4 m and the net height after pipeline installation is 2.35 m, then the score = 0.

[0100] Energy consumption assessment: Computational Fluid Dynamics (CFD) simulation: Use OpenFOAM to calculate the impact of increased pipeline length on pumping energy consumption. For example, if a pipeline is extended by 2m, resulting in an annual energy consumption increase of 120 kWh, with a baseline energy consumption of 5000 kWh, then the energy consumption score = 1 - 120 / 5000 = 0.976.

[0101] Degree of equipment power matching: Verify the compatibility between equipment power and pipeline load. For example, if the power of a certain water pump is adjusted from 15kW to 18kW, while the pipeline design flow only requires 15kW, then the matching degree score = 15 / 18 = 0.83.

[0102] The final impact degree score is calculated by weighted summation (structural safety weight 0.6, energy consumption weight 0.4). For example, for a certain change, the structural score is 0.92 and the energy consumption score is 0.83, the total score = 0.92×0.6 + 0.83×0.4 = 0.882.

[0103] Based on the change timestamp and impact degree score, dynamically allocate the fusion weights of multiple-party design changes through an exponential decay function; The fusion weights of design changes need to balance timeliness and technical rationality. The exponential decay function is defined as: where is the initial weight (obtained by normalizing the impact degree score); λ is the decay coefficient (default 0.05 / hour); is the current UTC time; is the change submission time.

[0104] Dynamic weight allocation process: Timestamp alignment: Convert all change times to Unix timestamps (millisecond level). For example, design change A was submitted at 1630000000000 (2021-08-27 00:00:00 UTC); Initial weight calculation: Normalize the impact degree score to [0,1]. For example, if the score of change A is 0.882, it is normalized to 0.882 / highest score 0.95 = 0.928; Decay correction: Assume that the current time is 24 hours away from change A, then the decay amount = 0.05×24 = 1.2, and the weight = 0.928×e^{-1.2}≈0.928×0.301 = 0.279; Weight normalization: After summing up all change weights, scale them proportionally to ensure the sum is 1. For example, the original weights of 3 changes are [0.279, 0.352, 0.189], and after normalization, they are [0.34, 0.43, 0.23].

[0105] Example scenario: Change A (8 hours ago, impact degree 0.882): weight = 0.34; Change B (2 hours ago, impact degree 0.75): weight = 0.43; Change C (36 hours ago, impact degree 0.92): weight = 0.23 (due to severe time decay).

[0106] ‌Use the Monte Carlo tree search algorithm to traverse the combination of changes after the fusion weight assignment, and filter the feasible solution set that meets the hard constraints such as net height and maintenance space; Monte Carlo tree search (MCTS) explores the solution space by simulating random change combinations. The specific steps are as follows: Node definition: Root node: the current state of the collaborative electromechanical model; Child node: the state of the model after applying a single design change; Edge: the weight of the change operation.

[0107] Selection phase: Starting from the root node, select the child node based on the UCB1 formula: Among them: is the cumulative reward of node i (such as constraint satisfaction); is the number of visits to node i; is the number of visits to the parent node; c is the exploration coefficient (default 1.414).

[0108] Expansion and simulation: When encountering an unexplored node, randomly select a change to apply and generate a new model state; Simulation reward calculation: Check the hard constraints such as net height (≥2.4m) and maintenance space (≥0.6m passage). For example, if a combination results in a net height of 2.3m, the reward = 0; if all are satisfied, the reward = 1.

[0109] Backtracking update: Update the Q value and N value of the path nodes in reverse according to the simulation results. After 1000 iterations, select the top 10% nodes with the highest rewards as the feasible solution set.

[0110] Example output: Solution 1: Apply Change A (weight 0.34) and Change B (weight 0.43), net height 2.45m, energy consumption optimized by 8%; Solution 2: Only apply Change B (weight 0.43), net height 2.5m, energy consumption optimized by 5%.

[0111] ‌Perform topological structure hash coding comparison on the feasible solution set, and generate a collaborative electromechanical model with consistent versions through the majority voting mechanism.

[0112] The topological structure hash coding generates a unique identifier through the following steps: Feature extraction: Extract the pipeline connection relationship (adjacency matrix), device coordinates (3D floating-point numbers), and pipe diameter sequence of the model; use Morton encoding to convert the 3D coordinates into 64-bit integers. For example, the coordinate (5.7, 3.1, 2.4) → Morton code = 0x3A7D...

[0113] Hash calculation: Concatenate the adjacency matrix, Morton code sequence, and pipe diameter data into a binary stream; use the SHA-256 algorithm to generate a 256-bit hash value. For example, the hash of solution 1 = 0x5b9e..., and the hash of solution 2 = 0xd4a3...

[0114] Majority voting mechanism: Hash clustering: Perform DBSCAN clustering (neighborhood radius = 2, minimum samples = 2) on the hash values of the feasible solution set to identify the mainstream version; Weighted voting: The voting right of each solution = its weight (result of step 2). For example: The weight of solution 1 is 0.34 and it belongs to cluster A (containing 3 solutions); The weight of solution 2 is 0.43 and it belongs to cluster B (containing 5 solutions); The total weight of cluster B = 0.43 × 5 = 2.15, and cluster A = 0.34 × 3 = 1.02 → Cluster B wins; Version generation: Select the solution with the highest weight in cluster B (such as weight 0.43) as the final collaborative electromechanical model.

[0115] Final output: The coordinates, connection relationships, and parameters of all devices and pipelines are stored in the BIM format (IFC standard); the version identifier (such as v2.1.5) is associated with the hash value (0xd4a3...) for traceability by the collaborative platform.

[0116] Specifically, according to the collaborative electromechanical model, use a distributed heterogeneous computing framework to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model, accelerate collision detection through a physics engine, and output an optimized electromechanical model and performance analysis report, including: According to the GPU video memory capacity, use the octree space segmentation algorithm to divide the collaborative electromechanical model into sub-model blocks that can be independently calculated; The core of the octree space partitioning algorithm is to recursively divide the three-dimensional space and decompose the complex electromechanical model into sub-modules that fit the GPU video memory capacity. First, based on the geometric density distribution of the collaborative electromechanical model (such as dense pipeline intersection areas and equipment cluster areas), a density-aware sampling algorithm is used to generate a three-dimensional geometric density heat map. This algorithm marks high-density areas by counting the number of geometric bodies (such as pipeline lengths and equipment volumes) within a unit volume (such as a 1m³ cube). For example, an area containing 10 pipeline segments and 5 devices has a density value marked as 15, while an empty area has a density value of 0.

[0117] Dynamic octree segmentation dynamically adjusts the division depth according to the GPU video memory capacity threshold (such as the 40GB video memory of NVIDIA A100) and the density gradient: Initial division: The entire model bounding box is used as the root node and recursively divided into 8 child nodes (the first layer of the octree).

[0118] Video memory prediction: The video memory occupancy of each child node is estimated by the number of geometric patches × patch data volume (such as each triangular patch occupying 128 bytes). For example, a child node containing 100,000 patches has a video memory occupancy of approximately 12.8MB.

[0119] Depth control: If the predicted value of the child node's video memory exceeds the threshold (such as the upper limit of a single piece of video memory being 5GB), it continues to be divided to the next layer until all child nodes meet the video memory limit. For example, a high-density area needs to be divided to the 5th layer (32×32×32 sub-blocks), while a low-density area is only divided to the 3rd layer.

[0120] Secondary segmentation: For sub-blocks with excessive video memory (such as a predicted value of 5.5GB), the segmentation granularity is adjusted through the dynamic balance factor injection algorithm. For example, it is divided again according to the density gradient within the over-limit sub-block to ensure that the video memory occupancy of the sub-block ≤ 4.8GB (reserving 10% buffer).

[0121] The boundary voxel diffusion algorithm is used to process the interface area between adjacent sub-blocks: Overlap extension: Add 2 layers of voxel buffers (voxel side length 0.1m) to each sub-block to ensure complete geometric interaction across sub-blocks during collision detection. For example, the edge pipeline segment of sub-block A extends into the buffer area of sub-block B to avoid detection omissions caused by segmentation.

[0122] Topological relationship: Build a linked list of parent and child nodes to record the spatial adjacency relationship of sub-blocks for communication optimization in subsequent parallel computing.

[0123] Output the set of sub - model blocks and its topological relationship tree. For example: Sub - block 1: Coordinate range (0~10m, 0~10m, 0~10m), VRAM occupancy 4.2GB; Sub - block 2: Coordinate range (10~20m, 0~10m, 0~10m), VRAM occupancy 3.8GB; Parent - child relationship: Sub - block 1 and Sub - block 2 share the buffer on the plane where X = 10m.

[0124] Allocate sub - model blocks to heterogeneous CPU - GPU hardware through the computing node performance sensor, and generate a parallel task scheduling table. The computing node performance sensor realizes the optimization of task allocation by dynamically evaluating the real - time load and hardware capabilities of the CPU and GPU. The hardware capability evaluation includes: GPU metrics: Number of CUDA cores (e.g., 6912 for NVIDIA A100), memory bandwidth (e.g., 1555GB / s), floating - point computing power (e.g., 19.5 TFLOPS); CPU metrics: Number of cores (e.g., 64 cores for AMD EPYC), memory bandwidth (e.g., 204.8GB / s), cache capacity (e.g., 256MB L3).

[0125] Task allocation rules: Compute - intensive tasks (such as pipeline collision detection, fluid simulation) are allocated to the GPU; Logic - intensive tasks (such as topological relationship verification, data verification) are allocated to CPU multi - threading.

[0126] Parallel task scheduling table generation process: Sub - block tagging: Add computing tags (such as "Collision detection - high priority", "Energy consumption simulation - low priority") to each sub - block.

[0127] Resource matching: Sub - blocks with high VRAM occupancy (> 3GB) are preferentially allocated to GPUs with higher memory bandwidth; Sub - blocks with low VRAM occupancy (≤1GB) and tasks with complex logical judgments are allocated to the CPU.

[0128] Load balancing: Use the greedy algorithm to dynamically adjust the task queue to ensure that the difference in VRAM occupancy of each GPU is < 10%, and the CPU core utilization rate > 80%. For example, a certain GPU's current load is 4.2GB, and the total load after new task allocation is 8GB (20% of 40GB VRAM). The scheduling table is shown in Table 2 as follows: Table 2 Sub-block ID Hardware type Task type Priority Estimated duration (ms) 001 GPU Collision detection High 120 002 CPU Topology verification Medium 45 003 GPU Computational fluid dynamics simulation Low 300 According to the parallel task scheduling table, inject rigid - body dynamics constraints into the pipeline collision detection task, and use the GPU parallel computing of the Bullet engine to accelerate the collision response calculation. The injection of rigid - body dynamics constraints includes parameter settings such as mass, friction coefficient, and elastic coefficient. For example: Pipeline quality: Calculated based on material density (steel: 7850 kg / m³) and volume, the mass of a steel pipe with a diameter of 0.5 m and a length of 10 m is 154 kg; Friction coefficient: Set to 0.3 between the pipeline and the support (steel-steel contact); Elastic coefficient: The collision restitution coefficient is set to 0.2 to avoid non-physical rebounds.

[0129] GPU parallelization implementation of the Bullet engine: Data conversion: Convert the sub-block geometry data into the convex hull shape of the Bullet engine (Convex Hull), and each triangular patch is converted into a rigid body mesh.

[0130] CUDA kernel call: Collision detection kernel: Each CUDA core (such as the 6912 cores of A100) processes the collision detection of a pair of rigid bodies, and uses the bounding volume hierarchy (BVH) to accelerate the query; Response calculation kernel: Parallelly calculate the changes in velocity and angular velocity after collision based on the impulse theorem.

[0131] Result aggregation: Transmit the data such as the collision point coordinates and penetration depth calculated by the GPU back to the host memory, and mark the conflicting pipeline IDs.

[0132] Example of acceleration effect: Traditional CPU calculation: Collision detection of 100,000 patches takes 1200 ms; GPU parallelization: For the same scale of data, it only takes 85 ms, and the speedup ratio reaches 14 times.

[0133] Aggregate the visual effect data of chunked rendering and the energy consumption simulation results, and generate a performance analysis report containing energy efficiency ratings and collision risk warnings through a heatmap fusion algorithm.

[0134] Aggregation of visual effect data: Chunked rendering: Each sub-block independently generates a pixel buffer containing material colors and light reflections on the GPU (such as the FBO of OpenGL); Image stitching: According to the spatial coordinates of the sub-blocks, stitch the pixel buffers into a complete model view, and use bilinear interpolation to eliminate seams.

[0135] Fusion of energy consumption simulation results: Device energy consumption: Multiply the device power (such as 5 kW for water pumps and 3 kW for fans) by the running duration to generate the total energy consumption value; Pipeline loss: Calculate the frictional resistance loss along the way based on the results of fluid mechanics simulation (unit: kW).

[0136] Heatmap fusion algorithm: Color mapping: Energy efficiency rating: Gradual change from green (high efficiency, energy consumption ≤ 50 kWh) to red (low efficiency, ≥ 200 kWh); Collision risk: Transparency represents probability (0% - 100%), and areas with penetration depth > 5 cm are highlighted in red.

[0137] Data overlay: Project energy consumption and collision data onto the surface of the 3D model, and achieve multi - layer visualization through Alpha blending.

[0138] Performance analysis report generation: Content: Includes the list of top 10 energy - efficient devices, coordinates of pipelines with high collision risk, optimization suggestions (such as adjusting pipeline paths, replacing high - efficiency devices); Format: PDF report (static) + WebGL 3D visualization (dynamic interaction).

[0139] Example: Collision detection in a certain area shows that the penetration depth of pipeline A and structural beam B is 8 cm, and the report suggests "Offset pipeline A by 0.5 m"; The annual energy consumption of a certain water pump reaches 3000 kWh, and the suggestion is "Replace it with a variable - frequency model (estimated energy saving of 25%)".

[0140] Specifically, according to the GPU video memory capacity, the collaborative electromechanical model is divided into independently computable sub - model blocks using the octree space - partitioning algorithm, including: Based on the geometric density distribution of the collaborative electromechanical model and the preset GPU video memory capacity threshold, a three - dimensional geometric density heat map is generated through the density - aware sampling algorithm, and spatial density distribution data including pipeline clusters and equipment - concentrated areas is output. In the BIM electromechanical model, the geometric density distribution reflects the aggregation degree of entities such as pipelines and equipment in three - dimensional space. The density - aware sampling algorithm divides the model space into cubic units (voxels) with a side length of 0.1 m through voxelization technology, and counts the number of geometric entities (such as pipelines, fans, distribution boxes) contained in each voxel. For example, if a voxel in a certain area contains 5 intersecting pipelines and 2 devices, its density value is 7.

[0141] The generation of the three - dimensional geometric density heat map is divided into three stages: Data pre - processing: Extract the three - dimensional coordinates and bounding box information of all entities in the electromechanical model, and filter out decorative components (such as labels, annotations).

[0142] Dynamic sampling: Use the Poisson Disk Sampling algorithm to evenly distribute points on the model surface, and the sampling interval is adaptively adjusted according to local density (interval of 0.05 m in dense areas and 0.2 m in sparse areas).

[0143] Kernel density estimation: With each sampling point as the center, apply the Gaussian kernel function (standard deviation σ = 0.3 m) to calculate its influence range, and superimpose all kernel function values to generate a continuous density field. For example, the heat map of a pipeline-intensive area shows red (density > 10), while the open area is blue (density < 2).

[0144] Video memory capacity threshold setting: According to the GPU hardware configuration (such as NVIDIA RTX 3090 with 24 GB of video memory), set the upper limit of single sub-block video memory occupancy to 8 GB (33% of the total video memory, reserving resources for the rendering and physics engine). Identify high-density areas (such as equipment rooms) through the density heat map to ensure that these areas are processed preferentially during subsequent segmentation.

[0145] Based on the spatial density distribution data, use the dynamic octree segmentation algorithm for spatial recursive partitioning to generate an initial set of sub-model blocks. Among them, the partitioning depth is dynamically adjusted according to the density gradient and the predicted video memory occupancy, and sub-model blocks with video memory occupancy labels are output; The dynamic octree segmentation algorithm starts from the entire model bounding box, layer by layer divides the space into 8 sub-cubes (Octant), and decides whether to continue subdividing according to the density gradient and video memory prediction: Initial partitioning: The overall model bounding box (such as 100m × 50m × 30m) is used as the root node and is first divided into 8 sub-blocks (each block is 50m × 25m × 15m).

[0146] Density gradient calculation: Calculate the standard deviation of the density within the sub-block. If it exceeds the threshold (such as standard deviation > 5), it is marked as a high-gradient area. For example, a sub-block contains dense pipeline intersections (density standard deviation 8.2) and needs to be further segmented.

[0147] Video memory occupancy prediction: Based on the number of geometric patches within the sub-block (such as 10,000 patches ≈ 300 MB of video memory occupancy), predict the current sub-block's video memory requirements. If the predicted value exceeds the threshold (such as 8 GB), it is forced to be segmented to a finer level.

[0148] Recursive termination conditions: Condition 1: The sub-block size reaches the minimum segmentation granularity (such as 0.5 m, to avoid excessive subdivision); Condition 2: The predicted video memory value ≤ threshold and the density gradient < 5.

[0149] Video memory occupancy label: Each sub-block records the number of geometric patches it contains, the size of the material texture map (such as 1024×1024 PNG ≈ 4 MB), and the estimated video memory occupancy (number of patches × 0.03 MB + texture map size). For example, a sub-block label is "number of patches 250,000, video memory 7.5 GB", which is close to the threshold and requires secondary segmentation.

[0150] According to the video memory occupancy label of the sub-model block and the GPU video memory capacity, the over-limit sub-blocks are re-segmented through the dynamic balance factor injection algorithm to generate a set of balanced sub-model blocks that meet the video memory constraints, and a segmentation structure tree containing the topological relationship between the parent and sub-model blocks is output; The dynamic balance factor injection algorithm solves the problem of video memory overrun still existing after the initial segmentation: Over-limit sub-block detection: Traverse all sub-blocks and filter out the nodes with a predicted video memory value > 8GB.

[0151] Re-segmentation strategy: Axial priority segmentation: Divide the sub-block into two along the longest axis (such as the X-axis) to generate two new sub-blocks; Density-guided segmentation: Perform non-uniform segmentation at the density peak position (determined by the heat map). For example, cut a 50m long sub-block at 35m so that the high-density area forms an independent block.

[0152] Balance factor calculation: Define the balance factor β = video memory overrun amount / threshold (such as β = (9GB - 8GB) / 8GB = 0.125). If β > 0.2, trigger a third segmentation.

[0153] Segmentation structure tree construction: Parent node: Record the spatial range and video memory label of the original sub-block; Child node: Store the information of the sub-blocks after re-segmentation and establish topological links. For example, if the parent block A is segmented into sub-blocks A1 and A2, their topological relationship is recorded as A → {A1, A2}.

[0154] Example: The predicted video memory of a certain initial sub-block is 9.5GB, and it is re-segmented into A1 (5GB) and A2 (4.5GB) after re-segmentation, meeting the video memory constraints. The segmentation structure tree is stored in JSON format for easy calling by the subsequent rendering engine.

[0155] Based on the segmentation structure tree, the interface area between adjacent sub-model blocks is overlapped and extended through the boundary voxel diffusion algorithm to generate the final sub-model blocks with buffer voxels.

[0156] The boundary voxel diffusion algorithm ensures the geometric continuity at the junction of sub-blocks, avoiding rendering cracks and physical simulation errors: Interface area identification: Traverse the segmentation structure tree, detect the contact surface between adjacent sub-blocks (such as A1 and A2), and extract their boundary voxels (voxels with a distance ≤ 0.2 meters from the contact surface).

[0157] Buffer extension: Unidirectional diffusion: Extend 3 layers of voxels (0.3 meters) from sub-block A1 to the direction of A2, and mark the extended area as the buffer of A1; Bidirectional synchronization: If adjacent sub - blocks both need to be rendered (such as A1 and B1), then both sides expand 2 layers of voxels to form an overlapping area.

[0158] Data redundancy processing: In the overlapping area, copy the geometric data of adjacent sub - blocks (such as the coordinates of pipeline endpoints) to ensure correct calculation of interactions during collision detection.

[0159] Final sub - model block generation: Each sub - block contains an ontology area (geometric data within the video memory label) and a buffer (expanded voxel data). For example, the original size of sub - block A1 is 50m×25m×15m, and after expansion, it becomes 50.6m×25.6m×15.6m. The buffer data is stored separately to optimize video memory occupancy.

[0160] It can be seen that according to the building structure model and the mechanical and electrical design constraint rule base, the initial topological structure of the mechanical and electrical system is generated through a graph neural network, and an electromechanical parametric model including pipeline paths, equipment layouts, and connection relationships is output; based on the electromechanical parametric model, cross - platform - compatible electromechanical data streams are generated; according to user operation behavior data and electromechanical data streams, design optimization parameters are dynamically generated through a reinforcement learning algorithm, and incremental data of the optimized electromechanical model is output; based on the incremental data of the electromechanical model, a collaborative electromechanical model with consistent versions is generated; according to the collaborative electromechanical model, a distributed heterogeneous computing framework is used to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model, and an optimized electromechanical model and a performance analysis report are output. Thus, the automatic modeling, optimized design, and dynamic collaboration of the mechanical and electrical system can be realized through intelligent algorithms, thereby improving the design efficiency, operation intelligence level, and energy utilization efficiency of the building mechanical and electrical system.

[0161] Another embodiment of the present invention provides a BIM - based electromechanical modeling system. Refer to Figure 3 , the system may include: A generation module 301, configured to generate an initial topological structure of the mechanical and electrical system through a graph neural network according to the building structure model and the mechanical and electrical design constraint rule base. The graph neural network fuses spatial geometric features and equipment energy consumption parameters, and outputs an electromechanical parametric model including pipeline paths, equipment layouts, and connection relationships; A conversion module 302, configured to perform feature alignment on multi - source heterogeneous data based on the electromechanical parametric model by using a dynamic priority encoding algorithm, and uniformly convert different BIM data formats into lightweight spatio - temporal encoding sequences to generate cross - platform - compatible electromechanical data streams; An adjustment module 303, configured to dynamically generate design optimization parameters through a reinforcement learning algorithm according to user operation behavior data and the electromechanical data stream. The reinforcement learning algorithm adjusts pipeline avoidance rules and conflict detection thresholds through a real - time feedback mechanism, and outputs incremental data of the optimized electromechanical model; The fusion module 304 is used to construct a collaborative optimization engine under spatio-temporal constraints based on the electromechanical model incremental data, fuse multiple design changes through an adaptive weight allocation algorithm, and generate a version-consistent collaborative electromechanical model; The output module 305 is used to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model according to the collaborative electromechanical model by using a distributed heterogeneous computing framework, accelerate collision detection through a physical engine, and output the optimized electromechanical model and performance analysis report.

[0162] It can be seen that according to the building structure model and the electromechanical design constraint rule base, the initial topological structure of the electromechanical system is generated through a graph neural network, and an electromechanical parametric model including pipeline paths, equipment layouts, and connection relationships is output; based on the electromechanical parametric model, cross-platform compatible electromechanical data streams are generated; according to the user operation behavior data and the electromechanical data streams, design optimization parameters are dynamically generated through a reinforcement learning algorithm, and the incremental data of the optimized electromechanical model is output; based on the incremental data of the electromechanical model, a version-consistent collaborative electromechanical model is generated; according to the collaborative electromechanical model, block rendering and parallel energy consumption simulation are performed on the collaborative electromechanical model by using a distributed heterogeneous computing framework, and the optimized electromechanical model and performance analysis report are output, so as to realize the automatic modeling, optimized design, and dynamic collaboration of the electromechanical system through intelligent algorithms, thereby improving the design efficiency, operation intelligence level, and energy utilization efficiency of the building electromechanical system.

[0163] An embodiment of the present invention further provides a storage medium, in which a computer program is stored, and the computer program is set to execute the steps in any one of the above method embodiments when running.

[0164] Specifically, in this embodiment, the above storage medium can be set to store a computer program for executing the following steps: S201, according to the building structure model and the electromechanical design constraint rule base, generate the initial topological structure of the electromechanical system through a graph neural network, and the graph neural network fuses spatial geometric features and equipment energy consumption parameters, and outputs an electromechanical parametric model including pipeline paths, equipment layouts, and connection relationships; S202, based on the electromechanical parametric model, perform feature alignment on multi-source heterogeneous data by using a dynamic priority coding algorithm, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate cross-platform compatible electromechanical data streams; S203, according to the user operation behavior data and the electromechanical data streams, dynamically generate design optimization parameters through a reinforcement learning algorithm, and the reinforcement learning algorithm adjusts pipeline avoidance rules and conflict detection thresholds through a real-time feedback mechanism, and outputs the incremental data of the optimized electromechanical model; S204. Based on the incremental data of the electromechanical model, construct a collaborative optimization engine under spatio-temporal constraints, and fuse multiple design changes through an adaptive weight allocation algorithm to generate a version-consistent collaborative electromechanical model. S205. According to the collaborative electromechanical model, use a distributed heterogeneous computing framework to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model, accelerate collision detection through a physical engine, and output the optimized electromechanical model and performance analysis report.

[0165] It can be seen that according to the building structure model and the electromechanical design constraint rule base, the initial topological structure of the electromechanical system is generated through a graph neural network, and an electromechanical parametric model including pipeline paths, equipment layouts, and connection relationships is output; based on the electromechanical parametric model, cross-platform compatible electromechanical data streams are generated; according to the user operation behavior data and the electromechanical data streams, design optimization parameters are dynamically generated through a reinforcement learning algorithm, and incremental data of the optimized electromechanical model is output; based on the incremental data of the electromechanical model, a version-consistent collaborative electromechanical model is generated; according to the collaborative electromechanical model, a distributed heterogeneous computing framework is used to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model, and the optimized electromechanical model and performance analysis report are output, so as to realize the automatic modeling, optimized design, and dynamic collaboration of the electromechanical system through intelligent algorithms, thereby improving the design efficiency, operation intelligence level, and energy utilization efficiency of the building electromechanical system.

[0166] An embodiment of the present invention also provides an electronic device, including a memory and a processor. A computer program is stored in the memory, and the processor is configured to run the computer program to execute the steps in any one of the above method embodiments.

[0167] Specifically, the above electronic device may further include a transmission device and an input / output device. Among them, the transmission device is connected to the above processor, and the input / output device is connected to the above processor.

[0168] Specifically, in this embodiment, the above processor may be configured to execute the following steps through a computer program: S201. According to the building structure model and the electromechanical design constraint rule base, generate the initial topological structure of the electromechanical system through a graph neural network. The graph neural network fuses spatial geometric features and equipment energy consumption parameters, and outputs an electromechanical parametric model including pipeline paths, equipment layouts, and connection relationships. S202. Based on the electromechanical parametric model, use a dynamic priority coding algorithm to align the features of multi-source heterogeneous data, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate cross-platform compatible electromechanical data streams. S203. Dynamically generate design optimization parameters according to the user operation behavior data and the mechanical and electrical data stream. The reinforcement learning algorithm adjusts the pipeline avoidance rules and conflict detection thresholds through a real-time feedback mechanism, and outputs the increment data of the optimized mechanical and electrical model. S204. Based on the increment data of the mechanical and electrical model, construct a collaborative optimization engine under spatio-temporal constraints, and fuse multiple design changes through an adaptive weight allocation algorithm to generate a collaborative mechanical and electrical model with consistent versions. S205. According to the collaborative mechanical and electrical model, use a distributed heterogeneous computing framework to perform block rendering and parallel energy consumption simulation on the collaborative mechanical and electrical model, accelerate collision detection through a physical engine, and output the optimized mechanical and electrical model and performance analysis report.

[0169] It can be seen that according to the building structure model and the mechanical and electrical design constraint rule library, the initial topological structure of the mechanical and electrical system is generated through a graph neural network, and the mechanical and electrical parametric model including pipeline paths, equipment layouts, and connection relationships is output; based on the mechanical and electrical parametric model, a cross-platform compatible mechanical and electrical data stream is generated; according to the user operation behavior data and the mechanical and electrical data stream, design optimization parameters are dynamically generated through a reinforcement learning algorithm, and the increment data of the optimized mechanical and electrical model is output; based on the increment data of the mechanical and electrical model, a collaborative mechanical and electrical model with consistent versions is generated; according to the collaborative mechanical and electrical model, a distributed heterogeneous computing framework is used to perform block rendering and parallel energy consumption simulation on the collaborative mechanical and electrical model, and the optimized mechanical and electrical model and performance analysis report are output, so that the automatic modeling, optimized design, and dynamic collaboration of the mechanical and electrical system can be realized through intelligent algorithms, thereby improving the design efficiency, operation intelligence level, and energy utilization efficiency of the building mechanical and electrical system.

[0170] The above has detailed the structure, features, and function effects of the present invention according to the illustrated embodiments. The above is only the preferred embodiment of the present invention, but the present invention is not limited to the scope defined by the drawings. Any changes made according to the concept of the present invention, or equivalent embodiments modified to equivalent changes, still within the spirit covered by the specification and drawings, shall be within the protection scope of the present invention.

Claims

1. A BIM-based mechanical and electrical modeling method, characterized in that, The method includes: According to the building structure model and the mechanical and electrical design constraint rule base, generate the initial topological structure of the mechanical and electrical system through a graph neural network, which fuses spatial geometric features and equipment energy consumption parameters and outputs a mechanical and electrical parametric model including pipeline paths, equipment layouts, and connection relationships; Based on the mechanical and electrical parametric model, use the dynamic priority coding algorithm to align the features of multi-source heterogeneous data, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate cross-platform compatible mechanical and electrical data streams; According to the user operation behavior data and the mechanical and electrical data stream, dynamically generate design optimization parameters through a reinforcement learning algorithm, which adjusts the pipeline avoidance rules and conflict detection thresholds through a real-time feedback mechanism and outputs the incremental data of the optimized mechanical and electrical model; Based on the incremental data of the mechanical and electrical model, construct a collaborative optimization engine under spatio-temporal constraints, fuse multi-party design changes through an adaptive weight allocation algorithm, and generate a consistent version of the collaborative mechanical and electrical model; According to the collaborative mechanical and electrical model, use a distributed heterogeneous computing framework to perform block rendering and parallel energy consumption simulation on the collaborative mechanical and electrical model, accelerate collision detection through a physical engine, and output the optimized mechanical and electrical model and performance analysis report.

2. The method according to claim 1, wherein The step of generating the initial topological structure of the mechanical and electrical system through a graph neural network according to the building structure model and the mechanical and electrical design constraint rule base, which fuses spatial geometric features and equipment energy consumption parameters and outputs a mechanical and electrical parametric model including pipeline paths, equipment layouts, and connection relationships, includes: Extract the three-dimensional geometric features of the beam-column spatial coordinates, net height limit, and opening positions from the BIM data of the building structure model to generate a geometric feature tensor containing topological constraints; Convert the pipe diameter matching rules and equipment spacing thresholds in the mechanical and electrical design constraint rule base into the edge weight matrix of the graph neural network, and perform multi-channel splicing with the geometric feature tensor to obtain the spliced geometric feature tensor; Generate an energy consumption feature vector based on the equipment energy consumption parameters, and construct an energy consumption weight graph of equipment nodes and pipeline edges through a spatial position association algorithm; Use the attention mechanism of the graph neural network to fuse the geometric constraints of the spliced geometric feature tensor and the energy consumption weights in the energy consumption weight graph, generate the optimal solution set of pipeline paths through iterative message passing, and output a mechanical and electrical parametric model including avoidance priority labels.

3. The method according to claim 2, wherein The step of using the dynamic priority coding algorithm to align the features of multi-source heterogeneous data based on the mechanical and electrical parametric model, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate cross-platform compatible mechanical and electrical data streams, includes: Perform semantic parsing on the geometric attributes, material parameters, and timestamps of multi-source BIM data including Revit and AutoCAD to generate a standardized metadata vector; Calculate the real-time priority index of each data stream through a sliding window algorithm according to the data update frequency and the criticality of the design stage; Input the real-time priority index and the standardized metadata vector into a spatio-temporal encoder, and use Fourier basis functions for mapping to generate a lightweight spatio-temporal coding sequence; Perform binary stream encapsulation on the spatio-temporal coding sequence, append data check codes and version identifiers, and generate a cross-platform electromechanical data stream that supports WebGL and the Unity engine.

4. The method according to claim 3, wherein Based on the user operation behavior data and the electromechanical data stream, dynamically generate design optimization parameters through a reinforcement learning algorithm. The reinforcement learning algorithm adjusts pipeline avoidance rules and conflict detection thresholds through a real-time feedback mechanism, and outputs increment data of the optimized electromechanical model, including: According to the user operation behavior data, capture the operation trajectories of the user dragging pipelines and adjusting equipment positions, and extract the behavior feature vectors of operation frequency, modification amplitude, and conflict trigger times. Construct a Markov decision process with the electromechanical data stream and the behavior feature vectors, and define pipeline curvature changes and conflict detection response times as the state space. Combine the penalty value for violating the avoidance rule and the reward value for conflict resolution efficiency to generate a composite reward signal for real-time feedback. According to the state space and the composite reward signal, optimize the pipeline avoidance curvature radius threshold and conflict detection sensitivity parameters through the policy gradient algorithm, and output increment data of the electromechanical model with a version identifier.

5. The method according to claim 4, wherein Based on the increment data of the electromechanical model, construct a collaborative optimization engine under spatio-temporal constraints, and fuse multiple design changes through an adaptive weight allocation algorithm to generate a collaborative electromechanical model with consistent versions, including: Analyze the pipeline offset and equipment parameter modification values in the increment data of the electromechanical model, and calculate the influence score of each design change on structural safety and energy consumption. Based on the change timestamp and influence score, dynamically allocate the fusion weights of multiple design changes through an exponential decay function. Use the Monte Carlo tree search algorithm to traverse the change combinations after the fusion weight allocation, and screen the feasible solution sets that meet the hard constraints of net height and maintenance space. Perform topological structure hash coding comparison on the feasible solution sets, and generate a collaborative electromechanical model with consistent versions through a majority voting mechanism.

6. The method according to claim 5, wherein According to the collaborative electromechanical model, use a distributed heterogeneous computing framework to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model, accelerate collision detection through a physical engine, and output the optimized electromechanical model and performance analysis report, including: According to the GPU video memory capacity, use the octree space segmentation algorithm to divide the collaborative electromechanical model into sub-model blocks that can be independently calculated. Allocate sub-model blocks to heterogeneous hardware of CPU and GPU through a computing node performance sensor to generate a parallel task scheduling table. According to the parallel task scheduling table, inject rigid body dynamics constraints into the pipeline collision detection task, and use the GPU parallel computing of the Bullet engine to accelerate the collision response calculation. Aggregate the visual effect data of block rendering and the energy consumption simulation results, and generate a performance analysis report including energy efficiency rating and collision risk warning through a heat map fusion algorithm.

7. The method according to claim 6, wherein According to the GPU video memory capacity, use the octree space segmentation algorithm to divide the collaborative electromechanical model into sub-model blocks that can be independently calculated, including: According to the geometric density distribution of the collaborative electromechanical model and the preset GPU video memory capacity threshold, generate a three-dimensional geometric density heat map through a density-aware sampling algorithm, and output the spatial density distribution data including pipeline clusters and equipment concentration areas. Based on the spatial density distribution data, a dynamic octree segmentation algorithm is used for spatial recursive partitioning to generate an initial set of sub-model blocks. Among them, the partitioning depth is dynamically adjusted according to the density gradient and the predicted value of video memory occupancy, and sub-model blocks with video memory occupancy labels are output. According to the video memory occupancy labels of the sub-model blocks and the GPU video memory capacity, the over-limit sub-blocks are secondarily segmented through a dynamic balance factor injection algorithm to generate an equilibrium set of sub-model blocks that meet the video memory constraints, and a segmentation structure tree including the topological relationship between the parent and sub-model blocks is output. Based on the segmentation structure tree, the interface area between adjacent sub-model blocks is overlapped and extended through a boundary voxel diffusion algorithm to generate the final sub-model blocks with buffer voxels.

8. An electromechanical modeling system based on BIM, characterized in that, The system includes: A generation module, configured to generate an initial topological structure of the electromechanical system through a graph neural network according to the building structure model and the electromechanical design constraint rule library. The graph neural network fuses spatial geometric features and device energy consumption parameters and outputs an electromechanical parametric model including pipe paths, device layouts, and connection relationships. A conversion module, configured to perform feature alignment on multi-source heterogeneous data based on the electromechanical parametric model by using a dynamic priority coding algorithm, uniformly convert different BIM data formats into lightweight spatio-temporal coding sequences, and generate an electromechanical data stream compatible across platforms. An adjustment module, configured to dynamically generate design optimization parameters through a reinforcement learning algorithm according to the user operation behavior data and the electromechanical data stream. The reinforcement learning algorithm adjusts the pipeline avoidance rules and conflict detection thresholds through a real-time feedback mechanism and outputs optimized electromechanical model incremental data. A fusion module, configured to construct a collaborative optimization engine under spatio-temporal constraints based on the electromechanical model incremental data, and fuse multiple design changes through an adaptive weight allocation algorithm to generate a consistent version of the collaborative electromechanical model. An output module, configured to perform block rendering and parallel energy consumption simulation on the collaborative electromechanical model by using a distributed heterogeneous computing framework according to the collaborative electromechanical model, accelerate collision detection through a physical engine, and output the optimized electromechanical model and a performance analysis report.

9. A storage medium, characterized in that, A computer program is stored in the storage medium, wherein the computer program is configured to execute the method according to any one of claims 1-7 when running.

10. An electronic device, comprising a memory and a processor, characterized in that, A computer program is stored in the memory, and the processor is configured to run the computer program to execute the method according to any one of claims 1-7.

Images