# Minimal-Order Functional Observer-Based Residual Generators for Fault Detection and Isolation of Dynamical Systems

Authors: H. M. Tran; H. Trinh
Journal: Mathematical Problems in Engineering
 (2016)

---

## Abstract

This paper examines the design of minimal-order residual generators for the purpose of detecting and isolating actuator and/or component faults in dynamical systems. We first derive existence conditions and design residual generators using only first-order observers to detect and identify the faults. When the first-order functional observers do not exist, then based on a parametric approach to the solution of a generalized Sylvester matrix equation, we develop systematic procedures for designing residual generators utilizing minimal-order functional observers. Our design approach gives lower-order residual generators than existing results in the literature. The advantages for having such lower-order residual generators are obvious from the economical and practical points of view as cost saving and simplicity in implementation can be achieved, particularly when dealing with high-order complex systems. Numerical examples are given to illustrate the proposed fault detection and isolation schemes. In all of the numerical examples, we design minimum-order residual generators to effectively detect and isolate actuator and/or component faults in the system.


---

## Body

## 1. Introduction

Industrial systems have become more and more complicated and expensive, and thus the requirement of safety and reliability in system operations is paramount [1]. In fact, high complex modern engineering systems are vulnerable to unavoidable faults. Faults can happen due to an internal event, change in environmental conditions, error in the design of the system, sensor failure, actuator malfunctioning, or even human mistakes during operation. The unexpected faults disrupt the system operation, break down part of or the whole system, and can lead to fatal consequences. Fault detection and isolation (FDI) providing failure signals, therefore, have been considered as a vital aspect of system control research. This research issue has attracted extensive studies to safeguard equipment as well as amend the safety and reliability of modern system performance. Since the early 1970s, there have been a large number of fruitful results in FDI which can be found in, for example, [1–30] and the references therein.In fault diagnosis area, there are two well-known model based fault diagnosis approaches. The first is the fault estimation based approach (see, e.g., [3–8]). By this approach, the systems are decoupled into fault-free and fault dependent parts. The faults can then be estimated via the observers of the fault-free part. The other is the residual-based approach which makes use of state observers to generate diagnostic signals or, in other words, residual generators. In [15], the authors provided a useful comparison between the two approaches. This study is interesting as it provides insightful knowledge and some shortcomings of each approach. The philosophy behind the residual-based approach is to estimate the system state vector based on the control inputs and the measured outputs. The residual generators are then constructed by a properly weighted output estimation error. The residuals are able to detect and identify the fault happening in the systems [9–14]. Obviously, the residual signals are expected to be close to zero in a fault-free condition and deviate from zero in the presence of a fault. For FDI purpose, a decision rule which is normally based on a threshold set is engaged to test for the likelihood of faults occurring in the systems.Regarding the residual-based approach, the residual signals in most studies are generated via primarily employing full-order state observers or filter schemes which can be found in, for instance, [16–25]. However, the design and implementation of the residual generators using full-order state observers normally require high degrees of complexity and computational work, especially when dealing with high-order complex systems. As stated in [30], in certain applications such as fault diagnostic or control system design, an estimation of the entire state vector is not necessary. Meanwhile, there have been some FDI schemes based on reduced-order state observers (see, e.g., [26–29]). In these schemes, the residual generators are constructed based on the observers of the partial state vector. By that a significantly lower order of the residual generators, in comparison with the ones employing full-order state observers, can be achieved. With an attempt to simplify the design of the residual generators, this trend is identified as very important from the practical point of view (see [31–35]).In this paper, by using minimal-order functional observers, we present a new FDI scheme to detect and identifyl unpredictable actuator and/or component fault signals entering from the inputs of dynamical systems. The systems considered in this paper have n state variables, p measured outputs, and m control inputs. Our approach to FDI utilizes the advantages of functional observer schemes which can be found in [36–41]. Due to the fact that functional observers are employed instead of full-order state observers (or, for that matter, reduced-order Luenberger state observers) to generate the residual signals, substantial reduction in the complexity of the overall designed FDI schemes can now be consequently achieved. Particularly, we first present a simple solution approach where residual generators are designed using only first-order functional observers to detect and isolate faults in the systems. When first-order functional observers are not possible to design, then the residual generators are designed based on minimal-order functional observers. To minimize the observer order, we employ a parametric technique to the solutions of a generalized Sylvester matrix equation appearing in the existence conditions. Regarding the timely fault detection (FD), designing the residuals only involves the functional observers with the order as low as [n-p+1/p], where [x] denotes the smallest integer larger than x. This is a new finding and has not yet been reported in the literature. The result is significant since it is clear that, for p>1, the order of the residual generator is much lower than any of the existing results in the literature. Furthermore, for timely isolation of l independent actuator and/or component faults in the system, we propose to construct a bank of l residual generators, each with the order as low as [n-p+1/p-1]. Thus, it is clear that our proposed FD and FI schemes, taking advantage of functional observers, are identified as most beneficial for complex large-scale systems where, by default, n and p are large values.The organization of this paper is as follows. In the next section (Section2), we present the system description and preliminaries where we consider linear dynamical systems with l unpredictable actuator and/or component fault signals entering from the system inputs. This section also introduces a novel residual generator that is constructed from reduced-order functional observers. Section 3 presents a detailed analysis on the design of minimal-order residual generators to trigger, in a timely manner, any fault that enters into the system. This follows by Section 4 where a bank of l residual generators is designed to isolate l likely faults. To achieve this, each residual generator is designed, using first-order or minimal-order functional observers, to be insensitive to one specific fault but sensitive to the remaining (l-1) faults. Subsequently, a logic table can be drawn up from the l residual generator outputs to detect and isolate the faults. Section 5 presents extensive numerical examples to highlight the attractive features of our proposed FDI schemes. Finally, Section 6 concludes the paper.


## 2. System Description and Preliminaries

In this paper, we consider dynamical systems withp outputs and m inputs and with unpredictable actuator fault signals f(t)∈Rl entering from the system inputs. In state space models, the systems are governed by the following equations:(1)x˙t=Axt+But+Dft,yt=Cxt,where x(t)∈Rn, u(t)∈Rm, and y(t)∈Rp are the state, input, and output vectors, respectively. A∈Rn×n, B∈Rn×m, and C∈Rp×n are known constant system matrices. D∈Rn×l is the fault identity matrix. We assume that rank(C)=p, without loss of generality, the fault identity matrix D is also assumed to be a known full-column rank matrix, and the faults fi(t), i=1,2,…,l, are linearly independent. This assumption avoids vagueness which may appear when some faults occur simultaneously; as a result, the residual generators may not detect these faults due to the zero overall effect of these faults [26].Let us consider the following reduced-order functional observer:(2)ω˙t=Nωt+Gyt+Hut,where ω(t)∈Rq, 1≤q<n, N∈Rq×q, G∈Rq×p, and H∈Rq×m are observer parameters to be determined such that ω(t) is an asymptotic estimate of a linear function Lx(t) when no fault appears in the system, that is, f(t)=0, and L∈Rq×n is a matrix to be determined for the purpose of FDI.We now define a residual generator,r(t), which is used to trigger the faults in the system:(3)rt=Tωt+Fyt,where T∈R1×q and F∈R1×p are residual parameters.Figure1 shows block-diagram implementation of the residual generator as defined in (2)-(3). By that, only known information of the inputs, u(t), and the outputs, y(t), of the system is utilized to generate the residual generator r(t).Figure 1
Block-diagram implementation of a residual generator.Obviously, regarding the FD purpose, parametersT, F, L, N, G, and H should be determined to meet the required functions of the residual generator such that(4)limt→∞rt=0ifft=0cor  undefinedifft≠0,where c≠0, f(t)=0 implies a faultless condition, and f(t)≠0 implies a faulty condition.Error dynamicse(t), which is defined to be the difference between the estimation ω(t) and the linear function Lx(t), is expressed as follows:(5)et=ωt-Lxt.By taking the derivative of the error vector (5) and then substituting ω˙(t) from (2) and x˙(t) from (1), the error dynamics can be written as follows:(6)e˙t=Net+NL+GC-LAxt+H-LBut-LDft.It is clear from (6) that, under the faultless condition, the error asymptotically converges to zero if the following conditions hold.Proposition 1.
Under faultless conditions, that is,f(t)=0, ω(t) is an asymptotic estimate of Lx(t) (i.e., e(t)→0 asymptotically) for any initial conditions x(0) and ω(0) if(7)NisHurwitz,(8)NL+GC-LA=0,(9)H-LB=0.Proof.
When no fault occurs in the system, if conditions (8) and (9) are satisfied then (6) is reduced to e˙(t)=Ne(t). Thus, if N is Hurwitz then e(t)→0 asymptotically. Note also that if all the eigenvalues of N can be arbitrarily assigned, then e(t)→0 with any prescribed rate. This completes the proof of Proposition 1.Definition 2.
The functional observer (2) is an Asymptotic Estimator if ω(t) is an asymptotic estimate of Lx(t) when f(t)=0.Since Proposition1 is satisfied and based on Definition 2, the error dynamics of an asymptotic observer takes the following form:(10)e˙t=Net-LDft.Substituting (5) into (3), the residual generator r(t) can be obtained as follows:(11)rt=Tet+TL+FCxt.According to (4) and (11), the residual generator can satisfy its proposed functions if the following conditions hold.Proposition 3.
An Asymptotic Estimator of form (2) can satisfy r(t) according to (4) for any x(0) and ω(0) if(12)TL+FC=0,(13)LD≠0.Proof.
Iff(t)=0 and also (12) and (13) are satisfied then according to (10) we have e(t)→0 asymptotically and according to (11) we have r(t)→0 asymptotically. When a fault appeared in the system, that is, f(t)≠0, and condition (13) holds, based on (10) we have e(t)↛0. Accordingly, the residual signals (11) deviate from zero, which indicates the fault happened in the system. Thus, the required functions of the residual generator as stated in (4) are satisfied. This completes the proof of Proposition 3.Now, the design of the functional observer (2) and the residual generator (3) reduces to determining the unknown matrices L, N, G, H, T, and F such that conditions (7)–(9), (12), and (13) are satisfied.


## 3. Fault Detection Scheme

In Section2, we showed that the functional observer (2) and the residual generator (3) can detect faults in the system if all the unknown parameters satisfying the conditions stated in Propositions 1 and 3 are found. Observe that if L is known, then from (9), H=LB, and condition (13), that is, LD≠0, can be easily verified. In this section, we propose a systematic procedure for solving coupled matrix equations (8) and (12) with the requirement that matrix N is Hurwitz. Note that, here, not only do we require that matrix N be Hurwitz, but also we desire its eigenvalues to be placed at some prespecified locations in the s-plane in order to achieve timely detection of faults.Let us first simplify matrix equations (8) and (12) by a partition technique defined in [38]. Regarding this, an invertible matrix P∈Rn×n is introduced:(14)P=C+C⊥,where C+∈Rn×p denotes the Moore-Penrose inverse of C, that is, CC+=Ip, and C⊥∈Rn×(n-p) denotes an orthogonal basis for the null-space of C, that is, CC⊥=0. Now the following partitions are defined:(15)CP=Ip0,(16)LP=L1L2,(17)P-1AP=A11A12A21A22,where submatrices L1∈Rq×p, L2∈Rq×(n-p), A11∈Rp×p, A12∈Rp×(n-p), A21∈R(n-p)×p, and A22∈R(n-p)×(n-p).Postmultiplying both sides of (8) and (12) by the matrix P, we obtain(18)NLP+GCP-LPP-1AP=0,TLP+FCP=0.By substituting (15)–(17) into (18), we achieve the following equations:(19)G=L1A11+L2A21-NL1,(20)F=-TL1,(21)NL2-L2A22-L1A12=0,(22)TL2=0.It is clear from (19) and (20) that matrices G and F can be computed once N, L1, L2, and T are found to satisfy (21) and (22).In the following, we discuss the solutions to coupled matrix equations (21) and (22). Observe that the solution to (21) depends on the characteristic of matrix A12∈Rp×(n-p). Hence, we classify A12 into two cases, namely, Case 1 where A12 is a column matrix and Case 2 where A12 is a row matrix.Case 1 (first-order residual generators).
In this case, we consider thatp>n/2; accordingly A12 is a column matrix. For this, we only need to design a first-order residual generator to detect faults in the system. Regarding this, the design procedure is detailed as follows.Theorem 4.
A first-order functional observer (2) always exists for system (1) when A12 is a column matrix; that is, p>n/2. Furthermore, a residual generator (3) can be constructed to detect faults in the system if condition (13) is satisfied.Proof.
To design a first-order functional observer, that is,q=1, N∈R1×1 can be chosen to be any negative scalar. Thus, let(23)N=s,s<0.
By lettingL2=0, (21) is reduced to the following:(24)L1A12=0.
SinceA12 is a column matrix, a solution to (24) where L1≠0 always exists. Let N(X) be a matrix of row basis vectors for the row-null-space of X; that is, N(X)X=0. Therefore, the solution for L1 in (24) can be achieved by first computing L^1 according to(25)L^1=NA12and then L1 can be selected as any row of L^1.
MatrixT≠0 in (22) can be arbitrarily chosen to be any nonzero scalar, say, α, since L2=0. Finally, if condition (13) is satisfied, a residual generator using a first-order functional observer exists to detect faults in the system. Matrices H, G, and F can then be easily obtained from (9), (19), and (20), respectively, to complete the design of the residual generator. This completes the proof of Theorem 4.It is worth pointing out that, in the derivation of a first-order residual generator, we do not impose the requirement that the matrix pair(A,C) is observable.Case 2 (minimal-order residual generators).
In this case, we consider that1<p≤n/2; accordingly A12 is a row matrix. Matrix A12 is considered to be full rank; that is, rank(A12)=p. For this, we design a minimal-order residual generator for FD by presenting a solution to coupled matrix equations (21) and (22) via a parametric technique. Here, N has preassigned distinct eigenvalues satisfying condition (7). For completeness, let us first present a parametric solution [42] to generalized Sylvester matrix equation (21). For the solution of (21), we require that the pair (A12,A22) be observable. This implies that the pair (C,A) is observable [38].
LetN∈Rq×q with q distinct eigenvalues be defined as follows:(26)N=Q-1ΛQ,where Q∈Rq×q is any freely chosen invertible matrix and Λ=diag⁡(s1,s2,…,sq), si≠sj for i≠j and Re{si}<0 for all i=1,2,…,q. With N as defined in (26), L1 and L2 satisfying (21) are given in the following parametric forms [42]:(27)L1=QUs1b1Us2b2⋯Usqbq⊤,(28)L2=QZs1b1Zs2b2⋯Zsqbq⊤,where bi∈Cp(i=1,2,…,q) are free vectors satisfying bi=b¯j if si=s¯j. s¯j denotes the complex conjugate of si. U(s)∈Rp×p and Z(s)∈R(n-p)×p are coprime polynomial matrices satisfying the following coprime factorization:(29)sIn-p-A22⊤-1A12⊤=ZsU-1s.
The reader can refer to [42] for a numerically reliable algorithm to compute Z(s) and U(s). Also, as suggested in [38], U(s) and Z(s) can be conveniently computed according to the following equations:(30)Us=det⁡sIn-p-A22Ip,(31)Zs=adjsIn-p-A22⊤A12⊤,where det(·) and adj(·) denote the determinant and the adjugate matrix of matrix (·), respectively. For any given A22, the characteristic polynomial can be obtained:(32)as≜det⁡sIn-p-A22=sn-p+a1sn-p-1+a2sn-p-2+⋯+an-p,where the coefficients ai, i=1,2,…,(n-p), are real constants. The adjugate matrix adj(·) is then obtained as follows:(33)adjsIn-p-A22⊤=Υ1sn-p-1+Υ2sn-p-2+Υ3sn-p-3+⋯+Υn-p,where Υi, i=1,2,…,n-p, are computed by using the coefficients of a(s) and matrix A22, where(34)Υ1=In-p,Υ2=Υ1A22⊤+a1In-p,Υ3=Υ2A22⊤+a2In-p,⋮Υn-p=Υn-p-1A22⊤+an-p-1In-p.
Note that if the preassigned eigenvalues ofN are complex then the resulting matrices Λ, L1, and L2 are also complex. As reported in [14], we can obtain real matrices Λ, L1, and L2 by applying the following simple computation. Here, without loss of generality, we assume that s1 and s2, s2=s¯1=α+βj, are a pair of the eigenvalues containing complex values, and all other eigenvalues of N are real and distinct. The real matrices Λ, L1, and L2 can be obtained as follows:(35)Λ=block-diag⁡Λ1,s3,…,sq,Λ1=αβ-βα,L1=QReUs1b1ImUs1b1⋯Usqbq⊤,L2=QReZs1b1ImZs1b1⋯Zsqbq⊤,where Re{·} and Im{·} denote the real and the imaginary parts of {·}, respectively.Now, by incorporatingL2 as defined in (28) into (22), we can solve for T. Let us now present the result for Case 2 by the following theorem.Theorem 5.
With1<p≤n/2 and rank⁡(A12)=p, a residual generator (3) with an order as low as q=[n-p+1/p] can be constructed to detect faults in the system if condition (13) is satisfied.Proof.
First, let us expressTQ as follows:(36)TQ=t1t2⋯tq,where ti≠0, i=1,2,…,q, are arbitrarily real numbers.
Onceti are scalars, by substituting (28) and (36) into the transpose of (22) and after some rearrangement the following equation is obtained:(37)Zs1t1Zs2t2⋯Zsqtqb1b2⋮bq=0.
Now, (37) can be expressed as follows:(38)Zb=0,where Z∈R(n-p)×qp and b∈Rqp and(39)Z=Zs1t1Zs2t2⋯Zsqtq,b=b1⊤b2⊤⋯bq⊤⊤.
Similar to the solution to (24), let N(Z) be defined such that ZN(Z)=0; then a solution to (38) always exists for b≠0 if N(Z)≠0. Accordingly, if Z is a row matrix, that is, the number of columns is greater than the number of rows, the solution to b≠0 always exists. That implies the following result:(40)q≥n-p+1p,and then b≠0 exists and can be taken to be any column of N(Z).
As a result, withq prescribed eigenvalues for N (i.e., si, i=1,2,…,q, are given) and for any arbitrary invertible matrix Q, matrices N, L1, and L2 are computed based on (26), (27), and (28), respectively. Matrix L is then calculated by (16) and condition (13) can be verified. If (13) is satisfied, the residual generator r(t) can detect faults in the system. Finally, H, G, F, and T are obtained from (9), (19), (20), and (36), respectively, to complete the design of the observer ω(t) and the residual r(t). This completes the proof of Theorem 5.Remark 6.
The observer orderq can be assigned to satisfy condition (40), where a solution to (38) always exists for b≠0. Thus, for the purpose of designing minimal-order observers, we only need to choose q=[n-p+1/p].Remark 7.
External disturbances or the uncertainties are unavoidable during the operation of the systems. If we take disturbances in the system where the disturbance matrix is defined asE∈Rn×r and the disturbance vector is d(t)∈Rr, system (1) now can be governed by the following equations:(41)x˙t=Axt+But+Dft+Edt,yt=Cxt.Based on the disturbance decoupling approach [7], the influence of the unknown disturbance can be eliminated. Using this approach, the conditions in Proposition 1 of this paper are as follows:(42)Nis  Hurwitz,NL+GC-LA=0,H-LB=0,LE=0.Since the conditionLE=0 is added, the solutions to the observer parameters will be more strict. Nevertheless, based on the solution approach in this paper, it is possible to design minimal-order observer-based residual generators to detect faults in the systems with unknown disturbances. In this case, the residual functions are also defined as (4) which means the threshold can be set as zero. In addition, it is also possible to extend the result to include nonlinearities in the systems. This topic deserves further research and will be a subject for future research. Another issue that deserves further research is related to the robust threshold selection. How to solve the robust threshold selection problem under uncertainties is an important research question and the reader is referred to the most recent and interesting research [43].Remark 8.
We conclude this section by considering the case where1<p≤n/2 and rank⁡(A12)<p. Note that, for this case, a first-order residual generator can be designed since a solution to (24) where L1≠0 exists due to the fact that rank⁡(A12)<p. Indeed, there exists N(A12)≠0 such that N(A12)A12=0. Accordingly, L1≠0 is obtained and the rest of the observer and residual generator parameters can be derived in the same way as reported in Case 1. A numerical example can be easily constructed to demonstrate this case. However, due to space limiting reason, a numerical example is not given in this paper.


## 4. Fault Isolation Scheme

In Section3, we discussed the design of minimal-order residual generators for FD in the systems. However, identifying the faults is also considered as an important task in system control since it provides the fault positions [15]. The information about the fault positions is then sent to the decision-maker for further actions dealing with the faults. In this regard, we present a systematic procedure to construct a bank of minimal-order residual generators which is used to isolate the faults. Hence, our proposed FI scheme significantly reduces the complexity in the implementation. The scheme is thus more suited to deal with complex high-order systems. Before showing the procedure, let us mention a logic for the fault isolation from the following [44].We consider, in this paper, that there may bel likely faults occurring in the system. Accordingly, for the purpose of FI, we propose to design a bank of l residual generators, in which each residual generator is expected to be insensitive to one specific fault but sensitive to the rest of the remaining faults. Thus, a kth residual generator, rk(t), is designed to be insensitive to the kth fault, that is, fk(t), and sensitive to the rest of the remaining faults. By that, when there is no fault in the system, the outputs of the residual generators remain as zero. However, when a fault, say, fk(t), has occurred, the output of the kth residual generator remains as zero; meanwhile, the outputs of the other (l-1) residual generators are not zero but turn to ck≠0, where ck is as defined in (52). Consequently, by measuring the output values of the l residual generators or using a set of residual thresholds, when a fault appears, we can identify the position of the fault.For simpler explaining of the logic, let us take an example where there are four possible faults, that is,fk(t), k=1,2,3,4, in the system. Accordingly, a bank of four minimal-order residual generators, rk(t), k=1,2,3,4, is designed to isolate the faults. Let us use a logic “1” to indicate that the output of a residual generator is bigger than a threshold value, that is, ck≠0, and a logic “0” to indicate that the output of a residual generator remains as zero (or less than a threshold value). Table 1 shows the logic for the fault isolation. In the table, for instance, when a fault f1(t) has occurred, residual r1(t) is insensitive to f1(t); hence it appears as “0.” Meanwhile, other residuals can trigger f1(t) so they are expressed as “1.” Therefore, we can identify that fault f1(t) has occurred. However, it is noted that this logic is only correct when the faults happen independently and also not simultaneously. In Section 2, we have made an assumption that avoids such a situation and hence the logic expressed in Table 1 can thus be used to isolate the faults in the system.Table 1
Fault isolation logic table.
r
1
(
t
)
r
2
(
t
)
r
3
(
t
)
r
4
(
t
)
No fault
0
0
0
0
f
1
(
t
)
0
1
1
1
f
2
(
t
)
1
0
1
1
f
3
(
t
)
1
1
0
1
f
4
(
t
)
1
1
1
0Now, by utilizing the above FI logic and for the rest of this section, we present systematic procedures to design each residual generator in the residual bank,rk(t), with minimal order. For this, let us rearrange and partition the fault vector, f(t), and the fault identity matrix, D, as follows:(43)ft=fktfRt,D=DkDR,where fk(t) is the kth fault, fR(t) contains the remaining (l-1) faults, Dk∈Rn×1, and DR∈Rn×(l-1).Thus, system (1) can now be rewritten as(44)x˙t=Axt+But+Dkfkt+DRfRt,yt=Cxt.Similar to Section2, let us now consider a reduced-order functional observer for the purpose of fault isolation:(45)ω˙kt=Nkωkt+Gkyt+Hkut,where ωk(t)∈Rq, 1≤q<n, Nk∈Rq×q, Gk∈Rq×p, and Hk∈Rq×m are observer parameters to be determined such that ωk(t) is an asymptotic estimate of the linear function Lkx(t) when f(t)=0 and Lk∈Rq×n is a matrix to be determined for the purpose of fault isolation.Let an error vectorek(t) be defined as follows:(46)ekt=ωkt-Lkxt.By taking the derivative of (46) and using (44) and (45), the following error dynamics is obtained:(47)e˙kt=Nkekt+NkLk+GkC-LkAxt+Hk-LkBut-LkDkfkt-LkDRfRt.Proposition 9.
Under no-fault conditions,ωk(t) is an asymptotic estimate of the function Lkx(t) (i.e., ek(t)→0 asymptotically) for any x(0) and ωk(0) if(48)NkisHurwitz,(49)NkLk+GkC-LkA=0,(50)Hk-LkB=0.Proof.
The proof of Proposition9 is the same as the proof of Proposition 1; thus it is omitted here.By using the estimateωk(t) and the system outputs, y(t), the residual generator rk(t), which is insensitive to fault fk(t) and sensitive to the other faults, fR(t), is now proposed:(51)rkt=Tkωkt+Fkyt,where rk(t)∈R, Tk∈R1×q, and Fk∈R1×p.Since faultsf(t) occur independently, matrices Tk and Fk need to be found to satisfy the following functions of rk(t):(52)limt→∞⁡rkt=0iffRt=0ckor  undefinediffRt≠0,where ck≠0, fR(t)=0 means that, except fault fk(t) which may or may not happen, other faults do not happen, and fR(t)≠0 means that any of the (l-1) faults can happen in the system.If all the conditions in Proposition9 are satisfied, from (45), (46), and (51), the residual rk(t) can be governed in the following equations:(53)e˙kt=Nkekt-LkDkfkt-LkDRfRt,rkt=Tkekt+TkLk+FkCxt.Proposition 10.
The residual generatorrk(t) is insensitive to fault fk(t) and sensitive to faults fR(t) for any x(0) and ωk(0) if(54)TkLk+FkC=0,(55)LkDk=0,(56)LkDR≠0.Proof.
The proof can be constructed by following similar lines as in the proof of Proposition3 and thus it is omitted here.From Propositions9 and 10, we can now determine the unknown parameters Lk, Nk, Gk, Hk, Tk, and Fk to complete the design of the residual generator rk(t). Clearly, matrix Hk can be calculated from (50) and condition (56) can be easily verified if Lk is found. Therefore, the residual generator design now reduces to find the solutions to unknown matrices Lk, Nk, Gk, Tk, and Fk which satisfy three conditions (49), (54), and (55). Here, we again assign stable eigenvalues to Nk and then the fault isolation scheme can be achieved in the following sections.As in Section3, let us use matrix P defined in (14) and the partitions in (15) and (17) and the following partitions:(57)LkP=Lk1Lk2,(58)P-1Dk=Dk1Dk2,where Lk1∈Rq×p, Lk2∈Rq×(n-p), Dk1∈Rp×1, and Dk2∈R(n-p)×1.Accordingly, matrix equations (49), (54), and (55) can be partitioned to the following:(59)Gk=Lk1A11+Lk2A21-NkLk1,(60)Fk=-TkLk1,(61)NkLk2-Lk2A22-Lk1A12=0,(62)TkLk2=0,(63)Lk1Dk1+Lk2Dk2=0.Clearly, with prescribed eigenvalues forNk in (48), from three matrix equations (61)–(63) matrices Lk1, Lk2, and Tk can be found. Moreover, based on (59) and (60), Gk and Fk are calculated, respectively, to complete the design of the residual generator. For this, we will consider two cases, namely, Cases 3 and 4. In Case 3, we present a solution to matrix equations (61)–(63) with only a first-order residual generator designed. Indeed, it is possible that a first-order residual generator exists when N([A12Dk1])≠0. This is discussed in Case 3. When a first-order residual generator does not exist, then in Case 4, based on a parametric solution approach, a residual generator can be constructed with the order as low as [n-p+1/p-1].Case 3 (first-order residual generators).
In this case, we design a bank of first-order residual generatorsrk(t), k=1,2,…,l, to isolate faults in the system. The existence conditions of each residual generator are presented in the following theorem.Theorem 11.
A first-order residual generatorrk(t) exists if N([A12Dk1])≠0 and condition (56) holds.Proof.
The proof of Theorem11 is similar to that of Theorem 4. For completeness, it is given here. To design a first-order residual generator rk(t), that is, q=1, Nk∈R1×1 can be assigned as any negative scalar, say, Nk=sk<0. By letting Lk2=0, we can arbitrarily choose Tk≠0 as any real number αk, αk≠0. Accordingly, (61)–(63) are now reduced to(64)Lk1Θk=0,whereΘk=A12Dk1.
As in Case1 (see also Remark 8), a solution to (64) where Lk1≠0 always exists if N(Θk)≠0 such that N(Θk)Θk=0. Therefore, solutions to Lk1 according to (64) can be computed by first finding L^k1, where(65)L^k1=NΘkand then Lk1 is selected as any row of L^k1.
Finally, if condition (56) is satisfied, that is, LkDR≠0, the rest of the parameters of the residual generator can be determined. This completes the proof of Theorem 11.Remark 12.
Note that wheneverp>n+1/2, N(Θk)≠0 always exists since Θk is a column matrix. As a result, a solution to Lk1≠0 always exists and a first-order residual generator can exist to isolate faults in the system.Case 4 (minimal-order residual generators).
In the case that a bank of first-order residual generators is not possible to design by applying the method presented in Case3, we can employ a parametric approach to design a bank of minimal-order residual generators to isolate faults in the system. For this, as in Case 2, we assume that the pair (C,A) is observable. In the remainder of this section, we present a systematic procedure which helps to design each residual generator, rk(t), of the residual bank. For this, we consider the case where rank(A12Dk1)=p and let us use similar notations as in Case 2 (Section 3) to state the solution of generalized Sylvester equation (61), where(66)Nk=Qk-1ΛkQk,(67)Lk1=QkUsk1bk1⋯Uskqbkq⊤,(68)Lk2=QkZsk1bk1⋯Zskqbkq⊤.
The following theorem presents the existence condition and the minimal order of the residual generatorrk(t).Theorem 13.
A residual generatorrk(t), with an order as low as n-p+1/p-1, exists if condition (56) holds.Proof.
The design of residual generatorrk(t) is reduced to solving three matrix equations (61)-(63) and with the satisfaction of condition (56). Since Qk is any invertible matrix, by substituting Lk1 and Lk2 from (67) and (68) into the transpose of (63), the following equation is obtained:(69)Dk1Dk2⊤Usk1bk1Usk2bk2⋯UskqbkqZsk1bk1Zsk2bk2⋯Zskqbkq=0.
From (69), the following q equations are obtained:(70)Dk1⊤Dk2⊤UskiZskibki=0,i=1,2,…,q.
It is a fact that there always exist nonsingular matricesΩki∈Rp×p(i=1,2,…,q), ΩkiΩki-1=Ip, such that the following partitions are satisfied:(71)Dk1⊤Dk2⊤UskiZskiΩki=Xki1Xki2,Ωki-1bki=bki1bki2,where Xki1∈R1×1, Xki1≠0, Xki2∈R1×(p-1), bki1∈R1×1, and bki2∈R(p-1)×1.
From (70) and (71), the following equations are obtained:(72)bki=Ωki-Xki1-1Xki2Ip-1bki2,i=1,2,…,q.
Let us denote that(73)TkQk=tk1tk2⋯tkq,where tki≠0, i=1,2,…,q, are arbitrarily chosen scalars.
By substitutingLk2 from (68) and TkQk from (73) into the transpose of (62), we obtain(74)Zsk1tk1Zsk2tk2⋯Zskqtkqbk1bk2⋮bkq=0.
Substituting (72) into (74), the following equation is obtained:(75)Φkb~k=0,where Φk∈R(n-p)×q(p-1) and b~k∈Rq(p-1)×1 and(76)b~k=bk12⊤bk22⊤⋯bkq2⊤⊤,Φki=tkiZskiΩki-Xki1-1Xki2Ip-1,Φk=Φk1Φk2⋯Φkq.
As in (38), if we define N(Φk) such that ΦkN(Φk)=0, then a solution to b~k≠0 exists if N(Φk)≠0. Specifically, N(Φk)≠0 always exists if the order q satisfies the following condition:(77)q≥n-p+1p-1,and then b~k can be taken to be any column of matrix b^k, where b^k is computed as(78)b^k=NΦk.
It is noted that if we assign an orderq such that condition (77) holds, a solution to b~k≠0 always exists. Therefore, with an attempt to minimize the residual generator order, we only need to prescribe the order as low as q=n-p+1/p-1 which is identified to be the lowest order satisfying (77).
Consequently, with prescribed eigenvalues ofNk and arbitrarily chosen tki≠0, matrices Lk1, Lk2, and Lk are then easily calculated from (67), (68), and (57), respectively. If condition (56) is satisfied, a minimal-order residual generator exists to isolate the faults. The remaining parameters Gk, Fk, and Tk can be obtained based on (59), (60), and (73), respectively, to complete the design of residual generator rk(t). This completes the proof of Theorem 13.


## 5. Numerical Examples

### 5.1. Example 1

In this example, we consider timely detection of faults in a dynamical system which hasn=8, p=5, m=2, and l=2. Since we have the case where p>n+1/2 and as discussed in Case 1 (Section 3) and Case 3 (Section 4), we can indeed design only first-order residual generators to effectively detect and isolate the faults in the system. For this example, the system matrices C=I50, A, B, and D are as given below:(79)A=-1011-21-300-53-4010-111-83021-2-402-61-5-211001-1202-20120-3-1121-10-10-83-20-1-40-6-3-2,B=10211-101311-3-1011,D=42-2.5-1.523-1-110-12-1042.5.SinceC is already in the desired form, that is, C=I50, P is an identity matrix; that is, P=I8. Accordingly, by (17), submatrices A11, A12, A21, and A22 are obtained, where(80)
A
11
A
12
A
21
A
22
=
-
1
0
1
1
-
2
1
-
3
0
0
-
5
3
-
4
0
1
0
-
1
1
1
-
8
3
0
2
1
-
2
-
4
0
2
-
6
1
-
5
-
2
1
1
0
0
1
-
1
2
0
2
-
2
0
1
2
0
-
3
-
1
1
2
1
-
1
0
-
1
0
-
8
3
-
2
0
-
1
-
4
0
-
6
-
3
-
2
.Now, the design of first-order residual generators can be readily carried out to detect and isolate the faults in the system.


#### 5.1.1. First-Order Residual Generator Detects Faults in the System

It is clear thatA12 is a column matrix and thus its null-space exists; that is, N(A12)≠0. As discussed in Case 1 (Section 3), a first-order functional observer exists for the FD purpose. Let us assign N=-8; L1 is then computed according to (25), where(81)L1=4-271410.Since lettingL2=[000] and by (16), matrix L is obtained as(82)L=4-271410000.By that, condition (13) is found to be satisfied since LD=110.589.5≠0. Hence, a first-order residual generator now can be designed to detect faults in the system. We complete the design by first choosing T=0.2 and matrices H, G, and F are then obtained based on (9), (19), and (20), respectively, where(83)H=-36-40,G=38-67-75156-7,F=-0.85.4-2.8-0.20.Figure2 shows that the first-order residual generator can detect faults f1(t) and f2(t) in the system. Fault f1(t) appears at the time t=10s and clears from the time t=20s. Fault f2(t) happens from the time t=30s to the time t=40s. It is clear from the figure that while the faults are happening, the residual generator triggers them, whereas when the faults clear, the residual generator converges to zero as expected. Note also that the residual generator is insensitive to the inputs u(t). It is clear from this example that the residual generator is designed by using a significantly lower-order (only first-order) functional observer. In contrast, existing FD schemes using full-order or reduced-order state observers would give higher-order schemes. This example thus serves to highlight the attractiveness of our FD scheme proposed in this paper.Figure 2
First-order observer-based residual generator detects faults in the system.


#### 5.1.2. First-Order Residual Bank Isolates Faults in the System

In this section, we demonstrate our solution approach to isolate the faults in the system as presented in Case3 (Section 4). For this system, there are two possible faults; thus we design a bank of two first-order residual generators, r1(t) and r2(t), to isolate the faults. Let us assign the eigenvalue for both residuals as Nk=-6, k=1,2. Now the conditions, which ensure the existence of each residual generator, will be verified and the design of the residual bank will be carried out.Residual Generator
r
1
(
t
). Here, r1(t) is designed to be insensitive to fault f1(t) but sensitive to f2(t). From partitions (43) and (58), D1, DR, and D11 are as given below:(84)D1=4-2.52-11-1-14⊤,DR=2-1.53-10202.5⊤,D11=4-2.52-11⊤.According to (65), L11 is found by computing N(Θ1). This gives(85)L11=-0.23530.58821.17650.94121.SinceL12=000, from (57), L1=L11000 and condition (56) is satisfied since L1DR=1.2353≠0. Hence, based on Theorem 11, first-order residual generator r1(t) exists for FI. Now, by assigning T1=8, matrices H1, G1, and F1 are calculated based on (50), (59), and (60), respectively, to complete the design of residual generator r1(t), where(86)H1=5.11761.3529,F1=1.8824-4.7059-9.4118-7.5294-8,G1=-2.76471.76471.05881.94126.4118.Residual Generator
r
2
(
t
). By applying the same process as for the residual generator r1(t), we have the following results for the residual generator r2(t), which is insensitive to fault f2(t) and sensitive to fault f1(t):(87)D2=2-1.53-10202.5⊤,DR=4-2.52-11-1-14⊤,D21=2-1.53-10⊤,L21=-0.29050.96090.98320.92741,L2=L21000.SinceL2DR=-1.5251≠0, condition (56) holds. Consequently, the residual generator r2(t) exists with a first order. Now, we can complete the design of r2(t) by calculating matrices H2, G2, and F2, where(88)H2=5.61451.9050,F2=2.3240-7.6872-7.8659-7.4190-8G2=-3.17881.94412.4804-0.18446.5084.Figure3 shows that a bank of two first-order residual generators can effectively and timely isolate the faults in the system. Here, fault f1(t) happens in the system from the time 20s and clears from the time 30s. By that, the output of residual generator r1(t) remains as zero. Meanwhile, that of the residual generator r2(t) derives from zero. Consequently, by observing the residual outputs, we can identify that fault f1(t) happened in the system. Clearly, the residual bank can effectively and timely isolate the faults in the system. This example again serves to illustrate the simplicity of our proposed FI scheme using minimal-order functional observers.Figure 3
First-order observer-based residual bank isolates faults in the system.
(a)
(b)


### 5.2. Example 2

This example is given to demonstrate Case2 (Section 3) and Case 4 (Section 4) by considering a system with n=8, p=3, m=2, and l=3, where C=[I30], and A, B, and D are as given below:(89)
A
=
A
11
A
12
A
21
A
22
=
-
5
2
0
1
0
1
9
-
1
1
-
1
0
0
1
-
1
0
1
1
0
-
5
3
4
0
-
3
2
-
3
1
1
-
8
3
1
4
2
-
2
-
4
0
0
-
6
0
1
0
0
0
-
1
1
-
2
-
3
3
-
1
2
0
2
3
7
1
-
7
0
1
1
0
-
2
1
0
0
-
1
,
B
=
1
0
0
1
1
-
1
0
0
0
1
1
-
2
1
1
-
1
0
,
D
=
1
-
2
1
-
2
-
1
-
2
-
2
1
3
0
-
3
1
2
0
-
1
2
1
0
-
2
-
1
1
1
-
1
2
.From (30)–(34), we obtain the following pair of coprime polynomial matrices U(s) and Z(s):(90)Us=s5+25s4+214s3+762s2+1118s+582I3,Zs=Υ1s4+Υ2s3+Υ3s2+Υ4s+Υ5A12⊤,where(91)Υ1=I5,Υ2=17013-2319-27110221041318020-1024,Υ3=8732531-3261107-9911218115218-2461247110-7310-195186,Υ4=1601313190-139212211135286-27791237887-3314138218261-731255-8339514,Υ5=901215072-168162138270246-186641533390-11310233267198-1711169-3354359.For this example, by applying the scheme discussed in Case2, we only need to design a residual generator based on a second-order functional observer to detect the faults in the system. Furthermore, for isolating the faults, we use only a bank of three residual generators which are designed based on third-order functional observers. The design is carried out in the following sections.


#### 5.2.1. Second-Order Residual Generator Detects Faults in the System

AsA12 has full-row rank, that is, rank(A12)=3 and 1<p<n/2, this falls into Case 2 (Section 3). By that, we can design a residual generator using a functional observer which has an order of q=[8-3+1/3]=2, that is, second order, to detect the faults in the system.Let us assign the eigenvalues ofN to be s1=-4 and s2=-5 and choose Q=I2. Also, scalars ti are chosen as TQ=-0.5-0.5. From (38), Z is obtained, where(92)Z⊤=-56.0-376110.0-63.077.0-25.0-19165.5-31.535.5-11.0-12438.0-27.014.0-90.5-84635.0-83.580.0-2.0-25668.0-30.0-8.064.5-19417.0-98.5-80.0.Clearly,Z is a row matrix; as a result, b≠0 exists and is obtained by taking any column of N(Z) in (38). Accordingly, b1 and b2 are obtained, where(93)b1=0.499-0.788-0.323⊤,b2=-0.0460.1520.014⊤.From (27) and (28), L1 and L2 are obtained:(94)L1=-8.99114.1845.8139.521-31.531-2.842,L2=9.441-9.441-5.4655.46517.877-17.877-4.1434.143-11.93511.935⊤.SinceP=I8, L=[L1L2] and it is easy to verify condition (13) that(95)LD=-27.81115.241-33.03057.0934.01677.164≠0.Thus, condition (13) is satisfied and hence a residual generator using a second-order functional observer can be constructed to detect the faults. The parameters of the observer and the residual generator are obtained by (26), (19), (9), (20), and (36), where(96)N=-400-5,G=-8.62843.934-22.5333.243-126.44516.720,H=22.491-36.989-18.99016.672,F=0.265-8.6731.485,T=-0.5-0.5.Figure4 indicates that the residual generator can detect the faults f1(t), f2(t), and f3(t) in the system. It is clear in this example that the design of the residual generator is very simple and systematic.Figure 4
Second-order observer-based residual generator detects the faults in the system.


#### 5.2.2. Third-Order Residual Bank Isolates the Faults in the System

By applying the scheme in Case4, for this system, we now proceed to design a bank of three residual generators which are based on third-order functional observers, q=[8-3+1/3-1]=3, to isolate the faults happening in the system.To design the residual bank, we, for the sake of simplicity, firstly assign the poles ofNk to be at sk1=-4, sk2=-5, and sk3=-7, k=1,2,3. Qk is chosen as Qk=I3, and TkQk is chosen as TkQk=[111] for all the three residual generators. In the remainder of this example, we will verify the conditions, which guarantee the existence of each residual generator, and complete the design by determining all the necessary parameters.Residual Generator
r
1
(
t
). This residual generator is designed such that it is insensitive to fault f1(t) but sensitive to faults f2(t) and f3(t). From partitions (43) and (58), D1, DR, D11, and D12 are obtained as(97)D1=110010-2-1⊤,DR=-2-11-301-1-11-231-1012⊤,D11=110⊤,D12=010-2-1⊤.From (75), Φ1 is obtained, where(98)Φ1⊤=-4.4216.64-24.111.783.82-7.5949.36-17.8920.7212.68-19.21295.01-127.0238.5836.52-106.06602.41-42.87218.16139.72-44.15119.43-15.886.0329.01-174.63246.4219.4183.2293.74.SinceΦ1 is a row matrix, b~1≠0 in (75) exists and is taken from N(Φ1). Accordingly, from (72), b11, b12, and b13 are obtained, where(99)b11=0.142-0.6840.721⊤,b12=-0.0180.057-0.083⊤,b13=-0.0070.0260.023⊤.From (67) and (68), L11 and L12 are obtained:(100)L11=-2.55512.318-12.9853.685-11.76717.1730.620-2.302-2.108,L12=-2.4507.670-5.21924.219-33.0468.8273.598-3.6460.04813.725-15.8292.1036.532-9.4702.938⊤.By (57) and P=I8 that L1=L11L12 and condition (56) is satisfied since(101)L1DR=-29.50320.2129.619-66.02884.683-7.166⊤≠0.Thus, residual generatorr1(t) based on a third-order functional observer exists, and from (50), (59), (60), and (73), the rest of the parameters of the residual generator are obtained, where(102)H1=-4.74956.05310.852-70.521-2.27310.639,G1=-5.217-60.95034.3887.36190.688-20.3411.980-50.161-5.276,F1=-1.7511.751-2.079,T1=111.By applying the same procedure as for designingr1(t), the following results are obtained for residual generators r2(t) and r3(t).Residual Generator
r
2
(
t
). This residual generator is designed such that it is insensitive to fault f2(t) but sensitive to faults f1(t) and f3(t). The following results are obtained:(103)D2=-2-11-301-1-1⊤,DR=110010-2-11-231-1012⊤,D21=-2-11⊤,D22=-301-1-1⊤,b21=0.311-0.8700.451⊤,b22=-0.0380.143-0.066⊤,b23=0.012-0.1140.037⊤,L21=-5.59515.664-8.1217.945-29.67813.729-1.09910.261-3.347,L22=1.2292.172-3.40113.219-17.1843.96511.325-14.4873.1618.705-10.8212.1151.283-2.1660.883⊤,L2DR=12.279-4.025-4.020-62.006112.689-35.150⊤≠0.SinceL2DR≠0, condition (56) is satisfied. Hence, residual generator r2(t) using a third-order functional observer exists and its design is completed by obtaining the following parameters:(104)H2=5.03123.0595-1.468-42.438-0.05313.366,G2=1.708-14.56015.436-11.903-34.079-4.98312.10040.992-9.027,F2=-1.2513.752-2.260,T2=111.Residual Generator
r
3
(
t
). This residual generator is designed such that it is insensitive to fault f3(t) but sensitive to faults f1(t) and f2(t). The following results are obtained:(105)D3=1-231-1012⊤,DR=110010-2-1-2-11-301-1-1⊤,D31=1-23⊤,D32=1-1012⊤,b31=0.005-0.5150.846⊤,b32=-0.0030.051-0.107⊤,b33=-0.007-0.0310.056⊤,L31=-0.0969.269-15.2370.673-10.60922.3360.6172.822-5.040,L32=-6.52413.4706-6.946817.257-21.0273.7701.943-3.0591.11613.946-18.6354.68912.033-15.8473.814⊤,L3DR=34.384-49.5319.259-28.77822.6104.358⊤≠0.SinceL3DR≠0, condition (56) is satisfied. Hence, the residual r3(t) exists with a third order. The rest of the parameters of the residual are obtained, where(106)H3=-11.47851.82217.162-66.490-2.43214.090,G3=19.109-35.90534.661-39.74740.643-20.74025.508-0.046-8.764,F3=-1.194-1.482-2.059,T3=111.Figure5 indicates that a bank of three third-order residual generators can isolate the faults f1(t), f2(t), and f3(t) in the system. In the figure, when fault f2(t) occurs in the system, the residual r2(t) is insensitive to the fault; thus its output remains as zero. Meanwhile, the residual generators r1(t) and r3(t) trigger the fault. By that we can isolate fault f2(t) in the system. This example again further highlights the efficiency of our proposed FI scheme in this paper.Figure 5
Third-order observer-based residual bank isolates the faults in the system.
(a)
(b)
(c)


## 5.1. Example 1

In this example, we consider timely detection of faults in a dynamical system which hasn=8, p=5, m=2, and l=2. Since we have the case where p>n+1/2 and as discussed in Case 1 (Section 3) and Case 3 (Section 4), we can indeed design only first-order residual generators to effectively detect and isolate the faults in the system. For this example, the system matrices C=I50, A, B, and D are as given below:(79)A=-1011-21-300-53-4010-111-83021-2-402-61-5-211001-1202-20120-3-1121-10-10-83-20-1-40-6-3-2,B=10211-101311-3-1011,D=42-2.5-1.523-1-110-12-1042.5.SinceC is already in the desired form, that is, C=I50, P is an identity matrix; that is, P=I8. Accordingly, by (17), submatrices A11, A12, A21, and A22 are obtained, where(80)
A
11
A
12
A
21
A
22
=
-
1
0
1
1
-
2
1
-
3
0
0
-
5
3
-
4
0
1
0
-
1
1
1
-
8
3
0
2
1
-
2
-
4
0
2
-
6
1
-
5
-
2
1
1
0
0
1
-
1
2
0
2
-
2
0
1
2
0
-
3
-
1
1
2
1
-
1
0
-
1
0
-
8
3
-
2
0
-
1
-
4
0
-
6
-
3
-
2
.Now, the design of first-order residual generators can be readily carried out to detect and isolate the faults in the system.


### 5.1.1. First-Order Residual Generator Detects Faults in the System

It is clear thatA12 is a column matrix and thus its null-space exists; that is, N(A12)≠0. As discussed in Case 1 (Section 3), a first-order functional observer exists for the FD purpose. Let us assign N=-8; L1 is then computed according to (25), where(81)L1=4-271410.Since lettingL2=[000] and by (16), matrix L is obtained as(82)L=4-271410000.By that, condition (13) is found to be satisfied since LD=110.589.5≠0. Hence, a first-order residual generator now can be designed to detect faults in the system. We complete the design by first choosing T=0.2 and matrices H, G, and F are then obtained based on (9), (19), and (20), respectively, where(83)H=-36-40,G=38-67-75156-7,F=-0.85.4-2.8-0.20.Figure2 shows that the first-order residual generator can detect faults f1(t) and f2(t) in the system. Fault f1(t) appears at the time t=10s and clears from the time t=20s. Fault f2(t) happens from the time t=30s to the time t=40s. It is clear from the figure that while the faults are happening, the residual generator triggers them, whereas when the faults clear, the residual generator converges to zero as expected. Note also that the residual generator is insensitive to the inputs u(t). It is clear from this example that the residual generator is designed by using a significantly lower-order (only first-order) functional observer. In contrast, existing FD schemes using full-order or reduced-order state observers would give higher-order schemes. This example thus serves to highlight the attractiveness of our FD scheme proposed in this paper.Figure 2
First-order observer-based residual generator detects faults in the system.


### 5.1.2. First-Order Residual Bank Isolates Faults in the System

In this section, we demonstrate our solution approach to isolate the faults in the system as presented in Case3 (Section 4). For this system, there are two possible faults; thus we design a bank of two first-order residual generators, r1(t) and r2(t), to isolate the faults. Let us assign the eigenvalue for both residuals as Nk=-6, k=1,2. Now the conditions, which ensure the existence of each residual generator, will be verified and the design of the residual bank will be carried out.Residual Generator
r
1
(
t
). Here, r1(t) is designed to be insensitive to fault f1(t) but sensitive to f2(t). From partitions (43) and (58), D1, DR, and D11 are as given below:(84)D1=4-2.52-11-1-14⊤,DR=2-1.53-10202.5⊤,D11=4-2.52-11⊤.According to (65), L11 is found by computing N(Θ1). This gives(85)L11=-0.23530.58821.17650.94121.SinceL12=000, from (57), L1=L11000 and condition (56) is satisfied since L1DR=1.2353≠0. Hence, based on Theorem 11, first-order residual generator r1(t) exists for FI. Now, by assigning T1=8, matrices H1, G1, and F1 are calculated based on (50), (59), and (60), respectively, to complete the design of residual generator r1(t), where(86)H1=5.11761.3529,F1=1.8824-4.7059-9.4118-7.5294-8,G1=-2.76471.76471.05881.94126.4118.Residual Generator
r
2
(
t
). By applying the same process as for the residual generator r1(t), we have the following results for the residual generator r2(t), which is insensitive to fault f2(t) and sensitive to fault f1(t):(87)D2=2-1.53-10202.5⊤,DR=4-2.52-11-1-14⊤,D21=2-1.53-10⊤,L21=-0.29050.96090.98320.92741,L2=L21000.SinceL2DR=-1.5251≠0, condition (56) holds. Consequently, the residual generator r2(t) exists with a first order. Now, we can complete the design of r2(t) by calculating matrices H2, G2, and F2, where(88)H2=5.61451.9050,F2=2.3240-7.6872-7.8659-7.4190-8G2=-3.17881.94412.4804-0.18446.5084.Figure3 shows that a bank of two first-order residual generators can effectively and timely isolate the faults in the system. Here, fault f1(t) happens in the system from the time 20s and clears from the time 30s. By that, the output of residual generator r1(t) remains as zero. Meanwhile, that of the residual generator r2(t) derives from zero. Consequently, by observing the residual outputs, we can identify that fault f1(t) happened in the system. Clearly, the residual bank can effectively and timely isolate the faults in the system. This example again serves to illustrate the simplicity of our proposed FI scheme using minimal-order functional observers.Figure 3
First-order observer-based residual bank isolates faults in the system.
(a)
(b)


## 5.1.1. First-Order Residual Generator Detects Faults in the System

It is clear thatA12 is a column matrix and thus its null-space exists; that is, N(A12)≠0. As discussed in Case 1 (Section 3), a first-order functional observer exists for the FD purpose. Let us assign N=-8; L1 is then computed according to (25), where(81)L1=4-271410.Since lettingL2=[000] and by (16), matrix L is obtained as(82)L=4-271410000.By that, condition (13) is found to be satisfied since LD=110.589.5≠0. Hence, a first-order residual generator now can be designed to detect faults in the system. We complete the design by first choosing T=0.2 and matrices H, G, and F are then obtained based on (9), (19), and (20), respectively, where(83)H=-36-40,G=38-67-75156-7,F=-0.85.4-2.8-0.20.Figure2 shows that the first-order residual generator can detect faults f1(t) and f2(t) in the system. Fault f1(t) appears at the time t=10s and clears from the time t=20s. Fault f2(t) happens from the time t=30s to the time t=40s. It is clear from the figure that while the faults are happening, the residual generator triggers them, whereas when the faults clear, the residual generator converges to zero as expected. Note also that the residual generator is insensitive to the inputs u(t). It is clear from this example that the residual generator is designed by using a significantly lower-order (only first-order) functional observer. In contrast, existing FD schemes using full-order or reduced-order state observers would give higher-order schemes. This example thus serves to highlight the attractiveness of our FD scheme proposed in this paper.Figure 2
First-order observer-based residual generator detects faults in the system.


## 5.1.2. First-Order Residual Bank Isolates Faults in the System

In this section, we demonstrate our solution approach to isolate the faults in the system as presented in Case3 (Section 4). For this system, there are two possible faults; thus we design a bank of two first-order residual generators, r1(t) and r2(t), to isolate the faults. Let us assign the eigenvalue for both residuals as Nk=-6, k=1,2. Now the conditions, which ensure the existence of each residual generator, will be verified and the design of the residual bank will be carried out.Residual Generator
r
1
(
t
). Here, r1(t) is designed to be insensitive to fault f1(t) but sensitive to f2(t). From partitions (43) and (58), D1, DR, and D11 are as given below:(84)D1=4-2.52-11-1-14⊤,DR=2-1.53-10202.5⊤,D11=4-2.52-11⊤.According to (65), L11 is found by computing N(Θ1). This gives(85)L11=-0.23530.58821.17650.94121.SinceL12=000, from (57), L1=L11000 and condition (56) is satisfied since L1DR=1.2353≠0. Hence, based on Theorem 11, first-order residual generator r1(t) exists for FI. Now, by assigning T1=8, matrices H1, G1, and F1 are calculated based on (50), (59), and (60), respectively, to complete the design of residual generator r1(t), where(86)H1=5.11761.3529,F1=1.8824-4.7059-9.4118-7.5294-8,G1=-2.76471.76471.05881.94126.4118.Residual Generator
r
2
(
t
). By applying the same process as for the residual generator r1(t), we have the following results for the residual generator r2(t), which is insensitive to fault f2(t) and sensitive to fault f1(t):(87)D2=2-1.53-10202.5⊤,DR=4-2.52-11-1-14⊤,D21=2-1.53-10⊤,L21=-0.29050.96090.98320.92741,L2=L21000.SinceL2DR=-1.5251≠0, condition (56) holds. Consequently, the residual generator r2(t) exists with a first order. Now, we can complete the design of r2(t) by calculating matrices H2, G2, and F2, where(88)H2=5.61451.9050,F2=2.3240-7.6872-7.8659-7.4190-8G2=-3.17881.94412.4804-0.18446.5084.Figure3 shows that a bank of two first-order residual generators can effectively and timely isolate the faults in the system. Here, fault f1(t) happens in the system from the time 20s and clears from the time 30s. By that, the output of residual generator r1(t) remains as zero. Meanwhile, that of the residual generator r2(t) derives from zero. Consequently, by observing the residual outputs, we can identify that fault f1(t) happened in the system. Clearly, the residual bank can effectively and timely isolate the faults in the system. This example again serves to illustrate the simplicity of our proposed FI scheme using minimal-order functional observers.Figure 3
First-order observer-based residual bank isolates faults in the system.
(a)
(b)


## 5.2. Example 2

This example is given to demonstrate Case2 (Section 3) and Case 4 (Section 4) by considering a system with n=8, p=3, m=2, and l=3, where C=[I30], and A, B, and D are as given below:(89)
A
=
A
11
A
12
A
21
A
22
=
-
5
2
0
1
0
1
9
-
1
1
-
1
0
0
1
-
1
0
1
1
0
-
5
3
4
0
-
3
2
-
3
1
1
-
8
3
1
4
2
-
2
-
4
0
0
-
6
0
1
0
0
0
-
1
1
-
2
-
3
3
-
1
2
0
2
3
7
1
-
7
0
1
1
0
-
2
1
0
0
-
1
,
B
=
1
0
0
1
1
-
1
0
0
0
1
1
-
2
1
1
-
1
0
,
D
=
1
-
2
1
-
2
-
1
-
2
-
2
1
3
0
-
3
1
2
0
-
1
2
1
0
-
2
-
1
1
1
-
1
2
.From (30)–(34), we obtain the following pair of coprime polynomial matrices U(s) and Z(s):(90)Us=s5+25s4+214s3+762s2+1118s+582I3,Zs=Υ1s4+Υ2s3+Υ3s2+Υ4s+Υ5A12⊤,where(91)Υ1=I5,Υ2=17013-2319-27110221041318020-1024,Υ3=8732531-3261107-9911218115218-2461247110-7310-195186,Υ4=1601313190-139212211135286-27791237887-3314138218261-731255-8339514,Υ5=901215072-168162138270246-186641533390-11310233267198-1711169-3354359.For this example, by applying the scheme discussed in Case2, we only need to design a residual generator based on a second-order functional observer to detect the faults in the system. Furthermore, for isolating the faults, we use only a bank of three residual generators which are designed based on third-order functional observers. The design is carried out in the following sections.


### 5.2.1. Second-Order Residual Generator Detects Faults in the System

AsA12 has full-row rank, that is, rank(A12)=3 and 1<p<n/2, this falls into Case 2 (Section 3). By that, we can design a residual generator using a functional observer which has an order of q=[8-3+1/3]=2, that is, second order, to detect the faults in the system.Let us assign the eigenvalues ofN to be s1=-4 and s2=-5 and choose Q=I2. Also, scalars ti are chosen as TQ=-0.5-0.5. From (38), Z is obtained, where(92)Z⊤=-56.0-376110.0-63.077.0-25.0-19165.5-31.535.5-11.0-12438.0-27.014.0-90.5-84635.0-83.580.0-2.0-25668.0-30.0-8.064.5-19417.0-98.5-80.0.Clearly,Z is a row matrix; as a result, b≠0 exists and is obtained by taking any column of N(Z) in (38). Accordingly, b1 and b2 are obtained, where(93)b1=0.499-0.788-0.323⊤,b2=-0.0460.1520.014⊤.From (27) and (28), L1 and L2 are obtained:(94)L1=-8.99114.1845.8139.521-31.531-2.842,L2=9.441-9.441-5.4655.46517.877-17.877-4.1434.143-11.93511.935⊤.SinceP=I8, L=[L1L2] and it is easy to verify condition (13) that(95)LD=-27.81115.241-33.03057.0934.01677.164≠0.Thus, condition (13) is satisfied and hence a residual generator using a second-order functional observer can be constructed to detect the faults. The parameters of the observer and the residual generator are obtained by (26), (19), (9), (20), and (36), where(96)N=-400-5,G=-8.62843.934-22.5333.243-126.44516.720,H=22.491-36.989-18.99016.672,F=0.265-8.6731.485,T=-0.5-0.5.Figure4 indicates that the residual generator can detect the faults f1(t), f2(t), and f3(t) in the system. It is clear in this example that the design of the residual generator is very simple and systematic.Figure 4
Second-order observer-based residual generator detects the faults in the system.


### 5.2.2. Third-Order Residual Bank Isolates the Faults in the System

By applying the scheme in Case4, for this system, we now proceed to design a bank of three residual generators which are based on third-order functional observers, q=[8-3+1/3-1]=3, to isolate the faults happening in the system.To design the residual bank, we, for the sake of simplicity, firstly assign the poles ofNk to be at sk1=-4, sk2=-5, and sk3=-7, k=1,2,3. Qk is chosen as Qk=I3, and TkQk is chosen as TkQk=[111] for all the three residual generators. In the remainder of this example, we will verify the conditions, which guarantee the existence of each residual generator, and complete the design by determining all the necessary parameters.Residual Generator
r
1
(
t
). This residual generator is designed such that it is insensitive to fault f1(t) but sensitive to faults f2(t) and f3(t). From partitions (43) and (58), D1, DR, D11, and D12 are obtained as(97)D1=110010-2-1⊤,DR=-2-11-301-1-11-231-1012⊤,D11=110⊤,D12=010-2-1⊤.From (75), Φ1 is obtained, where(98)Φ1⊤=-4.4216.64-24.111.783.82-7.5949.36-17.8920.7212.68-19.21295.01-127.0238.5836.52-106.06602.41-42.87218.16139.72-44.15119.43-15.886.0329.01-174.63246.4219.4183.2293.74.SinceΦ1 is a row matrix, b~1≠0 in (75) exists and is taken from N(Φ1). Accordingly, from (72), b11, b12, and b13 are obtained, where(99)b11=0.142-0.6840.721⊤,b12=-0.0180.057-0.083⊤,b13=-0.0070.0260.023⊤.From (67) and (68), L11 and L12 are obtained:(100)L11=-2.55512.318-12.9853.685-11.76717.1730.620-2.302-2.108,L12=-2.4507.670-5.21924.219-33.0468.8273.598-3.6460.04813.725-15.8292.1036.532-9.4702.938⊤.By (57) and P=I8 that L1=L11L12 and condition (56) is satisfied since(101)L1DR=-29.50320.2129.619-66.02884.683-7.166⊤≠0.Thus, residual generatorr1(t) based on a third-order functional observer exists, and from (50), (59), (60), and (73), the rest of the parameters of the residual generator are obtained, where(102)H1=-4.74956.05310.852-70.521-2.27310.639,G1=-5.217-60.95034.3887.36190.688-20.3411.980-50.161-5.276,F1=-1.7511.751-2.079,T1=111.By applying the same procedure as for designingr1(t), the following results are obtained for residual generators r2(t) and r3(t).Residual Generator
r
2
(
t
). This residual generator is designed such that it is insensitive to fault f2(t) but sensitive to faults f1(t) and f3(t). The following results are obtained:(103)D2=-2-11-301-1-1⊤,DR=110010-2-11-231-1012⊤,D21=-2-11⊤,D22=-301-1-1⊤,b21=0.311-0.8700.451⊤,b22=-0.0380.143-0.066⊤,b23=0.012-0.1140.037⊤,L21=-5.59515.664-8.1217.945-29.67813.729-1.09910.261-3.347,L22=1.2292.172-3.40113.219-17.1843.96511.325-14.4873.1618.705-10.8212.1151.283-2.1660.883⊤,L2DR=12.279-4.025-4.020-62.006112.689-35.150⊤≠0.SinceL2DR≠0, condition (56) is satisfied. Hence, residual generator r2(t) using a third-order functional observer exists and its design is completed by obtaining the following parameters:(104)H2=5.03123.0595-1.468-42.438-0.05313.366,G2=1.708-14.56015.436-11.903-34.079-4.98312.10040.992-9.027,F2=-1.2513.752-2.260,T2=111.Residual Generator
r
3
(
t
). This residual generator is designed such that it is insensitive to fault f3(t) but sensitive to faults f1(t) and f2(t). The following results are obtained:(105)D3=1-231-1012⊤,DR=110010-2-1-2-11-301-1-1⊤,D31=1-23⊤,D32=1-1012⊤,b31=0.005-0.5150.846⊤,b32=-0.0030.051-0.107⊤,b33=-0.007-0.0310.056⊤,L31=-0.0969.269-15.2370.673-10.60922.3360.6172.822-5.040,L32=-6.52413.4706-6.946817.257-21.0273.7701.943-3.0591.11613.946-18.6354.68912.033-15.8473.814⊤,L3DR=34.384-49.5319.259-28.77822.6104.358⊤≠0.SinceL3DR≠0, condition (56) is satisfied. Hence, the residual r3(t) exists with a third order. The rest of the parameters of the residual are obtained, where(106)H3=-11.47851.82217.162-66.490-2.43214.090,G3=19.109-35.90534.661-39.74740.643-20.74025.508-0.046-8.764,F3=-1.194-1.482-2.059,T3=111.Figure5 indicates that a bank of three third-order residual generators can isolate the faults f1(t), f2(t), and f3(t) in the system. In the figure, when fault f2(t) occurs in the system, the residual r2(t) is insensitive to the fault; thus its output remains as zero. Meanwhile, the residual generators r1(t) and r3(t) trigger the fault. By that we can isolate fault f2(t) in the system. This example again further highlights the efficiency of our proposed FI scheme in this paper.Figure 5
Third-order observer-based residual bank isolates the faults in the system.
(a)
(b)
(c)


## 5.2.1. Second-Order Residual Generator Detects Faults in the System

AsA12 has full-row rank, that is, rank(A12)=3 and 1<p<n/2, this falls into Case 2 (Section 3). By that, we can design a residual generator using a functional observer which has an order of q=[8-3+1/3]=2, that is, second order, to detect the faults in the system.Let us assign the eigenvalues ofN to be s1=-4 and s2=-5 and choose Q=I2. Also, scalars ti are chosen as TQ=-0.5-0.5. From (38), Z is obtained, where(92)Z⊤=-56.0-376110.0-63.077.0-25.0-19165.5-31.535.5-11.0-12438.0-27.014.0-90.5-84635.0-83.580.0-2.0-25668.0-30.0-8.064.5-19417.0-98.5-80.0.Clearly,Z is a row matrix; as a result, b≠0 exists and is obtained by taking any column of N(Z) in (38). Accordingly, b1 and b2 are obtained, where(93)b1=0.499-0.788-0.323⊤,b2=-0.0460.1520.014⊤.From (27) and (28), L1 and L2 are obtained:(94)L1=-8.99114.1845.8139.521-31.531-2.842,L2=9.441-9.441-5.4655.46517.877-17.877-4.1434.143-11.93511.935⊤.SinceP=I8, L=[L1L2] and it is easy to verify condition (13) that(95)LD=-27.81115.241-33.03057.0934.01677.164≠0.Thus, condition (13) is satisfied and hence a residual generator using a second-order functional observer can be constructed to detect the faults. The parameters of the observer and the residual generator are obtained by (26), (19), (9), (20), and (36), where(96)N=-400-5,G=-8.62843.934-22.5333.243-126.44516.720,H=22.491-36.989-18.99016.672,F=0.265-8.6731.485,T=-0.5-0.5.Figure4 indicates that the residual generator can detect the faults f1(t), f2(t), and f3(t) in the system. It is clear in this example that the design of the residual generator is very simple and systematic.Figure 4
Second-order observer-based residual generator detects the faults in the system.


## 5.2.2. Third-Order Residual Bank Isolates the Faults in the System

By applying the scheme in Case4, for this system, we now proceed to design a bank of three residual generators which are based on third-order functional observers, q=[8-3+1/3-1]=3, to isolate the faults happening in the system.To design the residual bank, we, for the sake of simplicity, firstly assign the poles ofNk to be at sk1=-4, sk2=-5, and sk3=-7, k=1,2,3. Qk is chosen as Qk=I3, and TkQk is chosen as TkQk=[111] for all the three residual generators. In the remainder of this example, we will verify the conditions, which guarantee the existence of each residual generator, and complete the design by determining all the necessary parameters.Residual Generator
r
1
(
t
). This residual generator is designed such that it is insensitive to fault f1(t) but sensitive to faults f2(t) and f3(t). From partitions (43) and (58), D1, DR, D11, and D12 are obtained as(97)D1=110010-2-1⊤,DR=-2-11-301-1-11-231-1012⊤,D11=110⊤,D12=010-2-1⊤.From (75), Φ1 is obtained, where(98)Φ1⊤=-4.4216.64-24.111.783.82-7.5949.36-17.8920.7212.68-19.21295.01-127.0238.5836.52-106.06602.41-42.87218.16139.72-44.15119.43-15.886.0329.01-174.63246.4219.4183.2293.74.SinceΦ1 is a row matrix, b~1≠0 in (75) exists and is taken from N(Φ1). Accordingly, from (72), b11, b12, and b13 are obtained, where(99)b11=0.142-0.6840.721⊤,b12=-0.0180.057-0.083⊤,b13=-0.0070.0260.023⊤.From (67) and (68), L11 and L12 are obtained:(100)L11=-2.55512.318-12.9853.685-11.76717.1730.620-2.302-2.108,L12=-2.4507.670-5.21924.219-33.0468.8273.598-3.6460.04813.725-15.8292.1036.532-9.4702.938⊤.By (57) and P=I8 that L1=L11L12 and condition (56) is satisfied since(101)L1DR=-29.50320.2129.619-66.02884.683-7.166⊤≠0.Thus, residual generatorr1(t) based on a third-order functional observer exists, and from (50), (59), (60), and (73), the rest of the parameters of the residual generator are obtained, where(102)H1=-4.74956.05310.852-70.521-2.27310.639,G1=-5.217-60.95034.3887.36190.688-20.3411.980-50.161-5.276,F1=-1.7511.751-2.079,T1=111.By applying the same procedure as for designingr1(t), the following results are obtained for residual generators r2(t) and r3(t).Residual Generator
r
2
(
t
). This residual generator is designed such that it is insensitive to fault f2(t) but sensitive to faults f1(t) and f3(t). The following results are obtained:(103)D2=-2-11-301-1-1⊤,DR=110010-2-11-231-1012⊤,D21=-2-11⊤,D22=-301-1-1⊤,b21=0.311-0.8700.451⊤,b22=-0.0380.143-0.066⊤,b23=0.012-0.1140.037⊤,L21=-5.59515.664-8.1217.945-29.67813.729-1.09910.261-3.347,L22=1.2292.172-3.40113.219-17.1843.96511.325-14.4873.1618.705-10.8212.1151.283-2.1660.883⊤,L2DR=12.279-4.025-4.020-62.006112.689-35.150⊤≠0.SinceL2DR≠0, condition (56) is satisfied. Hence, residual generator r2(t) using a third-order functional observer exists and its design is completed by obtaining the following parameters:(104)H2=5.03123.0595-1.468-42.438-0.05313.366,G2=1.708-14.56015.436-11.903-34.079-4.98312.10040.992-9.027,F2=-1.2513.752-2.260,T2=111.Residual Generator
r
3
(
t
). This residual generator is designed such that it is insensitive to fault f3(t) but sensitive to faults f1(t) and f2(t). The following results are obtained:(105)D3=1-231-1012⊤,DR=110010-2-1-2-11-301-1-1⊤,D31=1-23⊤,D32=1-1012⊤,b31=0.005-0.5150.846⊤,b32=-0.0030.051-0.107⊤,b33=-0.007-0.0310.056⊤,L31=-0.0969.269-15.2370.673-10.60922.3360.6172.822-5.040,L32=-6.52413.4706-6.946817.257-21.0273.7701.943-3.0591.11613.946-18.6354.68912.033-15.8473.814⊤,L3DR=34.384-49.5319.259-28.77822.6104.358⊤≠0.SinceL3DR≠0, condition (56) is satisfied. Hence, the residual r3(t) exists with a third order. The rest of the parameters of the residual are obtained, where(106)H3=-11.47851.82217.162-66.490-2.43214.090,G3=19.109-35.90534.661-39.74740.643-20.74025.508-0.046-8.764,F3=-1.194-1.482-2.059,T3=111.Figure5 indicates that a bank of three third-order residual generators can isolate the faults f1(t), f2(t), and f3(t) in the system. In the figure, when fault f2(t) occurs in the system, the residual r2(t) is insensitive to the fault; thus its output remains as zero. Meanwhile, the residual generators r1(t) and r3(t) trigger the fault. By that we can isolate fault f2(t) in the system. This example again further highlights the efficiency of our proposed FI scheme in this paper.Figure 5
Third-order observer-based residual bank isolates the faults in the system.
(a)
(b)
(c)


## 6. Conclusion

This work has presented novel FD and FI schemes using minimal-order functional observers to construct residual generators to timely detect and isolate actuator faults in dynamical systems. The proposed method is based on solving a generalized Sylvester matrix equation via a parametric approach. Existence conditions and systematic procedures for designing the proposed FD and FI schemes have been presented. The reduced order and the simplicity are the hallmark of the proposed novel FD and FI schemes. It is envisaged that these proposed schemes will have widespread applications in control systems to detect and isolate actuator and/or component faults.



---

*Source: 2740645-2016-05-05.xml*