State Observer for DES Under Partial Observation with Time Petri Nets

Abstract

This paper deals with a state observation approach for Discrete Event Systems with a known behavior. The system behavior is modeled using a Time Petri Net model. The proposed approach exploits temporal constraints to assess the system state and therefore detect and determine faults given partial observability of events. The goal here is to track the system state and to identify the event scenarios which occur on the system. Our approach uses the class graph of the Time Petri Net which models the complete system behavior to develop a state observer which is a base to perform online fault detection and diagnosing.

Appendices

Appendix 1 Illustration of the enumerative method

We will illustrate the utilization of the enumerative method in the accessibility analysis through the example shown in Fig. 7.

Fig. 7

Illustrative example

The initial class c ₀ of this system is characterized by the marking M ₀ = (1,0,0,1,0) and by a firing domain which is the resolution of the following linear system: $\left\{ \begin{array}{l} 2\leq \tau_1\leq 5\\ 2\leq \tau_3\leq 3\\ 0\leq \tau_4\leq 3\\ \end{array} \right.$

If t ₁ fires from c ₀ (between 2 and 3 $\text{tu}$, t ₁ cannot fire the first between 3 and 5 $\text{tu}$, because at the date 3, the maximum bound of the firing interval of t ₃ is reached, it is the case too for t ₄), the system state reaches the class c ₁ characterized by a marking M ₁ = (0,1,0,1,0) and by the following linear system: $\left\{ \begin{array}{l} 0\leq \tau_2\leq 3\\ 0\leq \tau_4\leq 1\\ \end{array} \right.$

Similarly, t ₂ can fire from c ₁ between 0 and 1 $\text{tu}$. It would lead the system state to the class c ₂ characterized by a marking M ₂ = (0,0,1,1,0), and by the firing domain which is the solution of the following linear system: $\left\{ \begin{array}{l} 0\leq \tau_4\leq 1\\ \end{array} \right.$ Here we did not represent all of the reachable classes.

Appendix 2 Sequence duration

The technique evoked above consists in applying an algorithm similar to the one presented in Section 3.2.2 for each transition t _i in the sequence s. However, instead of removing the variable τ _i corresponding to the fired transition t _i in the 3^rd step of this algorithm, this variable will just be replaced by a new variable θ _i . Replacing the τ _i variable by the θ _i one is the trick which will allow us to keep a trace of the history of all previous fired transitions. Thus θ _i becomes a parameter in the linear system of the class obtained after the firing of t _i and possibly of the following classes reached as a result of the realization of s.

Hence, the linear system corresponding to the firing domain of the last obtained class will contain as many parameters θ _i as transitions in the considered sequence s. Any solution $\underline{\theta}=(\theta_1,\dots, \theta_n)$ of this linear system represents a sequence of possible relative times for a DFS whose support is s.

Furthermore, the complete duration (or length) of s can be calculated by adding all values θ _i of the solution $\underline{\theta}$ found. In fact, it consists in adding up all relative times θ _i . The bounding of the complete duration is made by searching a lower and an upper limit to all sums ∑  _i θ _i of all solutions $\underline {\theta}$ of the linear system resulting from the application of the algorithm.

Let us note that this technique provides exactly the same result acquired if one applies the linear logic technique proposed by Pradin and Valette (2001).

Thanks to the technique discussed above, the checking of temporal properties, like temporal framing of the firing sequence durations, or establishing the time interval during which the system has a given marking, becomes possible. In this way, our estimator can be enriched with additional information.

An illustration of this technique is discussed below. The first chosen example (Fig. 8) is simple. Let us try to calculate the duration of t ₁.t ₂ sequence.

Fig. 8

Sequence duration 1

In the initial state, the system state can be represented by c ₀ class characterized by:

• the marking M ₀ = (1,0,0,0)

• the firing domain solution of the following linear system: $\left\{ \begin{array}{l} 2\leq \tau_1\leq 5\\ \end{array} \right.$

Firing of t ₁ from c ₀ (between 2 and 5 $\text{tu}$) leads the system state to the class c ₁ characterized by:

• the marking M ₁ = (0,1,0,0)

• the following linear system: $\left\{ \begin{array}{l} 2\leq \theta_1\leq 5\\ 0\leq \tau_2\leq 3\\ \end{array} \right.$

Let us note that the variable τ ₁ is abandoned, but this variable is replaced by variable θ ₁ in the first line of the new linear system.

Similarly, firing of t ₂ from c ₁ between 0 and 3 $\text{tu}$ leads the system state to the class c ₂ characterized by:

• the marking M ₂ = (0,0,1,0)

• a firing domain relating to the following linear system: $\left\{ \begin{array}{l} 2\leq \theta_1\leq 5\\ 0\leq \theta_2\leq 3\\ 0\leq \tau_3\leq 3\\ \end{array} \right.$

Here, one just replaced τ _i variables with θ _i ones (in this case τ ₂ by θ ₂), and a new variable τ ₃ corresponding to the enabling of t ₃ appears. Also it can be noted that at the end of sequence t ₁.t ₂, there are as many variables θ _i as transitions in this sequence.

The resolution of the linear system of c ₂ gives us the following bounds of sequence t ₁.t ₂ duration: 2 ≤ θ ₁ + θ ₂ ≤ 8

In fact, it is identical to sum the minimal limits of the static firing intervals of t ₁ and t ₂ on the left and the maximal limits on the right. That can be explained by the fact that there is no parallelism in this first example. Let us introduce now a more complex example (Fig. 9) that generalizes the way to calculate the temporal window of a sequence. In this example, the TPN structure is the same as in Fig. 8, but with a new initial marking. The initial state can be represented by c ₀ class characterized by:

• the marking M ₀ = (1,0,1,0)

• the firing domain resolution of the following linear system: $\left\{ \begin{array}{l} 2\leq \tau_1\leq 5\\ 0\leq \tau_3\leq 3\\ \end{array} \right.$

Firing of t ₁ from c ₀ between 2 and 3 $\text{tu}$ (because when $\text{tu}$ 3 is reached, t ₃ must inevitably fire) leads the system state to the c ₁ class characterized by:

• the marking M ₁ = (0,1,1,0)

• the linear system: $\left\{ \begin{array}{l} 2\leq \theta_1\leq 3\\ 0\leq \tau_2\leq 3\\ 2\leq \theta_1+\tau_3\leq 3\\ \end{array} \right.$

Fig. 9

Sequence duration 2

In the same way, firing of t ₂ from c ₁ between 0 and 1 $\text{tu}$ leads the system state to class c ₂ characterized by:

• the marking M ₂ = (0,0,2,0)

• the linear system below: $\left\{ \begin{array}{l} 2\leq \theta_1\leq 3\\ 0\leq \theta_2\leq 1\\ 0\leq \theta_1+\theta_2+\tau_3\leq 3\\ \end{array} \right.$

The resolution of the above linear system gives the following framing of the sequence t ₁.t ₂: 2 ≤ θ ₁ + θ ₂ ≤ 3

One can see clearly here that the endpoints of the sequence duration do not correspond to the respective sums of the firing interval limits of t ₁ and t ₂.

Appendix 3 Estimator structure making algorithm

The algorithm discussed below allows us to get the skeleton of our estimator. In this first algorithm, N denotes the current node under development, and NODES_TO_BE_TREATED the set of nodes which remain to be processed (search of the list of successor nodes). In addition, TREATED_NODES is the set of nodes which were already treated.

The set of nodes of the estimator is obtained by following the steps below:

• (1) /* initialization */

  {

  •    NODES_TO_BE_TREATED and TREATED_NODES are initially empty.

  •    create the initial node N ₀ which contains $\{c_0\}\cup\mathcal{UR}(c_0)$, add N ₀ to NODES_TO_BE_TREATED.

  }

• (2) /* recursive search of successor nodes */

  while there are some nodes to be treated (NODES_TO_BE_TREATED ≠ ∅)

  {

  • (a) •    pick a node N from NODES_TO_BE_TREATED.

    •    add N to TREATED_NODES.

  • (b) compute the set $T_{N-\text{obs}-\text{next}}$ of transitions in $T_\text o$ which can fire from a given class in N.

  • (c) compute the set $E_{N-\text{obs}-\text{next}}$ of observable events which can occur from a state class in N ($E_{N-\text{obs}-\text{next}}=evt(T_{N-\text{obs}-\text{next}})$).

    /* $T_{N-\text{obs}-\text{next}}$ and $E_{N-\text{obs}-\text{next}}$ are two sets in the mathematical sense of the term. That means an element does not repeat */

  • (d) /* determination of the reached node by the occurrence of an event e _i in $E_{N-\text{obs}-\text{next}}$ from N */

    for each event e _i in $E_{N-\text{obs}-\text{next}}$:

    {

    • (i) compute the set S _i of all classes c _j reached from a class in N, after the occurrence of e _i (the firing of a transition corresponding to e _i ), as well as the classes reached after an unobservable sequence from a class in S _i ($\mathcal{UR}(S_i)$).

    • (ii) if there is no node N _i with $S_i\cup \mathcal{UR}(S_i)$ as set off classes,

          •    create a new node N _i with $S_i\cup \mathcal{UR}(S_i)$ as set off classes,

          •    add N _i to NODES_TO_BE_TREATED.

    • (iii) /* N _i becomes a successor node to N */

      add (N _i ,e _i ) to NEXT(N).

    }

  }

Appendix 4 The complete Estimator building algorithm

• (1) {

  •    NODES_TO_BE_TREATED $\longleftarrow \emptyset$ and TREATED_NODES $\longleftarrow \emptyset$

  •    create a node N ₀

  •    $\text{SEC}(N_0)$ $\longleftarrow \{c_0\}$ and $\text{SSC}(N_0)$ $\longleftarrow$ $\mathcal{UR}$(c ₀)

  }

• (2) add N ₀ to NODES_TO_BE_TREATED

• (3) while (NODES_TO_BE_TREATED ≠ ∅)

  {

  • (a) •    $N\longleftarrow$ pick a node from NODES_TO_BE_TREATED

    •    NEXT(N) $\longleftarrow\ \emptyset$

    •    add N to TREATED_NODES

  • (b) compute $T_{N-\text{obs}-\text{next}}$ and $E_{N-\text{obs}-\text{next}}=evt(T_{N-\text{obs}-\text{next}})$

  • (c) repeat for each class c _i  ∈ $\text{SEC}(N)$:

    •    determine the set $\text{SCS}^{c_i}$ as well as the attributes (duration interval and destination class) of each sequence in $\text{SCS}^{c_i}$

    •    add the elements of $\text{SCS}^{c_i}$ to the candidate sequences table of c _i while ordering them in the increasing order of the maximum bounds of the duration intervals

  • (d) repeat for each event $e_k \in E_{N-\text{obs}-\text{next}}$:

    {

    • (i) compute:

      $\text{SEC}_k$= {f(c _i ,s.t _j ); c _i  ∈ $\text{SEC}(N)$, $t_j\in tr(e_k)\cap T_{N-\text{obs}-\text{next}}$ and $s\in T_\text{uo}^*\cup\epsilon$ such that s.t _j  ∈ $\text{SCS}^{c_i}$}

    • (ii) /* if the set SEC _k does not correspond to any set of entry classes of an already established node, create a new node with SEC _k as set of entry classes, or else add the node with SEC _k as set of entry classes to set of successor nodes of N */

              ∙ repeat for all N _i  ∈ NODES_TO_BE_TREATED ∪ TREATED_NODES:

                 if $\text{SEC}(N_i)$ = $\text{SEC}_k$, then:

                         − N _k ←N _i

                         − goto 3d.iii

              ∙ create a new node N _k

              ∙ $\text{SEC}(N_k) \longleftarrow \text{SEC}_k$, $\text{SSC}(N_k)$ $\longleftarrow$ $\mathcal{UR}(\text{SEC}_k)$

    • (iii) add (N _k ,e _k ) to NEXT(N)

    • (iv) repeat for each entry class c _l  ∈ $\text{SEC}(N_k)$:

                      ∙ repeat for each transition t _j  ∈ tr(e _k ) ∩ $T_{N-\text{obs}-\text{next}}$:

                              − add in the table of previous sequences of c _l all the sequences of $\text{SCS}_{N}^{t_j}$ which have c _l as destination class.

                                 With each of these sequences, associate its respective attributes (duration interval and origin class)

    • (v) if $N_k\not\in$ TREATED_NODES ∪ NODES_TO_BE_TREATED, then:

                      ∙ add N _k to NODES_TO_BE_TREATED.

  }

  }

Appendix 5 Proof of the proposition

Proposition 1

At any given time, the Estimator node containing the system state can be determined with certainty.

Proof

In order to prove this result, we will proceed by induction. The idea is that we split the follow-up duration in intervals ]θ _i ,θ _i + 1] where θ ₀ = 0 and ∀ i > 0, θ _i is the occurrence time of the $i^\text{th}$ observable event, which will be denoted e _i for simplicity. The sampling of the follow-up duration in intervals makes possible using a proof by induction while reasoning on each of these intervals.□

Initialization:

• At t = 0, the system state is in the c ₀ class of the initial node N ₀.

• in ]θ ₀ = 0,θ ₁[: no (observable) event was detected yet. Thus, the scenarios which could occur in this interval are of the form $\sigma\in\Sigma_\text{uo}\cup \epsilon$. In the TPN model, this corresponds to the firing of the transition sequence $s=tr(\sigma)\in T_\text{uo}^*\cup\epsilon$. Consequently, the system state reached one of the classes of the set:

  $$ \begin{array}{ll} E_0&=\{f(c_0,s)\neq\emptyset,s\in T_\text{uo}^*\cup\epsilon\}\\ &= \{f(c_0,\epsilon)\}\cup\{f(c_0,s)\neq\emptyset,s\in T_\text{uo}^*\}\\ &= \{c_0\}\cup\mathcal{UR}(c_0)\\ &= \text{SEC}(N_0)\cup\mathcal{UR}(\text{SEC}(N_0))\\ &= \text{SEC}(N_0)\cup \text{SSC}(N_0)\end{array}$$

  It is about the set of classes of N ₀ $\Longrightarrow$ The system state is then in the node N ₀ (can be represented by one of the classes of N ₀) during this period.

• At t = θ ₁: i.e when e ₁ occurs:

  We can affirm that the scenario which occurred since θ ₀ = 0 is of the form σ.e where $\sigma\in\Sigma_\text{uo}^*\cup\epsilon$. Thus, the system state is in one of classes of:

  $$ \begin{array}{ll} E_1&=\{f(c_0,s.t),s\in T_\text{uo}^*\cup\epsilon,t\in tr(e_1) \textrm{ such that }f(c_0,s.t)\neq\emptyset\}\\ &= \{f(c_i,s.t),c_i\in \text{SEC}(N_0), t\in tr(e_1)\cap T_{N_0-\text{obs}-\text{suiv}}, s\in T_\text{uo}^*\cup\epsilon\\ &{\kern13pt}\textrm{ such that }\ s.t\in \text{ESC}^c\}\\ &= \text{SEC}(f_N(N_0,e_1)) \end{array} $$

  Then, the system state is in one of the entry classes of the node successor of N ₀ by the arc labeled with e ₁.

Recurrence relation:

Suppose that the property is satisfied until the $n^\text{th}$ order, that is we are able to determine exactly in what node the system state is during the interval ]θ ₀ = 0,θ _n ], and let us prove that we can determine the node in which the system state is, at each instant of ]θ _n ,θ _n + 1]. For this, let us denote N _n as the node reached following the occurrence of e _n , i.e at θ _n .

• during ]θ _n ,θ _n + 1[: no observable event occurred. Thus, the set of scenarios which could occur are of the form $\sigma\in\Sigma_\text{uo}\cup \epsilon$. In the TPN model, this corresponds to the firing of the sequence transition $s=tr(\sigma)\in T_\text{uo}^*\cup\epsilon$. then, the system state reached one of the classes of the set:

  $$ \begin{array}{ll} E_n&=\big\{f(c_i,s)\neq\emptyset, c_i\in \text{SEC}(N_n),s\in T_\text{uo}^*\cup\epsilon\big\}\\[2pt] &= \big\{f(c_i,\epsilon),c_i\in \text{SEC}(N_n)\big\}\cup\big\{f(c_i,s)\neq\emptyset, c_i\in \text{SEC}(N_n),s\in T_\text{uo}^*\big\}\\[2pt] &= \big\{c_i\in \text{SEC}(N_n)\big\}\cup\mathcal{UR}\{c_i\in \text{SEC}(N_n)\big\}\\[2pt] &= \text{SEC}(N_n)\cup\mathcal{UR}(\text{SEC}(N_n))\\[2pt] &= \text{SEC}(N_n)\cup \text{SSC}(N_n)\end{array}$$

  It is about the set of classes of N _n $\Longrightarrow$ Hence, the system state is in the node N _n (in one of the classes of N _n ) during this period

• At t = θ _n + 1: i.e when e _n + 1 occurs:

  We can affirm that the scenario which occurred since θ _n is of the form σ.e _n + 1 where $\sigma\in\Sigma_\text{uo}^*\cup\epsilon$. Thus, the system state is in one of the classes of:

  $$ \begin{array}{ll} E_{n+1}&=\big\{f(c_i,s.t),c_i\in \text{SEC}(N_n), s\in T_\text{uo}^*\cup\epsilon,t\in tr(e_{n+1})\textrm{ such that }f(c_i,s.t) \neq\emptyset\big\}\\[3pt] &= \big\{f(c_i,s.t),c_i\in \text{SEC}(N_n), t\in tr(e_{n+1}) \cap T_{N_n-\text{obs}-\text{suiv}}, s\in T_\text{uo}^*\cup\epsilon\\[3pt] &{\kern12pt} \textrm{ such that }\ s.t\in \text{ESC}^{c_i}\big\}\\[3pt] &= \text{SEC}(f_N(N_n,e_{n+1}))\end{array}$$

  Then at θ _n + 1, the system state reaches one of the entry classes of the node successor of N _n by the arc labeled with e _n + 1.

Conclusion. At each moment of the follow-up process, the algorithm determines with certainty the estimator node which the system state is in.