¶ Initiating Event
¶ Description
The Model Exchange Format distinguishes the structure of the event trees, i.e., the set of sequences they encode, from what is collected along the sequences and how it is collected. Let us consider for now only the structural view point. With that respect, an event tree is made of the following components.
- One or more initiating events
- An ordered set of functional events (the columns)
- A set of end-states (so called sequences)
- A set of branches to describe sequences
Branches end up either with a sequence name or with a reference to another branch (such references are sometimes called transfers). They contain forks. Each fork is associated with a functional event. The initiating event could also be seen as a special fork (between the occurrence of this event and the occurrence of no event). In the Model Exchange Format, alternatives of the fork are called paths. Paths are labeled by the state of the functional event that labels the fork.
Figure I: Small Event Tree
Let us consider again the event tree pictured in the figure of a small event tree above. Assume that end states S1 and S3 on the one hand, S2 and S4 on the other hand, are identical, and that we merge the corresponding sub-trees. Assume moreover that the lowest success branch of the functional event H is actually a bypass. Then, the structure of the tree is pictured below. On this figure, the nodes of the tree are numbered from 1 to 8. The initiating event is represented as a fork. Finally, the branch (the sub-tree) rooted by the node 2 is named B1.
Figure II: Structure of an Event Tree
Components of the event tree pictured above are the following.
- The initiating event I
- The three functional events F, G, and H
- The end states S1, S2, S5, and S6
- The branch B1
- The tree rooted by the initial node (here the node 1)
Forks decompose the current branch according to the state of a functional event. Usually, this state is either “success” or “failure”. It may be “bypass” as well (as in our example for the path from node 6 to node 7). In the case of multiple branches, the name of a state is defined by the user.
Instructions to collect and to modify fault trees and probability distributions are applied at the different nodes. Instructions to be applied may depend on the initiating event and the states of functional events.
The states of functional events at a node depend on the path that has been followed from the root node to this node. By default, functional events are in an unspecified state, i.e., that the predicate “test-functional-event” (see XML representation for Test Events below) returns false in any case. The table below gives the states of functional events for all the possible paths starting from the root node of the event tree pictured in Figure II above. Empty cells correspond to unspecified states.
test-initiating-event = element test-initiating-event { name }
test-functional-event =
element test-functional-event {
name,
attribute state { Identifier }
}
Test Events
States of Functional Events for the different paths of the Event Tree in Figure II .
| Path | F | G | H |
|---|---|---|---|
| 1 | |||
| 1-2 | success | ||
| 1-2-3 | success | success | |
| 1-2-4 | success | failure | |
| 1-5 | failure | ||
| 1-5-2 | failure | success | |
| 1-5-2-3 | failure | success | success |
| 1-5-2-4 | failure | success | failure |
| 1-5-6 | failure | failure | |
| 1-5-6-7 | failure | failure | bypass |
| 1-5-6-8 | failure | failure | failure |
As mentioned above, an event tree may be parametric: the same tree can be used for several initiating events. To implement this idea, the Model Exchange Format provides the analyst with the notion of group of initiating events. Such a group has a name and may contain sub-groups. Groups of initiating events may be freely defined inside or outside event trees. There is one condition, however: an initiating event can be used in only one tree.
¶ XML Representation
We are now ready to explicitly define the XML grammar of the structure of event trees. Its RNC schema is given in Figure II-3 and II-4. In these figures, we leave instructions unspecified, for they do not concern the structure of the tree and are the subject of the next section. Note that branches and functional events cannot be declared (nor referred to) outside event trees, for there would be no meaning in doing so.
initiating-event-definition =
element define-initiating-event {
name,
attribute event-tree { Identifier }?,
label?,
attributes?,
(collected-item | consequence | consequence-group)?
}
initiating-event-group-definition =
element define-initiating-event-group {
name,
attribute event-tree { Identifier }?,
label?,
attributes?,
initiating-event+
}
initiating-event =
element initiating-event { name }
| element initiating-event-group { name }
collected-item = basic-event | gate | parameter
II-3. RNC form of the XML representation of initiating events
event-tree-definition =
element define-event-tree {
name,
label?,
attributes?,
functional-event-definition*,
sequence-definition*,
branch-definition*,
initial-state
}
functional-event-definition =
element define-functional-event { name, label?, attributes? }
sequence-definition =
element define-sequence { name, label?, attributes?, instruction* }
branch-definition =
element define-branch { name, label?, attributes?, branch }
initial-state = element initial-state { branch }
branch = instruction*, (fork | end-state)
fork =
element fork {
attribute functional-event { Identifier },
path+
}
path =
element path {
attribute state { Identifier },
branch
}
end-state =
element sequence { name }
| element branch { name }
II-4. RNC form of the XML representation of event trees and sequences
¶ Example
Consider again the event tree pictured in figure II-5. The XML description for this example is given below.
<define-event-tree name="my-first-event-tree" >
<define-functional-event name="F" />
<define-functional-event name="G" />
<define-functional-event name="H" />
<define-sequence name="S1" />
<define-sequence name="S2" />
<define-sequence name="S5" />
<define-sequence name="S6" />
<define-branch name="sub-tree7" >
<fork functional-event="H" >
<path state="success" >
<sequence name="S1" />
</path>
<path state="failure" >
<sequence name="S2" />
</path>
</fork>
<define-branch>
<initial-state>
<fork functional-event="F" >
<path state="success" >
<branch name="sub-tree7" />
</path>
<path state="failure">
<fork functional-event="G" >
<path state="success" >
<branch name="sub-tree7" />
</path>
<path state="failure">
<fork functional-event="H">
<path state="success" >
<sequence name="S5" />
</path>
<path state="failure" >
<sequence name="S6" />
</path>
</fork>
</path>
</fork>
</path>
</fork>
</initial-state>
</define-event-tree>
Figure II-5 XML representation for the structure of the Event Tree pictured in Figure II-2