Fault detection and diagnosis: computational issues and tools

TL;DR

This paper reviews computational challenges and tools for fault detection and diagnosis in linear systems, providing existence conditions and summarizing recent methods and software solutions.

Contribution

It formulates fault diagnosis problems, establishes solution existence conditions, and reviews recent computational methods and tools for fault detection filter synthesis.

Findings

Existence conditions for fault diagnosis solutions are provided.

Recent computational methods for fault detection filter synthesis are summarized.

Available software tools for fault diagnosis are described.

Abstract

A representative set of fault diagnosis problems is formulated for linear time-invariant systems with additive faults. For all formulated problems, general existence conditions of their solutions are given. An overview of recent developments of computational methods for the synthesis of fault detection filters is presented and available software tools are described.

Figures

Equations

$$\mathbf{y}(\lambda )=$$

$$G_f(\lambda )\mathbf{f}(\lambda )+G_w(\lambda )\mathbf{w}(\lambda ),$$

$${\begin{array}[]{rcl}E\lambda x(t)&=&Ax(t)+B_{u}u(t)+B_{d}d(t)+\\ &&\phantom{Ax(t)+\;}B_{f}f(t)+B_{w}w(t)\,,\\ y(t)&=&Cx(t)+D_{u}u(t)+D_{d}d(t)+\\ &&\phantom{Cx(t)+\;}D_{f}f(t)+D_{w}w(t)\,,\end{array}}$$

$$[\,G_{u}(\lambda)\;G_{d}(\lambda)\;G_{f}(\lambda)\;G_{w}(\lambda)\,]={\left[\begin{array}[]{c|cccc}A-\lambda E&B_{u}&B_{d}&B_{f}&B_{w}\\ \hline\cr C&D_{u}&D_{d}&D_{f}&D_{w}\end{array}\right]}.$$

$${\mathbf{r}}(\lambda)=Q(\lambda)\left[\begin{array}[]{c}{\mathbf{y}}(\lambda)\\ {\mathbf{u}}(\lambda)\end{array}\right],$$

$$\mathbf{r}(\lambda )=$$

$$R_f(\lambda )\mathbf{f}(\lambda )+R_w(\lambda )\mathbf{w}(\lambda ),$$

$$[R_u(\lambda )\mid R_d(\lambda )\mid R_f(\lambda )\mid R_w(\lambda )]:=$$

$$\displaystyle\;\;Q(\lambda)\left[\begin{array}[]{c|c|c|c}G_{u}(\lambda)&G_{d}(\lambda)&G_{f}(\lambda)&G_{w}(\lambda)\\ I_{m_{u}}&0&0&0\end{array}\right].$$

$$\begin{array}[]{ll}(i)&R_{u}(\lambda)=0,\\ (ii)&R_{d}(\lambda)=0.\end{array}$$

$$(iii)R_{f_j}(\lambda )\ne 0,j=1,\dots ,m_f\text{with}{R}_f(\lambda )\text{stable.}$$

$$\mathrm{rank}[G_d(\lambda )G_{f_j}(\lambda )]>\mathrm{rank}{G}_d(\lambda ),j=1,\dots ,m_f,$$

$${\begin{array}[]{ll}(iii)&R_{f_{j}}(\lambda)\not=0,j=1,\ldots,m_{f}\;\textrm{with}\;R_{f}(\lambda)\;\textrm{stable,}\\ (iv)&R_{w}(\lambda)\approx 0,\;\;\textrm{with}\;R_{w}(\lambda)\;\textrm{stable.}\end{array}}$$

$$\eta :=\frac{\underset{1\le j\le m_f}{\min }\Vert R_{f_j}(\lambda )\Vert }{\Vert R_w(\lambda )\Vert }$$

$${\mathbf{r}}^{(i)}(\lambda)=Q^{(i)}(\lambda)\left[\begin{array}[]{c}{\mathbf{y}}(\lambda)\\ {\mathbf{u}}(\lambda)\end{array}\right]\,,$$

$$r(t)=\left[\begin{array}[]{c}r^{(1)}(t)\\ \vdots\\ r^{(n_{b})}(t)\end{array}\right],\;Q(\lambda)=\left[\begin{array}[]{c}Q^{(1)}(\lambda)\\ \vdots\\ Q^{(n_{b})}(\lambda)\end{array}\right]\,.$$

$$R_{f}(\lambda)=\left[\begin{array}[]{ccc}R^{(1)}_{f_{1}}(\lambda)&\cdots&R^{(1)}_{f_{m_{f}}}(\lambda)\\ \vdots&\ddots&\vdots\\ R^{(n_{b})}_{f_{1}}(\lambda)&\cdots&R^{(n_{b})}_{f_{m_{f}}}(\lambda)\end{array}\right]\,,$$

$$R^{(i)}_{f_{j}}(\lambda):=Q^{(i)}(\lambda)\left[\begin{array}[]{c}G_{f_{j}}(\lambda)\\ 0\end{array}\right]$$

$${\begin{array}[]{llrll}S_{R_{f}}(i,j)&=&1&\text{ if }&R^{(i)}_{f_{j}}(\lambda)\not=0\;,\\ S_{R_{f}}(i,j)&=&0&\text{ if }&R^{(i)}_{f_{j}}(\lambda)=0\,.\end{array}}$$

$$(iii)S_{R_f}=S,\text{with}{R}_f(\lambda )\text{stable.}$$

$$\text{rank}[G_d(\lambda ){\hat{G}}_d^{(i)}(\lambda )G_{f_j}(\lambda )]>\text{rank}[G_d(\lambda ){\hat{G}}_d^{(i)}(\lambda )]$$

$$\mathrm{rank}[G_d(\lambda )G_f(\lambda )]=\mathrm{rank}{G}_d(\lambda )+m_f.$$

$${\tilde{R}}_{f_j}^{(i)}(\lambda ):=S_{ij}{R}_{f_j}^{(i)}(\lambda ),{\overline{R}}_{f_j}^{(i)}(\lambda ):=(1-S_{ij})R_{f_j}^{(i)}(\lambda ).$$

$${\begin{array}[]{ll}(iii)&S_{\widetilde{R}_{f}}=S,\;\overline{R}_{f}(\lambda)\approx 0,\;\text{with}\;R_{f}(\lambda)\;\text{stable,}\\ (iv)&R_{w}(\lambda)\approx 0,\;\text{with}\;R_{w}(\lambda)\;\text{stable.}\end{array}}$$

$${\begin{array}[]{ll}(iii)^{\prime}&S_{R_{f}}=S,\;\text{with}\;R_{f}(\lambda)\;\text{stable,}\\ (iv)^{\prime}&R_{w}(\lambda)\approx 0,\;\text{with}\;R_{w}(\lambda)\;\text{stable.}\end{array}}$$

$$\mathbf{r}(\lambda )=M_r(\lambda )\mathbf{f}(\lambda ).$$

$$(iii)R_f(\lambda )=M(\lambda )M_r(\lambda ).$$

$$Q(\lambda )G_e(\lambda )=[00M(\lambda )M_r(\lambda )],$$

$$G_{e}(\lambda):=\left[\begin{array}[]{ccc}G_{u}(\lambda)&G_{d}(\lambda)&G_{f}(\lambda)\\ I_{m_{u}}&0&0\end{array}\right].$$

$$\mathop{\mathrm{rank}}\,[\,G_{f}(\lambda)\;G_{d}(\lambda)\,]=\mathop{\mathrm{rank}}\,{\left[\begin{array}[]{cc}G_{f}(\lambda)&G_{d}(\lambda)\\ M_{r}(\lambda)&0\end{array}\right]}\,.\\$$

$${\begin{array}[]{ll}(iii)&R_{f}(\lambda)\approx M(\lambda)M_{r}(\lambda),\;\;\textrm{with}\;\;R_{f}(\lambda)\;\;\textrm{stable};\\ (iv)&R_{w}(\lambda)\approx 0,\;\;\textrm{with}\;\;R_{w}(\lambda)\;\;\textrm{stable.}\end{array}}$$

$$Q(\lambda )={\overline{Q}}_1(\lambda )Q_1(\lambda ),$$

Full text

Fault Detection and Diagnosis: Computational Issues and Tools

Andreas Varga

*Gilching, Germany *

varga.andreas@gmail.com

Abstract

A representative set of fault diagnosis problems is formulated for linear time-invariant systems with additive faults. For all formulated problems, general existence conditions of their solutions are given. An overview of recent developments of computational methods for the synthesis of fault detection filters is presented and available software tools are described.

Keywords

Fault detection and diagnosis; Fault detection and isolation; Model-matching synthesis; Numerical methods; Software tools

AMS subject classifications:

93-04, 93B40, 93B50, 93B55, 93C05, 93C15, 93C35, 93C55

1 Introduction

The theoretical developments of the model-based fault detection and diagnosis for linear time-invariant systems are essentially completed and widely documented in several monographs and textbooks [Gertler, 1998; Chen and Patton, 1999; Isermann, 2006; Ding, 2013; Blanke et al, 2016; Varga, 2017b]. Also the development of numerically reliable computational procedures for the synthesis of fault detection filters has been mostly finalized in the last decade. The author’s book [Varga, 2017b] is mainly dedicated to the presentation of the evolved new generation of computational synthesis procedures. These procedures are well suited as the basis of implementation of versatile software tools, which allow the solution of synthesis problems in the most general setting using the best available numerical methods.

This article presents an overview of the recent developments both in the computational synthesis procedures and associated software tools. We start by formulating a canonical set of exact and approximate synthesis problems of fault detection filters and give general solvability conditions, which guarantee the existence of the solutions in the most general setting, for both continuous- and discrete-time systems. For each of the formulated problems, general synthesis procedures have been developed in [Varga, 2017b], which guarantee the determination of a solution to a specific problem whenever a solution exists. The development of these procedures relies on several computational paradigms, which are discussed in details. They underly efficient and numerically reliable computational methods, which served for the implementation of software tools for the analysis of fault diagnosis problems and synthesis of fault detection filters.

2 Plant Models with Additive Faults

The underlying plant models to the discussed synthesis methods (also called synthesis models) are linear time-invariant (LTI) system models, where the faults are equated with special (unknown) disturbance inputs. An important class of models with additive faults arises when defining the fault signals for two main categories of faults, namely, actuator and sensor faults. Two basic forms of synthesis models are used.

The input-output plant model with additive faults has the form

[TABLE]

where ${\mathbf{y}}(\lambda)$, ${\mathbf{u}}(\lambda)$, ${\mathbf{d}}(\lambda)$, ${\mathbf{f}}(\lambda)$, and ${\mathbf{w}}(\lambda)$, with boldface notation, are the Laplace-transformed (in the continuous-time case) or Z-transformed (in the discrete-time case) $p$-dimensional system output vector $y(t)$, $m_{u}$-dimensional control input vector $u(t)$, $m_{d}$-dimensional disturbance vector $d(t)$, $m_{f}$-dimensional fault vector $f(t)$ and $m_{w}$-dimensional noise vector $w(t)$, respectively, and where $G_{u}(\lambda)$, $G_{d}(\lambda)$, $G_{f}(\lambda)$ and $G_{w}(\lambda)$ are the transfer-function matrices (TFMs) from the respective inputs to outputs. For simplicity, we will assume that all these TFMs are proper (i.e., finite for $\lambda=\infty$). Input-output models with additive faults of the form (2) are useful in formulating various fault diagnosis problems, in deriving general solvability conditions and in describing conceptual synthesis procedures. However, these models are generally not suited for numerical computations, due to the potentially high sensitivity of polynomial-based model representations.

For computational purposes, instead of the input-output model (2) with the compound TFM $[\,G_{u}(\lambda)\;G_{d}(\lambda)\;G_{f}(\lambda)\;G_{w}(\lambda)\,]$, an equivalent state-space model is used having the form

[TABLE]

with the $n$-dimensional state vector $x(t)$, where $\lambda x(t):=\dot{x}(t)$ or $\lambda x(t):=x(t+1)$ depending on the type of the system, continuous- or discrete-time, respectively. The matrix $E$ is generally invertible and is frequently taken as $E=I_{n}$. Plant models of the form (2) often arise from the linearization of nonlinear dynamic plant models in specific operation points and for fixed values of plant parameters. The noise inputs frequently account for the effects of uncertainties (e.g., inherent variabilities in operating points and parameters).

*Notation: *To indicate the input-output equivalence of the models in (2) and (2), we use the notation

[TABLE]

3 Residual Generation

A nonzero fault signal, $f\neq 0$, in (2) signifies a deviation from the normal behavior of the plant due to an unexpected event (e.g., physical component failure or supply breakdown). Generally, the occurrence of a fault must be detected as early as possible to prevent further degradation of the plant behavior. The fault diagnosis techniques are used to perform the detection of occurrence of faults (fault detection), the localization of detected faults (fault isolation), the reconstruction of the fault signal (fault estimation) and the classification of the detected faults and determination of their characteristics (fault identification). In a specific practical application, the term fault detection and diagnosis (FDD) may include, besides fault detection, also further aspects such as fault isolation, fault estimation, or fault identification (not discussed in this article).

A FDD system is a device (usually based on a collection of real-time processing algorithms) suitably set up to fulfill the above tasks. The minimal functionality of any FDD system is illustrated in Fig. 1.

The main component of any FDD system is the residual generator (or fault detection filter), which produces residual signals grouped in a $q$-dimensional vector $r$ by processing the available measurements $y$ and the known values of control inputs $u$. The role of the residual signals is to indicate the presence or absence of faults, and therefore the residual $r$ must be equal (or close) to zero in the absence of faults and significantly different from zero after a fault occurs. For decision-making, suitable measures of the residual magnitudes are generated in a scalar or vector $\theta$ (e.g., $\theta=\|r\|$) , which is then used to produce the corresponding decision variable or vector $\iota$ (e.g., $\iota=1$ if $\theta>\tau$ for a detected fault and $\iota=0$ if $\theta\leq\tau$ for the lack of faults, where $\tau$ is a given detection threshold). If $r(t)$ is a structured vector with, say $n_{b}$ components $r^{(i)}(t)$, $i=1,\ldots,n_{b}$, then $\theta$ and $\iota$ are $n_{b}$-dimensional vectors, with $\theta_{i}$ representing a measure of the magnitude of the $i$-th residual component (e.g., $\theta_{i}=\|r^{(i)}\|$) and the binary signature $\iota_{i}=1$ or $\iota_{i}=0$ corresponding to a fired (i.e, $\theta_{i}>\tau$) or not fired (i.e., $\theta_{i}\leq\tau$) component $r^{(i)}(t)$, respectively.

A linear residual generator employed in the FDD system in Fig. 1 has the input-output form

[TABLE]

where $Q(\lambda)$ is the TFM of the filter. For a physically realizable filter, $Q(\lambda)$ must be stable (i.e., proper and only with poles having negative real parts for a continuous-time system or magnitudes less than one for a discrete-time system). The (dynamic) order of $Q(\lambda)$ (also known as McMillan degree) is the dimension of the state vector of a minimal state-space realization of $Q(\lambda)$. The dimension $q$ of the residual vector $r(t)$ depends on the fault diagnosis problem to be solved. The form (3) of the fault detection filter is called the implementation form and is the basis of the real-time implementation of the fault detection filter.

The residual signal $r(t)$ in (3) generally depends via the system outputs $y(t)$ of all system inputs $u(t)$, $d(t)$, $f(t)$ and $w(t)$. The internal form of the filter is obtained by replacing in (3) ${\mathbf{y}}(\lambda)$ by its expression in (2), and is given by

[TABLE]

where

[TABLE]

For a successfully designed filter $Q(\lambda)$, all TFMs in the corresponding internal form (3) are stable, and additionally achieve specific fault detection requirements.

The basic functionality of a well-designed fault detection filter is to ensure the lack of false alarms, in the case when no faults occurred, and the lack of missed detection of faults, in the case of occurrence of a fault. The first requirement is fulfilled provided the residual signal $r(t)$ is zero, if there are no faults (i.e., $f(t)=0$) and no noise (i.e., $w(t)=0$), and in the presence of arbitrary control and disturbance inputs. If noise is present, then, in the case of absence of faults, the signal norm $\|r\|$ must be sufficiently small for all possible control, disturbance and noise inputs (i.e., $\theta\leq\tau_{a}$ for a sufficiently small alarm threshold $\tau_{a}$). The requirement on the lack of missed detections is fulfilled provided $\|r\|$ is sufficiently large for any fault of sufficiently large amplitude for all possible control, disturbance and noise inputs (i.e., $\theta>\tau_{d}$ for a certain detection threshold $\tau_{d}\geq\tau_{a}$).

The requirement on the lack of false alarms can be transcribed in concrete requirements on the TFMs in the internal form. It is always possible to completely decouple the control input $u(t)$ from the residual $r(t)$ (i.e., to achieve $R_{u}(\lambda)=0$), and we impose a similar condition on the disturbance input $d(t)$ by requiring $R_{d}(\lambda)=0$. To minimize the effect of the noise input $w(t)$ on the residual, we always aim to simultaneously minimize the norm of $R_{w}(\lambda)$. The distinction between the unknown inputs $d(t)$ and $w(t)$ lies solely in the way these signals are treated when solving the residual generator synthesis problem. For example, if the decoupling of all components of $d(t)$ is not possible, then some components of $d(t)$ can be redefined as additional noise inputs. The requirement on the lack of missed fault detection leads to additional requirements imposed on $R_{f}(\lambda)$ (see next section).

4 Fault Diagnosis Problems

In the literature dedicated to the solution of fault diagnosis problems we can observe a diversity of formulations of the basic fault diagnosis problems. The differences in problem formulations are partly due to the employed particular system theoretical frameworks and partly because of focusing on particular classes of solution methods. Therefore, it is important to formulate a (canonical) set of basic fault diagnosis problems which cover most practical applications. In this endeavour, (at least) two aspects have to be considered.

A first aspect is related to addressing the effects of uncertainties when solving fault diagnosis problems. In this context, two categories of problems may arise. The exact synthesis problems have as goal the determination of fault detection filters which fulfill strict (algebraic) existence conditions. In these problems the effects of the (ubiquitous) noise is fully neglected and the effects of (unknown) disturbances are exactly decoupled. The (more practice relevant) approximate synthesis problems solve essentially the same type of problems, with the additional goal of attenuating, as much as possible, the effects of the inherent noise. A meaningful requirement in formulating fault diagnosis problems is to ensure that the formulations of approximate problems include the formulations of exact problems if the effect of noise can be neglected. The expected consequence is that methods to solve approximate problems can be employed to solve exact problems too, while the solutions of exact problems can be also considered as candidate solutions of the approximate problems.

Another important aspect is to formulate the fault diagnosis problems independently of any particular solution method intended to be used to solve these problems. It is often the case that the applicability of a specific solution method involves additional (technical) conditions, which however are not necessary conditions for the solvability of the fault diagnosis problem. Therefore, to avoid such additional constraints, it is important to have problem formulations for which rigourous (ideally, necessary and sufficient) existence conditions of the solution exist, which guarantee solvability in the most general setting.

In all fault diagnosis problems formulated in what follows, we require that by a suitable choice of a stable fault detection filter $Q(\lambda)$, we achieve that the residual signal $r(t)$ is fully decoupled from the control input $u(t)$ and disturbance input $d(t)$. Thus, the following decoupling conditions must be generally fulfilled:

[TABLE]

For each fault diagnosis problem specific requirements have to be fulfilled, which are formulated as additional conditions in what follows. For the formulated problems we also give the existence conditions of the solutions of these problems in terms of some rank conditions.

Exact fault detection problem – EFDP

The basic additional requirement is simply to achieve by a suitable choice of a fault detection filter $Q(\lambda)$ that in the absence of noise input (i.e., $w(t)\equiv 0$), the residual $r(t)$ is influenced by all fault components $f_{j}(t)$, $j=1,\ldots,m_{f}$. Let $R_{f_{j}}(\lambda)$ denote the $j$-th column of $R_{f}(\lambda)$. This requirement can be expressed as the following detection condition to be fulfilled for all faults:

[TABLE]

The solvability conditions of the EFDP are simple rank conditions involving only the TFMs from the disturbances and faults:

Theorem 1**.**

For the system (2) with $w(t)\equiv 0$ the EFDP is solvable if and only if

[TABLE]

where $G_{f_{j}}(\lambda)$ denotes the $j$-th column of $G_{f}(\lambda)$.

Here, $\mathop{\mathrm{rank}}G(\lambda)$ denotes the normal rank of the rational TFM $G(\lambda)$, representing the maximal rank of the complex matrix $G(\lambda)$ over all values of $\lambda\in\mathds{C}$ such that $G(\lambda)$ has finite norm.

The conditions (10) define the complete fault detectability property of the system (2). These conditions are generically fulfilled if $p>m_{d}$, that is, when there are more measurements than disturbance inputs. The importance of solving EFDPs for fault diagnosis primarily lies in the fact that the solution of the (more involved) fault isolation problems can be addressed by successively solving several appropriately formulated EFDPs.

Approximate fault detection problem – AFDP

The effects of the noise input $w(t)$ can usually not be fully decoupled from the residual $r(t)$. In this case, the basic requirements for the choice of $Q(\lambda)$ can be expressed to achieve that the residual $r(t)$ is influenced by all fault components $f_{j}(t)$ and the influence of the noise signal $w(t)$ is negligible. Thus, the following two additional conditions have to be fulfilled:

[TABLE]

Here, $(iii)$ is the detection condition of all faults employed also in the EFDP, while $(iv)$ is the attenuation condition for the noise input. The condition $R_{w}(\lambda)\approx 0$ expresses the requirement that the transfer gain $\|R_{w}(\lambda)\|$ (measured by any suitable norm) can be made arbitrarily small.

The solvability conditions of the formulated AFDP are simply those of the EFDP:

Theorem 2**.**

For the system (2) the AFDP is solvable if and only if the EFDP is solvable.

On the basis of this result, any properly scaled solution of the EFDP can potentially serve as a solution of the AFDP as well. At signal level, a bounded noise input $w(t)$ such that $\|w\|\leq\delta_{w}$, can have a maximum contribution $\|R_{w}(\lambda)\|\delta_{w}$ in the residual $r(t)$, which automatically determines the minimum size $\delta_{f,min}$ of detectable faults. For example, $\delta_{f,min}$ can be computed as $\delta_{f,min}=\frac{\delta_{w}}{\eta}$, where

[TABLE]

is the fault-to-noise gap. The resulting value of $\delta_{f,min}$ can be used to assess the “practical” usefulness of any solution, and the maximization of the gap $\eta$ is always a meaningful goal for the synthesis of fault detection filters.

Exact fault detection and isolation problem – EFDIP

For the isolation of faults, we employ residual generator filters formed by stacking a bank of $n_{b}$ filters of the form

[TABLE]

where the $i$-th filter $Q^{(i)}(\lambda)$ generates the corresponding $i$-th residual component $r^{(i)}(t)$ (scalar or vector). This leads to the following structured residual vector $r(t)$ and block-structured filter $Q(\lambda)$

[TABLE]

The resulting $R_{f}(\lambda)$ is an $n_{b}\times m_{f}$ block-structured TFM of the form

[TABLE]

where the $(i,j)$-th block of $R_{f}(\lambda)$ is defined as

[TABLE]

and describes how the $j$-th fault $f_{j}$ influences the $i$-th residual component $r^{(i)}(t)$.

We associate to the block-structured $R_{f}(\lambda)$ in (15) the $n_{b}\times m_{f}$ binary structure matrix $S_{R_{f}}$, whose $(i,j)$-th element is defined as

[TABLE]

If $S_{R_{f}}(i,j)=1$ then we say that the residual component $r^{(i)}$ is sensitive to the $j$-th fault $f_{j}$, while if $S_{R_{f}}(i,j)=0$ then the $j$-th fault $f_{j}$ is decoupled from $r^{(i)}$. The $m_{f}$ columns of $S_{R_{f}}$ are called fault signatures. Since each nonzero column of $S_{R_{f}}$ is associated with the corresponding fault input, fault isolation can be performed by comparing the resulting binary decision vector $\iota$ in Fig. 1 (i.e., the signatures of fired or not fired residual components) with the fault signatures coded in the columns of $S_{R_{f}}$.

In the absence of noise input (i.e., $w(t)\equiv 0$) and for a given $n_{b}\times m_{f}$ structure matrix $S$, the EFDIP requires the determination of a stable filter $Q(\lambda)$ of the form (14) such that for the corresponding block-structured $R_{f}(\lambda)$ in (15), the following condition is additionally fulfilled:

[TABLE]

The solution of the EFDIP can be addressed by solving $n_{b}$ suitably formulated EFDPs. The $i$-th EFDP arises by reformulating the $i$-th EFDIP for determining the $i$-th filter $Q^{(i)}(\lambda)$ in (13) for a structure matrix which is the $i$-th row of $S$. This can be accomplished by redefining the fault components corresponding to zero entries in the $i$-th row of $S$ as additional disturbance inputs to be decoupled in the $i$-th residual component $r^{(i)}(t)$. Let $\widehat{G}_{d}^{(i)}(\lambda)$ be the TFM formed from the columns of $G_{f}(\lambda)$ for which $S_{ij}=0$. We have the following solvability conditions for the EFDIP, which simply express the solvability of the $n_{b}$ EFDPs formulated for the $n_{b}$ rows of of $S$:

Theorem 3**.**

For the system (2) with $w(t)\equiv 0$ and a given $n_{b}\times m_{f}$ structure matrix $S$, the EFDIP is solvable if and only if for $i=1,\ldots,n_{b}$

[TABLE]

for all $j$ such that $S_{ij}\not=0$.

The conditions (17) define the $S$ fault isolability property of the system (2). If $S$ has at most $k$ zero entries in each row, then these conditions are generically fulfilled if $p>m_{d}+k$, that is, when the number of measurements exceeds the number of disturbance inputs with at least $k$. An important case is when $S=I_{m_{f}}$ (i.e., diagonal), in which case $k=m_{f}-1$. If the conditions (17) are fulfilled, then the system (2) is called strongly isolable. For a strongly isolable system we have the following solvability conditions:

Theorem 4**.**

For the system (2) with $w\equiv 0$ and $S=I_{m_{f}}$, the EFDIP is solvable if and only if

[TABLE]

Generically, the condition (18) is fulfilled if $p\geq m_{f}+m_{d}$, which implies that the system must have at least as many measurements as the total number of disturbance and fault inputs. The importance of strong isolability is that it allows to isolate the occurrence of an arbitrary number (up to $m_{f}$) simultaneous faults.

Approximate fault detection and isolation problem – AFDIP

Let $S$ be a desired $n_{b}\times m_{f}$ structure matrix targeted to be achieved by using a structured fault detection filter $Q(\lambda)$ with $n_{b}$ row blocks as in (14). The $n_{b}\times m_{f}$ block-structured TFM $R_{f}(\lambda)$, corresponding to $Q(\lambda)$, is defined in (15). $R_{f}(\lambda)$ can be additively decomposed as $R_{f}(\lambda)=\widetilde{R}_{f}(\lambda)+\overline{R}_{f}(\lambda)$, where $\widetilde{R}_{f}(\lambda)$ and $\overline{R}_{f}(\lambda)$ have the same block structure as $R_{f}(\lambda)$ and have their $(i,j)$-th blocks defined as

[TABLE]

To address the approximate fault detection and isolation problem, we will target to enforce for the part $\widetilde{R}_{f}(\lambda)$ of $R_{f}(\lambda)$ the desired structure matrix $S$, while the part $\overline{R}_{f}(\lambda)$ must be (ideally) negligible. The soft approximate fault detection and isolation problem (soft AFDIP) can be formulated as follows. For a given $n_{b}\times m_{f}$ structure matrix $S$, determine a stable and proper filter $Q(\lambda)$ in the form (14) such that the following conditions are additionally fulfilled:

[TABLE]

The following (somewhat surprising) result states that the solvability condition of the AFDIP is precisely the solvability of the EFDP.

Theorem 5**.**

For the system (2) and a given structure matrix $S$ without zero columns, the soft AFDIP is solvable if and only if the EFDP is solvable.

The solvability of the EFDIP is clearly a sufficient condition for the solvability of the soft AFDIP, but is not, in general, also a necessary condition, unless we impose in the formulation of the AFDIP the stronger condition $\overline{R}_{f}(\lambda)=0$ (instead $\overline{R}_{f}(\lambda)\approx 0$). This is equivalent to require $S_{R_{f}}=S$. Therefore, we can alternatively formulate the strict AFDIP to fulfill the conditions:

[TABLE]

In this case we have the (expected) result:

Theorem 6**.**

For the system (2) and a given structure matrix $S$, the strict AFDIP is solvable with $S_{R_{f}}=S$ if and only if the EFDIP is solvable.

Exact model-matching problem – EMMP

Let $M_{r}(\lambda)$ be a given $q\times m_{f}$ TFM of a stable reference model specifying the desired input-output behavior from the faults to residuals as

[TABLE]

Thus, we want to achieve by a suitable choice of a stable $Q(\lambda)$ satisfying $(i)$ and $(ii)$ in (8), that we have additionally $R_{f}(\lambda)=M_{r}(\lambda)$. For example, a typical choice for $M_{r}(\lambda)$ is an $m_{f}\times m_{f}$ diagonal and invertible TFM, which ensures that each residual $r_{i}(t)$ is influenced only by the fault $f_{i}(t)$. This would allow the isolation of arbitrary combinations of up to $m_{f}$ simultaneous faults. The choice $M_{r}(\lambda)=I_{m_{f}}$ targets the solution of an exact fault estimation problem (EFEP).

To determine $Q(\lambda)$, we have to solve the linear rational equation (7), with the settings $R_{u}(\lambda)=0$, $R_{d}(\lambda)=0$, and $R_{f}(\lambda)=M_{r}(\lambda)$ ($R_{w}(\lambda)$ and $G_{w}(\lambda)$ are assumed empty matrices). The choice of $M_{r}(\lambda)$ may lead to a solution $Q(\lambda)$ which is not proper or is unstable or has both these undesirable properties. Therefore, besides determining $Q(\lambda)$, we also consider the determination of a suitable updating factor $M(\lambda)$ of $M_{r}(\lambda)$ to ensure the stability of the solution $Q(\lambda)$ for $R_{f}(\lambda)=M(\lambda)M_{r}(\lambda)$. Obviously, $M(\lambda)$ must be chosen a stable and invertible TFM. Additionally, by choosing $M(\lambda)$ diagonal, the zero and nonzero entries of $M_{r}(\lambda)$ can be also preserved in $R_{f}(\lambda)$ (i.e., to cope with the formulation of the EFDIP).

To address the above aspect, the EMMP can be formulated to also include the selection of a diagonal, stable and invertible TFM $M(\lambda)$ such that the following condition is additionally fulfilled:

[TABLE]

The conditions (8) and (21) represent a linear system of rational equations of the form

[TABLE]

where

[TABLE]

Therefore, the solvability condition of the EMMP follows from the standard solvability condition of systems of linear equations:

Theorem 7**.**

For the system (2) with $w\equiv 0$ and a given $M_{r}(\lambda)$, the EMMP is solvable if and only if the following condition is fulfilled

[TABLE]

When $M_{r}(\lambda)$ has full column rank $m_{f}$, the solvability condition (24) of the EMMP reduces to the strong isolability condition (18) of Theorem 4.

The solvability conditions become more involved if we strive for a stable solution $Q(\lambda)$ for a given reference model $M_{r}(\lambda)$ without allowing its updating. For example, this is the case when solving the EFEP for $M_{r}(\lambda)=I_{m_{f}}$, in which case, we have the following result.

Theorem 8**.**

For the system (2) with $w\equiv 0$, the EFEP is solvable if and only if the system is strongly fault isolable and $G_{f}(\lambda)$ is minimum phase.

Approximate model-matching problem – AMMP

Similarly to the formulation of the EMMP, we include the determination of an updating factor of the reference model in the formulation of the AMMP. Specifically, for a given stable TFM $M_{r}(\lambda)$, it is required to determine a stable filter $Q(\lambda)$ and a stable and invertible diagonal $M(\lambda)$ such that the following conditions are additionally fulfilled:

[TABLE]

Necessary and sufficient conditions for the solution of the AMMP are not known. However, a straightforward sufficient condition for the solvability of the AMMP is simply the solvability of the EMMP. Moreover, any solution of an exact problem (e.g., EFDP, EFDIP or EMMP) generates a meaningful reference model $M_{r}(\lambda):=R_{f}(\lambda)$, which can serve to improve the noise attenuation performance by solving an an appropriately formulated AMMP.

5 Synthesis of Fault Detection Filters

The recently developed computational procedures for the synthesis of fault detection filters [Varga, 2017b] share several computational paradigms, which are instrumental in developing generally applicable, numerically reliable and computationally efficient synthesis methods. In what follows we shortly review these paradigms and discuss their roles in the synthesis procedures.

Nullspace-based synthesis

An important synthesis paradigm is the use of the nullspace method as a first synthesis step to ensure the fulfillment of the decoupling conditions $R_{u}(\lambda)=0$ and $R_{d}(\lambda)=0$ in (8). This can be done by choosing $Q(\lambda)$ of the form

[TABLE]

where the factor $Q_{1}(\lambda)$ is a left annihilator of

[TABLE]

For any $Q(\lambda)$ of the form (26), we have

[TABLE]

Assume $r_{d}<p$ is the normal rank of $G_{d}(\lambda)$. Using standard linear algebra results, there exists a maximal full row rank left annihilator $N_{l}(\lambda)$ of size $(p-r_{d})\times(p+m_{u})$ such that $N_{l}(\lambda)G(\lambda)=0$. Any such an $N_{l}(\lambda)$ represents a basis of the left nullspace of the rational matrix $G(\lambda)$. With the choice $Q_{1}(\lambda)=N_{l}(\lambda)$, the expression (26) provides a parametrization of solutions of all fault diagnosis problems formulated in the previous section. For example, $N_{l}(\lambda)$ can be chosen in the product form

[TABLE]

where $N_{l,d}(\lambda)$ is a left nullspace basis of $G_{d}(\lambda)$ satisfying $N_{l,d}(\lambda)G_{d}(\lambda)=0$. For the synthesis of fault detection filters an important aspect is to use proper left nullspace bases of least dynamical orders. Such a basis $N_{l}(\lambda)$ has no finite or infinite zeros (i.e., $\mathop{\mathrm{rank}}N_{l}(\lambda)=p-r_{d}$ for all $\lambda\in\mathds{C}$) and can be chosen having arbitrary poles (e.g., stable).

The form (26) of the filter allows to reformulate all synthesis problems as simpler problems (without control and disturbance inputs), which allow to easily check the solvability conditions. With (26), the fault detection filter in (3) can be rewritten in the alternative form

[TABLE]

where

[TABLE]

with

[TABLE]

With this first preprocessing step, we reduced the original problems formulated for the system (2) to simpler ones, which can be formulated for the reduced system (31) (without control and disturbance inputs), for which we have to determine the TFM $\overline{Q}_{1}(\lambda)$ of the simpler fault detection filter (28).

At this stage we can assume that both $Q_{1}(\lambda)$ and the TFMs of the reduced system (31) are proper and even stable. This can be always achieved by replacing any basis $N_{l}(\lambda)$, with a stable basis $Q_{1}(\lambda)=M(\lambda)N_{l}(\lambda)$, where $M(\lambda)$ is an invertible, stable TFM (e.g., of least McMillan degree), such that $M(\lambda)[\,N_{l}(\lambda)\;\overline{G}_{f}(\lambda)\;\overline{G}_{w}(\lambda)\,]$ is stable. Such an $M(\lambda)$ can be determined as the (minimum-degree) denominator of a stable left coprime factorization of $[\,N_{l}(\lambda)\;\overline{G}_{f}(\lambda)\;\overline{G}_{w}(\lambda)\,]$.

All synthesis problems can be equivalently reformulated to determine a filter $\overline{Q}_{1}(\lambda)$ for the reduced system (31). As an example, we give the simpler conditions for the solvability of the EFDP (and also of the AFDP and soft AFDIP).

Corollary 1**.**

For the system (2) with $w\equiv 0$, let $Q_{1}(\lambda)$ be a rational basis of the left nullspace of $G(\lambda)$ in (27), and let (31) be the corresponding reduced system with $w\equiv 0$. Then, the EFDP is solvable if and only if

[TABLE]

Similar simpler conditions can be derived for the solvability of the EFDIP and strict AFDIP.

Particularly simple becomes the solvability condition of the EFDIP with strong isolability requirement (and also of the EMMP with invertible $M_{r}(\lambda)$) as the left invertibility of $\overline{G}_{f}(\lambda)$.

Corollary 2**.**

For the system (2) with $w\equiv 0$ and $S=I_{m_{f}}$, the EFDIP is solvable if and only if for the reduced system (31) with $w\equiv 0$ we have

[TABLE]

Filter updating techniques

In many synthesis procedures the TFM of the resulting filter $Q(\lambda)$ can be expressed in a factored form as

[TABLE]

where $Q_{1}(\lambda)$ is a left nullspace basis of $G(\lambda)$ in (27) satisfying $Q_{1}(\lambda)G(\lambda)=0$, and $Q_{1}(\lambda)$, $Q_{2}(\lambda)Q_{1}(\lambda)$, $\ldots$, can be interpreted as partial syntheses addressing specific requirements. Since each partial synthesis may represent a valid fault detection filter, this approach has a high flexibility in using or combining different synthesis techniques.

The determination of $Q(\lambda)$ in the factored form (35) can be formulated as a $K$-step synthesis procedure based on successive updating of an initial filter $Q=Q_{1}(\lambda)$ and the nonzero terms of its corresponding internal form

[TABLE]

as follows: for $k=2,\ldots,K$, do

Step $k$: Determine $Q_{k}(\lambda)$ using the current $Q(\lambda)$ and $R(\lambda)$ and then perform the updating as

[TABLE]

The updating operations are efficiently performed using state-space description based formulas. The state-space realizations of the TFMs $Q(\lambda)$ and $R(\lambda)$ in the implementation and internal forms can be jointly expressed in the generalized state-space (or descriptor system) representation

[TABLE]

The state-space realizations of $Q(\lambda)$ and $R(\lambda)$ share the matrices $A_{Q}$, $E_{Q}$ and $C_{Q}$. The preservation of these forms at each updating step is the basis of the filter updating based synthesis paradigm. To allow operations with non-proper TFMs (i.e., with singular $E_{Q}$), the use of the descriptor system representation is instrumental for developing numerically reliable computational algorithms.

The main benefit of using explicit state-space based updating formulas is the possibility to ensure at each step the cancellation of a maximum number of poles and zeros between the factors. This allows to keep the final order of the filter $Q(\lambda)$ as low as possible. In this way, the updating-based synthesis approach naturally leads to so-called integrated computational algorithms, with strongly coupled successive computational steps. Since the form of the realizations of $Q(\lambda)$ and $R(\lambda)$ in (36) are preserved, the stability is simultaneously achieved for both $Q(\lambda)$ and $R(\lambda)$ at the final synthesis step. At the last step, the standard state-space realization of $Q(\lambda)$ is usually recovered, to facilitate its real-time implementation.

Least order synthesis

The least order synthesis of FDI filters means to determine filters $Q(\lambda)$ with the least possible dynamical orders. This is a valuable synthesis goal which helps to reduce the computational burden related to the real-time implementation of the filters. The main tool to achieve least order synthesis is the solution of suitable minimal cover problems. If $X_{1}(\lambda)$ and $X_{2}(\lambda)$ are rational matrices of the same column dimension, then the left minimal cover problem is to find $X(\lambda)$ and $Y(\lambda)$ such that

[TABLE]

and the McMillan degree of $[\,X(\lambda)\;Y(\lambda)\,]$ is minimal. Two cases are relevant to solve synthesis problems of fault detection filters.

A typical second step in many synthesis procedures is to choose $Q_{2}(\lambda)$ such that the product $Q_{2}(\lambda)Q(\lambda)$ has least dynamical order and, simultaneously, a certain admissibility condition is fulfilled (usually involving the nonzero TFMs $R_{f}(\lambda)$ and $R_{w}(\lambda)$). Typically, after the first step, $Q(\lambda):=Q_{1}(\lambda)$, $R_{f}(\lambda):=\overline{G}_{f}(\lambda)$ and $R_{w}(\lambda):=\overline{G}_{w}(\lambda)$, and $Q_{1}(\lambda)$ is a left nullspace basis of $G(\lambda)$ in (27). The admissible choices of $Q_{2}(\lambda)$ depend on the subsequent steps of the employed particular synthesis procedure and express conditions related to fault detectability or some full rank conditions. For example, for the solution of the EFDP, the admissibility conditions are

[TABLE]

which guarantee the detectability of all fault components. For the solution of the AFDP, additionally to (38), the full row rank condition on $Q_{2}(\lambda)R_{w}(\lambda)$ has to be fulfilled as well. For the solution of the EMMP by using an inversion based approach, the admissibility condition is the invertibility of $Q_{2}(\lambda)R_{f}(\lambda)$, while for the solution of the AMMP the admissibility condition is the full row rank of $Q_{2}(\lambda)[\,R_{f}(\lambda)\;R_{w}(\lambda)\,]$. With the exception of (38), the admissibility conditions are not necessary, and are used only for convenience, to simplify the subsequent computational steps.

The determination of candidate solutions $Q_{2}(\lambda)$ such that $Q_{2}(\lambda)Q(\lambda)$ has least order can be done by solving left minimal cover problems of the form (37), where $X_{1}(\lambda)$ and $X_{2}(\lambda)$ represent disjoint subsets of basis vectors, such that: $Q(\lambda)=\left[\begin{smallmatrix}X_{1}(\lambda)\\ X_{2}(\lambda)\end{smallmatrix}\right]$, $Q_{2}(\lambda)=[\,I\;\;Y(\lambda)\,]$, and $X(\lambda)=Q_{2}(\lambda)Q(\lambda)$ and $Y(\lambda)$ represent the solution of the left cover problem. A systematic search over increasing orders of candidate solutions can be performed and the search stops when the admissibility conditions are fulfilled.

The cover technique also allows to determine least order solutions of the EMMP, where $Q(\lambda)$ satisfies the rational linear equation (22). The general solution of (22) can be expressed as

[TABLE]

where $X_{1}(\lambda)$ is a particular solution of (22) and $X_{2}(\lambda)$ is a left nullspace basis of $G_{e}(\lambda)$ in (23). Therefore, a least order solution $Q(\lambda)$ can be computed by solving a left cover problem.

State-space representation based computational methods for the solution of minimum dynamic cover problems are described in [Varga, 2017b, Sections 7.5 and 10.4], together with explicit updating formulas of the state-space realizations of $Q(\lambda)$ and $R(\lambda)$.

Coprime factorization techniques

A desired dynamics of the resulting final filters $Q(\lambda)$ and $R(\lambda)$ can be enforced by choosing a suitable invertible factor $M(\lambda)$, such that $M(\lambda)[\,Q(\lambda)\;R(\lambda)\,]$ has desired poles. This can be achieved by computing a left coprime factorization

[TABLE]

with $M(\lambda)$ and $[\,N_{Q}(\lambda)\;N_{R}(\lambda)\,]$ coprime and having arbitrary stable poles, and then performing the updating operation

[TABLE]

The stabilization via a left coprime factorization is usually performed as the last step of the synthesis procedures. If the preservation of the zero-nonzero pattern of $R_{f}(\lambda)$ is necessary (e.g., when solving fault isolation or model-matching problems), then $M(\lambda)$ can be chosen block diagonal.

To illustrate the updating technique, we consider a realization of the denominator factor $M(\lambda)$ of the form

[TABLE]

where $K$ (the so-called output injection gain matrix) is determined by eigenvalue assignment techniques to ensure stability (i.e., to assign the poles of $M(\lambda)$ to lie in a suitable stable region). Then, the numerator factors are obtained in forms compatible with $Q(\lambda)$ and $R(\lambda)$ in (36) as

[TABLE]

[TABLE]

Instead of using an explicitly computed output injection matrix $K$, it is possible to employ alternative coprime factorization methods, based on recursive pole dislocation techniques [Varga, 2017a], which produce directly the numerator factors $N_{Q}(\lambda)$ and $N_{R}(\lambda)$, and thus implicitly perform the updating operations as well.

Outer–co-inner factorization

For the solution of the approximate synthesis problems (i.e., AFDP, AFDIP or AMMP), the co-outer–co-inner factorization plays an important role. We only consider the particular case, of a stable and full row rank rational matrix $G(\lambda)$, without zeros on the boundary of the stability region, which can be factored as

[TABLE]

where $[\,G_{o}(\lambda)\;0\,]$ is the co-outer factor with $G_{o}(\lambda)$ invertible, stable and having only stable zeros (i.e, minimum-phase), and $G_{i}(\lambda)$ is inner (i.e., stable and $G_{i}(\lambda)G_{i}^{\sim}(\lambda)=I$; recall that $G_{i}^{\sim}(\lambda)$ is $G_{i}^{T}(-s)$ for a continuous-time system and $G_{i}^{T}(1/z)$ for a discrete-time system). If we partition $G_{i}(\lambda)$ compatibly with $[\,G_{o}(\lambda)\;0\,]$ as $G_{i}(\lambda)=\left[\begin{smallmatrix}G_{i,1}(\lambda)\\ G_{i,2}(\lambda)\end{smallmatrix}\right]$, then $G(\lambda)=G_{o}(\lambda)G_{i,1}(\lambda)$ is the outer–co-inner factorization of $G(\lambda)$ and (39) is the extended co-outer–inner factorization of $G(\lambda)$.

The role of this factorization is twofold. The post-multiplication of $G(\lambda)$ with $G_{i}^{\sim}(\lambda)$ achieves the column compression of $G(\lambda)$ to a full column rank matrix $G_{o}(\lambda)$, which is invertible (being also full row rank). Moreover, all resulting zeros of $G_{o}(\lambda)$ are stable, and therefore its inverse $G_{o}^{-1}(\lambda)$ is stable as well. In solving approximate synthesis problems, $G(\lambda)$ is either $R_{w}(\lambda)$ or $[\,R_{f}(\lambda)\;R_{w}(\lambda)\,]$ and the corresponding factor, say $Q_{4}(\lambda)$, is chosen $Q_{4}(\lambda)=G_{o}^{-1}(\lambda)$. If the factorizations algorithms proposed in [Oară and Varga, 2000] in the continuous-time case and in [Oară, 2005] for the discrete-time case, are employed, then the resulting outer factor has a realization of the form

[TABLE]

for certain $\widetilde{B}$ and $\widetilde{D}$ and explicit realizations of the updated filters $[\,Q(\lambda)\;R(\lambda)\,]\leftarrow G_{o}^{-1}(\lambda)[\,Q(\lambda)\;R(\lambda)\,]$ can be computed in the forms compatible with (36) as

[TABLE]

In the case when $G(\lambda)$ has zeros on the boundary of the stability domain, a factorization as in (39) can still be computed, with $G_{o}(\lambda)$ containing, besides the stable zeros, also all zeros on the boundary of the stability domain. In this case, the inverse $G_{o}^{-1}(\lambda)$ is unstable, or improper or both of them. Such a case is called non-standard and, when it is encountered, requires a special treatment. We should emphasize that non-standard cases occur only in conjunction with employing a particular solution method and are generally not related to the solvability of the fault diagnosis problems.

6 Synthesis Procedures

We present in this section three synthesis procedures of fault detection filters, to illustrate the application of the computational paradigms discussed in the previous section. A complete set of synthesis procedures for all formulated synthesis problems is presented in [Varga, 2017b].

As a first example, we give the complete synthesis procedure to solve the AFDP. This procedure can also be applied to solve the EFDP (if no noise inputs are present), and serves as a computational kernel for solving the AFDIP (and also of EFDIP) by computing repeatedly the solutions of appropriately formulated AFDPs.

**Procedure AFD

**

Inputs: $\{G_{u}(\lambda),G_{d}(\lambda),G_{f}(\lambda),G_{w}(\lambda)\}$

Outputs: $Q(\lambda)$, $R_{f}(\lambda)$, $R_{w}(\lambda)$, $\eta$

Compute a proper minimal left nullspace basis $Q_{1}(\lambda)$ of $G(\lambda)$ in (27); set $Q(\lambda)=Q_{1}(\lambda)$ and compute

[TABLE]

Exit if $\exists\,j$ such that $R_{f_{j}}(\lambda)=0$ (no solution). 2. 2.

Choose a proper $Q_{2}(\lambda)$ such that $Q_{2}(\lambda)Q(\lambda)$ has least order and satisfies $Q_{2}(\lambda)R_{f_{j}}(\lambda)\not=0$ $\forall\,j$ and $Q_{2}(\lambda)R_{w}(\lambda)$ has full row rank (admissibility);

update $[\,Q(\lambda)\;R(\lambda)\,]\leftarrow Q_{2}(\lambda)[\,Q(\lambda)\;R(\lambda)\,]$. 3. 3.

Compute the left coprime factorization

[TABLE]

such that $N_{Q}(\lambda)$ and $N_{R}(\lambda)$ have desired stable dynamics; update $[\,Q(\lambda)\;R(\lambda)\,]\leftarrow[\,N_{Q}(\lambda)\;N_{R}(\lambda)\,]$. 4. 4.

Compute the outer–co-inner factorization $R_{w}(\lambda)=R_{wo}(\lambda)R_{wi}(\lambda),$ where the outer factor $R_{wo}(\lambda)$ is invertible; with $Q_{4}(\lambda)=R_{wo}^{-1}(\lambda)$ update $[\,Q(\lambda)\;R(\lambda)\,]\leftarrow Q_{4}(\lambda)[\,Q(\lambda)\;R(\lambda)\,]$. 5. 5.

Evaluate the fault-to-noise gap $\eta$ in (12).

This procedure illustrates the discussed synthesis paradigms, as the nullspace-based reduction performed at Step 1, the least-order synthesis in conjunction with admissibility conditions at Step 2, allocation of filter dynamics via coprime factorization techniques at Step 3 and the use of outer–co-inner factorization at Step 4 (with an optimal choice of $Q_{4}(\lambda)$ to maximize the fault-to-noise gap). The flexibility of the factorization-based synthesis can be illustrated by skipping some of the synthesis steps. For example, if the least order synthesis is not of interest, then $Q_{2}(\lambda)=I$ at Step 2, and if additionally, the resulting $Q_{1}(\lambda)$ at Step 1 has an already satisfactory dynamics, then $Q_{3}(\lambda)=I$ at Step 3. Step 4 need not be performed if no noise inputs are present (i.e., the EFDP is solved), in which case the fault-to-noise gap is set to $\eta=\infty$ at Step 5. The occurrence of the non-standard case with $Q_{4}(\lambda)=R_{wo}^{-1}(\lambda)$ unstable at Step 4, can be simply handled, for example, by repeating the computations at Step 3 after performing Step 4.

The second example is the synthesis procedure to solve the strict AFDIP. A straightforward approach is to solve for each row of the given structure matrix $S$ an AFDP, for a synthesis model with redefined sets of disturbance and fault inputs. A potentially more efficient approach is to use first the nullspace-based paradigm to ensure the decoupling conditions $R_{u}(\lambda)=0$, $R_{d}(\lambda)=0$, and to obtain the reduced system (31), and then solve for each row of $S$ an AFDP for a reduced system with redefined sets of disturbance and fault inputs. This second approach is the basis of the following synthesis procedure.

**Procedure AFDI

**

Inputs: $\{G_{u}(\lambda),G_{d}(\lambda),G_{f}(\lambda),G_{w}(\lambda)\}$, $S\in\mathds{R}^{n_{b}\times m_{f}}$

Outputs: $Q^{(i)}(\lambda)$, $R_{f}^{(i)}(\lambda)$, $R_{w}^{(i)}(\lambda)$, $\eta_{i}$, $i=1,\ldots,n_{b}$.

Compute a minimal left nullspace basis $Q(\lambda)$ of $G(\lambda)$ in (27) and

[TABLE]

such that $Q(\lambda)$, $R_{f}(\lambda)$ and $R_{w}(\lambda)$ are stable. 2. 2.

For $\;i=1,...,n_{b}$

   

2.1)

Form $\overline{G}_{d}^{(i)}(\lambda)$ from the columns $R_{f_{j}}(\lambda)$ for which $S_{ij}=0$ and $\overline{G}_{f}^{(i)}(\lambda)$ from the columns $R_{f_{j}}(\lambda)$ for which $S_{ij}\not=0$.

2.2)

Apply Procedure AFD to the system described by \big{\{}0,\overline{G}_{d}^{(i)}(\lambda),\overline{G}_{f}^{(i)}(\lambda),R_{w}(\lambda)\big{\}} to obtain the stable filter $\overline{Q}^{(i)}(\lambda)$ and $\eta_{i}$.

Exit if no solution exists.

2.3)

Compute $Q^{(i)}(\lambda)=\overline{Q}^{(i)}(\lambda)Q(\lambda)$, $R_{f}^{(i)}(\lambda)=\overline{Q}^{(i)}(\lambda)R_{f}(\lambda)$ and $R_{w}^{(i)}(\lambda)=\overline{Q}^{(i)}(\lambda)R_{w}(\lambda)$.

This procedure can be easily adapted to solve a soft AFDIP, by applying at Step 2.2 the Procedure AFD to the quadruple \big{\{}0,0,\overline{G}_{f}^{(i)}(\lambda),\big{[}\,R_{w}(\lambda)\;\overline{G}_{d}^{(i)}(\lambda)\,\big{]}\big{\}}. Moreover, Procedure AFDI can be also employed to solve an EFDIP in the case when there are no noise inputs.

Finally, the third example is the synthesis procedure to solve the AMMP. The standard approach to address the solution of the AMMD is to determine a stable $Q(\lambda)$ which fulfills $R_{u}(\lambda)=0$ and $R_{d}(\lambda)=0$ and, simultaneously, minimizes the error norm $\|\mathcal{E}(\lambda)\|$, with

[TABLE]

This problem is solved by reducing it, using factorization techniques, to a least distance problem. Since the resulting optimal solution $Q(\lambda)$ may not result proper or stable, an updating factor $M(\lambda)$ can be used such that $M(\lambda)Q(\lambda)$ is stable. This updated filter can be interpreted as a suboptimal solution of a modified error norm minimization problem with $M_{r}(\lambda)$ replaced by $M(\lambda)M_{r}(\lambda)$.

The following synthesis procedure can be used to solve the AMMP for a strongly isolable system and an invertible and diagonal reference model $M_{r}(\lambda)$ using the error norm minimization approach sketched above.

**Procedure AMMS

**

Inputs: $\{G_{u}(\lambda),G_{d}(\lambda),G_{f}(\lambda),G_{w}(\lambda)\}$,

$M_{r}(\lambda)$ (invertible and diagonal)

Outputs: $Q(\lambda)$, $R_{f}(\lambda)$, $R_{w}(\lambda)$, $M(\lambda)$ (diagonal)

Compute a proper minimal left nullspace basis $Q_{1}(\lambda)$ of $G(\lambda)$ in (27); set $Q(\lambda)=Q_{1}(\lambda)$ and compute

[TABLE]

Exit if $\mathop{\mathrm{rank}}R_{f}(\lambda)<m_{f}$ (no solution). 2. 2.

Choose $Q_{2}(\lambda)$ such that $Q_{2}(\lambda)R(\lambda)$ has maximal full row rank and $Q_{2}(\lambda)Q(\lambda)$ has least McMillan degree; update $[Q(\lambda)\;R(\lambda)]\leftarrow Q_{2}(\lambda)[\,Q(\lambda)\;R(\lambda)\,]$. 3. 3.

Compute the extended co-outer–inner factorization

[TABLE]

With $Q_{3}(\lambda)=R_{o}^{-1}(\lambda)$, update $[Q(\lambda)\;R(\lambda)]\leftarrow Q_{3}(\lambda)[\,Q(\lambda)\;R(\lambda)\,]$ and compute

[TABLE] 4. 4.

Compute the stable solution $Q_{4}(\lambda)$ of the least-distance problem

[TABLE]

update $[\,Q(\lambda)\;R(\lambda)\,]\leftarrow Q_{4}(\lambda)[\,Q(\lambda)\;R(\lambda)\,]$. 5. 5.

Determine diagonal, invertible and stable $Q_{5}(\lambda):=M(\lambda)$ such that $M(\lambda)[\,Q(\lambda)\;R(\lambda)\,]$ is stable; update $[\,Q(\lambda)\;R(\lambda)\,]\leftarrow Q_{5}(\lambda)[\,Q(\lambda)\;R(\lambda)\,]$.

The solution of the least-distance problem at Step 4 depends on the employed norm (i.e., either the $\mathcal{H}_{2}$ norm or $\mathcal{H}_{\infty}$ norm) (see, for example, [Varga, 2017b] for suitable computational procedures).

The Procedure AMMS can be also employed to solve an EMMP for a strongly isolable system, with obvious simplifications (e.g., using $Q_{3}(\lambda)=R_{f}^{-1}(\lambda)$ at Step 3 and $Q_{4}(\lambda)=M_{r}(\lambda)$ at Step 4).

7 Software Tools

The development of dedicated software tools for the synthesis of fault detection filters must fulfill some general requirements for robust software implementation, but also some requirements specific to the field of fault detection. In what follows, we shortly discuss some of these requirements.

A basic requirement is the use of general, numerically reliable and computationally efficient numerical approaches as basis for the implementation of all computational functions, to guarantee the solvability of problems under the most general existence conditions of the solutions. Synthesis procedures suitable for robust software implementations are described in the book [Varga, 2017b].

For beginners, it is important to be able to easily obtain preliminary synthesis results. Therefore, for ease of use, simple and uniform user interfaces are desirable for all synthesis functions. This can be achieved by relying on meaningful default settings for all problem parameters and synthesis options. Also, the synthesis functions to solve approximate synthesis problems should be applicable to solve the exact synthesis problems as well. On the other side, the solution of an exact problem for a system with noise inputs, should provide a first approximation to the solution of the approximate synthesis problem.

For experienced users, an important requirement is to provide an exhaustive set of options to ensure the complete freedom in choosing problem-specific parameters and synthesis options. Among the frequently used synthesis options we mention: the number of residual signal outputs; stability degree for the poles of the resulting filters or the location of their poles; type of the employed nullspace basis (e.g., minimal proper, full-order observer based); performing least-order synthesis, etc.

The Fault Detection and Isolation Tools (FDITOOLS) is a publicly available collection of MATLAB m-files for the analysis and solution of fault diagnosis problems and has been implemented along the previously formulated requirements. FDITOOLS supports the basic synthesis approaches of linear residual generation filters for both continuous-time and discrete-time LTI systems. The underlying synthesis techniques rely on reliable numerical algorithms developed by the author and are described in the Chapters 5–7 of the book [Varga, 2017b]. The functions of the FDITOOLS collection rely on the Control System Toolbox [MathWorks, 2015, and later releases] and the Descriptor System Tools (DSTOOLS) [Varga, 2018a], which provides the basic tools for the manipulation of rational TFMs via their descriptor system representations. The version V1.0 of the FDITOOLS collection covers all synthesis procedures described in [Varga, 2017b] and, additionally, includes several useful analysis functions, as well as functions for an easy setup of synthesis models. A precursor of FDITOOLS was the Fault Detection Toolbox for MATLAB, a proprietary software of the German Aerospace Center (DLR), developed between 2004 and 2014 (for the status of this toolbox around 2006 see [Varga, 2006]).

A notable recent development is the free software package FaultDetectionTools111https://github.com/andreasvarga/FaultDetectionTools.jl, which implements the complete functionality of FDITOOLS in the Julia language. Julia is a powerful and flexible dynamic language, suitable for scientific and numerical computing, with performance comparable to traditional statically-typed languages such as Fortran or C. As a programming language, Julia features optional typing, multiple dispatch, and good performance, achieved using type inference and just-in-time compilation [Bezanson et al., 2017]. The underlying Julia packages DescriptorSystems222https://github.com/andreasvarga/DescriptorSystems.jl, for handling descriptor system representations, MatrixEquations333https://github.com/andreasvarga/MatrixEquations.jl, for solving various control related matrix equations (Lyapunov, Sylvester, Riccati), and MatrixPencils444https://github.com/andreasvarga/MatrixPencils.jl, for manipulation of matrix pencils, provide the required basic computational functionality for the implementation of FaultDetectionTools.

8 Recommended Reading

The book [Varga, 2017b] provides extensive information on the mathematical background of solving synthesis problems of fault detection filters, gives detailed descriptions of the underlying synthesis procedures and contains an extensive list of references to the relevant literature. The numerical aspects of the synthesis procedures are also amply described (a novelty in the fault detection related literature). Additionally, this book addresses the related model detection problematic, a multiple-model based approach to solve fault diagnosis problems (e.g., for parametric or multiplicative faults). For a concise presentation of the descriptor system techniques employed in the synthesis procedures, see the companion article [Varga, 2019a]. A shorter version of this article appeared in the Encyclopedia of Systems and Control [Varga, 2019b]. FDITOOLS is distributed as a free software via the Bitbucket repository https://bitbucket.org/DSVarga/fditools. A comprehensive documentation of version V1.0 is available in arXiv [Varga, 2018b].