Multi-computing unit integrated BIM model checking method and device

Abstract

The present invention discloses a BIM model checking method and device integrated with multiple computing units. In a SPARQL checking statement process generated based on an SNL rule, multiple target component variables are extracted from the SNL rule to form a component variable tuple; result marking is performed according to the rule type of the result part in the SNL rule; the component variable tuple is added to the query header of the SPARQL checking statement; in a process of querying a building semantic model, two component variables involved in the current computational rule are obtained from the component variable tuple, component entity tuples corresponding to the two component variables and component entity tuples corresponding to the component variable tuple are queried from the building semantic model, and each component entity tuple is associated with the component entity tuple and saved; the component entity tuple is calculated based on the current computational rule to determine the target component entity tuple, and the target component entity tuple corresponding to the target component entity tuple is queried; and based on the result marking, a final query result is obtained from the target component entity tuple.

Description

Technical Field

[0001] The present invention relates to the field of building technology, and in particular to a BIM model checking method and device integrated with multiple computing units. Background Art

[0002] BIM (Building Information Model) is a technology for building information applications based on three-dimensional models. It can be effectively applied to the planning, design, construction, and management of buildings and infrastructure. It is one of the most promising technologies in the building, engineering, and construction stages. In the process of promoting and implementing BIM technology, implementing building specification review based on BIM models plays an important role in promoting the progress and development of the BIM industry.

[0003] In the related art, the building code review tool BIMChecker can be used to review the BIM model to determine whether the building corresponding to the BIM model complies with the code. The basic flow chart of the BIMChecker tool for model checking is as follows: Figure 1 As shown in the figure, the overall process can be briefly divided into the following three steps: (1) converting the Revit model (or AutoCad model, IFC model, etc.) into the TTL model (the Terse RDF Triple Language) for checking; (2) converting the SNL (Structural Natural Language) rules written by the user according to the building code provisions into SPARQL query statements used for model checking; (3) using SPARQL queries to check the TTL model and outputting the query results as the checking results.

[0004] The BIMChecker tool has developed a geometric calculation unit that allows the program to directly perform geometric calculations to determine whether a component complies with the specification. The clauses that need to call the geometric calculation unit are called computational rules. The existing computational rule framework of the BIMChecker tool divides the SNL rules into different areas and obtains the inspection results by performing intersection and / or union calculations on different areas. The computational rule framework can operate normally when the clause has a single computational rule, but with the application of the BIMChecker tool in many places, the existing framework has encountered problems such as "failure to correctly output the required results" and "missing elimination of multiple components" when dealing with clauses that contain multiple computational rules at the same time. Summary of the invention

[0005] The present invention provides a multi-calculation unit integrated BIM model checking method and device, which can avoid the problems of "failure to correctly output the required results" and "missing multiple component elimination" when querying clauses containing multiple calculation rules. The specific technical solution is as follows:

[0006] In a first aspect, an embodiment of the present invention provides a BIM model checking method integrated with multiple computing units, the method comprising:

[0007] In the process of generating a SPARQL check statement based on a building rule description language SNL rule, a plurality of target component variables are extracted from the SNL rule to form a component variable tuple; the SNL rule is a building specification clause written based on SNL, and the target component variables include component variables involved in the computational rules of the condition part of the SNL rule and component variables involved in the result part;

[0008] Marking the result according to the rule type of the result part in the SNL rule;

[0009] Adding the component variable tuple to the query header of a SPARQL check statement;

[0010] In the process of querying the building semantic model based on the SPARQL check statement, for each computational rule, two component variables involved in the current computational rule are obtained from the component variable tuple, and all component entity tuples corresponding to the two component variables and component entity tuples corresponding to the component variable tuple are queried from the building semantic model, and each component entity tuple is associated with the component entity tuple and saved in a mapping list; the building semantic model is a model obtained by semantic extraction based on a building information model (BIM) model;

[0011] For each computational rule, each component entity binary is calculated based on the current computational rule to determine a target component entity binary that satisfies the current computational rule, and a target component entity tuple corresponding to the target component entity binary is searched from the mapping list;

[0012] Based on the result tag, a final query result for the SNL rule is obtained from the target component entity tuple.

[0013] Optionally, result marking is performed according to the rule type of the result part in the SNL rule, including:

[0014] When the result part of the SNL rule does not include computational rules, the target component variable representing the query result is marked as a result variable; when the result part of the SNL rule includes computational rules, the computational rules included in the result part of the SNL rule are marked as result clauses.

[0015] Optionally, marking the computational rules included in the result part of the SNL rule as result clauses includes:

[0016] In the computational rule information configuration file, the computational rules included in the result part of the SNL rule are marked as result clauses; the computational rule configuration file includes the computational rule content based on the SNL description, the component variable mapping relationship involved in the computational rule, and a mark of whether it belongs to the result clause.

[0017] Optionally, based on the result tag, obtaining a final query result for the SNL rule from the target component entity tuple includes:

[0018] If the query header of the SPARQL check statement corresponding to the SNL rule contains a result variable tag, then obtaining the component entity corresponding to the result variable from the target component entity tuple as the final query result;

[0019] If the computational rule information configuration file corresponding to the SNL rule contains a result clause tag, then the component entity tuple corresponding to the computational rule marked as the result clause is obtained from the target component entity tuple as the final query result.

[0020] Optionally, each component entity tuple is associated with the component entity tuple and saved in a mapping list, including:

[0021] The component entity binary tuple is used as the key, and the component entity tuple corresponding to the component entity binary tuple is used as the value and saved in the hash table.

[0022] In a second aspect, an embodiment of the present invention provides a BIM model checking device integrated with multiple computing units, the device comprising:

[0023] An extraction unit is used to extract multiple target component variables from a building rule description language SNL rule to form a component variable tuple in a SPARQL check statement process generated based on the SNL rule; the SNL rule is a building specification clause written based on SNL, and the target component variables include component variables involved in the computational rules of the condition part of the SNL rule and component variables involved in the result part;

[0024] A marking unit, used for marking a result according to a rule type of a result part in the SNL rule;

[0025] An adding unit, used for adding the component variable tuple to the query header of the SPARQL check statement;

[0026] A first acquisition unit is used for acquiring, for each computational rule, two component variables involved in the current computational rule from the component variable tuple in the process of querying the architectural semantic model based on the SPARQL check statement, and querying all component entity tuples corresponding to the two component variables and component entity tuples corresponding to the component variable tuple from the architectural semantic model; the architectural semantic model is a model obtained by semantic extraction based on a building information model (BIM) model;

[0027] A saving unit, used for respectively associating each component entity binary tuple with the component entity tuple and saving them in a mapping list;

[0028] A determination unit, for calculating each component entity binary based on the current computational rule for each computational rule, determining a target component entity binary that satisfies the current computational rule, and querying a target component entity tuple corresponding to the target component entity binary from the mapping list;

[0029] The second acquisition unit is used to acquire a final query result for the SNL rule from the target component entity tuple based on the result tag.

[0030] Optionally, the marking unit includes:

[0031] A first marking module, for marking a target component variable representing a query result as a result variable when the result part of the SNL rule does not include a computational rule;

[0032] The second marking module is used to mark the computational rules included in the result part of the SNL rule as result clauses when the result part of the SNL rule includes computational rules.

[0033] Optionally, the second marking module is used to mark the computational rules included in the result part of the SNL rules as result clauses in the computational rule information configuration file; the computational rule configuration file includes the computational rule content based on the SNL description, the component variable mapping relationship involved in the computational rule, and a mark of whether it belongs to the result clause.

[0034] Optionally, the second acquisition unit includes:

[0035] A first acquisition module is used for acquiring a component entity corresponding to a result variable from the target component entity tuple as a final query result if a query header of a SPARQL check statement corresponding to the SNL rule contains a result variable tag;

[0036] The second acquisition module is used to obtain the component entity binary corresponding to the computational rule marked as the result clause from the target component entity tuple as the final query result if the computational rule information configuration file corresponding to the SNL rule contains a result clause mark.

[0037] Optionally, the saving unit is used to use the component entity binary tuple as the key and the component entity tuple corresponding to the component entity binary tuple as the value to save it in the hash table.

[0038] In a third aspect, an embodiment of the present invention provides a storage medium having executable instructions stored thereon, which, when executed by a processor, enables the processor to implement the method described in the first aspect.

[0039] In a fourth aspect, an embodiment of the present invention provides an electronic device, including:

[0040] one or more processors;

[0041] a storage device for storing one or more programs,

[0042] When the one or more programs are executed by the one or more processors, the one or more processors implement the method described in the first aspect.

[0043] It can be seen from the above content that the multi-computational unit integrated BIM model checking method and device provided by the embodiment of the present invention can extract all necessary variables (including component variables involved in the computational rules of the conditional part of the SNL rule and component variables involved in the result part) at one time when performing data extraction, and store them as a tuple, and mark the result with the rule type of the result part of the SNL rule; then query the building semantic model through the SPARQL check statement, obtain all component entity tuples and corresponding component entity tuples required for each computational rule, and associate and save the two; then obtain the corresponding component entity tuple for each computational rule for calculation, determine the target component entity tuple that meets the current computational rule, and obtain the target component entity tuple corresponding to the target component entity tuple from the pre-saved mapping relationship; finally, according to the result mark, obtain the final query result for the SNL rule from the target component entity tuple. It can be seen that, since the embodiment of the present invention extracts all necessary variables to form a tuple in advance and marks them according to the rule type, then extracts necessary variables from the tuple for different computational rules and inputs them into the geometric calculation unit, after each calculation, the corresponding data is retained from the original tuple according to the return value and the mark, and the necessary results are output at the final output, so the required results can be correctly output each time according to the pre-performed result marking, and the entire process is to calculate independently for each computational rule, without the phenomenon of component elimination. Of course, any product or method implementing the present invention does not necessarily need to achieve all the advantages described above at the same time.

[0044] The innovative features of the embodiments of the present invention include but are not limited to the following:

[0045] 1. Through a new computational rule framework, "extract all necessary component variables to form component variable tuples" -> "mark component variables or computational rules according to rule types" -> "build a mapping list containing component entity tuples and component entity tuples" -> "calculate computational rules for each entity tuple to obtain target entity tuples that meet the conditions" -> "query the target component entity tuple corresponding to the target component entity tuple from the mapping list" -> "obtain the final query result from the target component entity tuple according to the result marking", it can avoid the problems of "failure to correctly output the required results" and "missing multiple component eliminations". Among them, when the result part of the SNL rule does not include computational rules, the target component variable representing the query result is marked as a result variable in the query header of the SPARQL check statement; when the result part of the SNL rule includes computational rules, the computational rule is marked as a result clause in the computational rule information configuration file. This marking method can facilitate the final output of the result according to the marking.

[0046] 2. By using the component entity binary tuple as the key and the component entity tuple corresponding to the component entity binary tuple as the value and saving them in the hash table, the amount of data can be reduced and the storage space can be saved. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the prior art descriptions. Obviously, the drawings described below are only some embodiments of the present invention. For those of ordinary skill in the art, other drawings can also be obtained based on these drawings without creative work.

[0048] Figure 1 A schematic diagram of a process for checking a building model based on a BIMChecker tool provided in the prior art;

[0049] Figure 2 A schematic flow chart of a multi-computing unit integrated BIM model checking method provided by an embodiment of the present invention;

[0050] Figure 3 An example diagram of a model checking method based on computational rules provided by an embodiment of the present invention;

[0051] Figure 4 A system architecture diagram of a BIMChecker tool provided in an embodiment of the present invention;

[0052] Figure 5 A class diagram for storing computational rule data provided by an embodiment of the present invention;

[0053] Figure 6 A model checking timing diagram based on computational rules provided by an embodiment of the present invention;

[0054] Figure 7 A schematic diagram of model checking results of a computational rule framework provided for the prior art;

[0055] Figure 8 A schematic diagram of a model checking result of a computational rule framework provided by an embodiment of the present invention;

[0056] Fig. 9 An example diagram of the position of an erroneous component in a model provided by an embodiment of the present invention;

[0057] Fig.10 A block diagram of a BIM model checking device integrating multiple computing units provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0058] The following will be combined with the accompanying drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0059] It should be noted that the terms "including" and "having" and any variations thereof in the embodiments of the present invention and the accompanying drawings are intended to cover non-exclusive inclusions. For example, a process, method, system, product or device comprising a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to these processes, methods, products or devices.

[0060] Structurally, SNL can be divided into simple sentences, complex sentences and conditional sentences.

[0061] Simple sentence = (prefix noun phrase (suffix noun phrase ((<and>|<or>) suffix noun phrase)*)|(prefix noun verb phrase ((<and>|<or>) verb phrase)*))

[0062] Complex sentence = simple sentence (<and> simple sentence)*

[0063] Conditional Sentences <if>(compound conditional sentence | there is a conditional sentence)

[0064] <then>(compound conditional sentence | there is a conditional sentence)

[0065] For example, if the original clause is "For civil buildings with a building height greater than 100m, the fire resistance limit of the floor shall not be less than 2.00h", then the SNL expression can be found in text 1:

[0066] Text 1

[0067]

[0068] The above examples are common rule samples based on SNL. The conditional part (i.e., the if part) of the following text 2 involves a computational rule ("the wall between area A-area B"), and the result part of text 3 involves a computational rule ("the minimum orthogonal horizontal distance of the outer window C-outer window D is >= 1000"). From the examples, it can be observed that SNL is easy to understand and can basically be read smoothly according to the word order of Chinese.

[0069] Text 2

[0070]

[0071] Text Three

[0072]

[0073] In the BIMChecker tool, a large number of computational rule geometry calculation units have been designed and implemented to meet the calculation requirements of various component geometric relationships. Each computational rule module handles an actual inspection requirement. The computational rule module directly obtains the geometric information of the component from the original model information by directly inputting the component ID number, and outputs the result component pair after calculation. The above computational rule module can check and give results for specific inspection requirements, but because of the flexibility of SNL itself, a clause may have more than one computational rule, and the position of the computational rule can be in both "if" and "then", so a single computational rule cannot play a role independently, and a computational framework is needed to integrate SPARQL query and computational rule inspection results. Based on this, the prior art proposes a set of computational rule frameworks, and its basic principles are as follows.

[0074] The computational rules are abstractly represented as S if ,S ifcomp ,S then ,S thencomp Four parts, SNL can be expressed as follows: if And S ifcomp Then S then And S thencomp , converted into logical form, it can be expressed as follows:

[0075]

[0076] Based on the results of the above logical calculations, SPARQL is used to calculate S if as well as The result is that the corresponding component is input into S ifcomp and The two computational rules are used to calculate the geometry of the component pairs obtained by intersection calculation and union calculation to obtain the final inspection result.

[0077] Input the TTL model into two SPARQLs to obtain query results. The query results here are ID pairs composed of ElementId of two computational rules. Part of the SPARQL query results are input into S ifcomp , get the query result, the result is ListA; S if Part of the SPARQL query results are input into S ifcomp , the result is ListB; S if Partial SPARQL query result input The result is ListC. Now the formula in the computational rule framework becomes the following form: ListA∨(ListB∧ListC). Take the intersection of the corresponding component pairs and then take the union of them. The final result is the query result of the computational rule.

[0078] However, the above computational rule framework has the following problems:

[0079] Problem 1: Unable to correctly output the required results

[0080] After calculating SPARQL, the computational rule framework inputs the component pairs that meet the conditions into the computation unit, and the output component pair set is a subset of the input component pair set. When the computational rule only exists in "if", due to the requirements of the computational rule, it must query the component pairs required by the computational rule in "if" and input them into the geometric computation unit. The output is the component pairs queried by the geometric computation unit, not the component objects queried in "then".

[0081] Problem 2: Incorrect review results due to design flaws in elimination

[0082] The computational rule framework eliminates components based on their IDs, but if the computational rule framework involves multiple groups of components of different types, elimination errors may occur.

[0083] In order to solve the above problems, the present invention provides a BIM model checking method and device for multiple computing units. The method provided in the embodiment of the present invention can be applied to any electronic device with computing capabilities, which can be a terminal or a server. In one implementation, the functional software implementing the method can exist in the form of a separate client software or in the form of a plug-in of the currently related client software, which is possible.

[0084] The embodiments of the present invention are described in detail below.

[0085] Figure 2 A flowchart of a multi-computing unit integrated BIM model checking method provided by an embodiment of the present invention. The method may include the following steps:

[0086] S100: In a process of generating a SPARQL check statement based on an SNL rule, extracting a plurality of target component variables from the SNL rule to form a component variable tuple.

[0087] The SNL rules are building code clauses written based on SNL, and the target component variables include component variables involved in the computational rules of the conditional part of the SNL rules and component variables involved in the result part.

[0088] Taking the above-mentioned text 2 as an example, when extracting the target component variable from the SNL rule, the conditional part of text 2 involves the SNL fragment of the computational rule "wall between area A-area B", and the component variables involved are "wall", "area A" and "area B". The result SNL fragment is "fire resistance limit of wall>=2.0", and the component variable involved is "wall". Combining the above information, the SNL rule involves 3 target component variables "wall", "area A" and "area B", which can constitute a component variable tuple (wall, area A, area B). Similarly, the component variable tuple of text three is (room A, room B, external window C, external window D).

[0089] S110: Mark the result according to the rule type of the result part in the SNL rule.

[0090] In practical applications, when the rule types involved in the result part of the SNL rule are different, the source of the results to be output is different. When the result part of the SNL rule does not include computational rules, the target component variable representing the query result is marked as a result variable, such as adding an "aim" tag. When the result part of the SNL rule includes computational rules, the computational rules included in the result part of the SNL rule are marked as result clauses.

[0091] While the non-computational part is organized into SPARQL, the computational rule part also needs to be organized uniformly. Each computational rule is checked against a specific component, and it is necessary to record the variable names involved. All this information is organized together to obtain a computational rule information configuration file, so that subsequent queries, calculations, and other operations can be performed according to the computational rule information configuration file. Therefore, when marking the computational rules, the computational rules included in the result part of the SNL rule can be marked as result clauses in the computational rule information configuration file; the computational rule configuration file includes the computational rule content described based on the SNL, the component variable mapping relationship involved in the computational rule, and a mark of whether it belongs to the result clause.

[0092] For example, the contents of the calculation rule configuration file can be as follows:

[0093]

[0094] S120: Add the component variable tuple to the query header of the SPARQL check statement.

[0095] In order to retain the above tuples in the SPARQL query results, except for the variables that need to be used as query results, the other parts are consistent with the existing SPARQL generation method, so other parts do not need to be changed, and only the SELECT part needs to be modified. Taking the SNL described in Text 2 and Text 3 as examples, the SPARQL query headers used to generate them are shown in Text 4 and Text 5 respectively. The component variables that need to be retained in Text 2 are (wall, area A, area B), where the query result to be output is wall, so it is marked as aim variable in Text 2 to obtain Text 4. The component variables that need to be retained in Text 3 are (room A, room B, external window C, external window D), and the query result to be output is a tuple composed of (external window C, external window D). Because the queried part is "then the minimum orthogonal horizontal distance of the external window C-external window D is >= 1000", this computational rule needs to be marked as a "result clause".

[0096] Text 4

[0097]

[0098] Text Five

[0099]

[0100] S130: In the process of querying the building semantic model based on the SPARQL check statement, for each computational rule, two component variables involved in the current computational rule are obtained from the component variable tuple, and all component entity tuples corresponding to the two component variables and component entity tuples corresponding to the component variable tuples are queried from the building semantic model, and each component entity tuple is associated with the component entity tuple and saved in a mapping list.

[0101] The architectural semantic model is a model obtained by semantic extraction based on the building information model BIM model, such as a TTL model. Using the generated SPARQL to query the model will obtain a large number of tuples, and the input required by the geometric calculation unit of the computational rule is the variable tuple required for the inspection. Therefore, it is necessary to split the required tuples in the tuple and input them into the computational rule. After the computational rule calculates the tuples that meet the terms, the corresponding tuples are screened out in the original data set. The input variables of each computational rule unit are a combination of tuples. In order to maintain the corresponding relationship between the input tuples and the related tuples, this relationship needs to be saved before the computational rule unit is input. In order to save storage space, the component entity tuple can be used as the key, and the component entity tuple corresponding to the component entity tuple can be used as the value and saved in the hash table.

[0102] S140: For each computational rule, calculate each component entity binary based on the current computational rule, determine a target component entity binary that satisfies the current computational rule, and query the target component entity tuple corresponding to the target component entity binary from the mapping list.

[0103] For example, Figure 3 As shown, for the computational rules shown in text 4, the four-tuple composed of (A, B, C, D) is obtained by extracting the target component variables. First, when calculating the first computational rule, only the two-tuple composed of the variable (A, B) is required. The two elements (A, B) are taken out from all the four-tuples to form a mapping of (A, B) to (A, B, C, D) such two-tuple to four-tuple. Then, with (A, B) as the key and (A, B, C, D) as the value, the data is added to the hash table. All (A, B) two-tuples are input into the geometric calculation unit. After the geometric calculation unit calculates the two-tuples that meet the conditions, the corresponding tuples are read from the hash table. For example, if the (A, B) two-tuple passes the check in the geometric calculation unit, all the corresponding tuples are included in the result set for subsequent calculations, and the tuples corresponding to the two-tuples that do not pass the check are automatically deleted because they are not included in the subsequent calculations. Subsequently, because the second computational rule requires the two-tuple composed of (C, D) as input, the calculation results are obtained in the same way.

[0104] Next, we analyze the time complexity of the above algorithm. In the pre-processing stage, the time complexity of adding each valid binary to the hash table is O(1), and the total time complexity is O(n). In the post-processing stage, the time complexity of each query when retrieving data from the hash table is O(1). The total amount of data is no more than n, and the total time complexity is O(n). Therefore, excluding the time taken by the computational rule module itself, the time complexity of the framework to organize input data and statistical results is O(n), and the calculation can be completed within linear time complexity.

[0105] S150: Based on the result tag, obtain a final query result for the SNL rule from the target component entity tuple.

[0106] Specifically, if the query header of the SPARQL check statement corresponding to the SNL rule contains a result variable tag, it means that the result part of the SNL rule does not involve a computational rule, and the component entity corresponding to the result variable can be obtained from the target component entity tuple as the final query result. For example, in text 4, it is mentioned that the tuple to be queried is (?A,?B,?aim), and the variable? aim is the wall to be queried. Therefore, after the query obtains the tuple, the value corresponding to the variable aim is taken out of the tuple, and the result set is sorted and output as the final query result.

[0107] If the computational rule information configuration file corresponding to the SNL rule contains a result clause tag, it means that the result part of the SNL rule involves computational rules, and the component entity tuple corresponding to the computational rule marked as the result clause can be obtained from the target component entity tuple as the final query result, that is, the result of the last calculation can be directly output to the error list as the final result. For example, the SNL in text three has sorted out all the necessary information of the computational rules in the previous steps (see the computational rule configuration file for details). It can be noticed that the second computational rule is marked as a result computational rule. The tuple required by this computational rule is (C, D). Therefore, the embodiment of the present invention takes out the (C, D) tuple from all the tuples as the result set output.

[0108] The multi-computational unit integrated BIM model checking method provided by the embodiment of the present invention can extract all necessary variables (including component variables involved in the computational rules of the conditional part of the SNL rule and component variables involved in the result part) at one time and store them as a tuple when performing data extraction, and mark the result with the rule type of the result part of the SNL rule; then query the building semantic model through the SPARQL check statement, obtain all component entity tuples and corresponding component entity tuples required for each computational rule, and associate and save the two; then obtain the corresponding component entity tuple for each computational rule to perform calculation, determine the target component entity tuple that satisfies the current computational rule, and obtain the target component entity tuple corresponding to the target component entity tuple from the pre-saved mapping relationship; finally, according to the result mark, obtain the final query result for the SNL rule from the target component entity tuple. It can be seen that since the embodiment of the present invention pre-extracts all necessary variables to form a tuple and marks them according to the rule type, then extracts the necessary variables from the tuple according to different computational rules and inputs them into the geometric calculation unit, after each calculation, the corresponding data is retained from the original tuple according to the return value and the mark, and the necessary results are output at the end, the required results can be correctly output each time according to the pre-performed result marking, and the entire process is to perform calculations independently for each computational rule, and there is no component elimination phenomenon.

[0109] Based on the above method embodiment, another embodiment of the present invention provides a BIMChecker tool system, such as Figure 4 As shown, the system includes a Revit model parsing module, an SNL file parsing module, a TTL model generation module, a SPARQL query generation module, a computational rule framework module, a geometric calculation unit module and a SPARQL query engine module.

[0110] The Revit model parsing module is a separately made Revit plug-in that parses the Revit model based on the .NET API provided by Revit and stores the information of the entire model as a Json file for subsequent inspection work.

[0111] The SNL file parsing module is used to store the query SNL statements and related rule texts in an independent SNL file in the form of XML. This module parses the relevant information from the SNL file and stores it in the memory for subsequent work.

[0112] The TTL model generation module extracts information from the Json file obtained by parsing the Revit model and converts it into a TTL semantic model.

[0113] The SPARQL query generation module converts the SNL language provided by the SNL file into the SPARQL language for model checking.

[0114] The computational rule framework module is responsible for processing the SNL related to the computational rules, generating SPARQL dedicated to the computational rules, inputting the query results into each corresponding geometric calculation unit for calculation, and summarizing the calculation results. That is, this module is mainly used to execute the above method.

[0115] The geometric calculation unit module prepares a variety of independent geometric calculation functions to calculate related geometric problems in response to different computational rule requirements.

[0116] After the TTL model and the SPARQL query are prepared, the SPARQL query engine module performs the final SPARQL query in the module. The embodiment of the present invention uses the ARQ engine provided by Jena to perform the SPARQL query.

[0117] The following introduces the system architecture and implementation details of the computational rule framework module. Figure 5 The class diagram for storing computational rule data is shown, where the CompSimple class records the information required for a single computational rule, the member variable output variable marks whether the computational rule is a result rule, and the member variable compVars records the components involved in the computational rule and the corresponding SPARQL variable name consisting of (component, variable name) pairs. MultipleCompSparqlStruct records the relevant information of all computational rules in the entire SNL, where the member variable sparql records the original SPARQL of the computational rule, the member variable compSimples records the relevant information of each computational rule, and the member variable varMap records the (component, variable name) pairs consisting of the components corresponding to each variable in the multi-tuple obtained by SPARQL and the SPARQL variable name. This information will be used in the computational rule checking process.

[0118] The timing diagram of the entire computational rule checking process is as follows: Figure 6 As shown, the check first obtains the SPARQL required for the computational rules in SNL and all the computational rule information in SNL from the solveComputationalRule function through the function Snl2MultipleCompSparql, and the return type is MultipleCompSparqlStruct. Then, call the QuerySPARQL function to perform a SPARQL query, which will return a query result tuple after SPARQL reordering. Then, loop through the CompSimple information of all computational rules, obtain the tuple to be queried from the tuple, input the geometric calculation unit function compFunc corresponding to the computational rule, and the function returns the tuple that passes the check and then restores it to the tuple to be queried. After each computational rule has executed the corresponding check, based on whether the result type is a computational rule, take out the corresponding data from the remaining tuple and return the output to obtain the check result.

[0119] The following is an actual case to illustrate the effect of model checking based on the new computational rule framework:

[0120] (I) Case Model

[0121] The model-related information used for testing in the embodiment of the present invention is shown in Table 1. Since the measurement of model volume can be based on the model volume or the number of data such as various entities and relationships in the model, they are listed here. The information in the table is based on the TTL information extracted during the actual inspection.

[0122] Table 1

[0123] Model Name Model size Entity Attributes Relationship A villa model 9.2MB 254 3121 595 Model of a startup building 124MB 7292 58182 25279 A middle school project building 42.8MB 6461 39978 21266

[0124] 2. Computational rule framework testing

[0125] The embodiment of the present invention uses a case to illustrate the application of the computational rule framework in an actual project. The building model of a middle school project is checked using the Code for Fire Protection Design of Buildings. Taking Article 8.1.7 of the Code for Fire Protection Design of Buildings as an example, the SNL compiled based on this article is shown in Text 6.

[0126] Text 6

[0127]

[0128] The new computational rule framework and the original computational rule framework were used for testing. The results are as follows: Figure 7 and Figure 8 As shown in the figure, it can be seen that the old calculation rule outputs the component pairs of the room instead of the wall components to be checked. The new calculation rule correctly obtains the wall as the check result. Fig. 9 As shown, check the IDs of the two rooms and the wall in the middle respectively, which is Figure 7 and Figure 8 The three IDs found indicate that the computational rules correctly handle the result type errors generated by the old computational rules framework.

[0129] Corresponding to the above method embodiment, the embodiment of the present invention provides a BIM model checking device integrated with multiple computing units, such as Fig.10 As shown, the device may include:

[0130] The extraction unit 20 is used to extract multiple target component variables from the building rule description language SNL rule to form a component variable tuple in the process of generating a SPARQL check statement based on the SNL rule; the SNL rule is a building specification clause written based on SNL, and the target component variables include the component variables involved in the calculation rules of the condition part of the SNL rule and the component variables involved in the result part;

[0131] A marking unit 22, used for marking a result according to a rule type of a result part in the SNL rule;

[0132] An adding unit 24, configured to add the component variable tuple to a query header of a SPARQL check statement;

[0133] A first acquisition unit 26 is used for acquiring, for each computational rule, two component variables involved in the current computational rule from the component variable tuple in the process of querying the architectural semantic model based on the SPARQL check statement, and querying all component entity tuples corresponding to the two component variables and component entity tuples corresponding to the component variable tuple from the architectural semantic model; the architectural semantic model is a model obtained by semantic extraction based on a building information model (BIM) model;

[0134] A storage unit 28, used for respectively associating each component entity binary tuple with the component entity tuple and saving them in a mapping list;

[0135] A determination unit 210 is used to calculate each component entity binary based on the current computational rule for each computational rule, determine a target component entity binary that satisfies the current computational rule, and query a target component entity tuple corresponding to the target component entity binary from the mapping list;

[0136] The second acquisition unit 212 is used to acquire the final query result for the SNL rule from the target component entity tuple based on the result tag.

[0137] Optionally, the marking unit 22 includes:

[0138] A first marking module, for marking a target component variable representing a query result as a result variable when the result part of the SNL rule does not include a computational rule;

[0139] The second marking module is used to mark the computational rules included in the result part of the SNL rule as result clauses when the result part of the SNL rule includes computational rules.

[0140] Optionally, the second marking module is used to mark the computational rules included in the result part of the SNL rules as result clauses in the computational rule information configuration file; the computational rule configuration file includes the computational rule content based on the SNL description, the component variable mapping relationship involved in the computational rule, and a mark of whether it belongs to the result clause.

[0141] Optionally, the second obtaining unit 212 includes:

[0142] A first acquisition module is used for acquiring a component entity corresponding to a result variable from the target component entity tuple as a final query result if a query header of a SPARQL check statement corresponding to the SNL rule contains a result variable tag;

[0143] The second acquisition module is used to obtain the component entity binary corresponding to the computational rule marked as the result clause from the target component entity tuple as the final query result if the computational rule information configuration file corresponding to the SNL rule contains a result clause mark.

[0144] Optionally, the storage unit 28 is configured to use the component entity binary tuple as a key and the component entity tuple corresponding to the component entity binary tuple as a value to store them in a hash table.

[0145] The multi-computational unit integrated BIM model checking device provided by the embodiment of the present invention can extract all necessary variables (including component variables involved in the computational rules of the conditional part of the SNL rule and component variables involved in the result part) at one time and store them as a tuple when performing data extraction, and mark the result with the rule type of the result part of the SNL rule; then query the building semantic model through the SPARQL check statement, obtain all component entity tuples and corresponding component entity tuples required for each computational rule, and associate and save the two; then obtain the corresponding component entity tuple for each computational rule to perform calculation, determine the target component entity tuple that satisfies the current computational rule, and obtain the target component entity tuple corresponding to the target component entity tuple from the pre-saved mapping relationship; finally, according to the result mark, obtain the final query result for the SNL rule from the target component entity tuple. It can be seen that since the embodiment of the present invention pre-extracts all necessary variables to form a tuple and marks them according to the rule type, then extracts the necessary variables from the tuple according to different computational rules and inputs them into the geometric calculation unit, after each calculation, the corresponding data is retained from the original tuple according to the return value and the mark, and the necessary results are output at the end, the required results can be correctly output each time according to the pre-performed result marking, and the entire process is to perform calculations independently for each computational rule, and there is no component elimination phenomenon.

[0146] Based on the above method embodiment, another embodiment of the present invention further provides a storage medium on which executable instructions are stored. When the instructions are executed by a processor, the processor implements the above method.

[0147] Based on the above method embodiment, another embodiment of the present invention further provides an electronic device, including:

[0148] one or more processors;

[0149] a storage device for storing one or more programs,

[0150] When the one or more programs are executed by the one or more processors, the one or more processors implement the method as described above.

[0151] The above-mentioned system and device embodiments correspond to the method embodiments and have the same technical effects as the method embodiments. For specific descriptions, please refer to the method embodiments. The device embodiments are obtained based on the method embodiments. For specific descriptions, please refer to the method embodiment part, which will not be repeated here. It can be understood by those of ordinary skill in the art that the accompanying drawings are only schematic diagrams of one embodiment, and the modules or processes in the accompanying drawings are not necessarily necessary for implementing the present invention.

[0152] Those skilled in the art can understand that the modules in the device in the embodiment can be distributed in the device in the embodiment according to the description of the embodiment, or can be changed accordingly and located in one or more devices different from the embodiment. The modules in the above embodiment can be combined into one module, or can be further divided into multiple sub-modules.

[0153] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present invention.< / then> < / if>

Claims

1. A multi-computational unit integrated BIM model checking method, characterized in that: The method comprises: In the process of generating a SPARQL check statement based on a building rule description language SNL rule, a plurality of target component variables are extracted from the SNL rule to form a component variable tuple; the SNL rule is a building specification clause written based on SNL, and the target component variables include component variables involved in the computational rules of the condition part of the SNL rule and component variables involved in the result part; Marking the result according to the rule type of the result part in the SNL rule; Adding the component variable tuple to the query header of a SPARQL check statement; In the process of querying the building semantic model based on the SPARQL check statement, for each computational rule, two component variables involved in the current computational rule are obtained from the component variable tuple, and all component entity tuples corresponding to the two component variables and component entity tuples corresponding to the component variable tuple are queried from the building semantic model, and each component entity tuple is associated with the component entity tuple and saved in a mapping list; the building semantic model is a model obtained by semantic extraction based on a building information model (BIM) model; For each computational rule, each component entity binary is calculated based on the current computational rule to determine a target component entity binary that satisfies the current computational rule, and a target component entity tuple corresponding to the target component entity binary is searched from the mapping list; Based on the result tag, a final query result for the SNL rule is obtained from the target component entity tuple.

2. The method according to claim 1, characterized in that The result is marked according to the rule type of the result part in the SNL rule, including: When the result part of the SNL rule does not include computational rules, the target component variable representing the query result is marked as a result variable; when the result part of the SNL rule includes computational rules, the computational rules included in the result part of the SNL rule are marked as result clauses.

3. The method according to claim 2, characterized in that The computational rules included in the result part of the SNL rule are marked as result clauses, including: In the computational rule information configuration file, the computational rules included in the result part of the SNL rule are marked as result clauses; the computational rule configuration file includes the computational rule content based on the SNL description, the component variable mapping relationship involved in the computational rule, and a mark of whether it belongs to the result clause.

4. The method according to claim 3, characterized in that Based on the result tag, obtaining a final query result for the SNL rule from the target component entity tuple includes: If the query header of the SPARQL check statement corresponding to the SNL rule contains a result variable tag, then obtaining the component entity corresponding to the result variable from the target component entity tuple as the final query result; If the computational rule information configuration file corresponding to the SNL rule contains a result clause tag, then the component entity tuple corresponding to the computational rule marked as the result clause is obtained from the target component entity tuple as the final query result.

5. The method according to any one of claims 1 to 4, characterized in that Each component entity tuple is associated with the component entity tuple and saved in a mapping list, including: The component entity binary is used as a key, and the component entity tuple corresponding to the component entity binary is used as a value and saved in a hash table.

6. A BIM model checking device integrated with multiple computing units, characterized in that: The device comprises: An extraction unit is used to extract multiple target component variables from a building rule description language SNL rule to form a component variable tuple in a SPARQL check statement process generated based on the SNL rule; the SNL rule is a building specification clause written based on SNL, and the target component variables include component variables involved in the computational rules of the condition part of the SNL rule and component variables involved in the result part; A marking unit, used for marking a result according to a rule type of a result part in the SNL rule; An adding unit, used for adding the component variable tuple to the query header of the SPARQL check statement; A first acquisition unit is used for acquiring, for each computational rule, two component variables involved in the current computational rule from the component variable tuple in the process of querying the architectural semantic model based on the SPARQL check statement, and querying all component entity tuples corresponding to the two component variables and component entity tuples corresponding to the component variable tuple from the architectural semantic model; the architectural semantic model is a model obtained by semantic extraction based on a building information model (BIM) model; A saving unit, used for respectively associating each component entity binary tuple with the component entity tuple and saving them in a mapping list; A determination unit, for calculating each component entity binary based on the current computational rule for each computational rule, determining a target component entity binary that satisfies the current computational rule, and querying a target component entity tuple corresponding to the target component entity binary from the mapping list; The second acquisition unit is used to acquire a final query result for the SNL rule from the target component entity tuple based on the result tag.

7. The device according to claim 6, characterized in that The marking unit comprises: A first marking module, for marking a target component variable representing a query result as a result variable when the result part of the SNL rule does not include a computational rule; The second marking module is used to mark the computational rules included in the result part of the SNL rule as result clauses when the result part of the SNL rule includes computational rules.

8. The device according to claim 7, characterized in that The second marking module is used to mark the computational rules included in the result part of the SNL rules as result clauses in the computational rule information configuration file; the computational rule configuration file includes the computational rule content described based on the SNL, the component variable mapping relationship involved in the computational rule, and a mark of whether it belongs to the result clause.

9. A storage medium, characterized in that: Executable instructions are stored thereon, and when the instructions are executed by a processor, the processor implements the method according to any one of claims 1 to 5.

10. An electronic device, characterized in that: include: one or more processors; a storage device for storing one or more programs, When the one or more programs are executed by the one or more processors, the one or more processors implement the method of any one of claims 1 to 5.

Images