How to generate a fault tree

Abstract

To efficiently and automatically generate a fault tree.SOLUTION: A fault tree generation method includes the step of receiving assembly data and one or a plurality of ladder programs as input, and the method further includes: the step in which the assembly data includes a facility or line assembly tree and the one or the plurality of ladder programs include a facility or line control logic; and the step of generating a fault tree related to facility architecture based on an assembly tree structure included in the assembly data and the control logic included in the one or the plurality of ladder programs.SELECTED DRAWING: Figure 2

Description

[Technical Field]

[0001] The present disclosure relates to a system and method for automated generation of fault trees. [Background technology]

[0002] Maintaining production line uptime is essential to maximize factory productivity. One factor that reduces line uptime is machine failure due to some abnormal condition, which requires rapid recovery based on root cause analysis of the machine failure. For this purpose, fault tree analysis using a fault tree is commonly performed. A fault tree is a tree diagram that includes a top node that indicates the failure event, lower nodes that indicate the root cause phenomenon, and one or more branches that indicate the causal relationships between the phenomena. When a failure is described in the fault tree, it is possible to immediately identify the root cause, making it an effective method for preventing or eliminating prolonged downtime.

[0003] Fault trees are sometimes manually generated by equipment designers because they require the equipment's architecture to describe causal relationships. When equipment includes actuators and / or sensors, a typical programmable logic controller can be used to control the equipment with a ladder program, achieving highly reliable operation. Because this type of equipment is designed not only by mechanical engineers but also by electrical and control engineers, fault trees are created by different design teams. This collaborative work requires a significant amount of time, and the shortage of such experts has recently become more serious. To solve the above problems, several related technologies have been proposed.

[0004] One example of related technology is a system that has a causal relationship database that stores equipment failure events and their causal relationships based on past failure events, and further contains the names of component parts related to these causal relationships as indexes. In this system, by inputting the name of a component when building a fault tree, the related causal relationships are displayed, allowing the fault tree to be built efficiently.

[0005] In the above example, a fault tree can be constructed using information accumulated in the past. However, as a prerequisite, it is necessary to accumulate information on past failure events of similar products. Therefore, there is a problem that it cannot be applied to newly installed equipment or lines. Another problem is that it takes a lot of time to build a causal relationship database. [Prior art documents] [Patent documents]

[0006] [Patent Document 1] Japanese Patent Application Publication No. 2017-194727 Summary of the Invention

[0007] The present disclosure includes the automatic generation of fault trees.

[0008] The present disclosure proposes a system that automatically constructs a fault tree using conventional design documents such as machine design drawings and control programs, and minimized rules or databases that can be generated from the design documents, without using prepared information such as cause information that does not yet exist in newly designed equipment or lines.

[0009] To address the problems in the related art, the embodiments described herein include the following aspects.

[0010] The described embodiment includes a novel technique for automatically generating a fault tree. The fault tree generation system receives as input assembly data including an equipment or line assembly tree and a ladder program including equipment or line control logic, and generates a fault tree by connecting the upper part of the fault tree generated from the assembly tree structure in the assembly data with the lower part of the fault tree obtained from the control logic in the ladder program.

[0011] In an embodiment including a fault tree generation system, the system generates a fault tree by connecting the upper part of the fault tree and the lower part of the fault tree based on the number of words in the full path of the upper part of the fault tree and the top word of the path in the lower part of the fault tree.

[0012] In one embodiment of the fault tree generation system, when generating the upper part of the fault tree, the system extracts major components from the assembly tree included in the assembly data using a parts name database that indicates each actuator, each sensor, component, etc. in addition to the assembly structure.

[0013] In an embodiment including a fault tree generation system, the system uses a read-write variable name database for each actuator, each sensor, component, etc. to extract key variables from the control logic when generating the subsections of the fault tree, and extracts the tree structure by converting the ladders associated with the key variables.

[0014] In an embodiment including a fault tree generation system, the part name database and variable name database of the fault tree generation system may have part names and variable names, respectively, grouped into common groups, and connections in both trees are made within the common groupings.

[0015] One aspect of the present disclosure is a method that includes receiving as input assembly data and one or more ladder programs, where the assembly data includes an equipment or line assembly tree and the one or more ladder programs include equipment or line control logic, the method including generating a fault tree associated with the equipment architecture based on the assembly tree structure configured in the assembly data and the control logic configured in the one or more ladder programs.

[0016] One aspect of the present disclosure is a computer program that causes a computer to execute a process that receives as input assembly data and one or more ladder programs, the assembly data including an assembly tree for a facility or line, and the one or more ladder programs including facility or line control logic, and that generates a fault tree associated with the facility architecture based on the assembly tree structure configured in the assembly data and the control logic configured in the one or more ladder programs.

[0017] One aspect of the present disclosure is a system including means for receiving as input assembly data and one or more ladder programs, the assembly data including an equipment or line assembly tree and the one or more ladder programs including equipment or line control logic, the system further including means for generating a fault tree associated with the equipment architecture based on the assembly tree structure configured in the assembly data and the control logic configured in the one or more ladder programs.

[0018] One aspect of the present disclosure is an apparatus for facilitating automatic generation of a fault tree, the apparatus including a processor receiving as input assembly data and one or more ladder programs, the assembly data including an equipment or line assembly tree, the one or more ladder programs including equipment or line control logic, and the processor generating a fault tree associated with an equipment architecture based on the assembly tree structure configured in the assembly data and the control logic configured in the one or more ladder programs. [Brief explanation of the drawings]

[0019] [Figure 1] FIG. 1 illustrates an example of an architecture for an automatic fault tree generation system. [Figure 2] FIG. 1 illustrates an example block diagram of an automatic fault tree generation system. [Figure 3] 1A and 1B are diagrams for explaining an example of parts and products assembled by the example apparatus. [Figure 4] FIG. 1 is a diagram illustrating an example of an overview of a device, the movement of parts, and related sensors. [Figure 5] FIG. 1 illustrates an example process flow chart for an example apparatus. [Figure 6] FIG. 10 is a diagram illustrating an example of assembly data and related input / output variables in a ladder program. [Figure 7] FIG. 10 is a diagram for explaining an example of a ladder program. [Figure 8] FIG. 10 is a diagram for explaining an example of a ladder program. [Figure 9] FIG. 10 is a diagram for explaining an example of a ladder program. [Figure 10] FIG. 10 is a diagram for explaining an example of a ladder program. [Figure 11] FIG. 1 illustrates an example of a flowchart of an automatic fault tree generation system. [Figure 12] FIG. 12 is a diagram showing an example of a processing result of the flowchart in FIG. [Figure 13] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. FIG. [Figure 14] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. FIG. [Figure 15] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. FIG. [Figure 16] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. FIG. [Figure 17] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. FIG. [Figure 18] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. FIG. [Figure 19] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. FIG. [Figure 20] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. FIG. [Figure 21] FIG. 10 is a diagram illustrating an example of matching accuracy. [Figure 22] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. FIG. [Figure 23] FIG. 1 is a diagram for explaining an example of a flowchart of an automatic fault tree generation system. [Figure 24] FIG. 10 is a diagram for explaining an example of assembly data. [Figure 25] FIG. 10 is a diagram for explaining an example of assembly data. [Figure 26] FIG. 1 illustrates an example architecture of an automatic fault tree generation system. [Figure 27] FIG. 1 is a block diagram illustrating an example of an automatic fault tree generation system. [Figure 28] FIG. 1 is a diagram illustrating an example of a flowchart of an automatic fault tree generation system. [Figure 29] FIG. 10 is a diagram illustrating an example of a grouped node name database. [Figure 30] FIG. 24 is a diagram showing an example of a processing result of the flowchart in FIG. 23. [Figure 31] FIG. 10 is a diagram illustrating an example of a grouped node name database. [Figure 32] FIG. 24 is a diagram for explaining an example of a processing result of the flowchart in FIG. 23. [Figure 33] FIG. 24 is a diagram for explaining an example of a processing result of the flowchart in FIG. 23. [Figure 34] FIG. 24 is a diagram for explaining an example of a processing result of the flowchart in FIG. 23. [Figure 35] FIG. 10 is a diagram illustrating an example of matching accuracy. [Figure 36] FIG. 10 is a diagram illustrating an example of matching accuracy. [Figure 37] FIG. 1 illustrates an exemplary computing environment with exemplary computing devices suitable for use in some exemplary embodiments. DETAILED DESCRIPTION OF THE INVENTION

[0020] The following detailed description provides details of the figures and embodiments of the present application. Reference numerals and redundant element descriptions between figures have been omitted for clarity. Terms used throughout this specification are provided by way of example and are not intended to be limiting. For example, the use of the term "automatic" can include fully automatic or semi-automatic embodiments with user or administrator control over certain aspects of the embodiment, depending on the desired implementation of one skilled in the art practicing embodiments of the present invention. Selection can be performed by a user through a user interface or other input means, or can be performed through a desired algorithm. The embodiments described herein can be utilized singularly or in combination, and the functionality of the embodiments can be performed through any means according to the desired implementation.

[0021] The present application will be described in detail with reference to three examples. In the first example, an overview of the system can be explained, for example, as shown in Figures 1 and 2. In the second example, an example of equipment, for example, as shown in Figures 3 to 10, will be explained. Figures 3 to 10 include an assembly tree and a ladder program. In the third example, a flowchart and processing flow will be explained using example equipment data in Figures 12 to 22.

[0022] 1 illustrates an example system architecture for an automatic fault tree generation system 100. The automatic fault tree generation system includes a processor that executes one or more modules associated with the automatic fault tree generation system. The modules may include, but are not limited to, an assembly data analysis module, a ladder data analysis module, or a fault tree connection module. The processor may communicate with input modules, output devices, or memory / storage that may store analysis rules.

[0023] An example block diagram of the system is shown in Figure 2. As shown in Figure 2, system inputs may include assembly data, such as CAD data, and ladder programs. An assembly data analysis module 206 can receive inputs from an assembly data input module 202 and corresponding analysis rules 204.

[0024] The ladder data analysis module 212 can receive input from the ladder data input module 208 and corresponding analysis rules 210. The fault tree connection module 214 can analyze and convert input data from both the assembly data analysis module and the ladder analysis module into a tree diagram containing nodes and branches. After each conversion, both modules are connected into a tree in a connection module to construct a final fault tree as the output of the system. The fault tree output module 216 can receive input from the fault tree connection module in tree generation.

[0025] FIG. 3 shows an example of parts and products that may be assembled by equipment. For example, part A 301 and part B 302 may be parts of an assembled product 303. In the example of FIG. 3, part A and part B may be coupled or connected to assemble the product. FIG. 4 shows an overview 400 of equipment movement, part movement, and associated sensors. FIG. 4 shows an example of the movement process of part A 301 and part B 302 to assemble product 303.

[0026] FIG. 5 shows a process flowchart diagram 500 of an example facility. One function of the facility is to insert part B into part A to assemble a product. The part movement process shown in FIG. 4 may include a conveying process and a transporting process for inserting or connecting part B to part A. Such conveying and transporting processes may include one or more motors for the conveyor and / or insertion process, a clamper for clamping part B, and an air cylinder for transporting part B for the insertion process. Laser sensors may be used to detect the movement of each part and the facility and / or to ensure proper assembly. An example process includes placing part A and part B in their respective part entry areas. Then, part A is transported to the insertion area, and part B is transported to the waiting area. The conveying process may stop when part A or part B reaches its respective designated area, e.g., the insertion area. Then, a clamper may place part B in the waiting area. Then, the clamper may pick up part B and move part B to the insertion area of ​​part A. The clamper may insert part B into part A, and part B may be released upon insertion of part B into part A. The assembled product is then transported to an ejection area.

[0027] FIG. 6 shows a diagram 600 of an assembly tree that may be included in CAD data and associated input / output variables in a ladder program. The assembly tree may include both assemblies and parts, and the assembly tree is generated by a designer. The automated equipment may include user interfaces such as push buttons and safety components such as light curtains and emergency stop (E-stop) buttons. Components such as drive units and detection units may be electrically connected to a controller. The controller may be a programmable logic controller (PLC), and a programming language (e.g., a ladder program) may utilize the variables shown in FIG. 6, for example.

[0028] Figure 7 is an example of a ladder program 700. Ladder programs can document the design and construction of relay racks used in manufacturing and process control. The name comes from the fact that programs in this language resemble a ladder, with two vertical rails and a series of horizontal rungs between them. Signals come from the positive voltage side and go to the ground side. Once the logic is clear, variables can be changed. The program starts at the top rung and repeats as necessary until the bottom rung is reached.

[0029] Figures 8-10 show examples of ladder programs that can be used to implement the process flow in the present equipment, as shown in connection with Figures 4 and 5. Rungs R1-17 may contain variable definition areas for inputs and outputs, runs R18-20 may contain control logic for both conveyors, runs R21-26 may contain control logic for transporting part B, and runs R27-30 may contain control logic for the insertion process.

[0030] FIG. 11 shows an example flowchart 1100 of an automatic fault tree generation system. The input data for A-1 is shown, for example, in FIG. 6, and the input data for B1 is shown, for example, in FIGS. 8-10. At A-2, an assembly tree is extracted from A-1. At A-3, the main layers of the assembly tree, excluding parts, are extracted. At A-4, a message related to the error (e.g., "is not correctly working") is added to each tree node. At A-5, a super-tree of the fault tree is generated.

[0031] At B-2, the primary variables representing the movement are identified. At B-3, rungs associated with the primary variables of the movement are extracted from the input ladder program. At B-4, each tree node is converted into a tree with a status message (e.g., "is on" or "is off"). At B-5, subtrees of the fault tree are generated.

[0032] In C-1, the generated upper and lower trees are obtained. In C-2, at least one full path from the bottom node to the top node of the upper tree is selected, and all words in the selected full path are extracted as word group A. In C-3, a top node is selected from one of the lower trees, and all words within that node are extracted as word group B. In C-4, the amount of matching words between word group A and word group B is calculated. In C-5, processes C2 to C4 are repeated to count all combinations, and the count can be treated as the degree of matching. In C-6, the connection between the upper tree bottom node and the lower tree top node is determined based at least on the order of the degree of matching. In C-7, each lower tree is connected to each upper tree node so that the output connected tree forms a fault tree.

[0033] FIG. 12 shows the processing results from A-4 onward in FIG. 11 and represents the upper part of a fault tree based on the facility structure. The fault tree may include at least one of nodes, branches, and logic gates. A fault phenomenon or its cause is input to a node, and related nodes are connected by lines called branches. With this connection, the upper node is called the parent node of the lower node, and the lower node is called the child node of the upper node. FIG. 12 shows examples of nodes, branches, and logic gates that may be used. However, this disclosure is not intended to be limited to the examples disclosed herein. In some examples, different combinations or numbers of nodes, branches, or logic gates may be used.

[0034] FIG. 13 shows the partial processing results from B-3 onward in FIG. 11. For example, rungs R18 to R20 can constitute the rungs used in the partial processing results from B-3 onward in FIG. 11. FIG. 14 shows the partial processing results after B-4 as an example of a processing procedure. In B-2, a key variable may be selected based on some rule. In this example equipment, since the word "Request" commands movement, "Request" is searched for among all variables in the ladder program to select the key variable. As described in FIG. 7, the ladder program may be converted into a tree diagram as shown in FIG. 14. In some embodiments, True and False may be converted using the words "is on" or "is off." FIG. 15 shows an example of the processing results from B-4 onward in FIG. 11. The trees in FIGS. 14 and 15 may include subsections of fault trees.

[0035] The partial fault tree is generated up to A-4 and B-4 processes, transferred to the connection module in A-5 and B-5 processes, and retrieved for connection in C-1 process. The connection procedure starts from C-2 process and runs up to word matching calculation, connecting the upper and lower parts of the fault tree to generate a complete fault tree. The word matching calculation can use source word groups and target word groups.

[0036] FIG. 16 shows an example 1600 of word groups extracted from a higher-level tree that can be used as source word groups, and FIG. 17 shows an example 1700 of word groups extracted from a lower-level tree that can be used as target word groups. At least one advantage of the present disclosure is that full path words are used instead of bottom nodes in the higher-level tree because the bottom nodes in the higher-level tree may not contain all of the words that describe the assigned function. This is because the higher-level tree is a tree diagram generated to prevent duplicate node names. In some aspects, the lower-level tree is generated from program variables, and these variables have unique names throughout the program. Using full paths in the higher-level tree can be beneficial and enable accurate matching.

[0037] The rule for matching counting is "How many FPX words existing TNY," which means C-4 in Figure 11, and the calculation result 1800 is shown in Figure 18. To determine the connection nodes, a deviation calculation 1900 is calculated, which represents the difference from the average value, as shown in Figure 19.

[0038] An example of the determination rule is as follows:

[0039] @1.Select the item with the highest deviation value in the TNX row.

[0040] @2. If the parent node and child node have the same score, select the child node.

[0041] Figure 20 shows an example 2000 of selected connections in bold. For example, TN1 and FP3 provide a connection, TN2 and FP4 provide a connection, TN3 and FP7 provide a connection, TN4 and FP7 provide a connection, TN5 and FP7 provide a connection, TN6 and FP6 provide a connection, and TN7 and FP6 provide a connection. Figure 21 shows an example 2100 of matching accuracy, indicating that all connections are correctly matched. Figure 22 shows an example 2200 of the final fault tree, which may be the output from the flowchart in Figure 11.

[0042] FIG. 23 shows an example flowchart 2300 of an automatic fault tree generation system. The flowchart in FIG. 23 is similar to the flowchart of the automatic fault tree generation system in FIG. 11, but there are some differences. For example, the differences between the flowchart in FIG. 11 and the flowchart in FIG. 23 are steps A-1 and A-2.5 in FIG. 23. The input data included in step A-1 may include not only CAD data 2400 shown in FIG. 24 but also bill of material (BOM) data 2500, as shown in FIG. 25. In some examples, drawing number names are used in CAD data to describe assembly trees, and BOM data can be used to convert drawing numbers to assembly or part names. This conversion allows the same calculations as in the example flowchart in FIG. 11 to be valid even if the assembly data is separated into CAD data and BOM data. In this way, the flowchart in FIG. 23 can generate upper and lower fault trees, similar to the example in FIG. 11.

[0043] FIG. 26 provides an example architecture for an automatic fault tree generation system 2600. The example architecture for the automatic fault tree generation system of FIG. 26 can have similar components and functionality to the example architecture for the automatic fault tree generation system of FIG. 1, except that the analysis rules are replaced by a database. FIG. 27 shows an example system block diagram 2700. The block diagram shown in FIG. 27 is similar to the system block diagram shown in FIG. 2, but there are some differences. For example, the differences from the block diagram of FIG. 2 are that several databases are used in the analysis module, whereas in the block diagram of FIG. 27, several groups defined in the database are used in the connection process, and the output of the assembly data analysis module 206 is based on input from the assembly data input module 202 and input from the node name grouping database 2702. Furthermore, the output from the ladder data analysis module 212 is based on input from the ladder data input module 208 and input from the variable name grouping database 2704.

[0044] FIG. 28 shows an example flowchart 2800 of the automatic fault tree generation system, and FIG. 29 shows an example 2900 of the node name grouping database 2702. The example flowchart of FIG. 28 is configured similarly to the flowchart of FIG. 11 but includes an additional step, namely, A-3.5. In A-3.5, nodes can be extracted by searching the grouped node name database. The illustrated grouped node name database is used in A-3.5 of FIG. 28 to search for nodes and extract important nodes, such as drive units and measurement units, from the assembly tree.

[0045] Fig. 30 shows an example 3000 of the processing result after the A-3.5 process in Fig. 28. Based on the database usage, detailed key components such as motors and laser sensors that may be the root cause of the failure can be extracted.

[0046] FIG. 31 shows an example 3100 of the variable name grouping database 2704 that can be used in B-2 of the processing example of FIG. 28. Variables in a program include name variables that can indicate specific names and / or expressions. In some embodiments, variables can include abbreviated names such as, but not limited to, LS (laser sensor), LC (light curtain), PB (push button), etc. The variable database can correctly extract key variables related to key logic. FIG. 32 shows the processing results after B-4 of FIG. 28, where multiple sub-fault trees can be extracted using variable names.

[0047] Figure 33 shows an example 3300 of word groups extracted from an upper tree as source word groups, and Figure 34 shows an example 3400 of word groups extracted from a lower tree as target word groups. At least another difference from the conventional example is that a group including both Figure 33 and Figure 34 is used in the connection process. In order to reduce matching errors due to an increase in combinations, matching calculations are performed using internal groups.

[0048] FIG. 35 shows an example 3500 calculated without group information, and FIG. 36 shows an example 3600 calculated with group information. After calculations are performed for each intra-group, the results are combined. Comparing FIG. 35 and FIG. 36 shows that the presence of group information improves matching accuracy. Separate calculations also reduce calculation time.

[0049] The disclosed system can be configured to generate fault trees using design documents and minimized rules or databases. Using this system can shorten design time, reduce design costs related to maintainability design, and reduce on-site problems after shipment by optimizing built-in alarm functions before shipping equipment or production lines. It also improves the ease of designing new architecture equipment and lines, expanding and increasing the business of equipment builders and line builders. The generated fault trees can be used to realize technology transfer between design and support teams, improving support efficiency. By utilizing the generated fault trees, equipment customers can minimize downtime by reducing oversights in root cause analysis, quickly identifying root causes, and shortening contact times with vendor support.

[0050] FIG. 37 illustrates an example computing environment including a computing device suitable for use in embodiments, such as those illustrated in connection with any of FIGS. 1-36. The computing environment can be used to facilitate implementation of the architectures illustrated in FIGS. 1-36. Additionally, any of the embodiments described herein can be implemented based on the architectures, APIs, microservices systems, etc. illustrated in FIGS. 1-36. The computing device 3705 of the computing environment 3700 can include one or more processing units, cores, or processors 3710, memory 3715 (e.g., RAM, ROM, and / or the like), internal storage 3720 (e.g., magnetic, optical, solid-state storage, and / or organic), and / or I / O interface 3725, any of which can be coupled by a communication mechanism or bus 3730 for communicating information or embedded in the computing device 3705. The I / O interface 3725 can be configured to receive images from a camera or provide images to a projector or display device, depending on the desired implementation.

[0051] The computing device 3705 may be communicatively coupled to an input / user interface 3735 and an output device / interface 3740. Either or both of the input / user interface 3735 and the output device / interface 3740 may be wired or wireless interfaces and may be detachable. The input / user interface 3735 may include any device, component, sensor, or interface, physical or virtual, that can be used to provide input (e.g., buttons, touchscreen interfaces, keyboards, pointing / cursor controllers, microphones, cameras, Braille, motion sensors, optical readers, and / or similar devices). The output device / interface 3740 may include displays, televisions, monitors, printers, speakers, Braille, etc. In some examples, the input / user interface 3735 and the output device / interface 3740 may be embedded in the computing device 3705 or physically coupled to the computing device 3705. In other embodiments, other computing devices may function as or provide the functionality of input / user interface 3735 and output device / interface 3740 of computing device 3705.

[0052] Examples of computing devices 3705 may include, but are not limited to, highly mobile devices (e.g., smartphones, devices mounted on vehicles and other machines, devices carried by humans and animals, etc.), mobile devices (e.g., tablets, notebook computers, laptop computers, personal computers, portable televisions, radios, etc.), and devices not designed for mobility (e.g., desktop computers, other computers, information kiosks, televisions, radios with one or more processors embedded therein and / or coupled thereto, etc.).

[0053] Computing device 3705 may be communicatively coupled (e.g., via I / O interface 3725) to external storage 3745 and network 3750 for communicating with any number of networked components, devices, and systems, including one or more computing devices of the same or different configurations. Computing device 3705 or any connected computing device may function, provide a service, or be referred to as a server, client, thin server, general machine, special purpose machine, or other label.

[0054] I / O interface 3725 can include, but is not limited to, wired and / or wireless interfaces using any communication or I / O protocol or standard (e.g., Ethernet, 802.11x, Universal System Bus, WiMax, modem, cellular network protocols, etc.) for communicating information to and from at least all connected components, devices, and networks in computing environment 3700. Network 3750 can be any network or combination of networks (e.g., the Internet, a local area network, a wide area network, a telephone network, a cellular network, a satellite network, etc.).

[0055] The computing device 3705 may use and / or communicate using computer-usable or computer-readable media, including transient and non-transitory media. Transitory media include transmission media (e.g., metallic cables, optical fibers), signals, carrier waves, etc. Non-transitory media include magnetic media (disks, tapes, etc.), optical media (CD ROM, digital video disks, Blu-ray disks, etc.), solid-state media (RAM, ROM, flash memory, solid-state storage, etc.), and other non-volatile storage or memory.

[0056] The computing device 3705 can be used to implement techniques, methods, applications, processes, or computer-executable instructions in some exemplary computing environments. The computer-executable instructions can be obtained from a transitory medium and stored on and obtained from a non-transitory medium. The executable instructions can be obtained from one or more of a programming language, a scripting language, and a machine language (e.g., C, C++, C#, Java, Visual Basic, Python, Perl, JavaScript, etc.).

[0057] The processor 3710 can run under any operating system (OS) in a native or virtual environment. One or more applications can be deployed, including a logic unit 3760, an application programming interface (API) unit 3765, an input unit 3770, an output unit 3775, and an inter-unit communication mechanism 3795 for different units to communicate with each other, the OS, and other applications. The described units and elements may vary in design, function, configuration, or implementation and are not limited to the configurations provided herein. The processor 3710 can be in the form of a hardware processor, such as a central processing unit (CPU), or a combination of hardware and software units.

[0058] In some embodiments, when information or instructions to execute are received by API unit 3765, it may be communicated to one or more other units (e.g., logic unit 3760, input unit 3770, output unit 3775). In some embodiments, logic unit 3760 may be configured to control the flow of information between units and direct the services provided by API unit 3765, input unit 3770, and output unit 3775 in some of the embodiments described above. For example, the flow of one or more processes or implementations may be controlled by logic unit 3760 alone or in cooperation with API unit 3765. Input unit 3770 may be configured to obtain inputs for calculations described in embodiments, and output unit 3775 may be configured to provide outputs based on the calculations described in embodiments.

[0059] 1-36 , the instructions may include receiving, as input, assembly data and one or more ladder programs, where the assembly data includes an assembly tree for the equipment or line, and the one or more ladder programs include control logic for the equipment or line. The processor 3710 generates a fault tree associated with the equipment architecture based on the assembly tree structure included in the assembly data and the control logic included in the one or more ladder programs.

[0060] The processor 3710 may be configured to execute instructions of a method, for example, in any of Figures 1 to 36, that connects an upper portion of a first fault tree based on an assembly tree structure contained in assembly data with a lower portion of a second fault tree based on control logic contained in one or more ladder programs.

[0061] The processor 3710 may be configured to execute instructions of a method that includes extracting one or more components of an equipment architecture from an assembly tree of an equipment or line in the assembly data based on a part name database that identifies each of one or more components from a top portion of a first fault tree, for example, in any of Figures 1 to 36.

[0062] The processor 3710 can be configured to execute instructions of a method, for example, in any of Figures 1 to 36, including extracting one or more variables from equipment or line control logic based on a variable name database of one or more components of the equipment architecture, and extracting an assembly tree structure based on a ladder program associated with the one or more variables.

[0063] Some portions of the detailed description are presented in terms of algorithms and symbolic representations of operations within a computer. These algorithmic descriptions and symbolic representations are the means used by those skilled in the data processing arts to convey the substance of their innovations to others skilled in the art. An algorithm is a sequence of defined steps leading to a desired end state or result. In the illustrative examples, the steps performed require specific quantities of physical manipulations to achieve a specific result.

[0064] Unless otherwise indicated, as will be apparent from the discussion herein, discussions throughout this specification using terms such as "processing," "computing," "calculating," "determining," "displaying," and the like may include operations and processes of a computing system or other information processing device that manipulate and transform data represented as physical (electrical) quantities in the computing system's registers and memory into other data similarly represented as physical quantities in the computing system's memory, registers, or other information storage, or transmission or display device.

[0065] Examples also relate to apparatus for performing the operations herein. This apparatus may be specially constructed for the required purposes, or it may include one or more general-purpose computers selectively activated or reconfigured by one or more computer programs. Such computer programs may be stored on a computer-readable medium, such as a computer-readable storage medium or a computer-readable signal medium. Computer-readable storage media include tangible media such as, but not limited to, optical disks, magnetic disks, read-only memory, random-access memory, solid-state devices and drives, as well as other types of tangible or non-transitory media suitable for storing electronic information. Computer-readable signal media may include media such as carrier waves. The algorithms and displays presented herein are not inherently related to any particular computer or other apparatus. A computer program may include a pure software implementation containing instructions for performing the operations of a desired implementation.

[0066] Various general-purpose systems may be used with programs and modules according to the embodiments herein, or more specialized apparatus may be constructed to perform the desired method steps. Moreover, the embodiments are not described with reference to a particular programming language. Various programming languages ​​may be used to implement the techniques of the embodiments described herein. Instructions in the programming language may be executed by one or more processing units, such as a central processing unit (CPU), processor, or controller.

[0067] As is known in the art, the operations described above may be performed by hardware, software, or some combination of software and hardware. Various aspects of the embodiments may be implemented using circuits and logic devices (hardware), while other aspects may be implemented using instructions stored on a computer-readable medium (software) that, when executed by a processor, cause the processor to perform an implementation of the present application. Furthermore, some embodiments of the present application may be performed solely in hardware, while other embodiments may be performed solely in software. Furthermore, the various functions described may be performed in a single unit or may be spread across multiple components in any manner. When performed by software, the methods may be executed by a processor, such as a general-purpose computer, based on instructions stored on a computer-readable medium. If desired, the instructions may be stored on the medium in a compressed and / or encrypted format.

[0068] Moreover, other embodiments of the present invention will be apparent to those skilled in the art from consideration of this specification and practice of the techniques of the present invention. Various aspects and / or components of the described embodiments may be used alone or in any combination. It is intended that the specification and examples be considered as exemplary only, with the true scope and spirit of the present application being indicated by the following claims. [Explanation of symbols]

[0069] 100 Automatic Fault Tree Generation System 206 Assembly Data Analysis Module 202 Assembly Data Input Module 204 Analysis Rules 212 Ladder Data Analysis Module 208 Ladder Data Input Module 210 Analysis Rules 214 Fault Tree Connection Module 2702 Node Name Grouping Database 2704 Variable Name Grouping Database

Claims

1. receiving as input assembly data and one or more ladder programs, the assembly data including an equipment or line assembly tree and the one or more ladder programs including equipment or line control logic; generating a fault tree associated with an equipment architecture based on an assembly tree structure included in the assembly data and control logic included in the one or more ladder programs; The step of generating a fault tree associated with the facility architecture further comprises: A method comprising a step of connecting an upper portion of a first fault tree based on an assembly tree structure included in the assembly data and a lower portion of a second fault tree based on control logic included in the one or more ladder programs.

2. A method according to claim 1, A method in which the step of connecting the upper part of the first fault tree based on the assembly tree structure and the lower part of the second fault tree based on the control logic is based on the amount of words contained in the full path of the upper part of the first fault tree and the top words of the path of the lower part of the second fault tree.

3. A method according to claim 1, extracting one or more components of the facility architecture from a facility or line assembly tree in the assembly data based on a part name database that identifies each of the one or more components from a top portion of the first fault tree.

4. The method of claim 1, generating a fault tree associated with the facility architecture, extracting one or more variables from the plant or line control logic based on a variable name database of one or more components of the plant architecture; extracting the assembly tree structure based on a ladder program associated with the one or more variables.

5. The method of claim 1, the fault tree part name database and variable name database include part names or variable names grouped into one or more common groups; The method of claim 1, wherein the connection between the first fault tree and the second fault tree is based on the grouping of the one or more common groups.

6. In the method according to claim 1, The method, wherein the equipment or line assembly tree includes associated input and output variables in the one or more ladder programs.

7. The method of claim 1, The method, wherein the fault tree associated with the facility architecture includes one or more nodes, one or more branches, and one or more logic gates.

8. The method according to claim 7, the one or more nodes contain information related to a failure event; A method, wherein each of the one or more nodes is connected to a respective branch of the one or more branches.

9. The method of claim 7, comprising: The one or more logic gates are connected between an upper portion of the first fault tree and a lower portion of the second fault tree.

10. A non-transitory computer-readable medium storing instructions for causing one or more processors to perform a process, the process comprising: receiving as input assembly data and one or more ladder programs, the assembly data including an equipment or line assembly tree and the one or more ladder programs including equipment or line control logic; generating a fault tree associated with an equipment architecture based on an assembly tree structure included in the assembly data and control logic included in the one or more ladder programs; A non-transitory computer-readable medium, wherein the processing includes a step of connecting an upper portion of a first fault tree based on an assembly tree structure included in the assembly data and a lower portion of a second fault tree based on control logic included in the one or more ladder programs.

11. The non-transitory computer-readable medium of claim 10, A non-transitory computer-readable medium, wherein the step of connecting the upper part of the first fault tree based on the assembly tree structure and the lower part of the second fault tree based on the control logic is based on the amount of words contained in the full path of the upper part of the first fault tree and the top words of the path of the lower part of the second fault tree.

12. The non-transitory computer-readable medium of claim 10, the process further includes extracting one or more components of the facility architecture from an equipment or line assembly tree in the assembly data based on a part name database that identifies each of the one or more components from a top portion of the first fault tree.

13. The non-transitory computer-readable medium of claim 10, The process comprises: extracting one or more variables from the plant or line control logic based on a variable name database of one or more components of the plant architecture; and extracting the assembly tree structure based on a ladder program associated with the one or more variables.

14. The non-transitory computer-readable medium of claim 10, the fault tree part name database and variable name database include part names or variable names grouped into one or more common groups; a connection between the first fault tree and the second fault tree based on a grouping of the one or more common groups; 15. The non-transitory computer-readable medium of claim 10, A non-transitory computer-readable medium, wherein the equipment or line assembly tree includes associated input and output variables in the one or more ladder programs.

16. The non-transitory computer-readable medium of claim 10, a fault tree associated with the facility architecture including one or more nodes, one or more branches, and one or more logic gates; the one or more nodes contain information related to a failure event; each of the one or more nodes is connected to a respective branch of the one or more branches; the one or more logic gates are connected between an upper portion of the first fault tree and a lower portion of the second fault tree.

17. A system comprising: a facility architecture based on an assembly tree structure; a processor, The processor: receiving as input assembly data and one or more ladder programs, the assembly data including an equipment or line assembly tree and the one or more ladder programs including equipment or line control logic; generating a fault tree associated with the equipment architecture based on an assembly tree structure included in the assembly data and control logic included in the one or more ladder programs; A system that connects an upper portion of a first fault tree based on an assembly tree structure contained in the assembly data and a lower portion of a second fault tree based on control logic contained in the one or more ladder programs.

Images