A curtain wall node intelligent matching method based on a rule engine and a knowledge graph

Abstract

The application provides a curtain wall node intelligent matching method based on a rule engine and a knowledge graph, relates to the technical field of curtain wall engineering, and first acquires a curtain wall engineering project design requirement document, extracts a curtain wall component topology constraint set and a curtain wall performance index constraint set; then determines an anchor point entity in the curtain wall node knowledge graph according to the curtain wall component topology constraint set, expands a path, combines the curtain wall performance index constraint set, filters attributes to obtain a candidate curtain wall node path set; then detects node type conflicts and interface type omissions on the candidate curtain wall node path set to obtain a compliant curtain wall node path set; finally, interface geometric parameters of the compliant curtain wall node path set are compared, and the path passing the comparison is reserved as a curtain wall node assembly sequence, that is, a matching scheme. The application can efficiently and accurately match curtain wall nodes and improve the design and construction quality of curtain wall engineering.

Description

Technical Field

[0001] This application relates to the field of curtain wall engineering technology, and more specifically, to a method for intelligent matching of curtain wall nodes based on rule engines and knowledge graphs. Background Technology

[0002] Traditional methods for matching curtain wall details rely heavily on manual experience. Designers must sift through a vast amount of data on curtain wall details based on the project's design requirements and their understanding of the components and performance indicators. This approach is not only inefficient but also susceptible to limitations imposed by the designer's individual experience and knowledge, potentially leading to inaccurate matching results and failing to fully meet the complex requirements of curtain wall projects.

[0003] With the development of information technology, although some automated matching methods based on simple rules have emerged, these methods often only consider some constraints and lack a comprehensive consideration of the topological relationships and performance indicators of curtain wall components. This makes it difficult to accurately and comprehensively match curtain wall nodes that meet the actual engineering requirements. Furthermore, existing methods also have shortcomings in handling interface compatibility and geometric parameter matching between curtain wall nodes, failing to effectively guarantee the overall performance and quality of the assembled curtain wall nodes. Summary of the Invention

[0004] In view of this, the purpose of this application is to provide a method for intelligent matching of curtain wall nodes based on rule engine and knowledge graph.

[0005] According to a first aspect of this application, a method for intelligent matching of curtain wall nodes based on a rule engine and a knowledge graph is provided, the method comprising: Obtain the design requirements document for the curtain wall project, and extract the topological constraint set of curtain wall components and the constraint set of curtain wall performance indicators from the design requirements document for the curtain wall project; Based on the topological constraint set of the curtain wall components, anchor point entities are determined in the pre-constructed curtain wall node knowledge graph. Starting from the anchor point entity, path expansion is performed along the assembly relationship edge. During the path expansion process, attribute filtering is performed on the curtain wall node instances along the path based on the curtain wall performance index constraint set to obtain a candidate curtain wall node path set. For each candidate curtain wall node path in the candidate curtain wall node path set, extract the node type label and interface type label of each curtain wall node instance. Call the node mutual exclusion rule to perform conflict detection on the node type label sequence, call the node dependency rule to perform missing detection on the interface type label sequence, and remove the candidate curtain wall node paths with type conflicts or missing interfaces to obtain a compliant curtain wall node path set. For each compliant curtain wall node path in the compliant curtain wall node path set, the interface geometric parameter pairs of adjacent curtain wall node instances are extracted sequentially along the arrangement direction of the curtain wall node instance sequence. The absolute value of the difference in interface geometric parameters is compared with a preset interface tolerance threshold. Compliant curtain wall node paths with out-of-tolerance interface geometric parameters are filtered out, and compliant curtain wall node paths that pass the interface geometric parameter comparison are retained as curtain wall node assembly sequences, which serve as curtain wall node matching schemes that match the design requirements document of the curtain wall project.

[0006] According to a second aspect of this application, a curtain wall node intelligent matching system based on a rule engine and knowledge graph is provided. The curtain wall node intelligent matching system based on a rule engine and knowledge graph includes a machine-readable storage medium and a processor. The machine-readable storage medium stores machine-executable instructions. When the processor executes the machine-executable instructions, the curtain wall node intelligent matching system based on a rule engine and knowledge graph implements the aforementioned curtain wall node intelligent matching method based on a rule engine and knowledge graph.

[0007] Based on any of the above aspects, the technical effect of this application is as follows: First, the topological constraint set and performance index constraint set of curtain wall components are accurately extracted from the curtain wall project design requirements document. Based on the topological constraint set, anchor point entities are determined in a pre-built curtain wall node knowledge graph, and path expansion is performed. Combined with the performance index constraint set, attribute filtering is applied to the curtain wall node instances along the path, quickly identifying candidate curtain wall node paths that meet the basic constraints, significantly improving matching efficiency. By performing node type conflict detection and interface type missing detection on the candidate curtain wall node paths, problematic paths are eliminated, resulting in a compliant curtain wall node path set. This effectively avoids installation problems caused by incompatible node types or missing interfaces, ensuring proper connections between curtain wall nodes. Finally, the interface geometric parameters of the compliant curtain wall node paths are compared, eliminating paths with out-of-tolerance interface geometric parameters and retaining the paths that pass the comparison as the curtain wall node assembly sequence. This ensures the geometric accuracy and overall performance of the assembled curtain wall nodes, improving the design quality and construction efficiency of the curtain wall project. Attached Figure Description

[0008] Figure 1 A flowchart illustrating the intelligent matching method for curtain wall nodes based on rule engines and knowledge graphs provided in this application embodiment is shown. Figure 2 This paper illustrates a schematic diagram of the component structure of the intelligent matching system for curtain wall nodes based on rule engines and knowledge graphs provided in an embodiment of this application. Detailed Implementation

[0009] Figure 1This paper illustrates a flowchart of the intelligent matching method for curtain wall nodes based on rule engines and knowledge graphs provided in an embodiment of this application. The detailed steps include: This embodiment uses the intelligent selection and assembly matching of aluminum profile curtain wall node systems in a building curtain wall project as an application scenario to provide a detailed description of the technical solution of the present invention. In this embodiment, the curtain wall project design requirement document is a structured building information model exported text, including sections describing the spatial layout of curtain wall components and performance index requirements. The pre-built curtain wall node knowledge graph is stored in the form of a graph database. Entity types include curtain wall node types such as vertical frames, horizontal beams, corner nodes, expansion joints, operable sash frames, and glass subframes. Assembly relationship edges include types such as plug-in, lap, screw, and snap-fit ​​connections. The edge weight attribute records the normalized value of the frequency of adoption of the assembly relationship in historical projects. The use of the design requirement document has been authorized by the project owner and the design party. The historical project data referenced in the construction of the knowledge graph has been anonymized with project names and had its geographical coordinates blurred.

[0010] Step S110: Obtain the curtain wall project design requirements document, and extract the topological constraint set of curtain wall components and the constraint set of curtain wall performance indicators from the curtain wall project design requirements document.

[0011] The structured text content of the curtain wall project design requirements document is read through the Building Information Modeling (BIM) data exchange interface. The curtain wall project design requirements document uses chapter numbers and subheadings as structural markers. The document content includes a chapter on the overall description of the curtain wall system, a chapter on the detailed list of curtain wall components, and a chapter on the physical performance requirements of the curtain wall. The document is scanned in its entirety, and the content is loaded into an in-memory string buffer according to chapter markers, with paragraph markers serving as the smallest unit of analysis.

[0012] Step S111: Perform paragraph boundary recognition processing on the curtain wall project design requirement document. Based on the paragraph first-line indentation mark and the blank line mark between paragraphs in the curtain wall project design requirement document, divide the curtain wall project design requirement document into several text unit sequences with independent semantics.

[0013] The entire string of the curtain wall engineering project design requirements document is scanned, using line breaks as line separators to segment the entire text into a line sequence. The line sequence is traversed, and each line is checked for the presence of spaces or tabs at the beginning exceeding a preset indentation threshold. If such a line exists, it is marked as a first-line indented line. Simultaneously, the blank line intervals between adjacent lines are checked. If a blank line containing only line breaks exists between two lines, it is marked as a paragraph break. When a line simultaneously satisfies both a first-line indentation marker and a paragraph break marker between it and the preceding line, a paragraph break boundary point is set before that line. The text content between all paragraph break boundary points is extracted into independent text units, arranged in the original text's chronological order to form a text unit sequence. Each text unit is appended with its starting and ending line indexes from the original text.

[0014] Step S112: Perform word segmentation on each text unit in the text unit sequence to obtain the word unit sequence corresponding to each text unit, perform part-of-speech tagging on the word unit sequence, and assign part-of-speech tags to each word unit.

[0015] For each text unit in the text unit sequence, a dictionary-based maximum matching word segmentation algorithm combined with a custom vocabulary for the curtain wall domain is used for word segmentation. The custom vocabulary for the curtain wall domain is constructed by extracting nouns of curtain wall components and performance indicators from the building curtain wall terminology standard. The word segmentation algorithm starts from the beginning of the text unit string, takes the longest substring from the current pointer position to the end of the string, and matches it with the vocabulary. If a match is successful, it is segmented into a word unit and the pointer is moved. If a match fails, the current character is segmented as a single-character word unit and the pointer is moved, repeating until the end of the string. After segmentation, a word unit sequence is obtained.

[0016] The sequence of word units is input into a conditional random field (CRF)-based part-of-speech tagging (POS) model. The feature template of this CRF model includes the word text and part-of-speech tag of the previous word unit, the word text of the current word unit, the word text of the next word unit, and whether the current word unit exists in the curtain wall component noun sub-vocabulary or the locative noun sub-vocabulary as a binary feature. The output of the CRF model is a sequence of part-of-speech tags corresponding to the sequence of word units. These tags include curtain wall component noun tags, locative noun tags, ordinal number tags, structural verb tags, attribute noun tags, punctuation tags, and other word tags.

[0017] In this embodiment, the specific definitions of various tags in the part-of-speech tagging system are as follows: The curtain wall component noun label refers to a word unit labeled to represent the name of a specific component entity in the field of curtain wall engineering. The judgment basis for a curtain wall component noun is that the word text of the word unit exists in the curtain wall component noun sub-vocabulary of the preset custom vocabulary in the curtain wall field. Exemplary contents of the curtain wall component noun sub-vocabulary include: "vertical frame", "beam", "upright column", "transom", "corner upright column", "expansion joint node", "opening sash", "glass auxiliary frame", "press plate", "buckling cover", "support plate", "adapter", "embedded part", "connecting angle code", "heat insulation strip", "sealing rubber strip", etc. Any word unit whose word text exactly matches any entry in the above sub-vocabulary is assigned a curtain wall component noun label.

[0018] The orientation noun label refers to a word unit labeled to represent a spatial orientation or relative positional relationship. The judgment basis for an orientation noun is that the word text of the word unit exists in the preset orientation noun sub-vocabulary. Exemplary contents of the orientation noun sub-vocabulary include: "upper side", "lower side", "left side", "right side", "front side", "rear side", "inner side", "outer side", "top", "bottom", "end portion", "middle portion", "edge", "corner position", "connection position", "interface position", etc. Any word unit whose word text exactly matches any entry in the above sub-vocabulary is assigned an orientation noun label.

[0019] The ordinal number label refers to a word unit labeled to represent a sequence number or arrangement order. Ordinal numbers include two categories: one is Chinese ordinal expressions, such as "first", "second", "third", "first and foremost", "secondly", "finally", etc.; the other is numeric numbering expressions, such as "1.", "2.", "(1)", "(2)", "①", "②", etc. Any word unit whose word text matches the above ordinal expression patterns is assigned an ordinal number label.

[0020] The structural verb label refers to a verbal word unit labeled to represent an assembly action or connection mode between components. The judgment basis for a structural verb is that the word text of the word unit exists in the preset structural verb sub-vocabulary. Exemplary contents of the structural verb sub-vocabulary include: "insert", "socket joint", "lap joint", "bolted connection", "screw fastening", "snap connection", "welding", "riveting", "adhesive bonding", "press in", "nest", "fasten by buckling", "hanging connection", "slide in", etc. Any word unit whose word text exactly matches any entry in the above sub-vocabulary is assigned a structural verb label.

[0021] Attribute noun tags refer to noun units labeled to represent the physical properties, geometric parameters, or material characteristics of a component. The determination of an attribute noun is based on the existence of its text in a pre-defined attribute noun sub-word list. Examples of attribute noun sub-word lists include: "air tightness," "water tightness," "wind pressure resistance," "thermal performance," "sound insulation," "fire resistance," "in-plane deformation performance," "impact resistance," "section width," "section height," "wall thickness," "length," "span," "material," "surface treatment," "color," "strength grade," and "modulus of elasticity," etc. Any word unit whose text precisely matches any term in the above sub-word lists is assigned an attribute noun tag.

[0022] Punctuation tags refer to word units marked as punctuation marks. Punctuation tags cover both Chinese and English punctuation marks, including periods, commas, semicolons, colons, pause marks, quotation marks, parentheses, dashes, hyphens, etc. Punctuation tags are assigned to any word unit that is a single punctuation character.

[0023] Other word tags refer to word units that do not belong to any of the above tag categories, including common nouns, adjectives, adverbs, classifiers, conjunctions, and auxiliary words. Any word unit that does not meet any of the aforementioned tag assignment criteria will be assigned an "other word tag".

[0024] Step S113: Identify word units with part-of-speech tags of curtain wall component nouns from the word unit sequence, and establish a component node record for each identified curtain wall component noun. The component node record contains the position index of the curtain wall component noun in the text unit and the sequence number of the text unit in which it is located.

[0025] Traverse the sequence of word units and filter out word units whose part-of-speech tags are curtain wall component nouns. For each filtered curtain wall component noun, create a component node record data structure containing a component noun text field, a location index field, and a text unit sequence number field. The value of the location index field is the sequential number of the word unit in the word unit sequence, and the value of the text unit sequence number field is the sequential number of the current text unit in the text unit sequence. Sort all component node records in ascending order of location index to form a component node record list.

[0026] Step S114: Using the component node record of each curtain wall component noun as the anchor point, search forward in the word unit sequence for positional modifier word units with part-of-speech tags of locative nouns or ordinal numbers, and search backward for dominating verb units with part-of-speech tags of structural verbs and attribute modifier word units with part-of-speech tags of attribute nouns.

[0027] For each component node record in the component node record list, using its position index as the anchor point, set up a forward search window and a backward search window. The forward search window covers a preset number of word units before the anchor point. Within this window, the part-of-speech tag of each word unit is checked in order of proximity to the anchor point. When a word unit with the part-of-speech tag of locative noun or ordinal number is encountered, the search stops and the word unit is marked as a positional modifier word unit. At the same time, the number of word units spanned between the positional modifier word unit and the anchor point word unit is recorded as the modification distance value. The backward search window covers a preset number of word units after the anchor point. Within this window, the part-of-speech tags are checked in order of proximity to the anchor point. The first word unit with the part-of-speech tag of structural verb is marked as a dominating verb word unit, and the first word unit with the part-of-speech tag of attribute noun is marked as an attribute modifier word unit.

[0028] Step S115: Combine the searched location modifier units with the curtain wall component nouns to form a curtain wall component location description phrase; combine the searched domineering verb units with the curtain wall component nouns to form a curtain wall component action description phrase; combine the searched attribute modifier units with the curtain wall component nouns to form a curtain wall component attribute description phrase.

[0029] The text of the location modifier unit extracted in step S114 is concatenated with the text of the curtain wall component noun in the order of location modifier first, followed by curtain wall component noun, to form a string, which serves as the location description phrase for the curtain wall component. The text of the governing verb unit extracted in step S114 is concatenated with the text of the curtain wall component noun in the order of governing verb first, followed by curtain wall component noun, to form a string, which serves as the action description phrase for the curtain wall component. The text of the attribute modifier unit extracted in step S114 is concatenated with the text of the curtain wall component noun in the order of attribute modifier first, followed by curtain wall component noun, to form a string, which serves as the attribute description phrase for the curtain wall component. Each phrase is accompanied by the text unit sequence number of the component node record from which it originates.

[0030] Step S116: Based on the spatial orientation meaning of the position modifiers in the description phrases of curtain wall component locations, determine the spatial orientation relationship type between any two curtain wall component nouns, and combine the curtain wall component noun pairs with spatial orientation relationships and their corresponding spatial orientation relationship types to form topological relationship entries.

[0031] Iterate through all curtain wall component location description phrases, extracting the curtain wall component nouns and location modifier units from each phrase. The spatial orientation meaning of the location modifier units is determined by looking up a preset spatial relationship mapping table. This table defines the mapping from location nouns to spatial relationship types, which include enumerated values ​​such as above, below, left, right, inside, outside, top, and bottom. For any two curtain wall component location description phrases belonging to the same text unit, if the spatial orientation meaning of the location modifier unit in one phrase is spatially adjacent or relative to the spatial orientation meaning of the location modifier unit in the other phrase, then a spatial orientation relationship exists between the curtain wall component nouns in these two phrases. Establish a topological relationship entry, whose data structure includes a first curtain wall component noun field, a second curtain wall component noun field, and a spatial orientation relationship type field. The set of all topological relationship entries is called the topological relationship entry set.

[0032] Step S117: Based on the assembly semantics of the governing verb unit in the action description phrase of the curtain wall component, search for the assembly connection type word corresponding to the governing verb unit in the preset assembly verb and assembly type mapping table, and combine the curtain wall component noun pair with the assembly connection type word to form an assembly relationship entry.

[0033] Iterate through all curtain wall component action description phrases, extracting the curtain wall component nouns and governing verb units from each phrase. The pre-defined mapping table between assembly verbs and assembly types is a key-value storage structure, where the key is the governing verb and the value is the assembly connection type word. The values ​​for assembly connection type words include enumerated values ​​such as plug-in, lap-in, screw-in, snap-fit ​​connection, and welding. Use the text of the governing verb unit as the query key to look up the corresponding assembly connection type word in the mapping table. For any two curtain wall component action description phrases belonging to the same text unit and appearing in the same sentence structure, if the curtain wall component noun in one phrase is the action performer and the curtain wall component noun in the other phrase is the action receiver, then an assembly relationship entry is established. The data structure of this assembly relationship entry includes a first curtain wall component noun field, a second curtain wall component noun field, and an assembly connection type word field. The set of all assembly relationship entries is called the assembly relationship entry set.

[0034] Step S118: Match the attribute modifiers in the description phrases of curtain wall components with the preset curtain wall performance index vocabulary word by word, mark the successfully matched attribute modifiers as performance index words, and associate the performance index words with the names of curtain wall components to form curtain wall performance index constraint entries.

[0035] The pre-defined curtain wall performance index glossary contains terms for physical performance indicators of curtain walls as defined in standards, including names and corresponding grade values ​​for indicators such as airtightness, watertightness, wind pressure resistance, in-plane deformation performance, thermal performance, and airborne sound insulation performance. All curtain wall component attribute description phrases are traversed, and the text of the attribute modifier units is extracted. This text is then matched precisely with each entry in the pre-defined curtain wall performance index glossary. If a match is successful, the attribute modifier unit is marked as a performance index term, and its matched performance index type is recorded. A curtain wall performance index constraint entry is created. The data structure of this constraint entry includes a curtain wall component noun field, a performance index type field, and a performance index grade value field. The performance index grade value field is extracted from the numerical or grade description units following the attribute modifier unit. The set of all curtain wall performance index constraint entries is called the curtain wall performance index constraint entry set.

[0036] Step S119: Summarize all topological relationship entries and assembly relationship entries extracted from the text unit sequence to generate a curtain wall component topological constraint set; summarize all curtain wall performance index constraint entries extracted from the text unit sequence to generate a curtain wall performance index constraint set.

[0037] The set of topology relationship entries generated in step S116 and the set of assembly relationship entries generated in step S117 are merged to form the curtain wall component topology constraint set. The data structure of the curtain wall component topology constraint set is a composite object containing two fields: a list of topology relationship entries and a list of assembly relationship entries. The set of curtain wall performance index constraint entries generated in step S118 is used as the curtain wall performance index constraint set, and its data structure is a list of curtain wall performance index constraint entries. The curtain wall component topology constraint set and the curtain wall performance index constraint set are used as inputs for step S120.

[0038] Step S120: Based on the topological constraint set of the curtain wall components, determine the anchor point entity in the pre-constructed curtain wall node knowledge graph. Starting from the anchor point entity, perform path expansion along the assembly relationship edge. During the path expansion process, simultaneously filter the attributes of the curtain wall node instances along the path based on the curtain wall performance index constraint set to obtain the candidate curtain wall node path set.

[0039] The pre-built curtain wall node knowledge graph is stored using an attribute graph model. Entity node types include vertical frame nodes, horizontal beam nodes, corner nodes, expansion joint nodes, operable sash frame nodes, and glass subframe nodes. Entity attributes include entity type labels, interface type labels, interface geometric parameter sets, and performance indicator attribute sets. Relationship types include plug-in edges, lap-in edges, screw-in edges, and snap-fit ​​connections. The direction of assembly relationship edges is defined by the assembly direction mapping table corresponding to the assembly connection type term. The edge weight attribute records the normalized value of the adoption frequency of this assembly relationship in historical engineering projects.

[0040] Step S131: Extract all curtain wall component names appearing in the topology relationship entries and assembly relationship entries from the curtain wall component topology constraint set. Arrange the extracted curtain wall component names in the order of their first appearance in the curtain wall engineering project design requirement document to form a curtain wall component name sequence. Take the curtain wall component name that appears first in the curtain wall component name sequence as the anchor point component name. Search for all curtain wall node instances whose entity type tags match the anchor point component names in the pre-built curtain wall node knowledge graph. Mark the retrieved curtain wall node instances as the anchor point entity set.

[0041] Traverse the list of topological relationship entries and the list of assembly relationship entries in the topological constraint set of curtain wall components, extract the values ​​of the first curtain wall component noun field and the second curtain wall component noun field from each entry, and merge them into a deduplication set of curtain wall component nouns. For each curtain wall component noun in this deduplication set, find the text unit number and position index of the first occurrence of the curtain wall component noun from the text unit sequence generated in step S111, and sort them in ascending order according to the rule of text unit number first, followed by position index, to obtain the curtain wall component noun sequence. Take the first element of the curtain wall component noun sequence as the anchor component noun.

[0042] Execute a graph query in the pre-built curtain wall node knowledge graph, where the query condition is the text of the anchor point component noun whose entity type label attribute value equals the query condition. The query returns all curtain wall node instances that meet the condition, and the node identifiers of these curtain wall node instances are aggregated into an anchor point entity set.

[0043] Step S132: For each anchor entity in the anchor entity set, extract the entity attribute set of the anchor entity in the pre-built curtain wall node knowledge graph. Compare the entity attribute set with the curtain wall performance index constraint entries associated with the anchor component nouns in the curtain wall performance index constraint set. Remove anchor entities whose entity attribute sets do not meet the curtain wall performance index constraint entries to obtain a filtered anchor entity set. For each anchor entity in the filtered anchor entity set, extend outward along the assembly relationship edge in the pre-built curtain wall node knowledge graph starting from the anchor entity. Add the adjacent curtain wall node instances pointed to by the assembly relationship edge to the current path. The current path is recorded as the sequence of curtain wall node instances from the anchor entity to the adjacent curtain wall node instances.

[0044] From the curtain wall performance index constraint set, all entries whose curtain wall component noun field value equals the anchor point component noun are selected. For each anchor point entity in the anchor point entity set, its entity attribute set is extracted; the entity attribute set is a key-value pair mapping structure. For each selected curtain wall performance index constraint entry, it is checked whether the anchor point entity's entity attribute set has a corresponding performance index type key and whether its attribute value meets the performance index level requirement. The comparison rule for attribute values ​​is determined based on the numerical direction of the performance index type: if a larger performance index value is better, the entity attribute value must be greater than or equal to the performance index level value in the constraint entry; if a smaller value is better, the entity attribute value must be less than or equal to the performance index level value in the constraint entry. Anchor point entities that do not meet the requirements are removed from the anchor point entity set, resulting in a filtered anchor point entity set.

[0045] For each anchor entity in the filtered set of anchor entities, query the pre-built curtain wall node knowledge graph for all assembly relationship edges with that anchor entity as the source node and the relationship direction as the outgoing direction. Obtain the target node of each assembly relationship edge as an adjacent curtain wall node instance. For each assembly relationship edge, create a current path record. This current path is a list structure, where the first element is the node identifier of the anchor entity, and the last element is the node identifier of the adjacent curtain wall node instance. One assembly relationship edge corresponds to one current path record.

[0046] Step S133: Extract the entity type label of the curtain wall node instance at the end of the current path, and match the entity type label with the next curtain wall component name after the anchor component name in the curtain wall component name sequence. If the match is successful, continue to expand outward along the assembly relationship edge. If the match fails, delete the curtain wall node instance at the end of the current path from the pre-built curtain wall node knowledge graph and backtrack to the previous curtain wall node instance to try other assembly relationship edges.

[0047] For each current path record, find the next curtain wall component name at the index position corresponding to the number of curtain wall node instances already included in the current path from the curtain wall component name sequence. Take the curtain wall node instance at the end of the current path and query its entity type tag attribute value in the pre-built curtain wall node knowledge graph. Perform string matching between the entity type tag and the next curtain wall component name. If the match is successful, continue to expand outward along the assembly relationship edge starting from the curtain wall node instance at the end of the current path according to the method in step S132, and append the new adjacent curtain wall node instance to the end of the current path. If the match fails, the node at the end of the current path does not satisfy the topological constraints, and the path is backtracked to the previous curtain wall node instance, and the next assembly relationship edge is selected from the untried assembly relationship edges to continue expansion. If all assembly relationship edges of the curtain wall node instance at the end of the current path have been tried and all have failed, continue backtracking upward. If backtracking reaches the anchor entity and all assembly relationship edges of the anchor entity have been tried, the path expansion of the anchor entity ends.

[0048] Step S134: For each newly added curtain wall node instance after path expansion, extract the entity attribute set of the curtain wall node instance, compare the entity attribute set with the curtain wall performance index constraint entries associated with the corresponding curtain wall component names in the curtain wall performance index constraint set, and remove curtain wall node instances whose entity attribute sets do not meet the curtain wall performance index constraint entries.

[0049] After adding a new adjacent curtain wall node instance to the current path at each path expansion step, attribute filtering is performed immediately. Constraint entries whose curtain wall component noun fields match the curtain wall component nouns in the current step are extracted from the curtain wall performance index constraint set. The entity attribute set of the newly added curtain wall node instance is checked against the attribute comparison rules of step S132 to see if it satisfies all constraint entries. If not, the newly added curtain wall node instance is removed from the current path, and the process backtracks to the previous curtain wall node instance to try other assembly relationship edges.

[0050] Step S135: When the path extends to the last curtain wall component name in the sequence of curtain wall component names and the entity type label of the curtain wall node instance at the end of the path matches the curtain wall component name, mark the current path as a complete candidate curtain wall node path. Repeat the path extension and attribute filtering operations until all possible assembly relationship edges of all anchor entities in the filtered anchor entity set have been traversed, resulting in multiple candidate curtain wall node paths. Summarize all candidate curtain wall node paths to form a candidate curtain wall node path set.

[0051] During path expansion, the number of curtain wall node instances in the current path is checked to see if it equals the total number of elements in the curtain wall component noun sequence. If they are equal and the entity type label of the curtain wall node instance at the end of the path matches the last element of the curtain wall component noun sequence, then the current path constitutes a complete path, is marked as a candidate curtain wall node path, and stored in the candidate path collection list. After the current path is processed, backtracking is performed to continue exploring other possible combinations of assembly relationship edges. When all assembly relationship edges of all anchor entities have been explored using depth-first recursion, all candidate curtain wall node paths in the candidate path collection list constitute the candidate curtain wall node path set.

[0052] Step S140: For each candidate curtain wall node path in the candidate curtain wall node path set, extract the node type label and interface type label of each curtain wall node instance. Call the node mutual exclusion rule to perform conflict detection on the node type label sequence, call the node dependency rule to perform missing detection on the interface type label sequence, and remove the candidate curtain wall node paths with type conflicts or missing interfaces to obtain the compliant curtain wall node path set.

[0053] Step S141: Traverse each candidate curtain wall node path in the candidate curtain wall node path set, obtain the sequence of curtain wall node instances arranged in expansion order in the current candidate curtain wall node path, and for each curtain wall node instance in the sequence of curtain wall node instances, read the node type label and interface type label of the curtain wall node instance from the entity attribute set of the pre-built curtain wall node knowledge graph. The node type label is used to identify the functional category of the curtain wall node, and the interface type label is used to identify the geometric shape category of the curtain wall node connection interface.

[0054] Candidate curtain wall node paths are read one by one from the candidate curtain wall node path set. Each candidate curtain wall node path is a list of node identifiers, arranged in the order of path expansion. For each node identifier in the node identifier list, its entity attribute set is queried in the pre-built curtain wall node knowledge graph through the node identifier index. The node type label attribute value and interface type label attribute value are read from the entity attribute set. The node type label values ​​include vertical frame type, horizontal beam type, corner type, telescopic type, operable sash frame type, and glass subframe type. The interface type label values ​​include square plug type, round plug type, overlapping flat plate type, screw ear plate type, and snap-on groove type. A node description record is generated for each curtain wall node instance, containing three fields: node identifier, node type label, and interface type label.

[0055] Step S142: Arrange the node type tags of all curtain wall node instances in the curtain wall node instance sequence in order to form a node type tag sequence. Match the node type tag sequence with each node mutual exclusion rule in the preset node mutual exclusion rule library. Each node mutual exclusion rule in the preset node mutual exclusion rule library defines two mutually exclusive node type tag pairs. When the two node type tags defined by the mutual exclusion rule appear simultaneously in the node type tag sequence, it is determined that there is a type conflict in the current candidate curtain wall node path.

[0056] The node type tags in the node description records of each curtain wall node instance generated in step S141 are extracted and arranged into a node type tag sequence according to the path order. The preset node mutual exclusion rule base is a list of rules, where each rule contains a first mutual exclusion label field and a second mutual exclusion label field. The rule semantics are that the node types identified by the first and second mutual exclusion labels cannot appear in the same path. The node type tag sequence is traversed, and all duplicate node type tags are removed to form a node type tag set. For each rule in the preset node mutual exclusion rule base, it is checked whether the first mutual exclusion label of the rule belongs to the node type tag set and whether the second mutual exclusion label also belongs to the node type tag set. If both belong to the set, it is determined that the current candidate curtain wall node path has a type conflict, and the path is marked as a type conflict path.

[0057] Step S143: Combine the interface type tags of adjacent curtain wall node instances in the curtain wall node instance sequence into interface type tag pairs to generate an interface type tag pair sequence corresponding to the curtain wall node instance sequence.

[0058] For each pair of adjacent node description records in the node description record sequence, the interface type label of the preceding node description record is paired with the interface type label of the following node description record to form an interface type label pair. All interface type label pairs are arranged sequentially to form an interface type label pair sequence. The data structure of each interface type label pair includes a preceding interface type label field and a following interface type label field.

[0059] Step S144: Match the interface type tag pair sequence with each node dependency rule in the preset node dependency rule library. Each node dependency rule in the preset node dependency rule library defines the dependency relationship between the preceding interface type tag and the following interface type tag. When the preceding interface type tag in the interface type tag pair is required to follow a specific following interface type tag in the node dependency rule, but the actual following interface type tag does not match, it is determined that there is an interface missing in the current candidate curtain wall node path.

[0060] The preset node dependency rule base is a list of rules. Each rule contains a preceding interface type label field, a dependency relationship type field, and a desired following interface type label field. The dependency relationship type field can be either a required match or a recommended match. The system iterates through each interface type label pair in the sequence, using the preceding interface type label and the actual following interface type label of each candidate adjacent node instance as query conditions to search for a matching rule in the preset node dependency rule base. If a rule with a required dependency relationship type is found, and the actual following interface type label is not equal to the desired following interface type label value of the rule, then the current candidate curtain wall node path is determined to have a missing interface, and the path is marked as a missing interface path. If the dependency relationship type is a recommended match, no missing interface determination is triggered.

[0061] Step S145: Remove candidate curtain wall node paths that are determined to have type conflicts and candidate curtain wall node paths that are determined to have missing interfaces from the candidate curtain wall node path set. Mark the candidate curtain wall node paths that have not been removed as compliant curtain wall node paths. Summarize all compliant curtain wall node paths to form a compliant curtain wall node path set.

[0062] Iterate through each candidate curtain wall node path in the candidate curtain wall node path set. If the path is not marked as a type conflict path or an interface missing path, mark it as a compliant curtain wall node path and add it to the compliant curtain wall node path set. Paths marked as type conflict or interface missing are discarded directly.

[0063] Step S150: For each compliant curtain wall node path in the compliant curtain wall node path set, extract the interface geometric parameter pairs of adjacent curtain wall node instances sequentially along the arrangement direction of the curtain wall node instance sequence. Compare the absolute value of the interface geometric parameter difference with the preset interface tolerance threshold, filter out compliant curtain wall node paths with out-of-tolerance interface geometric parameters, and retain the compliant curtain wall node paths that pass the interface geometric parameter comparison as the curtain wall node assembly sequence, which serves as the curtain wall node matching scheme that matches the curtain wall engineering project design requirement document.

[0064] Step S151: Traverse each compliant curtain wall node path in the compliant curtain wall node path set and obtain the sequence of curtain wall node instances arranged in the expansion order in the current compliant curtain wall node path.

[0065] Read each compliant curtain wall node path from the compliant curtain wall node path set. Each compliant curtain wall node path is a list of node identifiers, and the order of the list is consistent with the generation order of the path expansion in step S135.

[0066] Step S152: Extract the first pair of adjacent curtain wall node instances from the curtain wall node instance sequence. The pair of adjacent curtain wall node instances consists of a front curtain wall node instance and a rear curtain wall node instance that are arranged in adjacent positions.

[0067] Starting with the first and second elements of the node identifier list, adjacent node identifiers are paired sequentially to form adjacent curtain wall node instance pairs. Each adjacent curtain wall node instance pair contains two fields: a preceding node identifier and a following node identifier.

[0068] Step S153: Read the interface geometric parameter set of the front curtain wall node instance and the interface geometric parameter set of the rear curtain wall node instance from the pre-built curtain wall node knowledge graph.

[0069] For each pair of adjacent curtain wall node instances, the entity attribute set of the corresponding curtain wall node instance is queried in the pre-built curtain wall node knowledge graph based on the preceding node identifier and the following node identifier. The interface geometric parameter set attribute is extracted from the entity attribute set. The interface geometric parameter set is a mapping structure containing multiple geometric parameter key-value pairs. The geometric parameter keys include the interface cross-section width and the interface cross-section height.

[0070] Step S154: Extract the geometric parameter field of the output interface corresponding to the assembly relationship edge from the interface geometric parameter set of the front curtain wall node instance. The geometric parameter field includes the interface cross-section width parameter and the interface cross-section height parameter.

[0071] From the interface geometric parameter set of the front curtain wall node instance, the identifier key of the output interface is determined according to the assembly connection type word of the assembly relationship edge connecting the two curtain wall node instances. This identifier key is used as a prefix to concatenate the interface cross-section width key name and the interface cross-section height key name, and the corresponding values ​​are read from the interface geometric parameter set. The interface cross-section width parameter is in millimeters, and the interface cross-section height parameter is in millimeters.

[0072] Step S155: Extract the geometric parameter field of the input interface corresponding to the assembly relationship edge from the interface geometric parameter set of the rear curtain wall node instance. The geometric parameter field of the input interface includes the interface cross-section width parameter and the interface cross-section height parameter.

[0073] The same method as step S154 is used, but the identifier key of the input interface is used as a prefix to read the corresponding interface section width parameter value and interface section height parameter value from the interface geometric parameter set of the rear curtain wall node instance.

[0074] Step S156: Calculate the absolute value of the difference between the interface cross-sectional width parameter of the output interface and the interface cross-sectional width parameter of the input interface, and calculate the absolute value of the difference between the interface cross-sectional height parameter of the output interface and the interface cross-sectional height parameter of the input interface.

[0075] Let the width parameter of the pre-amplifier output interface be Wout, and the width parameter of the post-amplifier input interface be Win. The absolute value of the width difference ΔW = |Wout - Win|. Let the height parameter of the pre-amplifier output interface be Hout, and the height parameter of the post-amplifier input interface be Hin. The absolute value of the height difference ΔH = |Hout - Hin|.

[0076] Step S157: Compare the absolute value of the difference between the interface cross-section width parameters with the width tolerance value in the preset interface tolerance threshold, and compare the absolute value of the difference between the interface cross-section height parameters with the height tolerance value in the preset interface tolerance threshold.

[0077] The preset interface tolerance thresholds include a width tolerance value TolW and a height tolerance value TolH, both measured in millimeters. These values ​​are determined by the curtain wall system type and assembly connection type. The tolerance table is pre-stored as a lookup table with the curtain wall system type and assembly connection type as the combined index key. ΔW is compared to TolW, and ΔH is compared to TolH.

[0078] Step S158: When the absolute value of the difference in the interface cross-section width parameter exceeds the width tolerance value or the absolute value of the difference in the interface cross-section height parameter exceeds the height tolerance value, it is determined that the interface geometric parameters of the current adjacent curtain wall node instance pair are out of tolerance, and the compliant curtain wall node path containing the adjacent curtain wall node instance pair is removed from the compliant curtain wall node path set; when the absolute value of the difference in the interface cross-section width parameter does not exceed the width tolerance value and the absolute value of the difference in the interface cross-section height parameter does not exceed the height tolerance value, the next set of adjacent curtain wall node instance pairs is extracted and the interface geometric parameter comparison operation is repeated until all adjacent curtain wall node instance pairs in the current compliant curtain wall node path pass the interface geometric parameter comparison; the compliant curtain wall node path in the current compliant curtain wall node path where all adjacent curtain wall node instance pairs pass the interface geometric parameter comparison is marked as a curtain wall node assembly sequence, and multiple compliant curtain wall node paths can generate multiple curtain wall node assembly sequences.

[0079] If ΔW > TolW or ΔH > TolH, the interface geometric parameters at the current adjacent curtain wall node instance pair are determined to be out of tolerance. The entire compliant curtain wall node path is deemed unqualified and deleted from the compliant curtain wall node path set. The comparison of subsequent adjacent curtain wall node instance pairs for this path is stopped. If ΔW ≤ TolW and ΔH ≤ TolH, the adjacent curtain wall node instance pair passes the comparison, and the next pair of adjacent curtain wall node instance pairs is selected to continue executing steps S152 to S158. When all adjacent curtain wall node instance pairs in the current compliant curtain wall node path have been traversed and all have passed the comparison, the compliant curtain wall node path is marked as a curtain wall node assembly sequence. The curtain wall node assembly sequences generated by all compliant curtain wall node paths that meet the conditions constitute the output set of the curtain wall node matching scheme.

[0080] Step S210: Before determining the anchor point entity in the pre-built curtain wall node knowledge graph based on the curtain wall component topology constraint set, perform topology completeness detection processing on each topology relation entry in the curtain wall component topology constraint set to identify whether there are isolated curtain wall component names in the curtain wall component topology constraint set. Isolated curtain wall component names are curtain wall component names that do not appear in any topology relation entry or assembly relation entry in the curtain wall component topology constraint set.

[0081] Iterate through the list of topological relationship entries and the list of assembly relationship entries in the topological constraint set of curtain wall components generated in step S119, extract the values ​​of the first curtain wall component noun field and the second curtain wall component noun field of all entries, and merge them into an associated curtain wall component noun set. Iterate through each curtain wall component noun in the curtain wall component noun sequence and check whether it exists in the associated curtain wall component noun set. If a curtain wall component noun does not exist in the associated curtain wall component noun set, mark it as an isolated curtain wall component noun, and record the word text of the isolated curtain wall component noun and its position index in the curtain wall component noun sequence.

[0082] Step S220: When an isolated curtain wall component name is detected, the text paragraph block containing the isolated curtain wall component name is reread from the curtain wall engineering project design requirements document. The text paragraph block is processed to resolve the reference, and the referent words in the text paragraph block pointing to the isolated curtain wall component name are identified. Based on the referent words, the curtain wall component name being referred to is traced back. The isolated curtain wall component name and the curtain wall component name being referred to are combined to form a complete topological relationship entry and added to the curtain wall component topological constraint set.

[0083] Based on the text unit sequence number recorded in step S113 for isolated curtain wall component nouns, the string content of the corresponding text unit is read from the text unit sequence segmented in step S111. Simultaneously, a preset number of text units preceding this text unit are read as text paragraph blocks. The text paragraph blocks undergo referential resolution processing using a Hobbes-based pronoun resolution algorithm: each noun phrase and pronoun in the text paragraph block is scanned. When a referential word is encountered, the noun phrase that is identical to the referential word in gender, number, and person and is the closest in distance is searched along the forward path in the syntactic parsing tree as the referred word. If the text of the referred word appears in the curtain wall component noun sequence, a topological relation entry is established. The first curtain wall component noun field of this topological relation entry is the referred word, the second curtain wall component noun field is the isolated curtain wall component noun, and the spatial orientation relation type field is filled with the context association type. The completed topological relation entry is appended to the topological relation entry list of the curtain wall component topological constraint set.

[0084] Step S230: Perform assembly direction inference processing on each assembly relationship entry in the topology constraint set of the curtain wall components, extract assembly connection type words from the assembly relationship entries, map the assembly connection type words to assembly direction identifiers according to the preset assembly direction mapping table, the preset assembly direction mapping table defines the correspondence between assembly connection type words and insertion direction, socket direction, and lap direction, and attach the assembly direction identifiers to the assembly relationship entries.

[0085] Iterate through each assembly relationship entry in the assembly relationship entry list of the curtain wall component topology constraint set, and read the value of its assembly connection type term field. The default assembly direction mapping table is a key-value pair mapping structure, where the key is the assembly connection type term and the value is the assembly direction identifier. The enumerated values ​​of the assembly direction identifier include "first pointing to second direction" and "second pointing to first direction." For example, the plug type term maps "first pointing to second direction," the socket type term maps "second pointing to first direction," and the lap type term defaults to "top pointing to bottom direction" based on the curtain wall's gravity direction. Append the assembly direction identifier obtained from the table lookup as a new field to the data structure of the assembly relationship entry.

[0086] Step S240: Perform topological sorting on the assembly relationship entries and topological relationship entries with attached assembly direction identifiers. Take the first appearance of the curtain wall component name in the curtain wall project design requirements document as the starting node, determine the order of adjacent curtain wall component names based on the spatial orientation relation words in the topological relationship entries, determine the subordinate order of curtain wall component name pairs based on the assembly direction identifiers in the assembly relationship entries, and generate a topological sequence of curtain wall components with direction markers.

[0087] Construct a directed graph data structure, where each node represents a curtain wall component noun in the sequence of curtain wall component nouns. Traverse the list of topological relationship entries. For each topological relationship entry, determine the edge direction based on the spatial orientation relationship type: for the "upper" type, the edge points from the lower node to the upper node; for the "left" type, the edge points from the right node to the left node; and for the "bottom" type, the edge points from the top node to the bottom node. Traverse the list of assembly relationship entries. For each assembly relationship entry, determine the edge direction based on the assembly direction identifier: for the "first to second direction" type, the edge points from the first curtain wall component noun node to the second curtain wall component noun node, and vice versa for the "second to first direction" type. Perform topological sorting on the directed graph, starting with the curtain wall component noun node with an in-degree of zero, and output the node sequence sequentially to generate a curtain wall component topological sequence with direction labels. Each element in this topological sequence contains a curtain wall component noun and its corresponding direction label.

[0088] Step S250: Perform consistency alignment processing between the topology sequence of curtain wall components with directional markers and the assembly relationship edge direction in the pre-built curtain wall node knowledge graph. When the direction of adjacent curtain wall component names in the topology sequence of curtain wall components with directional markers is opposite to the direction of the assembly relationship edge between the corresponding curtain wall node instances in the pre-built curtain wall node knowledge graph, reverse the corresponding assembly relationship edge in the pre-built curtain wall node knowledge graph to obtain the direction-aligned curtain wall node knowledge graph. The anchor point entity is determined in the direction-aligned curtain wall node knowledge graph, and the path extension is performed along the direction-aligned assembly relationship edge.

[0089] For each pair of adjacent curtain wall component names in the topology sequence with direction markings, obtain their index position in the curtain wall component name sequence. In the pre-built curtain wall node knowledge graph, query whether there is an assembly relationship edge between the curtain wall node instances under the entity type label corresponding to these two curtain wall component names. If an assembly relationship edge exists, check whether the direction of the assembly relationship edge is consistent with the direction specified in the topology sequence of curtain wall components with direction markings. The direction comparison rule is: if curtain wall component name A points to curtain wall component name B in the sequence, then the corresponding assembly relationship edge should have the node instance corresponding to A as the source node and the node instance corresponding to B as the target node. If the directions are opposite, perform the reverse operation of the assembly relationship edge and update the edge direction. After all edge directions are aligned, a direction-aligned curtain wall node knowledge graph is obtained. This direction-aligned curtain wall node knowledge graph is used for anchor point entity determination and path expansion in step S120.

[0090] Step S310: After obtaining the candidate curtain wall node path set, perform path coherence scoring on each candidate curtain wall node path in the candidate curtain wall node path set, and extract the association strength value of the assembly relationship edge of adjacent curtain wall node instances in the pre-built curtain wall node knowledge graph from the candidate curtain wall node path. The association strength value is the edge weight attribute of the assembly relationship edge in the pre-built curtain wall node knowledge graph.

[0091] Iterate through each candidate curtain wall node path in the candidate curtain wall node path set generated in step S135. For each candidate curtain wall node path, sequentially extract adjacent curtain wall node instance pairs. For each pair of adjacent curtain wall node instances, query the assembly relationship edge connecting the two curtain wall node instances in the pre-built curtain wall node knowledge graph, and read the edge weight attribute value of the assembly relationship edge. The edge weight attribute value represents the normalized value of the adoption frequency of the assembly relationship in historical projects, and the value is between zero and one.

[0092] Step S320: Accumulate the association strength values ​​of the assembly relationship edges corresponding to all adjacent curtain wall node instances in the candidate curtain wall node path to obtain the path coherence accumulation value.

[0093] For each pair of adjacent curtain wall node instances in the current candidate curtain wall node path, obtain their association strength value, and sum all association strength values ​​to obtain the path coherence cumulative value Scoh=sum(Wi), where i ranges from 1 to N-1, N is the total number of node instances in the candidate curtain wall node path, and Wi is the association strength value of the assembly relationship edge corresponding to the i-th pair of adjacent node instances.

[0094] Step S330: For each candidate curtain wall node path, extract the node level depth value of each curtain wall node instance in the pre-built curtain wall node knowledge graph from the candidate curtain wall node path. The node level depth value is the number of path hops from the curtain wall node instance to the root node of the main curtain wall structure. Sum the node level depth values ​​of each curtain wall node instance to obtain the cumulative path level depth value.

[0095] In the pre-built curtain wall node knowledge graph, each curtain wall node instance stores a node level depth value attribute, which represents the minimum number of path hops required to reach the node instance from the root node of the curtain wall main structure along the assembly relationship edge. For each curtain wall node instance in the current candidate curtain wall node path, its node level depth value is read, and all node level depth values ​​are summed to obtain the path level depth accumulation value Sdepth=sum(Dj), where j ranges from 1 to N, and Dj is the node level depth value of the j-th node instance.

[0096] Step S340: Sort all candidate curtain wall node paths in the candidate curtain wall node path set independently based on the cumulative value of path continuity and the cumulative value of path level depth, respectively, to obtain the ranking of each candidate curtain wall node path in the path continuity dimension and the ranking in the path level depth dimension.

[0097] All candidate curtain wall node paths in the candidate curtain wall node path set are sorted in descending order of their cumulative path coherence value (Scoh), with the path with the highest Scoh ranking 1, and so on, to obtain the coherence ranking Rcoh. All candidate curtain wall node paths in the candidate curtain wall node path set are sorted in ascending order of their cumulative path hierarchy depth value (Sdepth), with the path with the lowest Sdepth ranking 1, and so on, to obtain the hierarchy depth ranking Rdepth.

[0098] Step S350: Based on the preset weights, perform a weighted sum of the rankings of each candidate curtain wall node path in the path continuity dimension and the path level depth dimension to obtain the comprehensive path ranking value of each candidate curtain wall node path.

[0099] The preset weighting coefficients αcoh and αdepth satisfy αcoh + αdepth = 1. The overall path ranking value Rtotal = αcoh × Rcoh + αdepth × Rdepth. The values ​​of αcoh and αdepth can be adjusted according to the project's preference for path coherence and node simplicity.

[0100] Step S360: Sort the candidate curtain wall node paths in the candidate curtain wall node path set in ascending order of the comprehensive path ranking value, and input the sorted candidate curtain wall node path set into the processing step of conflict detection of the curtain wall node instance sequence contained in each candidate curtain wall node path in the candidate curtain wall node path set.

[0101] The paths in the candidate curtain wall node path set are sorted in ascending order based on their overall path ranking value Rtotal, with the path having the lowest Rtotal ranked first. This sorted set of candidate curtain wall node paths is then used as input for the conflict detection process in step S140, ensuring that conflict detection prioritizes paths with higher overall rankings.

[0102] Step S410: After obtaining the candidate curtain wall node path set, perform node redundancy detection processing on each candidate curtain wall node path in the candidate curtain wall node path set, and identify duplicate curtain wall node instance pairs with the same entity type label and the same node level depth value in the pre-built curtain wall node knowledge graph from the curtain wall node instance sequence of the candidate curtain wall node path.

[0103] Iterate through each candidate curtain wall node path in the candidate curtain wall node path set. For each path's sequence of curtain wall node instances, extract the entity type label and node level depth value for each curtain wall node instance. Group the curtain wall node instance sequences by entity type label. For curtain wall node instances within the same entity type label group, check if there are two curtain wall node instances with the same node level depth value. If so, mark them as a duplicate curtain wall node instance pair.

[0104] Step S420: When a pair of duplicate curtain wall node instances is identified, extract the entity type labels of the adjacent curtain wall node instances in the candidate curtain wall node path of each of the two curtain wall node instances in the pair. If the entity type labels of the adjacent curtain wall node instances of the two curtain wall node instances are the same, then mark the two curtain wall node instances as a pair of redundant nodes that can be merged.

[0105] For each pair of duplicate curtain wall node instances, locate their predecessor and successor adjacent curtain wall node instances in the candidate curtain wall node path. Extract the entity type labels of the predecessor and successor adjacent curtain wall node instances. If the predecessor and successor adjacent entity type labels of two curtain wall node instances are the same, then the two curtain wall node instances are determined to have the same connection method and are marked as a mergeable redundant node pair.

[0106] Step S430: Extract the set of interface geometric parameters for each curtain wall node instance in the mergeable redundant node pair, compare the parameter values ​​of the same interface geometric parameter fields in the set of interface geometric parameters, remove the curtain wall node instances whose parameter values ​​of each interface geometric parameter field in the set of interface geometric parameters are inferior to those of the other curtain wall node instance, and retain the curtain wall node instance with the best set of interface geometric parameters.

[0107] The interface geometric parameter set of two curtain wall node instances in a mergeable redundant node pair is read from the pre-built curtain wall node knowledge graph. For each geometric parameter field in the interface geometric parameter set, the parameter values ​​of the two curtain wall node instances are compared. The rules for judging the superiority of parameters are determined according to the parameter type: for interface cross-section width and height, the smaller the deviation from the design target value, the better; for interface wall thickness and load-bearing strength, the larger the value, the better. After comparing each field, if curtain wall node instance A is not better than curtain wall node instance B in all parameter fields, then A is eliminated and B is retained; otherwise, B is eliminated and A is retained. If they have advantages and disadvantages, a weighted comprehensive score is calculated, and the curtain wall node instance with the higher comprehensive score is retained.

[0108] Step S440: Reconnect the retained curtain wall node instances to the assembly relationship edges that were originally connected to the removed curtain wall node instances in the candidate curtain wall node path, generate candidate curtain wall node paths after removing redundancy, replace the original candidate curtain wall node paths in the candidate curtain wall node path set with the candidate curtain wall node path set after removing redundancy, and input the replacement candidate curtain wall node path set into the conflict detection processing step of the curtain wall node instance sequence contained in each candidate curtain wall node path in the candidate curtain wall node path set.

[0109] In the candidate curtain wall node path, the node identifiers of the rejected curtain wall node instances are replaced with the node identifiers of the retained curtain wall node instances, and the assembly relationship edges of adjacent curtain wall node instances are updated. After the replacement, a candidate curtain wall node path with redundancy removed is obtained. This path is written into the candidate curtain wall node path set to overwrite the original path. After all mergeable redundant node pairs have been processed, the updated candidate curtain wall node path set is used as the input for step S140.

[0110] Step S510: After outputting the curtain wall node assembly sequence, obtain the set of building main structure interface parameters corresponding to the curtain wall node instance in the current curtain wall project. The set of building main structure interface parameters includes the embedded part position coordinate parameters and the reserved interface size parameters of the main structure.

[0111] Extract the building structure interface parameters from the structural design section of the curtain wall project design requirements document. The embedded part location coordinate parameters are a three-dimensional coordinate array, containing the X-axis, Y-axis, and Z-axis elevation coordinates for each embedded part. The main structure reserved interface size parameters include the reserved slot width, reserved slot depth, and reserved slot length, measured in millimeters.

[0112] Step S520: Extract the front curtain wall node instance that is at the beginning and the end curtain wall node instance that is at the end from the curtain wall node assembly sequence. Read the main connection interface geometric parameters of the front curtain wall node instance and the boundary closing interface geometric parameters of the end curtain wall node instance from the pre-built curtain wall node knowledge graph.

[0113] The curtain wall node assembly sequence is an ordered list. The first element of the list is the front-end curtain wall node instance, and the last element is the end-end curtain wall node instance. The entity attribute set of the front-end curtain wall node instance is queried from the pre-built curtain wall node knowledge graph to extract the geometric parameters of the main connection interface, which includes the interface width, interface height, and interface depth. Similarly, the entity attribute set of the end curtain wall node instance is queried to extract the geometric parameters of the boundary termination interface, which includes the termination width, termination height, and termination angle.

[0114] Step S530: Perform size matching and comparison processing on the geometric parameters of the main connection interface of the front-end curtain wall node instance and the size parameters of the reserved interface of the main structure in the set of interface parameters of the main structure, and calculate the difference between the size parameters of each geometric dimension of the main connection interface and the size parameters of the corresponding geometric dimension of the reserved interface of the main structure.

[0115] Let the width, height, and depth of the main connection interface of the front curtain wall node instance be Wf, Hf, and Df, respectively, and the width, height, and depth of the reserved interface in the main structure be Ws, Hs, and Ds, respectively. The dimensional differences are ΔWfront = |Wf - Ws|, ΔHfront = |Hf - Hs|, and ΔDfront = |Df - Ds|.

[0116] Step S540: When the difference between the geometric parameters of the main connection interface and the size parameters of the reserved interface of the main structure exceeds the preset tolerance range of the main interface, retrieve the curtain wall node instance with the interface conversion function type from the pre-built curtain wall node knowledge graph as the candidate instance of the conversion joint, insert the candidate instance of the conversion joint between the front curtain wall node instance and the main structure of the building, and generate the curtain wall node assembly sequence with conversion joint.

[0117] The preset main interface tolerance range includes thresholds for width tolerance, height tolerance, and depth tolerance. If ΔWfront is greater than the width tolerance, or ΔHfront is greater than the height tolerance, or ΔDfront is greater than the depth tolerance, a conversion joint is required. The pre-built curtain wall node knowledge graph is searched for curtain wall node instances whose entity type label is "interface conversion function type," whose input interface geometry parameters match the reserved interface size parameters of the main structure, and whose output interface geometry parameters match the main connection interface geometry parameters of the front-end curtain wall node instance. The node identifier of the successfully matched conversion joint candidate instance is inserted at the very beginning of the curtain wall node assembly sequence, generating a curtain wall node assembly sequence with conversion joints.

[0118] Step S550: Match the boundary closing interface geometric parameters of the end curtain wall node instance with the curtain wall boundary closing constraints extracted from the curtain wall engineering project design requirements document. When the boundary closing interface geometric parameters of the end curtain wall node instance do not meet the curtain wall boundary closing constraints, retrieve a curtain wall node instance of the terminal closing function type from the pre-built curtain wall node knowledge graph to replace the end curtain wall node instance, or retrieve a curtain wall node instance of the terminal additional function type from the pre-built curtain wall node knowledge graph and attach it to the end curtain wall node instance to generate a curtain wall node assembly sequence that meets the boundary closing constraints.

[0119] Extract the curtain wall boundary termination constraints from the curtain wall boundary section of the curtain wall engineering project design requirements document, including termination method type and termination size requirements. Compare the boundary termination interface geometry parameters of the end curtain wall node instance with the termination size requirements; if they do not meet the requirements, search for alternative or supplementary solutions. In the pre-built curtain wall node knowledge graph, search for curtain wall node instances with the entity type label "end termination function type" and whose boundary termination interface geometry parameters meet the termination constraints, and replace the original end curtain wall node instance. If a completely replacement node cannot be found, search for curtain wall node instances with the entity type label "end additional function type" that can be connected to the original end curtain wall node instance through an assembly relationship edge, and append them to the end of the curtain wall node assembly sequence.

[0120] Step S560: Output the curtain wall node assembly sequence with conversion joints or the curtain wall node assembly sequence that satisfies the boundary closing constraint as the updated curtain wall node assembly sequence.

[0121] The curtain wall node assembly sequence processed in steps S540 and S550 is output as the final matching result.

[0122] Step S610: After obtaining the candidate curtain wall node path set, extract the curtain wall construction stage constraint information from the curtain wall engineering project design requirement document. The curtain wall construction stage constraint information includes the construction stage sequence identifier and the set of installable curtain wall component types corresponding to each construction stage sequence identifier.

[0123] The construction phase constraint information is extracted from the construction organization design section of the curtain wall engineering project design requirements document. The construction phase sequence identifiers are arranged according to the construction progress, and each construction phase sequence identifier corresponds to a set of installable curtain wall component types. This set of installable curtain wall component types defines the list of curtain wall node entity type labels that are allowed to be installed in that phase.

[0124] Step S620: Perform construction stage matching processing on the sequence of curtain wall node instances contained in each candidate curtain wall node path in the candidate curtain wall node path set and the curtain wall construction stage constraint information. Check whether the entity type label of each curtain wall node instance in the sequence of curtain wall node instances belongs to the set of installable curtain wall component types corresponding to the construction stage sequence identifier in order from front to back according to the construction stage sequence identifier.

[0125] The construction phase sequence is identified as P1, P2, ..., PK. Construction phases are assigned to each curtain wall node instance according to the node order in the sequence. Starting from P1, the entity type label of each curtain wall node instance is checked sequentially to see if it belongs to the set of installable curtain wall component types for the current construction phase. If it does, the curtain wall node instance is assigned to the current construction phase, and the process continues to check the next curtain wall node instance and the next construction phase. After assignment, each construction phase corresponds to a subsequence of curtain wall node instances.

[0126] Step S630: When there is a curtain wall node instance in the curtain wall node instance sequence whose entity type label does not belong to the set of installable curtain wall component types corresponding to the current construction stage sequence identifier, the position of the curtain wall node instance in the curtain wall node instance sequence is moved to the next curtain wall node instance subsequence corresponding to the next construction stage sequence identifier, and a new curtain wall node instance sequence that conforms to the construction stage sequence constraint is formed.

[0127] If the entity type label of a curtain wall node instance does not belong to the set of installable curtain wall component types in the current construction phase, it is postponed to the next construction phase for re-examination. If it still does not match after being postponed to the last construction phase, the candidate curtain wall node path is marked as a construction phase mismatch and removed from the candidate curtain wall node path set. All curtain wall node instance sequences that satisfy the construction phase sequence constraints after adjustment constitute a new sequence set.

[0128] Step S640: Read the installation process attributes of each curtain wall node instance in the sequence of curtain wall node instances that conforms to the construction stage sequence constraints from the pre-built curtain wall node knowledge graph. The installation process attributes include installation tool requirement tags and installation operation space requirement tags.

[0129] The installation tool requirement is marked as an enumerated value in the preset tool type set, including electric wrenches, manual screwdrivers, hoisting equipment, etc. The installation operation space requirement includes the operation space length, operation space width, and operation space height, in millimeters.

[0130] Step S650: For the curtain wall node instance subsequences corresponding to the same construction stage sequence identifier in the curtain wall node instance sequence that conforms to the construction stage sequence constraints, curtain wall node instances using the same installation tools are grouped according to the differences in the installation tool requirement markers, and curtain wall node instances with complementary operation space requirements are arranged adjacently according to the compatibility of the installation operation space requirement markers, so as to obtain the curtain wall node assembly sequence after construction process optimization.

[0131] Within the same construction phase, curtain wall node instances are clustered according to installation tool requirements. Instances using the same installation tools are grouped into the same installation group. Within each installation group, installation groups are sorted by the versatility of the most frequently used tool. Within each installation group, curtain wall nodes with high and low installation space requirements are alternated to maximize overall operation space utilization. This sorting adjustment yields the optimized curtain wall node assembly sequence.

[0132] Step S660: Replace the corresponding compliant curtain wall node path in the compliant curtain wall node path set with the curtain wall node assembly sequence optimized by the construction process, and input the replaced compliant curtain wall node path set into the processing step of comparing the interface geometric parameters of each compliant curtain wall node path in the compliant curtain wall node path set.

[0133] Replace the original sequence with the curtain wall node assembly sequence optimized by the construction process, update the content of the corresponding path in the compliant curtain wall node path set, and use the updated compliant curtain wall node path set as the input for the interface geometric parameter comparison in step S150.

[0134] For example, the method may also include: step S710: after obtaining the candidate curtain wall node path set, extract the three-dimensional curved surface model data of the curtain wall building facade from the curtain wall engineering project design requirement document. The three-dimensional curved surface model data of the curtain wall building facade includes the spatial coordinate sequence of the facade curved control points and the curvature distribution information of the facade curved surface pieces.

[0135] The 3D surface model data is read from the building skin model section of the curtain wall project design requirements document. The facade surface control points are 3D point arrays with X, Y, and Z coordinates. The facade surface patches are sets of triangular patches generated by connecting adjacent control points through triangulation, and each triangular patch carries a Gaussian curvature value and a mean curvature value.

[0136] Step S720: Perform local surface expansion processing on the 3D curved surface model data of the curtain wall building facade. Using the exterior curved surface area covered by each candidate curtain wall node path in the candidate curtain wall node path set as the processing unit, calculate the geodesic curvature change curve of the curved surface area along the arrangement direction of the curtain wall node instance sequence.

[0137] For each candidate curtain wall node path, the spatial position of each curtain wall node instance in its sequence is projected onto the 3D curved surface model of the curtain wall building facade, determining the surface area covered by the path. Sampling is performed on the surface area along the direction of the curtain wall node instance sequence, and the geodesic curvature value of the surface along that direction is calculated at each sampling point. The geodesic curvature value is calculated by first calculating the first and second fundamental form coefficients of the surface at that point, and then substituting them into the Euler curvature formula along the geodesic direction. The geodesic curvature values ​​of the sampling points are arranged in the sampling order to form a geodesic curvature variation curve.

[0138] Step S730: Extract curvature abrupt change points from the geodesic curvature change curve. Mark the points in the geodesic curvature change curve where the absolute value of the second derivative of curvature exceeds the preset curvature abrupt change threshold as curvature abrupt change points. Use the corresponding positions of the curvature abrupt change points on the three-dimensional curved surface model of the curtain wall building facade as the adaptive surface segmentation positions.

[0139] The second derivative of curvature is calculated for each sampling point of the geodesic curvature variation curve using a three-point difference scheme. The absolute value of the second derivative at each sampling point is compared with a preset curvature abrupt change threshold; sampling points exceeding the threshold are marked as curvature abrupt change points. These curvature abrupt change points are then mapped back to the three-dimensional spatial coordinates of the three-dimensional curved surface model of the curtain wall building facade, resulting in a set of adaptive surface segmentation positions.

[0140] Step S740: Map the adaptive segmentation position of the curved surface to the candidate curtain wall node path. When the distance between the assembly connection position of the adjacent curtain wall node instance in the candidate curtain wall node path and the adaptive segmentation position of the curved surface is less than the preset position deviation tolerance, insert a curtain wall node instance of curved surface corner adaptation type between the adjacent curtain wall node instances. The curtain wall node instance of curved surface corner adaptation type is retrieved from the pre-built curtain wall node knowledge graph by entity type label.

[0141] Calculate the 3D spatial distance between the assembly connection position of each pair of adjacent curtain wall node instances in the candidate curtain wall node path and each surface adaptive segmentation position. If the distance is less than the preset position deviation tolerance, retrieve curtain wall node instances with the entity type label of surface corner adaptation from the pre-built curtain wall node knowledge graph, and insert the retrieved node instances between the adjacent curtain wall node instances.

[0142] Step S750: Read the bending deformation adaptation parameters of the newly inserted curved corner adaptation type curtain wall node instance from the pre-built curtain wall node knowledge graph. The bending deformation adaptation parameters include the maximum adaptable bending angle and the bending stiffness coefficient. Compare the angle between the interface normal vectors of the two curtain wall node instances connected to the curved corner adaptation type curtain wall node instance with the maximum adaptable bending angle, and filter out the curved corner adaptation type curtain wall node instances whose interface normal vector angle exceeds the maximum adaptable bending angle.

[0143] Calculate the angle between the interface normal vectors of the adjacent curtain wall node instances on both sides of the newly inserted node. The angle is obtained by taking the inverse cosine of the dot product of the two normal vectors. Compare this angle with the maximum adaptable bending angle of the newly inserted node. If the angle is greater than the maximum adaptable bending angle, discard the node instance that adapts to the surface corner and search for an alternative node with a larger bending deformation adaptation parameter.

[0144] Step S760: For the retained curved corner adaptation type curtain wall node instance, pass the interface geometric parameters of the curtain wall node instances on both sides connected to it to the input and output interfaces of the curved corner adaptation type curtain wall node instance, adjust the interface adaptation parameters of the curved corner adaptation type curtain wall node instance according to the interface geometric parameter matching relationship, and generate candidate curtain wall node paths that have been adaptively adjusted by the curved surface.

[0145] Write the interface section width and height values ​​of the two curtain wall node instances into the input and output interface geometric parameters of the curved corner adaptation type curtain wall node instance, respectively. If there is a dimensional deviation, adjust the tolerance compensation value in the interface adaptation parameters of the curved corner adaptation type curtain wall node instance. After completing the parameter adjustment, obtain the candidate curtain wall node path after surface adaptive adjustment. Replace the original path with the adjusted path and input the set of candidate curtain wall node paths into step S140.

[0146] Step S810: After obtaining the candidate curtain wall node path set, obtain the historical wind pressure load time series data set of the curtain wall building location corresponding to the curtain wall project design requirement document. The historical wind pressure load time series data set includes wind pressure value sequence and wind direction angle sequence recorded in chronological order.

[0147] Historical wind pressure load time-series data were retrieved from the meteorological data appendix cited in the curtain wall project design requirements document. Wind pressure values ​​are measured in kilopascals, and wind direction angles are measured in degrees.

[0148] Step S820: Perform wind pressure extreme value extraction processing on the historical wind pressure load time series data set, mark the wind pressure values ​​in the wind pressure value sequence that exceed the preset wind pressure extreme value threshold as wind pressure extreme value points, and record the wind direction angle and timestamp corresponding to each wind pressure extreme value point.

[0149] Traverse the wind pressure value sequence, compare each wind pressure value with a preset wind pressure extreme threshold, and mark those exceeding the threshold as wind pressure extreme points. For each wind pressure extreme point, record its wind pressure value, wind direction angle, and timestamp.

[0150] Step S830: Based on the wind direction angle corresponding to each wind pressure extreme point, group the wind pressure extreme points according to the preset wind direction quadrant to which the wind direction angle belongs, sort the wind pressure values ​​corresponding to the wind pressure extreme points in each preset wind direction quadrant, extract the maximum wind pressure value in each preset wind direction quadrant, and generate a mapping table between wind direction quadrants and maximum wind pressure values.

[0151] The circumference is divided into a preset number of wind direction quadrants. Each extreme wind pressure point is assigned to the corresponding wind direction quadrant according to its wind direction angle value. Within each wind direction quadrant, the wind pressure values ​​of the extreme wind pressure points are sorted in descending order, and the maximum value is taken as the maximum wind pressure value of that wind direction quadrant, generating a key-value mapping table from wind direction quadrants to the maximum wind pressure value.

[0152] Step S840: For each candidate curtain wall node path in the candidate curtain wall node path set, extract the normal vector orientation of the curtain wall node instance sequence on the exterior facade of the curtain wall building, map the normal vector orientation to the preset wind direction quadrant, and read the maximum wind pressure value that the candidate curtain wall node path can withstand from the mapping table between the wind direction quadrant and the maximum wind pressure value.

[0153] Calculate the average direction vector of the external normal vector of each curtain wall node instance on the curtain wall facade in each candidate curtain wall node path, convert the average direction vector into an azimuth angle and map it to the wind direction quadrant, and read the corresponding maximum wind pressure value from the mapping table.

[0154] Step S850: Read the wind pressure bearing parameters of each curtain wall node instance in the candidate curtain wall node path from the pre-built curtain wall node knowledge graph. The wind pressure bearing parameters include the ultimate wind pressure value and the allowable wind pressure deformation deflection value.

[0155] Query the wind pressure bearing parameter field in the entity attribute set of each curtain wall node instance, and read the ultimate wind pressure resistance value Plimit and the allowable wind pressure deformation deflection value Dallow. The ultimate wind pressure resistance value is in kilopascals and the allowable wind pressure deformation deflection value is in millimeters.

[0156] Step S860: Compare the maximum wind pressure value borne by the candidate curtain wall node path with the ultimate wind pressure resistance value of each curtain wall node instance one by one. When the ultimate wind pressure resistance value of a curtain wall node instance is lower than the maximum wind pressure value, mark the curtain wall node instance as a node with insufficient wind pressure resistance, and retrieve curtain wall node instances of the wind pressure resistance enhancement type from the pre-built curtain wall node knowledge graph to replace the node with insufficient wind pressure resistance.

[0157] For each curtain wall node instance, if Plimit<Pmax, it is marked as a node with insufficient wind pressure resistance. In the pre-built curtain wall node knowledge graph, curtain wall node instances whose entity type label is wind pressure resistance reinforcement type and whose ultimate wind pressure resistance value is greater than or equal to the maximum wind pressure value are retrieved, and the node instance with the entity type label closest to the original node is selected therefrom for replacement.

[0158] Step S870: arranging the allowable wind pressure deformation deflection values adopted by each curtain wall node instance in the candidate curtain wall node path after the wind pressure resistance reinforcement replacement in sequence along the candidate curtain wall node path to form an allowable wind pressure deformation deflection value sequence, calculating the absolute value of the difference between adjacent values in the allowable wind pressure deformation deflection value sequence, and when the absolute value of the difference exceeds a preset deformation coordination tolerance, inserting a curtain wall node instance of a deformation coordination transition type between the adjacent curtain wall node instances with the excessive absolute difference, so as to generate a candidate curtain wall node path after wind pressure deformation coordination.

[0159] Assume that the allowable wind pressure deformation deflection values of adjacent node instances are D1 and D2 respectively, and the absolute difference ΔD=|D1-D2| is calculated. If ΔD is greater than the deformation coordination tolerance Dtol, curtain wall node instances whose entity type label is deformation coordination transition type and whose allowable wind pressure deformation deflection value is between D1 and D2 are retrieved in the pre-built curtain wall node knowledge graph, and inserted between the adjacent nodes. The check is repeated until all adjacent differences do not exceed Dtol.

[0160] Step S880: replacing the original candidate curtain wall node path in the candidate curtain wall node path set with the candidate curtain wall node path after wind pressure deformation coordination, and inputting the replaced candidate curtain wall node path set into a processing step of performing conflict detection on the curtain wall node instance sequence included in each candidate curtain wall node path in the candidate curtain wall node path set.

[0161] The paths processed in step S860 and step S870 overwrite the original paths, and the updated candidate curtain wall node path set is used as the input for the conflict detection in step S140.

[0162] Step S910: after the candidate curtain wall node path set is obtained, a completed curtain wall project node configuration case library is constructed, the completed curtain wall project node configuration case library comprises a plurality of case records, and each case record comprises a project feature description field of a completed curtain wall project and an actually used curtain wall node instance sequence field.

[0163] Data of a plurality of completed curtain wall projects are extracted from an enterprise project archive database, the building height, shape coefficient, seismic fortification intensity and basic wind load value of each completed curtain wall project form a project feature description field, and an actual curtain wall node identifier sequence extracted from the curtain wall detailed design drawing of the completed curtain wall project forms an actually used curtain wall node instance sequence field.

[0164] Step S920: For each case record in the completed curtain wall project node configuration case library, extract the curtain wall building height attribute, curtain wall building shape coefficient attribute, curtain wall building location seismic fortification intensity attribute, and curtain wall building location wind load basic value attribute from the project feature description field to generate the original project feature vector.

[0165] Each case record generates a four-dimensional original project feature vector, with the four dimensions corresponding to the building height value, shape coefficient value, seismic fortification intensity value, and basic wind load value, respectively.

[0166] Step S930: For each candidate curtain wall node path in the candidate curtain wall node path set, extract the curtain wall building height attribute, curtain wall building shape coefficient attribute, seismic fortification intensity attribute of the location of the curtain wall building, and basic wind load attribute of the location of the curtain wall building from the curtain wall project design requirements document, and generate the current original project feature vector.

[0167] Extract the corresponding attribute values ​​of the current project from the project overview section of the design requirements document to generate the same four-dimensional feature vector of the current original project.

[0168] Step S940: Normalize each attribute component in the original project feature vector and the current original project feature vector respectively, mapping the values ​​of all attribute components to the same numerical range, to obtain the normalized project feature vector and the current project feature vector.

[0169] The minimum and maximum value normalization method is adopted. For each attribute component, the minimum and maximum values ​​of the attribute component in the case library are calculated respectively. The original value is subtracted from the minimum value and then divided by the difference between the maximum and minimum values ​​to map to the interval between zero and one.

[0170] Step S950: Calculate the vector Euclidean distance between the current project feature vector and the normalized project feature vector of each case record in the completed curtain wall project node configuration case library. Sort the case records in ascending order of vector Euclidean distance and select the case record with the smallest vector Euclidean distance as the closest completed case.

[0171] The Euclidean distance formula is sqrt(sum((Vcurr_k-Vcase_k)^2)), where k iterates through the four dimensions. After calculating the distance for all cases, sort them in ascending order, and take the case with the smallest distance as the closest completed case.

[0172] Step S960: Extract the curtain wall node instance sequence from the field of the actual curtain wall node instance sequence that is closest to the completed case. Perform sequence comparison processing between the extracted curtain wall node instance sequence and the curtain wall node instance sequence of the candidate curtain wall node path to locate the position of the curtain wall node instance where the node type label does not match in the two sequences.

[0173] The dynamic programming algorithm in sequence alignment is used to perform a global comparison of two node type label sequences, calculate the minimum edit distance, and backtrack the comparison path to locate the position where the type labels do not match.

[0174] Step S970: For curtain wall node instance locations where the node type label does not match, extract the curtain wall node instance corresponding to the location from the sequence of curtain wall node instances actually used in the most similar completed case, and search the pre-built curtain wall node knowledge graph for a candidate set of curtain wall node instances with the same entity type label as the curtain wall node instance.

[0175] In the pre-built knowledge graph of curtain wall nodes, query all node instances whose entity type label is equal to the entity type label of the corresponding node instance in the case, and form a candidate set.

[0176] Step S980: Select the curtain wall node instance with the highest matching degree between the entity attribute set and the curtain wall performance index constraint set of the current curtain wall project from the candidate curtain wall node instance set, replace the curtain wall node instances in the candidate curtain wall node path whose node type labels do not match, and generate the case-driven optimized candidate curtain wall node path.

[0177] The matching degree is calculated as the number of entity attribute sets of each node instance in the candidate set that satisfy the corresponding constraint entries in the curtain wall performance index constraint set. The node instance with the highest matching degree is selected to replace the original mismatched node. The replaced path overwrites the original path, and the updated candidate curtain wall node path set is input into step S140 for conflict detection.

[0178] Step S1010: After obtaining the candidate curtain wall node path set, obtain the curtain wall building internal structure model data corresponding to the curtain wall engineering project design requirement document. The curtain wall building internal structure model data includes the axial position coordinates of the building structure beams and columns and the elevation surface data of the building structure floor slabs.

[0179] Read the starting and ending coordinates of the building structure beams and columns, as well as the elevation values ​​of the floor slabs, from the structural model section of the curtain wall project design requirements document.

[0180] Step S1020: Extract curtain wall node instances that are connected to the main building structure from the sequence of curtain wall node instances of each candidate curtain wall node path in the candidate curtain wall node path set. Mark these curtain wall node instances as main connection nodes and obtain the spatial coordinates of the main connection nodes on the exterior facade of the curtain wall building.

[0181] Filter curtain wall node instances with entity type tags of "embedded part connection type" or "main body support type" as main body connection nodes. Read their spatial coordinates from the node attributes.

[0182] Step S1030: For each main connection node, perform spatial projection processing on the internal structural model data of the curtain wall building based on the spatial position coordinates of the main connection node, project the connection extension line into the building along the interface normal vector direction of the main connection node, and calculate the coordinates of the intersection point of the connection extension line with the axis of the building structural beams and columns or the elevation plane of the building structural floor slab.

[0183] Starting from the spatial coordinates of the main connection node, and taking the opposite direction of the interface normal vector as the ray direction, calculate the distance between the ray and the axis of the structural beam and column, or the intersection of the ray and the floor slab elevation surface, and obtain the coordinates of the intersection point.

[0184] Step S1040: Use the spatial distance between the intersection point coordinates and the spatial position coordinates of the main connection node as the main connection span value. Read the maximum allowable connection span value of the main connection node from the pre-constructed curtain wall node knowledge graph and compare the main connection span value with the maximum allowable connection span value.

[0185] Calculate the Euclidean distance between the two points to obtain the main connection span value. Query the node entity attribute set to read the maximum allowed connection span value, and compare the two values.

[0186] Step S1050: When the main connection span value exceeds the maximum allowable connection span value, retrieve curtain wall node instances of auxiliary support connection type from the pre-constructed curtain wall node knowledge graph, and arrange them at equal intervals on the connection extension line between the main connection node and the intersection point according to the preset arrangement spacing of the curtain wall node instances of auxiliary support connection type, and insert the curtain wall node instances of auxiliary support connection type in sequence along the connection extension line.

[0187] Calculate the number of auxiliary support nodes to be inserted based on the span value exceeding the allowable value. The number is calculated by dividing the excess value by the maximum allowable connection span value, rounded up, and then minus one. Calculate the placement coordinates of each auxiliary support node at equal intervals along the connection extension line, and insert auxiliary support connection type node instances sequentially.

[0188] Step S1060: Recalculate the segmental main body connection span value between adjacent curtain wall node instances after inserting auxiliary support connection type curtain wall node instances. Compare the segmental main body connection span value with the maximum allowable connection span value of each curtain wall node instance. If the segmental main body connection span value still exceeds the limit, continue to insert auxiliary support connection type curtain wall node instances until all segmental main body connection span values ​​do not exceed the corresponding maximum allowable connection span value.

[0189] Calculate the segment span value between every two adjacent nodes and compare it with the maximum connection span of each of the two endpoints. If any segment exceeds the limit, continue to encrypt and insert until all segments are satisfied.

[0190] Step S1070: For the candidate curtain wall node path after the auxiliary support is supplemented, check the interface compatibility between the newly inserted auxiliary support connection type curtain wall node instance and the existing curtain wall node instance in the candidate curtain wall node path, replace the auxiliary support connection type curtain wall node instance with incompatible interface with the auxiliary support connection type curtain wall node instance with compatible interface, and generate the candidate curtain wall node path after the main connection is enhanced.

[0191] Check whether the interface type label of the newly inserted node satisfies the node dependency rule of step S144 with the interface type labels of adjacent existing nodes. If not, search the knowledge graph for a replacement node that satisfies the dependency rule.

[0192] Step S1080: Replace the original candidate curtain wall node paths in the candidate curtain wall node path set with the enhanced candidate curtain wall node paths of the main body connection, and input the replaced candidate curtain wall node path set into the processing step of conflict detection of the curtain wall node instance sequence contained in each candidate curtain wall node path in the candidate curtain wall node path set.

[0193] The path processed in step S1070 is overwritten with the original path, and the updated candidate curtain wall node path set is used as the input for conflict detection in step S140.

[0194] Figure 2This application illustrates a curtain wall node intelligent matching system 100 based on a rule engine and knowledge graph, comprising a processor 1001 and a memory 1003. The processor 1001 and memory 1003 are connected, for example, via a bus 1002. Optionally, the curtain wall node intelligent matching system 100 may further include a transceiver 1004, which can be used for data interaction between this curtain wall node intelligent matching system and other curtain wall node intelligent matching systems based on a rule engine and knowledge graph, such as sending and / or receiving data. It should be noted that in actual scheduling, the transceiver 1004 is not limited to one, and the structure of this curtain wall node intelligent matching system 100 based on a rule engine and knowledge graph does not constitute a limitation on the embodiments of this application.

[0195] The memory 1003 is used to store program code for executing the embodiments of this application, and its execution is controlled by the processor 1001. The processor 1001 is used to execute the program code stored in the memory 1003 to implement the steps shown in the foregoing method embodiments.

[0196] The above description is only an optional implementation method for some implementation scenarios of this application. It should be noted that for those skilled in the art, other similar implementation methods based on the technical concept of this application, without departing from the technical concept of this application, also fall within the protection scope of the embodiments of this application.

Claims

1. A method for intelligent matching of curtain wall nodes based on rule engine and knowledge graph, characterized in that, The method includes: Obtain the design requirements document for the curtain wall project, and extract the topological constraint set of curtain wall components and the constraint set of curtain wall performance indicators from the design requirements document for the curtain wall project; Based on the topological constraint set of the curtain wall components, anchor point entities are determined in the pre-constructed curtain wall node knowledge graph. Starting from the anchor point entity, path expansion is performed along the assembly relationship edge. During the path expansion process, attribute filtering is performed on the curtain wall node instances along the path based on the curtain wall performance index constraint set to obtain a candidate curtain wall node path set. For each candidate curtain wall node path in the candidate curtain wall node path set, extract the node type label and interface type label of each curtain wall node instance. Call the node mutual exclusion rule to perform conflict detection on the node type label sequence, call the node dependency rule to perform missing detection on the interface type label sequence, and remove the candidate curtain wall node paths with type conflicts or missing interfaces to obtain a compliant curtain wall node path set. For each compliant curtain wall node path in the compliant curtain wall node path set, the interface geometric parameter pairs of adjacent curtain wall node instances are extracted sequentially along the arrangement direction of the curtain wall node instance sequence. The absolute value of the difference in interface geometric parameters is compared with a preset interface tolerance threshold. Compliant curtain wall node paths with out-of-tolerance interface geometric parameters are filtered out, and compliant curtain wall node paths that pass the interface geometric parameter comparison are retained as curtain wall node assembly sequences, which serve as curtain wall node matching schemes that match the design requirements document of the curtain wall project.

2. The intelligent matching method for curtain wall nodes based on rule engine and knowledge graph according to claim 1, characterized in that, The process of obtaining the curtain wall project design requirements document, and extracting the curtain wall component topology constraint set and curtain wall performance index constraint set from the curtain wall project design requirements document, includes: The curtain wall project design requirement document is processed by paragraph boundary recognition. Based on the paragraph first-line indentation mark and the blank line mark between paragraphs in the curtain wall project design requirement document, the curtain wall project design requirement document is divided into several text unit sequences with independent semantics. Each text unit in the text unit sequence is segmented to obtain a word unit sequence corresponding to each text unit. The word unit sequence is then subjected to part-of-speech tagging to assign a part-of-speech tag to each word unit. Identify word units whose part-of-speech tags are curtain wall component nouns from the word unit sequence, and establish a component node record for each identified curtain wall component noun. The component node record contains the position index of the curtain wall component noun in the text unit and the sequence number of the text unit in which it is located. Using the component node record of each curtain wall component noun as the anchor point, the word unit sequence is searched forward for positional modifier word units with part-of-speech tags of locative nouns or ordinal numbers, and backward for dominating verb units with part-of-speech tags of structural verbs and attribute modifier word units with part-of-speech tags of attribute nouns. The searched location modifier units are combined with the curtain wall component nouns to form a curtain wall component location description phrase; the searched domineering verb units are combined with the curtain wall component nouns to form a curtain wall component action description phrase; and the searched attribute modifier units are combined with the curtain wall component nouns to form a curtain wall component attribute description phrase. Based on the spatial orientation meaning of the position modifiers in the phrase describing the location of the curtain wall components, the spatial orientation relationship type between any two curtain wall component nouns is determined, and the curtain wall component nouns with spatial orientation relationships are combined with the corresponding spatial orientation relationship types to form topological relationship entries; Based on the assembly semantics of the governing verb unit in the action description phrase of the curtain wall component, the assembly connection type word corresponding to the governing verb unit is searched in the preset assembly verb and assembly type mapping table, and the curtain wall component noun pair is combined with the assembly connection type word to form an assembly relationship entry. The attribute modifiers in the description phrases of the curtain wall components are matched word by word with the preset curtain wall performance index vocabulary. The matched attribute modifiers are marked as performance index words. The performance index words are associated with the names of the curtain wall components to form curtain wall performance index constraint entries. All topological relationship entries and assembly relationship entries extracted from the text unit sequence are summarized to generate the topological constraint set of the curtain wall components. All curtain wall performance index constraint entries extracted from the text unit sequence are summarized to generate the curtain wall performance index constraint set.

3. The intelligent matching method for curtain wall nodes based on rule engine and knowledge graph according to claim 1, characterized in that, The anchor point entity is determined in the pre-constructed curtain wall node knowledge graph based on the topological constraint set of the curtain wall components. Path expansion is then performed along the assembly relationship edge starting from the anchor point entity. During path expansion, the attributes of the passed curtain wall node instances are simultaneously filtered according to the curtain wall performance index constraint set to obtain a candidate curtain wall node path set, including: Extract all curtain wall component names appearing in the topology relationship entries and assembly relationship entries from the curtain wall component topology constraint set. Arrange the extracted curtain wall component names in the order of their first appearance in the curtain wall engineering project design requirements document to form a curtain wall component name sequence. Take the curtain wall component name that appears first in the curtain wall component name sequence as the anchor point component name. Search the pre-built curtain wall node knowledge graph for all curtain wall node instances whose entity type tags match the anchor point component name. Mark the retrieved curtain wall node instances as the anchor point entity set. For each anchor entity in the anchor entity set, extract the entity attribute set of the anchor entity in the pre-built curtain wall node knowledge graph. Compare the entity attribute set with the curtain wall performance index constraint entries associated with the anchor component noun in the curtain wall performance index constraint set. Remove anchor entities whose entity attribute sets do not meet the curtain wall performance index constraint entries to obtain a filtered anchor entity set. For each anchor entity in the filtered anchor entity set, extend outward along the assembly relationship edge in the pre-built curtain wall node knowledge graph starting from the anchor entity. Add the adjacent curtain wall node instances pointed to by the assembly relationship edge to the current path. The current path is recorded as a sequence of curtain wall node instances from the anchor entity to the adjacent curtain wall node instances. Extract the entity type label of the curtain wall node instance at the end of the current path, and match the entity type label with the next curtain wall component name after the anchor component name in the curtain wall component name sequence. If the match is successful, continue to expand outward along the assembly relationship edge. If the match fails, delete the curtain wall node instance at the end of the current path from the pre-built curtain wall node knowledge graph and backtrack to the previous curtain wall node instance to try other assembly relationship edges. For each newly added curtain wall node instance after path expansion, extract the entity attribute set of the curtain wall node instance, compare the entity attribute set with the curtain wall performance index constraint entries associated with the corresponding curtain wall component names in the curtain wall performance index constraint set, and remove curtain wall node instances whose entity attribute sets do not meet the curtain wall performance index constraint entries. When the path extends to the last curtain wall component name in the sequence of curtain wall component names and the entity type label of the curtain wall node instance at the end of the path matches the curtain wall component name, the current path is marked as a complete candidate curtain wall node path. The path extension and attribute filtering operations are repeated until all possible assembly relationship edges of all anchor entities in the filtered anchor entity set have been traversed, resulting in multiple candidate curtain wall node paths. All candidate curtain wall node paths are then summarized to form the candidate curtain wall node path set.

4. The intelligent matching method for curtain wall nodes based on rule engine and knowledge graph according to claim 1, characterized in that, The process involves extracting the node type and interface type labels from the sequence of curtain wall node instances contained in each candidate curtain wall node path in the candidate curtain wall node path set. Node type label sequences are then subjected to conflict detection using node mutual exclusion rules, and interface type label sequences are subjected to missing value detection using node dependency rules. Candidate curtain wall node paths with type conflicts or missing interfaces are removed to obtain a compliant curtain wall node path set, including: Traverse each candidate curtain wall node path in the candidate curtain wall node path set, obtain the sequence of curtain wall node instances arranged in expansion order in the current candidate curtain wall node path, and for each curtain wall node instance in the sequence of curtain wall node instances, read the node type label and interface type label of the curtain wall node instance from the entity attribute set of the pre-built curtain wall node knowledge graph. The node type label is used to identify the functional category of the curtain wall node, and the interface type label is used to identify the geometric shape category of the curtain wall node connection interface. The node type tags of all curtain wall node instances in the curtain wall node instance sequence are arranged in order to form a node type tag sequence. The node type tag sequence is matched with each node mutual exclusion rule in the preset node mutual exclusion rule library. Each node mutual exclusion rule in the preset node mutual exclusion rule library defines two mutually exclusive node type tag pairs. When the two node type tags defined by the mutual exclusion rule appear simultaneously in the node type tag sequence, it is determined that there is a type conflict in the current candidate curtain wall node path. The interface type tags of adjacent curtain wall node instances in the curtain wall node instance sequence are combined into interface type tag pairs to generate an interface type tag pair sequence corresponding to the curtain wall node instance sequence. The interface type tag pair sequence is matched with each node dependency rule in the preset node dependency rule library. Each node dependency rule in the preset node dependency rule library defines the dependency relationship between the preceding interface type tag and the following interface type tag. When the preceding interface type tag in the interface type tag pair is required to follow a specific following interface type tag in the node dependency rule, but the actual following interface type tag does not match, it is determined that there is an interface missing in the current candidate curtain wall node path. Candidate curtain wall node paths that are determined to have type conflicts and candidate curtain wall node paths that are determined to have missing interfaces are removed from the candidate curtain wall node path set. Candidate curtain wall node paths that are not removed are marked as compliant curtain wall node paths. All compliant curtain wall node paths are aggregated to form the compliant curtain wall node path set.

5. The intelligent matching method for curtain wall nodes based on rule engine and knowledge graph according to claim 1, characterized in that, For each compliant curtain wall node path in the compliant curtain wall node path set, the interface geometric parameter pairs of adjacent curtain wall node instances are extracted sequentially along the arrangement direction of the curtain wall node instance sequence. The absolute value of the difference in interface geometric parameters is compared with a preset interface tolerance threshold. Compliant curtain wall node paths with out-of-tolerance interface geometric parameters are filtered out, and compliant curtain wall node paths that pass the interface geometric parameter comparison are retained as the curtain wall node assembly sequence, including: Traverse each compliant curtain wall node path in the compliant curtain wall node path set to obtain the sequence of curtain wall node instances arranged in expansion order in the current compliant curtain wall node path; Extract the first pair of adjacent curtain wall node instances from the sequence of curtain wall node instances. The pair of adjacent curtain wall node instances consists of a front curtain wall node instance and a rear curtain wall node instance that are arranged in adjacent positions. Read the interface geometric parameter set of the front curtain wall node instance and the interface geometric parameter set of the rear curtain wall node instance from the pre-built curtain wall node knowledge graph; Extract the geometric parameter field of the output interface corresponding to the assembly relationship edge from the interface geometric parameter set of the front curtain wall node instance. The geometric parameter field includes the interface cross-section width parameter and the interface cross-section height parameter. Extract the geometric parameter field of the input interface corresponding to the assembly relationship edge from the interface geometric parameter set of the rear curtain wall node instance. The geometric parameter field of the input interface includes the interface cross-section width parameter and the interface cross-section height parameter. Calculate the absolute value of the difference between the interface cross-sectional width parameter of the output interface and the interface cross-sectional width parameter of the input interface, and calculate the absolute value of the difference between the interface cross-sectional height parameter of the output interface and the interface cross-sectional height parameter of the input interface; The absolute value of the difference in the interface cross-section width parameter is compared with the width tolerance value in the preset interface tolerance threshold, and the absolute value of the difference in the interface cross-section height parameter is compared with the height tolerance value in the preset interface tolerance threshold. When the absolute value of the difference in the interface cross-section width parameter exceeds the width tolerance value or the absolute value of the difference in the interface cross-section height parameter exceeds the height tolerance value, it is determined that the interface geometric parameters of the current adjacent curtain wall node instance pair are out of tolerance, and the compliant curtain wall node path containing the adjacent curtain wall node instance pair is removed from the compliant curtain wall node path set. When the absolute value of the difference between the interface cross-section width parameters does not exceed the width tolerance value and the absolute value of the difference between the interface cross-section height parameters does not exceed the height tolerance value, continue to extract the next set of adjacent curtain wall node instance pairs and repeat the interface geometric parameter comparison operation until all adjacent curtain wall node instance pairs in the current compliant curtain wall node path have passed the interface geometric parameter comparison. The compliant curtain wall node path is marked as a curtain wall node assembly sequence by comparing all adjacent curtain wall node instance pairs in the current compliant curtain wall node path through interface geometric parameters. Multiple compliant curtain wall node paths can generate multiple curtain wall node assembly sequences.

6. The intelligent matching method for curtain wall nodes based on rule engine and knowledge graph according to claim 1, characterized in that, The method further includes: Before determining the anchor point entity in the pre-built curtain wall node knowledge graph based on the curtain wall component topology constraint set, a topology completeness detection process is performed on each topology relationship entry in the curtain wall component topology constraint set to identify whether there are isolated curtain wall component names in the curtain wall component topology constraint set. The isolated curtain wall component names are curtain wall component names that do not appear in any topology relationship entry or assembly relationship entry in the curtain wall component topology constraint set. When the isolated curtain wall component name is detected, the text paragraph block containing the isolated curtain wall component name is reread from the curtain wall project design requirements document. The text paragraph block is subjected to reference resolution processing to identify the referent words in the text paragraph block that point to the isolated curtain wall component name. Based on the referent words, the curtain wall component name being referred to is traced back. The isolated curtain wall component name and the curtain wall component name being referred to are combined to form a complete topological relationship entry and added to the curtain wall component topological constraint set. For each assembly relationship entry in the topological constraint set of the curtain wall components, the assembly direction inference process is performed. Assembly connection type words are extracted from the assembly relationship entries. The assembly connection type words are mapped to assembly direction identifiers according to the preset assembly direction mapping table. The preset assembly direction mapping table defines the correspondence between assembly connection type words and insertion direction, socket direction, and lap direction. The assembly direction identifiers are attached to the assembly relationship entries. The assembly relationship entries and topology relationship entries with attached assembly direction identifiers are sorted by topology. The first appearance of the curtain wall component name in the curtain wall project design requirements document is taken as the starting node. The order of adjacent curtain wall component names is determined according to the spatial orientation relation words in the topology relationship entries. The subordinate order of curtain wall component name pairs is determined according to the assembly direction identifier in the assembly relationship entries. A topology sequence of curtain wall components with direction markers is generated. The topological sequence of curtain wall components with directional markers is aligned with the assembly relationship edges in the pre-built curtain wall node knowledge graph. When the direction of adjacent curtain wall component names in the topological sequence of curtain wall components with directional markers is opposite to the direction of the assembly relationship edges between corresponding curtain wall node instances in the pre-built curtain wall node knowledge graph, the corresponding assembly relationship edges in the pre-built curtain wall node knowledge graph are reversed to obtain a direction-aligned curtain wall node knowledge graph. The anchor point entity is determined in the direction-aligned curtain wall node knowledge graph, and the path extension is performed along the direction-aligned assembly relationship edges.

7. The intelligent matching method for curtain wall nodes based on rule engine and knowledge graph according to claim 1, characterized in that, The method further includes: After obtaining the candidate curtain wall node path set, a path coherence scoring process is performed on each candidate curtain wall node path in the candidate curtain wall node path set. The association strength value of the assembly relationship edge of adjacent curtain wall node instances in the pre-built curtain wall node knowledge graph is extracted from the candidate curtain wall node path. The association strength value is the edge weight attribute of the assembly relationship edge in the pre-built curtain wall node knowledge graph. The association strength values ​​of the assembly relationship edges corresponding to all adjacent curtain wall node instances in the candidate curtain wall node path are accumulated to obtain the path coherence accumulation value. For each candidate curtain wall node path, extract the node level depth value of each curtain wall node instance in the pre-built curtain wall node knowledge graph from the candidate curtain wall node path. The node level depth value is the number of path hops of the curtain wall node instance from the root node of the main curtain wall structure. Sum the node level depth values ​​of each curtain wall node instance to obtain the cumulative path level depth value. Based on the cumulative value of path coherence and the cumulative value of path hierarchy, all candidate curtain wall node paths in the candidate curtain wall node path set are independently sorted to obtain the ranking of each candidate curtain wall node path in the path coherence dimension and the ranking in the path hierarchy depth dimension. Based on the preset weights, the ranking of each candidate curtain wall node path in the path coherence dimension and the ranking in the path level depth dimension are weighted and summed to obtain the comprehensive path ranking value of each candidate curtain wall node path. The candidate curtain wall node paths in the candidate curtain wall node path set are sorted in ascending order of the comprehensive path ranking value. The sorted candidate curtain wall node path set is then input into the conflict detection process for the sequence of curtain wall node instances contained in each candidate curtain wall node path in the candidate curtain wall node path set.

8. The intelligent matching method for curtain wall nodes based on rule engine and knowledge graph according to claim 1, characterized in that, The method further includes: After obtaining the candidate curtain wall node path set, node redundancy detection processing is performed on each candidate curtain wall node path in the candidate curtain wall node path set. Duplicate curtain wall node instance pairs with the same entity type label and the same node level depth value in the pre-built curtain wall node knowledge graph are identified from the curtain wall node instance sequence of the candidate curtain wall node path. When the duplicate curtain wall node instance pair is identified, the entity type labels of the adjacent curtain wall node instances of each of the two curtain wall node instances in the candidate curtain wall node path are extracted. If the entity type labels of the adjacent curtain wall node instances of the two curtain wall node instances are the same, the two curtain wall node instances are marked as a mergeable redundant node pair. Extract the set of interface geometric parameters for each curtain wall node instance in the mergeable redundant node pair, compare the parameter values ​​of the same interface geometric parameter fields in the set of interface geometric parameters, remove curtain wall node instances whose parameter values ​​of each interface geometric parameter field in the set of interface geometric parameters are inferior to those of another curtain wall node instance, and retain the curtain wall node instance with the best set of interface geometric parameters. The retained curtain wall node instances are reconnected to the assembly relationship edges that were originally connected to the removed curtain wall node instances in the candidate curtain wall node path, generating a candidate curtain wall node path after redundancy removal. The candidate curtain wall node paths after redundancy removal are used to replace the original candidate curtain wall node paths in the candidate curtain wall node path set. The replaced candidate curtain wall node path set is then input into the process step of conflict detection of the curtain wall node instance sequence contained in each candidate curtain wall node path in the candidate curtain wall node path set.

9. The intelligent matching method for curtain wall nodes based on rule engine and knowledge graph according to claim 1, characterized in that, The method further includes: After outputting the curtain wall node assembly sequence, obtain the building main structure interface parameter set corresponding to the curtain wall node instance in the current curtain wall project. The building main structure interface parameter set includes embedded part position coordinate parameters and main structure reserved interface size parameters. Extract the front curtain wall node instance that is first and the end curtain wall node instance that is last from the curtain wall node assembly sequence. Read the main connection interface geometric parameters of the front curtain wall node instance and the boundary closing interface geometric parameters of the end curtain wall node instance from the pre-built curtain wall node knowledge graph. The geometric parameters of the main connection interface of the front curtain wall node instance are compared with the size parameters of the reserved interface of the main structure in the set of interface parameters of the main structure of the building. The difference between the size parameters of each geometric dimension of the main connection interface and the size parameters of the corresponding geometric dimension of the reserved interface of the main structure is calculated. When the difference between the geometric parameters of the main connection interface and the size parameters of the reserved interface of the main structure exceeds the preset tolerance range of the main interface, the curtain wall node instance with the interface conversion function type is retrieved from the pre-built curtain wall node knowledge graph as a candidate instance of the conversion joint, and the candidate instance of the conversion joint is inserted between the front-end curtain wall node instance and the main building structure to generate a curtain wall node assembly sequence with conversion joint. The boundary closing interface geometric parameters of the end curtain wall node instance are matched with the curtain wall boundary closing constraints extracted from the curtain wall engineering project design requirements document. When the boundary closing interface geometric parameters of the end curtain wall node instance do not meet the curtain wall boundary closing constraints, a curtain wall node instance of the terminal closing function type is retrieved from the pre-built curtain wall node knowledge graph to replace the end curtain wall node instance, or a curtain wall node instance of the terminal additional function type is retrieved from the pre-built curtain wall node knowledge graph and added to the end curtain wall node instance to generate a curtain wall node assembly sequence that meets the boundary closing constraints. The curtain wall node assembly sequence with conversion joint or the curtain wall node assembly sequence that satisfies the boundary closing constraint is output as the updated curtain wall node assembly sequence.

10. The intelligent matching method for curtain wall nodes based on rule engine and knowledge graph according to claim 1, characterized in that, The method further includes: After obtaining the candidate curtain wall node path set, the curtain wall construction stage constraint information is extracted from the curtain wall engineering project design requirement document. The curtain wall construction stage constraint information includes the construction stage sequence identifier and the set of installable curtain wall component types corresponding to each construction stage sequence identifier. The sequence of curtain wall node instances contained in each candidate curtain wall node path in the candidate curtain wall node path set is matched with the curtain wall construction stage constraint information. The entity type label of each curtain wall node instance in the sequence of curtain wall node instances is checked in turn according to the construction stage sequence identifier from front to back to see if it belongs to the set of installable curtain wall component types of the corresponding construction stage sequence identifier. When there is a curtain wall node instance in the curtain wall node instance sequence whose entity type label does not belong to the set of installable curtain wall component types corresponding to the current construction stage sequence identifier, the position of the curtain wall node instance in the curtain wall node instance sequence is moved to the next curtain wall node instance subsequence corresponding to the next construction stage sequence identifier, and a new curtain wall node instance sequence that conforms to the construction stage sequence constraint is formed. The installation process attributes of each curtain wall node instance in the sequence of curtain wall node instances that conform to the construction stage sequence constraints are read from the pre-constructed curtain wall node knowledge graph. The installation process attributes include installation tool requirement tags and installation operation space requirement tags. For curtain wall node instance subsequences corresponding to the same construction stage sequence identifier in the curtain wall node instance sequence that conforms to the construction stage sequence constraint, curtain wall node instances using the same installation tools are grouped according to the differences in the installation tool requirement markers, and curtain wall node instances with complementary operation space requirements are arranged adjacently according to the compatibility of the installation operation space requirement markers, so as to obtain the curtain wall node assembly sequence after construction process optimization. The optimized curtain wall node assembly sequence replaces the corresponding compliant curtain wall node path in the compliant curtain wall node path set. The replaced compliant curtain wall node path set is then input into the processing step of comparing the interface geometric parameters of each compliant curtain wall node path in the compliant curtain wall node path set.

Images