Graph-Based Industrial Flow Model Building System, Apparatus, and Method

Abstract

Various embodiments of the teachings herein include a method for building a graph-based industrial flow model. The method may comprise: importing a set of entities based on an industrial flow including a user-defined entity and a system-defined entity; querying the model for the user-defined entity, and if found, obtaining a connection of the user-defined entity, otherwise generating a new implementation layer; querying the model for an implementation layer of the user-defined entity, and if found, obtaining a connection of the implementation layer of the user-defined entity, otherwise generating a new implementation layer; querying the model for the system-defined entity, and if the system-defined entity is found, obtaining a connection of the system-defined entity, otherwise generating a new implementation layer; and iteratively performing the above queries until a final graph-based model for the industrial flow results.

Claims

1. A method for building a graph-based industrial flow model, the method comprising importing a set of entities based on an industrial flow, wherein the set of entities comprises a user-defined entity and a system-defined entity; querying the industrial flow model for the user-defined entity, and if the user-defined entity is found, obtaining a connection of the user-defined entity, otherwise generating a new implementation layer; querying the industrial flow model for an implementation layer of the user-defined entity, and if the implementation layer of the user-defined entity is found, obtaining a connection of the implementation layer of the user-defined entity, otherwise generating a new implementation layer; querying the industrial flow model for the system-defined entity, and if the system-defined entity is found, obtaining a connection of the system-defined entity, otherwise generating a new implementation layer; and iteratively performing the above queries until a final graph-based model for the industrial flow results.

2. The method according to claim 1, wherein: the set of entities comprises a parameter; and the method further comprises querying the model for the parameter, and if the parameter is not found, generating a new implementation layer.

3. The method according to claim 1, wherein, before the importing step, the method further comprises: analyzing the industrial flow and decomposing the industrial flow into a plurality of entities, the entities comprising user-defined entities, system-defined entities, and parameters; and dividing the plurality of entities into sets, each set of entities comprising a user-defined entity and a system-defined entity, or a user-defined entity, a system-defined entity and a parameter, wherein each set of entities represents a different industrial process.

4. The method according to claim 3, the industrial flow comprises a plurality of sets of entities; and after the set dividing step, the method further comprises sorting the plurality of sets of entities of the industrial flow.

5. The method according to claim 3, wherein the industrial flow model building method further comprises connecting one implementation layer to another implementation layer to indicate that the implementation layer is implemented by another implementation layer.

6. A graph-based industrial flow model building system comprising: a processor; and a memory coupled to the processor, wherein the memory stores instructions that, when executed by the processor, cause an electronic device to: import a set of entities based on an industrial flow, wherein the set of entities comprises a user-defined entity and a system-defined entity; query the model for the user-defined entity, and if the user-defined entity is found, obtaining a connection of the user-defined entity, otherwise generating a new implementation layer; query the model for an implementation layer of the user-defined entity, and if the implementation layer of the user-defined entity is found, obtain a connection of the implementation layer of the user-defined entity, otherwise generating a new implementation layer; and query the model for the system-defined entity, and if the system-defined entity is found, obtain a connection of the system-defined entity, otherwise generating a new implementation layer; and iteratively perform the above actions until a final graph-based model results.

7. The graph-based industrial flow model building system according to claim 6, wherein: the set of entities comprises a parameter; and the actions further comprise query the model for the parameter, and if the parameter is not found, generating a new implementation layer.

8. The graph-based industrial flow model building system according to claim 6, wherein, before the importing action, the actions further comprise: analyzing the industrial flow and decomposing the industrial flow into a plurality of entities, the entities comprising user-defined entities, system-defined entities and parameters; and dividing the plurality of entities into sets, each set of entities comprising a user-defined entity and a system-defined entity, or a user-defined entity, a system-defined entity and a parameter, wherein each set of entities represents a different industrial process.

9. The graph-based industrial flow model building system according to claim 8, wherein: the industrial flow comprises a plurality of sets of entities; after the set dividing action, the actions further comprise sorting the plurality of sets of entities of the industrial flow.

10. The graph-based industrial flow model building system according to claim 8, wherein the actions further comprise connecting one implementation layer to another implementation layer to indicate that the implementation layer is implemented by another implementation layer.

11-12. (canceled)

13. A computer-readable medium having stored thereon computer-executable instructions that, when executed, cause at least one processor to: import a set of entities based on an industrial flow, wherein the set of entities comprises a user-defined entity and a system-defined entity; query the industrial flow model for the industrial flow for the user-defined entity, and if the user-defined entity is found, obtaining a connection of the user-defined entity, otherwise generating a new implementation layer; query the industrial flow model for an implementation layer of the user-defined entity, and if the implementation layer of the user-defined entity is found, obtaining a connection of the implementation layer of the user-defined entity, otherwise generating a new implementation layer; and query the industrial flow model for system-defined entity, and if the system-defined entity is found, obtaining a connection of the system-defined entity, otherwise generating a new implementation layer, and iteratively perform the above queries until a final graph-based model for the industrial flow results.

Description

BRIEF DESCRIPTION OF THE DRAWINGS

[0022] FIG. 1 is a schematic diagram of a model in which one user-defined entity is defined by two system-defined entities;

[0023] FIG. 2 is a schematic diagram of a model in which a user-defined entity is defined by a system-defined entity by using three different parameters;

[0024] FIG. 3 is a schematic diagram of adding an intermediate layer to an industrial flow model by a graph-based industrial flow model building mechanism incorporating teachings of the present disclosure;

[0025] FIG. 4 is a schematic structural diagram of a graph-based industrial flow model building apparatus incorporating teachings of the present disclosure; and

[0026] FIG. 5 is a schematic structural diagram of a model in which a graph-based industrial flow mechanism is carried out incorporating teachings of the present disclosure.

DETAILED DESCRIPTION

[0027] The teachings of the present disclosure include a graph-based industrial flow model building method, the method including: importing a set of entities which are based on one industrial flow, to build a graph-based model for the industrial flow, where the set of entities includes a user-defined entity and a system-defined entity; querying the graph-based model for the industrial flow for the user-defined entity, and if the user-defined entity is found, obtaining a connection of the user-defined entity, otherwise generating a new implementation layer; querying the model for an implementation layer of the user-defined entity, and if the implementation layer of the user-defined entity is found, obtaining a connection of the implementation layer of the user-defined entity, otherwise generating a new implementation layer; and querying the model for the system-defined entity, and if the system-defined entity is found, obtaining a connection of the system-defined entity, otherwise generating a new implementation layer, and iteratively performing the above steps until a final graph-based model for the industrial flow is obtained.

[0028] In some embodiments, the set of entities includes a user-defined entity, a system-defined entity and a parameter, and the industrial flow model building method further includes querying the model for the parameter, and if the parameter is not found, generating a new implementation layer.

[0029] In some embodiments, before the importing step, the method further includes the following steps: analyzing the industrial flow and decomposing the industrial flow into a plurality of entities, the entities including user-defined entities, system-defined entities and parameters; and dividing the plurality of entities into sets, each set of entities including a user-defined entity and a system-defined entity, or a user-defined entity, a system-defined entity and a parameter, where each set of entities represents a different industrial process.

[0030] In some embodiments, the industrial flow includes a plurality of sets of entities, where after the set dividing step, the method further includes sorting the plurality of sets of entities of the industrial flow.

[0031] In some embodiments, the industrial flow model building method further includes connecting one implementation layer to another implementation layer to indicate that the implementation layer is implemented by another implementation layer.

[0032] Some embodiments include a graph-based industrial flow model building system, the system including: a processor; and a memory coupled to the processor, where the memory stores instructions that, when executed by the processor, cause an electronic device to perform actions including: importing a set of entities which are based on one industrial flow, to build a graph-based model for the industrial flow, where the set of entities includes a user-defined entity and a system-defined entity; querying the graph-based model for the industrial flow for the user-defined entity, and if the user-defined entity is found, obtaining a connection of the user-defined entity, otherwise generating a new implementation layer; querying the model for an implementation layer of the user-defined entity, and if the implementation layer of the user-defined entity is found, obtaining a connection of the implementation layer of the user-defined entity, otherwise generating a new implementation layer; and querying the model for the system-defined entity, and if the system-defined entity is found, obtaining a connection of the system-defined entity, otherwise generating a new implementation layer, and iteratively performing the above actions until a final graph-based model for the industrial flow is obtained.

[0033] In some embodiments, the set of entities includes a user-defined entity, a system-defined entity and a parameter, and the actions further include: querying the model for the parameter, and if the parameter is not found, generating a new implementation layer.

[0034] In some embodiments, before the importing action, the actions further include analyzing the industrial flow and decomposing the industrial flow into a plurality of entities, the entities including user-defined entities, system-defined entities and parameters; and dividing the plurality of entities into sets, each set of entities including a user-defined entity and a system-defined entity, or a user-defined entity, a system-defined entity and a parameter, where each set of entities represents a different industrial process.

[0035] In some embodiments, the industrial flow includes a plurality of sets of entities, where after the set dividing action, the actions further include sorting the plurality of sets of entities of the industrial flow.

[0036] In some embodiments, the actions further include connecting one implementation layer to another implementation layer to indicate that the implementation layer is implemented by another implementation layer.

[0037] Some embodiments include a graph-based industrial flow model building apparatus, the apparatus including: an importing means, which imports a set of entities which are based on one industrial flow, to build a graph-based model for the industrial flow, where the set of entities includes a user-defined entity and a system-defined entity; a first query means, which queries the graph-based model for the industrial flow for the user-defined entity, and if the user-defined entity is found, obtains a connection of the user-defined entity, otherwise generates a new implementation layer; a second query means, which queries the model for an implementation layer of the user-defined entity, and if the implementation layer of the user-defined entity is found, obtains a connection of the implementation layer of the user-defined entity, otherwise generates a new implementation layer; and a third query means, which queries the model for the system-defined entity, and if the system-defined entity is found, obtains a connection of the system-defined entity, otherwise generates a new implementation layer.

[0038] Some embodiments include a computer program product tangibly stored on a computer-readable medium and including computer-executable instructions that, when executed, cause at least one processor to perform one or more of the methods as described in the present disclosure.

[0039] Some embodiments include a computer-readable medium having stored thereon computer-executable instructions that, when executed, cause at least one processor to perform one or more of the methods as described in the present disclosure.

[0040] The teachings of the present disclosure may be used to generate an intermediate layer in the user-defined entity and the system-defined entity, which can prevent ambiguity of a flow and logic in an industrial flow model. The implementation layer will be automatically generated once a user connects one system-defined entity to one user-defined entity, which indicates that the user-defined entity is implemented by one system-defined entity. Because the implementation layer is to ensure correct reflection of different processes in a graph-based industrial flow graph, any change in an entity connected to a specific intermediate layer will cause the generation of a new intermediate layer, while original unchanged entities remain the same, such that the change in the entity can be reflected in the industrial flow graph.

[0041] Various specific embodiments of the teachings of the present disclosure are described below in conjunction with the accompanying drawings.

[0042] In some embodiments, a graph-based industrial flow model building mechanism, in which an implementation layer is added to an industrial flow model to represent that a user-defined entity is implemented by a system-defined entity, such that the user-defined entity is in a one-to-one correspondence with the system-defined entity, thus distinguishing them during reuse in different industrial flows. Once the system-defined entity or a parameter corresponding to an implementation mode of the user-defined entity is changed, a new implementation layer will be generated.

[0043] These teachings make it possible to generate an intermediate layer in the user-defined entity and the system-defined entity, which can prevent ambiguity of a flow and logic in an industrial flow model. The implementation layer will be automatically generated once a user connects one system-defined entity to one user-defined entity, which indicates that the user-defined entity is implemented by one system-defined entity. Because the implementation layer is to ensure correct reflection of different processes in a graph-based industrial flow graph, any change in an entity connected to a specific intermediate layer will cause the generation of a new intermediate layer, while original entities remain unchanged, such that the change in the entity can be reflected in the industrial flow graph.

[0044] As shown in FIG. 3, in a model M.sub.21, although one user-defined entity UE.sub.21 can be implemented by two system-defined entities SE.sub.21 and SE.sub.22, respectively, one intermediate layer is added to distinguish between each different system-defined entity and the same user-defined entity in the present invention. In other words, an intermediate layer IMP.sub.21 is set between the user-defined entity UE.sub.21 and the system-defined entity SE.sub.21, and an intermediate layer IMP.sub.22 is set between the user-defined entity UE.sub.21 and the system-defined entity SE.sub.22. As shown in FIG. 3, in the model M.sub.21, although there are three different parameters between a user-defined entity UE.sub.22 and a system-defined entity SE.sub.23, an intermediate layer is added, for each parameter, among the user-defined entity, the system-defined entity and a parameter in the present invention. In other words, an intermediate layer IMP.sub.23 is set among a parameter P.sub.1, the user-defined entity UE.sub.22 and the system-defined entity SE.sub.23, an intermediate layer IMP.sub.24 is set among a parameter P.sub.2, the user-defined entity UE.sub.22 and the system-defined entity SE.sub.23, and an intermediate layer IMP.sub.25 is set among a parameter P.sub.3, the user-defined entity UE.sub.22 and the system-defined entity SE.sub.23.

[0045] In some embodiments, a graph-based industrial flow model building method, the method including the steps as follows. As shown in FIG. 4, a graph-based industrial flow model building apparatus 100 includes a user-defined entity filter 101, a first selector 102, an implementation layer filter 103, a second selector 104, a system-defined entity filter 105, a third selector 106, a parameter filter 107, a fourth selector 108, an implementation layer releaser 109, an implementation layer generator 110, a user-defined entity storage S.sub.1, a connection storage S.sub.2, an implementation layer storage S.sub.3, a system-defined entity storage S.sub.4, and a parameter storage S.sub.5.

[0046] First, step A1 is performed, in which step a set of entities based on one industrial flow are imported in the user-defined entity filter 101 to build a graph-based model for the industrial flow, where the set of entities includes a user-defined entity and a system-defined entity. In some embodiments, it is assumed that the input set of entities includes one user-defined entity UE.sub.21 as shown in FIG. 3 and a system-defined entity SE.sub.21 corresponding to the user-defined entity UE.sub.21, to build the graph-based model for the industrial flow, which is a model M.sub.21. Exemplarily, the user-defined entity UE.sub.21 is “transport”, which can be implemented by two system-defined entities, namely, a system-defined entity SE.sub.21 “truck” and a system-defined entity SE.sub.22 “autonomous vehicle”, respectively. However, in the present invention, each time a set of entities needs to be input, namely, one user-defined entity and one system-defined entity that correspond to each other, the user-defined entity UE.sub.21 and the system-defined entity SE.sub.21 are input for the first time in this embodiment.

[0047] Then, step A2 is performed, in which step the graph-based model M.sub.21 for the industrial flow is queried for the user-defined entity UE.sub.21 “transport”, and if the user-defined entity UE.sub.21 “transport” is found, a connection of the UE.sub.21 “transport” is obtained, otherwise a new implementation layer is generated.

[0048] In some embodiments, the user-defined entity storage S.sub.1 is queried to find out whether the user-defined entity UE.sub.21 “transport” exists therein, and if the user-defined entity UE.sub.21 “transport” exists in the user-defined entity storage S.sub.1, the user-defined entity UE.sub.21 “transport” is obtained from the user-defined entity storage S.sub.1 and the connection of the user-defined entity UE.sub.21 “transport” is obtained from the connection storage S.sub.2, and a query result is output to the first selector 102. Otherwise, a query result is output to the first selector 102 and a new implementation layer is generated by the implementation layer generator 110.

[0049] If the user-defined entity UE.sub.21 “transport” can be found, then step A3 is performed, in which step the model M.sub.21 is queried for an implementation layer IMP.sub.21 of the user-defined entity UE.sub.21 “transport”, and if the implementation layer IMI′21 of the user-defined entity UE.sub.21 “transport” can be found, a connection of the implementation layer IMP.sub.21 of the user-defined entity UE.sub.21 “transport” is obtained, otherwise a new implementation layer is generated.

[0050] In some embodiments, it is queried in the implementation layer filter 103 to find out whether the implementation layer IMI′21 of the user-defined entity UE.sub.21 “transport” exists, and if the implementation layer IMP.sub.21 of the user-defined entity UE.sub.21 “transport” exists in the implementation layer storage S.sub.3, the implementation layer IMP.sub.21 is obtained from the implementation layer storage S.sub.3 and the connection of the implementation layer IMP.sub.21 is acquired obtained from the connection storage S.sub.2, and a query result is output to the second selector 104. Otherwise, a query result is output to the second selector 104 and a new implementation layer is generated by the implementation layer generator 110.

[0051] Next, step A4 is performed, in which step the model M.sub.21 is queried for a system-defined entity SE.sub.21 “truck”, and if the system-defined entity SE.sub.21 “truck” can be found, a connection of the system-defined entity SE.sub.21 “truck” is obtained, otherwise a new implementation layer is generated.

[0052] In some embodiments, it is queried in the system-defined entity filter 105 to find out whether the system-defined entity SE.sub.21 “truck” exists, and if the system-defined entity SE.sub.21 “truck” exists in the system-defined entity storage S.sub.4, the system-defined entity SE.sub.21 “truck” is obtained from the system-defined entity storage S.sub.4 and the connection of the system-defined entity SE.sub.21 “truck” is obtained from the connection storage S.sub.2, and a query result is output to the third selector 106. Otherwise, a query result is output to the third selector 106 and a new implementation layer is generated by the implementation layer generator 110. The implementation layer is released by the implementation layer releaser 109.

[0053] By performing steps A1, A2, A3 and A4, the present invention can determine such an industrial flow in which the user-defined entity UE.sub.21 “transport” is implemented by the system-defined entity SE.sub.21 “truck”. The implementation layer IMP.sub.21 is set between the user-defined entity UE.sub.21 “transport” and the system-defined entity SE.sub.21 “truck”, and is used to indicate a unique relationship between the user-defined entity UE.sub.21 “transport” and the system-defined entity SE.sub.21 “truck”. Once any of the user-defined entity UE.sub.21 “transport”, the system-defined entity SE.sub.21 “truck”, and the implementation layer IMP.sub.21 is not found in the model M.sub.21, it is ensured that the logic and sequence of the user-defined entity UE.sub.21 “transport” and the system-defined entity SE.sub.21 “truck” is determined by a unique intermediate layer. Once there is any change in any entity, a new intermediate layer is generated.

[0054] The above steps A1, A2 and A3 are iteratively performed until a final graph-based model M.sub.21 for the industrial flow is obtained. In this embodiment, following the user-defined entity UE.sub.21 “transport”, the system-defined entity SE.sub.21, and the implementation layer IMP.sub.21, a second set of entities is then imported, where the second set of entities includes the user-defined entity UE.sub.21 and a system-defined entity SE.sub.22 “autonomous vehicle”. The graph-based model M.sub.21 for the industrial flow is queried for the user-defined entity UE.sub.21 “transport”, and if the user-defined entity UE.sub.21 “transport” can be found, a connection of the UE.sub.21 “transport” is obtained. Then, the model M.sub.21 is queried for an implementation layer IMP.sub.22 of the user-defined entity UE.sub.21 “transport”, and if the implementation layer IMP.sub.22 of the user-defined entity UE.sub.21 “transport” can be found, a connection of the implementation layer IMP.sub.22 of the user-defined entity UE.sub.21 “transport” is obtained. Next, the model M.sub.21 is queried for the system-defined entity SE.sub.22 “autonomous vehicle”, and if the system-defined entity SE.sub.22 “autonomous vehicle” can be found, a connection of the system-defined entity SE.sub.22 “autonomous vehicle” is obtained. If any of the user-defined entity UE.sub.21 “transport”, the system-defined entity SE.sub.21, and the implementation layer IMP.sub.21 cannot be found, a new implementation layer is generated immediately. The implementation layer IMP.sub.22 is set between the user-defined entity UE.sub.21 “transport” and the system-defined entity SE.sub.22 “autonomous vehicle”, and is used to indicate a unique relationship between the user-defined entity UE.sub.21 “transport” and the system-defined entity SE.sub.22 “autonomous vehicle”. After the above entities are all determined, the final graph-based model M.sub.21 for the industrial flow can be determined.

[0055] In some embodiments, the graph-based model for the industrial flow includes different parameters, in addition to the user-defined entities and the system-defined entities. The set of entities further includes a user-defined entity, a system-defined entity and a parameter. In some embodiments, in a model M.sub.22, a user-defined entity UE.sub.22 “connecting piece” is implemented by a system-defined entity SE.sub.23 “screw”. There are three different parameters “M6”, “M8” and “M12”, which represent screws with diameters of M6, M8 and M12, respectively. However, the user-defined entity UE.sub.22 “connecting piece” is implemented by the system-defined entity SE.sub.23 “screw” with the diameter of M6, the user-defined entity UE.sub.22 “connecting piece” is implemented by the system-defined entity SE.sub.23 “screw” with the diameter of M8, and the user-defined entity UE.sub.22 “connecting piece” is implemented by the system-defined entity SE.sub.23 “screw” with the diameter of M12, which represent three different industrial flows, respectively, and should thus be distinguished.

[0056] Thus, in the iteratively performed step A1, the first set of entities imported in the user-defined entity filter 101 includes the user-defined entity UE.sub.22 “connecting piece”, the system-defined entity SE.sub.23 “screw” and the parameter P1 “M6”, then the second set of entities imported in the user-defined entity filter 101 includes the user-defined entity UE.sub.22 “connecting piece”, the system-defined entity SE.sub.23 “screw” and the parameter P2 “M8”, and finally the third set of entities imported in the user-defined entity filter 101 includes the user-defined entity UE.sub.22 “connecting piece”, the system-defined entity SE.sub.23 “screw” and the parameter P3 “M12”. Steps A2, A3 and A4 are used to determine the logic and sequence of the user-defined entity UE.sub.22 “connecting piece” and the system-defined entity SE.sub.23 “screw”, which are similar to those described in the above embodiment, and will not be repeated for the sake of brevity.

[0057] After the above steps are iteratively performed, it can be determined that the user-defined entity UE.sub.22 “connecting piece” and the system-defined entity SE.sub.23 “screw” exist in the model M.sub.22, and there are three implementation layers between the user-defined entity UE.sub.22 “connecting piece” and the system-defined entity SE.sub.23 “screw”, which are respectively an implementation layer IMP.sub.23, an implementation layer IMP.sub.24, and an implementation layer IMP.sub.25.

[0058] After step A4, the method further includes step A5: the model M.sub.22 is queried for the parameter P1 “M6”, and if the parameter P1 cannot be found, a new implementation layer is generated. In some embodiments, it is queried in the parameter filter 107 to find out whether the parameter P1 “M6” exists, and if the parameter P1 “M6” exists in the parameter storage S.sub.5, the parameter P1 “M6” is obtained from the parameter storage S.sub.5, and a query result is output to the second selector 104. Otherwise, a query result is output to the fourth selector 108 and a new implementation layer is generated by the implementation layer generator 110.

[0059] Similarly, the model M.sub.22 is queried for the parameter P2 “M8”, and if the parameter P1 cannot be found, a new implementation layer is generated. In some embodiments, it is queried in the parameter filter 107 to find out whether the parameter P2 “M8” exists, and if the parameter P2 “M8” exists in the parameter storage S.sub.5, the parameter P2 “M8” is obtained from the parameter storage S.sub.5, and a query result is output to the second selector 104. Otherwise, a query result is output to the fourth selector 108 and a new implementation layer is generated by the implementation layer generator 110.

[0060] In some embodiments, the model M.sub.22 is queried for the parameter P3 “M12”, and if the parameter P3 cannot be found, a new implementation layer is generated. Specifically, it is queried in the parameter filter 107 to find out whether the parameter P3 “M12” exists, and if the parameter P3 “M12” exists in the parameter storage S.sub.5, the parameter P3 “M12” is obtained from the parameter storage S.sub.5, and a query result is output to the second selector 104. Otherwise, a query result is output to the fourth selector 108 and a new implementation layer is generated by the implementation layer generator 110.

[0061] After the above steps are performed, the model M.sub.22 is output.

[0062] In some embodiments, before step A1, the method further includes: analyzing the industrial flow and decomposing the industrial flow into a plurality of entities, the entities including user-defined entities, system-defined entities and parameters; and dividing the plurality of entities into sets, each set of entities including a user-defined entity and a system-defined entity, or a user-defined entity, a system-defined entity and a parameter, where each set of entities represents a different industrial process.

[0063] In some embodiments, the industrial flow includes a plurality of sets of entities, where after the set dividing step, the method further includes the following step: sorting the plurality of sets of entities of the industrial flow. For example, the industrial flow as shown in FIG. 3 is decomposed into three entities, which are respectively the user-defined entity UE.sub.21 “transport”, the system-defined entity SE.sub.21 “truck”, and the system-defined entity SE.sub.22 “autonomous vehicle”. Moreover, the above entities are divided into sets, where a first set of entities includes the user-defined entity UE.sub.21 “transport” and the system-defined entity SE.sub.21 “truck”, and a second set of entities includes the user-defined entity UE.sub.21 “transport” and the system-defined entity SE.sub.22 “autonomous vehicle”. Then, the above two sets of entities are sorted. Optionally, the first set of entities that includes the user-defined entity UE.sub.21 “transport” and the system-defined entity SE.sub.21 “truck” is imported first, and then the second set of entities that includes the user-defined entity UE.sub.21 “transport” and the system-defined entity SE.sub.22 “autonomous vehicle” is imported.

[0064] In some embodiments, the industrial flow as shown in FIG. 3 is decomposed into five entities, which are respectively the user-defined entity UE.sub.22 “connecting piece”, and the system-defined entity SE.sub.23 “screw” and its parameter P1 “M6”, parameter P2 “M8” and parameter P3 “M12”. Then, the above entities are divided into sets, where a first set of entities includes the user-defined entity UE.sub.22 “connecting piece”, and the system-defined entity SE.sub.23 “screw” and its parameter P1 “M6”, a second set of entities includes the user-defined entity UE.sub.22 “connecting piece”, and the system-defined entity SE.sub.23 “screw” and its parameter P2 “M8”, and a third set of entities includes the user-defined entity UE.sub.22 “connecting piece”, and the system-defined entity SE.sub.23 “screw” and its parameter P3 “M12”. Then, the above two sets of entities are sorted. Optionally, the first set of entities is imported first, then the second set of entities is imported, and finally the third set of entities is imported.

[0065] FIG. 5 is a schematic structural diagram of a model in which a graph-based industrial flow mechanism is carried out. In this embodiment, the industrial flow includes two different processes, one of which involves moving an object by a robot of company A that is named “name 1”. The robot “name 1” is performed, but no movement occurs. The robot “name 1” is performed twice by implementation layers IMP.sub.33 and IMP.sub.34 by using a movement module of a programming functional module. The object is moved by an implementation layer IMP.sub.37 that is implemented by the implementation layer IMP.sub.34. Moreover, the autonomous vehicle has moved twice by an implementation layer IMP.sub.35 and an implementation layer IMP.sub.36 by using the same movement module, and the implementation layer IMP.sub.36 performs an implementation layer IMP.sub.38 to move the same object.

[0066] Therefore, in this embodiment, there are both entities that are repeated in the same process and entities that are repeated in different processes, and there are different processes that coexist in the same model, and the above processes are also connected to each other through the entities. Implementation of the teachings herein can make the causal and logical relationships of the industrial flow very clear.

[0067] A model M.sub.23 output after the implementation of the present invention is as shown in FIG. 5. System-defined entities include a robot, companies A, B and C that provide the robot, an autonomous vehicle, companies D, E and F that provide the autonomous vehicle, and a programming functional module and its submodules for movement, camera turn-on and braking. User-defined entities include names 1 and 2 of the robot, states 1 and 2 of the robot, name 3 of the autonomous vehicle, states 3 and 4 of the autonomous vehicle, and tasks 1 and 2. Moreover, there are a plurality of parameters in the model M.sub.23, which are respectively a parameter P31, a parameter P32, a parameter P33, a parameter P.sub.34, and a parameter P.sub.35. Each parameter includes the left of an x-axis, a y-axis and a z-axis, and an angle of rotation about each of the x-axis, y-axis and z-axis, as well as a velocity and an acceleration.

[0068] In some embodiments, the parameter P31 represents the transformation of the robot “name 1” from an initial attitude to a target attitude, where in the initial attitude, three-dimensional coordinates of an initial position of the robot are as follows: x=−1.8; y=0; and z=0, with an angle of rotation about z being 1.07, an angle of rotation about y being 0, an angle of rotation about x being 0, the velocity of the robot's movement being 0.2, and the acceleration being 0.1. Similarly, the parameter P.sub.32 also represents the transformation of the robot “name 1” from an initial attitude to a target attitude. The robot switches from “state 1” indicated by the parameter P.sub.31 to “state 2” indicated by the parameter P.sub.32, which is implemented by a “movement” module of the programming functional module.

[0069] In some embodiments, the parameter P.sub.33 represents the transformation of the autonomous vehicle “name 3” from an initial attitude to a target attitude. Similarly, the parameter P.sub.34 also represents the transformation of the autonomous vehicle “name 3” from an initial attitude to a target attitude. The autonomous vehicle switches from “state 3” indicated by the parameter P.sub.33 to “state 4” indicated by the parameter P.sub.32, which is implemented by a “camera turn-on” module of the programming functional module.

[0070] Both the autonomous vehicle and the robot can be used to move an object. The parameter P.sub.35 represents the transformation of the object from an initial attitude to a target attitude, that is, from a target state 1 to a target state 2.

[0071] In some embodiments, a plurality of implementation layers are set among different entities, and the implementation layers, as blank nodes, indicate logical and sequential relationships among the entities to distinguish between them. Specifically, the implementation layer IMP.sub.32 is set between the system-defined entity “company A” and the user-defined entity “name 1”; the implementation layer IMP.sub.32 is set between the system-defined entity “company A” and the user-defined entity “name 2”; the implementation layer IMP.sub.33 connects a plurality of entities such as the system-defined entity “movement”, the user-defined entities “name 1”, “task 1” and “state 1”, and the parameter P.sub.31; the implementation layer IMP.sub.34 connects a plurality of entities such as the system-defined entity “movement”, the user-defined entities “state 2”, “task 2” and “state 1”, and the parameter P.sub.32; the implementation layer IMP.sub.35 is set between the system-defined entity “company E” and the user-defined entity “name 3”; the implementation layer IMP.sub.36 connects a plurality of entities such as the system-defined entity “camera turn-on” and the user-defined entities “state 3”, “task 2” and “state 4”, and the parameter P.sub.34; and an implementation layer IMP.sub.39 connects a plurality of entities such as the system-defined entity “camera turn-on”, the user-defined entities “name 3”, “task 1” and “state 3”, and the parameter P.sub.33. The implementation layer IMP.sub.37 is implemented by the implementation layer IMP.sub.34, and the implementation layer IMP.sub.38 is implemented by the implementation layer IMP.sub.36. The implementation layer IMP.sub.37 connects the user-defined entity “target state 1” and the parameter P.sub.35, and the implementation layer IMP.sub.38 connects the user-defined entity “target state 2” and the parameter P.sub.35.

[0072] In some embodiments, the industrial flow model building method further includes the following step: connecting one implementation layer to another implementation layer to indicate that the implementation layer is implemented by another implementation layer. Therefore, the implementation layers, as the blank nodes, are not only used to indicate the sequential and logical relationships among the user-defined entities, the system-defined entities and the parameters, and the interconnected implementation layers represent that one implementation layer is implemented by another implementation layer.

[0073] The industrial flow model building mechanisms described herein are efficient and represents dynamic industrial processes with static entities and their connections, where the user-defined entities and the system-defined entities are connected to each other without causing ambiguity of logic and sequence, and the causality and influence of the interconnections thereof are very clear.

[0074] In some embodiments, the system-defined entities such as functional modules, parameters and systematic classifications, and the user-defined entities such as project names, structures and parameters can be reduced in the same repetitive process, and the user-defined entities and the system-defined entities can be used in any number of different repetitive processes. All processes in which the user-defined entities and the system-defined entities are not used can also be presented in the same model. This means that industrial flows implementing the teachings herein are also connected to each other, and any entity can be input, such that the user can obtain the entire process chain. For example, a task can be defined by many different actions, a tool can be defined by a plurality of different apparatuses, and the user can recommend actions and tools by utilizing the methods and/or systems described herein to perform an industrial process with desired entities and parameters.

[0075] In some embodiments, intermediate entities can be automatically generated and connected to the system-defined entities and the user-defined entities, so that the system-defined entities and the user-defined entities are connected to each other and repeated by entities of different implementations.

[0076] In some embodiments, there is a graph-based industrial flow model building system, the system including: a processor; and a memory coupled to the processor, where the memory stores instructions that, when executed by the processor, cause an electronic device to perform actions including: importing a set of entities which are based on one industrial flow, to build a graph-based model for the industrial flow, where the set of entities includes a user-defined entity and a system-defined entity; querying the graph-based model for the industrial flow for the user-defined entity, and if the user-defined entity is found, obtaining a connection of the user-defined entity, otherwise generating a new implementation layer; querying the model for an implementation layer of the user-defined entity, and if the implementation layer of the user-defined entity is found, obtaining a connection of the implementation layer of the user-defined entity, otherwise generating a new implementation layer; and querying the model for the system-defined entity, and if the system-defined entity is found, obtaining a connection of the system-defined entity, otherwise generating a new implementation layer, and iteratively performing the above actions until a final graph-based model for the industrial flow is obtained.

[0077] In some embodiments, the set of entities includes a user-defined entity, a system-defined entity and a parameter, and the actions further include: querying the model for the parameter, and if the parameter is not found, generating a new implementation layer.

[0078] In some embodiments, before the importing action, the actions further include: analyzing the industrial flow and decomposing the industrial flow into a plurality of entities, the entities including user-defined entities, system-defined entities and parameters; and dividing the plurality of entities into sets, each set of entities including a user-defined entity and a system-defined entity, or a user-defined entity, a system-defined entity and a parameter, where each set of entities represents a different industrial process.

[0079] In some embodiments, the industrial flow includes a plurality of sets of entities, where after the set dividing action, the actions further include: sorting the plurality of sets of entities of the industrial flow.

[0080] In some embodiments, the actions further include: connecting one implementation layer to another implementation layer to indicate that the implementation layer is implemented by another implementation layer.

[0081] In some embodiments, there is a graph-based industrial flow model building apparatus, the apparatus including: an importing means, which imports a set of entities which are based on one industrial flow, to build a graph-based model for the industrial flow, where the set of entities includes a user-defined entity and a system-defined entity; a first query means, which queries the graph-based model for the industrial flow for the user-defined entity, and if the user-defined entity is found, obtains a connection of the user-defined entity, otherwise generates a new implementation layer; a second query means, which queries the model for an implementation layer of the user-defined entity, and if the implementation layer of the user-defined entity is found, obtains a connection of the implementation layer of the user-defined entity, otherwise generates a new implementation layer; and a third query means, which queries the model for the system-defined entity, and if the system-defined entity is found, obtains a connection of the system-defined entity, otherwise generates a new implementation layer.

[0082] In some embodiments, there is a computer program product tangibly stored on a computer-readable medium and including computer-executable instructions that, when executed, cause at least one processor to perform one or more of the methods as described herein.

[0083] In some embodiments, there is a computer-readable medium having stored thereon computer-executable instructions that, when executed, cause at least one processor to perform one or more of the methods as described herein.

[0084] Although the content of the present disclosure has been described in detail by means of the above-mentioned embodiments, it should be noted that the above description should not be construed as limiting the scope of the present disclosure. Various modifications and substitutions to the present invention will be apparent to those skilled in the art upon reading the content above. Therefore, the scope of protection should be defined by the appended claims. In addition, any reference sign in the claims should not be construed as limiting the claims involved. The term “include/comprise” does not exclude other apparatuses or steps not listed in the claims or the specification. The terms “first”, “second”, etc., are merely used to refer to names, and do not denote any particular order.