From fdab16e56d1aef030dc911c7784adeefbbba09f7 Mon Sep 17 00:00:00 2001 From: "Documenter.jl" Date: Wed, 24 Jan 2024 14:12:07 +0000 Subject: [PATCH] build based on f4a0783 --- dev/FDDbasics.html | 2 +- dev/FDIObjects.html | 6 +++--- dev/FDIanalysis.html | 4 ++-- dev/FDIperformance.html | 8 ++++---- dev/FDIsynthesis.html | 20 ++++++++++---------- dev/FDIutils.html | 6 +++--- dev/MDObjects.html | 4 ++-- dev/MDanalysis.html | 6 +++--- dev/MDbasics.html | 2 +- dev/MDperformance.html | 10 +++++----- dev/MDsynthesis.html | 4 ++-- dev/SynthesisParadigms.html | 2 +- dev/index.html | 2 +- dev/makeindex.html | 2 +- dev/search.html | 2 +- 15 files changed, 40 insertions(+), 40 deletions(-) diff --git a/dev/FDDbasics.html b/dev/FDDbasics.html index 2bd202d..ffabb5a 100644 --- a/dev/FDDbasics.html +++ b/dev/FDDbasics.html @@ -61,4 +61,4 @@ \end{array}\]

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).

For the synthesis of fault detection and isolation filters which solve the EMMP the function emmsyn is available. This function can also address the solution of the EMMP with more general reference models (e.g., having components from the control inputs and/or disturbance inputs).

Approximate model-matching problem (AMMP}

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

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

AMMP: Determine a stable residual generator $Q(\lambda)$ and a stable, diagonal, and invertible $M(\lambda)$ such that

\[\begin{array}{rl} (i) & R_u(\lambda) = 0 \\ (ii) & R_d(\lambda) = 0 \\ (iii) & R_f(\lambda) \approx M(\lambda)M_r(\lambda) \\ (iv) & \|R_w(\lambda) \| \approx 0 \;\; \text{with} \;\; R_w(\lambda) \;\; {\color{magenta} \text{stable}} - \end{array}\]

A criterion suitable to characterize the solution of approximate model-matching based syntheses is the residual error norm

\[J_3 = \big\| R(\lambda)- M_r(\lambda)\big\|_{\infty/2}, \]

where $R(\lambda) = R_f(\lambda)$ and $M_r(\lambda)$ the reference model (possibly updated). For more generality, this criterion can be defined with $R(\lambda) = [\, R_u(\lambda)\; R_d(\lambda)\; R_f(\lambda)\; R_w(\lambda) \,\,]$, the resulting internal form, and $M_r(\lambda)$ the desired reference model $M_r(\lambda) = [\, M_{ru}(\lambda)\; M_{rd}(\lambda)\; M_{rf}(\lambda)\; M_{rw}(\lambda)\,]$. When applied to the results computed by other synthesis approaches (e.g., to solve the AFDP or AFDIP), this criterion can be formulated as

\[\widetilde J_3 = \big\| R_w(\lambda)\big\|_{\infty/2}, \]

which corresponds to assume that $M(\lambda) = I$ and $M_r(\lambda) = [\, R_u(\lambda)\; R_d(\lambda)\; R_f(\lambda)\; 0 \,]$ (i.e., a perfect matching of control, disturbance and fault channels is always achieved).

For the synthesis of fault detection and isolation filters which solve the AMMP the function ammsyn is available. This function can also address the solution of the AMMP with more general reference models (e.g., having components from the control inputs, disturbance inputs and noise inputs). For the evaluation of the model-matching performace the function fdimmperf is available.

References

[1] A. Varga, Solving Fault Diagnosis Problems – Linear Synthesis Techniques, Vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

+ \end{array}\]

A criterion suitable to characterize the solution of approximate model-matching based syntheses is the residual error norm

\[J_3 = \big\| R(\lambda)- M_r(\lambda)\big\|_{\infty/2}, \]

where $R(\lambda) = R_f(\lambda)$ and $M_r(\lambda)$ the reference model (possibly updated). For more generality, this criterion can be defined with $R(\lambda) = [\, R_u(\lambda)\; R_d(\lambda)\; R_f(\lambda)\; R_w(\lambda) \,\,]$, the resulting internal form, and $M_r(\lambda)$ the desired reference model $M_r(\lambda) = [\, M_{ru}(\lambda)\; M_{rd}(\lambda)\; M_{rf}(\lambda)\; M_{rw}(\lambda)\,]$. When applied to the results computed by other synthesis approaches (e.g., to solve the AFDP or AFDIP), this criterion can be formulated as

\[\widetilde J_3 = \big\| R_w(\lambda)\big\|_{\infty/2}, \]

which corresponds to assume that $M(\lambda) = I$ and $M_r(\lambda) = [\, R_u(\lambda)\; R_d(\lambda)\; R_f(\lambda)\; 0 \,]$ (i.e., a perfect matching of control, disturbance and fault channels is always achieved).

For the synthesis of fault detection and isolation filters which solve the AMMP the function ammsyn is available. This function can also address the solution of the AMMP with more general reference models (e.g., having components from the control inputs, disturbance inputs and noise inputs). For the evaluation of the model-matching performace the function fdimmperf is available.

References

[1] A. Varga, Solving Fault Diagnosis Problems – Linear Synthesis Techniques, Vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

diff --git a/dev/FDIObjects.html b/dev/FDIObjects.html index 68bea4d..86e004b 100644 --- a/dev/FDIObjects.html +++ b/dev/FDIObjects.html @@ -1,4 +1,4 @@ -Building fault detection and isolation related objects · FaultDetectionTools.jl
Edit on GitHub

Building fault detection and isolation related objects

  • FDIModel Fault detection and isolation synthesis model.
  • FDFilter Fault detection filter object.
  • FDIFilter Fault detection and isolation filter object.
  • FDFilterIF Fault detection filter internal form object.
  • FDIFilterIF Fault detection and isolation filter internal form object.
  • fdimodset Setup of synthesis models for solving fault detection and isolation problems.
  • fdIFeval Evaluation of the internal forms of fault detection and isolation filters.
FaultDetectionTools.FDIModel — Type
FDIModel <: AbstractFDDObject

Type for synthesis models employed to solve fault detection and isolation problems.

If sysf::FDIModel is the synthesis model object, the underlying descriptor system model can be obtained via sysf.sys and the dimensions of the control, disturbance, fault, noise and auxiliary vectors are contained in the integers sysf.mu, sysf.md, sysf.mf, sysf.mw and sysf.ma, respectively. The ranges of indices of control, disturbance, fault, noise and auxiliary inputs can be accessed as sysf.controls, sysf.disturbances, sysf.faults, sysf.noise and sysf.aux, respectively.

source
FaultDetectionTools.fdimodset — Function
fdimodset(sys; controls, c, disturbances, d, faults, f, fa, faults_sen, fs, noise, n, aux) -> sysf::FDIModel

Build for a given linear time-invariant system model sys = (A-λE,B,C,D), a synthesis model object sysf::FDIModel to be used in conjunction with the analysis and synthesis functions of FDI filters. If sys is a vector of system models, then sysf results as a vector of synthesis model objects.

The information on the partition of the input components in control, disturbance, fault, noise and auxiliary inputs can be specified using the following keyword arguments:

controls = inpu or c = inpu specifies the indices inpu of the control inputs (default: void)

disturbances = inpd or d = inpd specifies the indices inpd of the disturbance inputs (default: void)

faults = inpf or f = inpf specifies the indices inpf of the fault inputs (default: void)

fa = inpfa specifies the indices inpfa of control inputs subject to actuator fault (default: void)

faults_sen = inpfs or fs = inpfs specifies the indices inpfs of the system outputs subject to sensor fault inputs (default: void)

noise = inpn or noise = inpn specifies the indices inpn of the noise inputs (default: void)

aux = inpa specifies the indices inpa of the auxiliary inputs (default: void)

The indices of inputs or outputs can be specified as integer vectors, integer scalars or integer UnitRanges.

The resulting sysf contains the partitioned system sysf.sys = (A-λE,[Bu Bd Bf Bw Bv],C,[Du Dd Df Dw Dv]), where Bu, Bd, Bf, Bw and Bv are the input matrices from the control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs v, respectively, and Du, Dd, Df, Dw and Dv are the feedthrough matrices from those inputs. The dimensions of control, disturbance, fault, noise and auxiliary input vectors are contained in sysm.mu, sysm.md, sysm.mf, sysm.mw and sysm.ma, respectively.

Method: If G(λ) is the p x m transfer function matrix of sys, then the resulting system sysf has an equivalent input output form [Gu(λ) Gd(λ) Gf(λ) Gw(λ) Gv(λ)], where the following relations define the component matrices: Gu(λ) = G(λ)*Su, Gd(λ) = G(λ)*Sd, Gf(λ) = [G(λ)*Sf Ss], Gw(λ) = G(λ)*Sw, Gv(λ) = G(λ)*Sv, with the selection matrices Su, Sd, Sf, Sw and Sv formed from the columns of the m-th order identity matrix and Ss is formed from the columns of the p-th order identity matrix.

source
FaultDetectionTools.FDFilter — Type
FDFilter <: AbstractFDDObject

Type for fault detection filters resulted as solutions of fault detection problems.

If filter::FDFilter is the fault detection filter object, the underlying descriptor system model can be obtained via filter.sys and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in filter.ny and filter.mu, respectively. The ranges of the indices of output and control inputs can be accessed as filter.outputs and filter.controls, respectively.

source
FaultDetectionTools.FDFilter — Method
FDFilter(sys, ny, mu) -> Q::FDFilter

Build for a given linear time-invariant descriptor system model sys = (A-λE,B,C,D), a fault detection filter object Q, as determined with the synthesis functions of FDI filters. ny and mu are the number of measured outputs and the number of control inputs, respectively. It is assumed that B = [By Bu Bv] and D = [Dy Du Dv] are partitioned matrices such that By and Dy have ny columns, and Bu and Du have mu columns, where By and Bu are the input matrices from the measured outputs y and control inputs u, Dy and Du are the feedthrough matrices from the measured outputs y and control inputs u.

The resulting Q contains the partitioned system Q.sys = (A-λE,[By Bd],C,[Dy Du]) and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in Q.ny and Q.mu, respectively.

source
FaultDetectionTools.FDFilterIF — Type
FDFilterIF <: AbstractFDDObject

Type for the internal form of fault detection filters resulted as solutions of fault detection problems.

If filter::FDFilterIF is the fault detection filter internal form object, the underlying descriptor system model can be obtained via filter.sys and the dimensions of the control, disturbance, fault, noise and auxiliary vectors are contained in the integers filter.mu, filter.md, filter.mf, filter.mw and filter.ma, respectively. The ranges of indices of control, disturbance, fault, noise and auxiliary inputs can be accessed as filter.controls, filter.disturbances, filter.faults, filter.noise and filter.aux, respectively.

source
FaultDetectionTools.FDFilterIF — Method
FDFilterIF(sys; mu = 0, md = 0, mf = 0, mw = 0, ma = 0, moff = 0) -> R::FDFilterIF

Build for a given linear time-invariant descriptor system model sys = (A-λE,B,C,D), a fault detection filter internal form object R, as determined with the synthesis functions of FDI filters. mu, md, mf, mw and maux are the dimensions of control, disturbance, fault, noise and auxiliary input vectors, respectively. It is assumed that B = [Boff Bu Bd Bf Bw Bv] and D = [Doff Du Dd Df Dw Dv] are partitioned matrices such that Boff and Doff have moff columns, Bu and Du have mu columns, Bd and Dd have md columns, Bf and Df have mf columns, Bw and Dw have mw columns, and Bv and Dv have maux columns.

The resulting R contains the partitioned system R.sys = (A-λE,[Bu Bd Bf Bw Bv],C,[Du Dd Df Dw Dv]) and the dimensions of control, disturbance, fault, noise and auxiliary input vectors are contained in R.mu, R.md, R.mf, R.mw and R.ma, respectively.

source
FaultDetectionTools.FDIFilter — Type
FDIFilter <: AbstractFDDObject

Type for fault detection and isolation filters resulted as solutions of fault detection and isolation problems.

If filter::FDIFilter is the fault detection and isolation filter object, the underlying i-th descriptor system model can be obtained via filter.sys[i] and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in filter.ny and filter.mu, respectively. The ranges of the indices of output and control inputs can be accessed as filter.outputs and filter.controls, respectively.

source
FaultDetectionTools.FDIFilter — Method
FDIFilter(sys, ny, mu) -> Q::FDIFilter

Build for a vector of linear time-invariant descriptor system models sys[i] = (Ai-λEi,Bi,Ci,Di) with the same number of inputs, a fault detection and isolation filter object Q, as determined with the synthesis functions of FDI filters. ny and mu are the number of measured outputs and the number of control inputs, respectively. It is assumed that each Bi = [Byi Bui Bvi] and Di = [Dyi Dui Dvi] are partitioned matrices such that Byi and Dyi have ny columns, and Bui and Dui have mu columns, where Byi and Bui are the input matrices from the measured outputs y and control inputs u, Dyi and Dui are the feedthrough matrices from the measured outputs y and control inputs u.

The resulting Q contains the vector of partitioned systems Q.sys[i] = (Ai-λEi,[Byi Bdi],Ci,[Dyi Dui]) and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in Q.ny and Q.mu, respectively.

source
FaultDetectionTools.FDIFilterIF — Type
FDIFilterIF <: AbstractFDDObject

Type for the internal form of fault detection and isolation filters resulted as solutions of fault detection and isolation problems.

If filter::FDIFilterIF is the fault detection and isolation filter internal form object, the underlying i-th descriptor system model can be obtained via filter.sys[i] and the dimensions of the control, disturbance, fault, noise and auxiliary vectors are contained in the integers filter.mu, filter.md, filter.mf, filter.mw and filter.ma, respectively. The ranges of indices of control, disturbance, fault, noise and auxiliary inputs can be accessed as filter.controls, filter.disturbances, filter.faults, filter.noise and filter.aux, respectively. .

source
FaultDetectionTools.FDIFilterIF — Method
FDIFilterIF(sys; mu = 0, md = 0, mf = 0, mw = 0, ma = 0, moff = 0 ) -> R::FDIFilterIF

Build for a vector of linear time-invariant descriptor system models sys[i] = (Ai-λEi,Bi,Ci,Di), a fault detection and isolation filter internal form object R, as determined with the synthesis functions of FDI filters. mu, md, mf, mw and ma are the dimensions of control, disturbance, fault, noise and auxiliary input vectors, respectively. It is assumed that each Bi = [Boffi Bui Bdi Bfi Bwi Bvi] and Di = [Doffi Dui Ddi Dfi Dwi Dvi] are partitioned matrices such that Boffi and Doffi have moff columns, Bui and Dui have mu columns, Bdi and Ddi have md columns, Bfi and Dfi have mf columns, Bwi and Dwi have mw columns, and Bvi and Dvi have ma columns.

The resulting R contains the vector of partitioned systems R.sys[i] = (A-λE,[Bui Bdi Bfi Bwi Bvi],C,[Dui Ddi Dfi Dwi Dvi]) and the dimensions of control, disturbance, fault, noise and auxiliary input vectors are contained in R.mu, R.md, R.mf, R.mw and R.ma, respectively.

source
FaultDetectionTools.fdIFeval — Function
fdIFeval(sysQ::FDFilter, sysf::FDIModel; minimal = false, atol, atol1 = atol, atol2 = atol, rtol, fast = true) -> sysR::FDFilterIF

Compute the internal form sysR of the fault detection filter sysQ applied to the synthesis model sysf. If sysf has the partitioned transfer function matrix G(λ) = [ Gu(λ) Gd(λ) Gf(λ) Gw(λ) Gv(λ) ] in accordance with the partitioned system inputs as controls, disturbances, faults, noise and auxiliary inputs, respectively, and Q(λ) = [ Qy(λ) Qu(λ) ] is the partitioned transfer function matrix of the fault detection filter sysQ in accordance with the partitioned filter inputs as measurable outputs and control inputs, then the transfer function matrix R(λ) of the resulting internal form sysR is given by

 R(λ) = | Qy(λ)  Qu(λ) | * | Gu(λ)  Gd(λ) Gf(λ) Gw(λ) Gv(λ) |
-                           |  I       0     0     0     0   |

A minimal descriptor realization is computed if minimal = true and a possibly non-minimal realization is determined if minimal = false (default).

The minimal realization computation relies on pencil manipulation algorithms which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

If (Ar-λEr,Br,Cr,Dr) is the full order descriptor realization of sysR.sys, then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Ar, Br, Cr, Dr, the absolute tolerance for the nonzero elements of Er, and the relative tolerance for the nonzero elements of Ar, Br, Cr, Dr and Er. The default relative tolerance is nϵ, where ϵ is the working machine epsilon and n is the order of the system sysR. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
fdIFeval(sysQ::FDIFilter, sysf::FDIModel; minimal = false, atol, atol1 = atol, atol2 = atol, rtol, fast = true) -> sysR::FDIFilterIF

Compute the internal form sysR of the fault detection and isolation filter sysQ applied to the synthesis model sysf. If sysf has the partitioned transfer function matrix G(λ) = [ Gu(λ) Gd(λ) Gf(λ) Gw(λ) Gv(λ) ] in accordance with the partitioned system inputs as controls, disturbances, faults, noise and auxiliary inputs, respectively, and Qi(λ) = [ Qyi(λ) Qui(λ) ] is the partitioned transfer function matrix of the i-th filter sysQ.sys[i] in accordance with the partitioned filter inputs as measurable outputs and control inputs, then the transfer function matrix Ri(λ) of the i-th filter in the resulting internal form sysR.sys[i] is given by

 Ri(λ) = | Qyi(λ)  Qui(λ) | * | Gu(λ)  Gd(λ) Gf(λ) Gw(λ) Gv(λ) |
-                              |  I       0     0     0     0   |

Minimal descriptor realizations are computed if minimal = true and a possibly non-minimal realization is determined if minimal = false (default).

The minimal realization computation relies on pencil manipulation algorithms which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

If (Ari-λEri,Bri,Cri,Dri) is the full order descriptor realization of sysR.sys[i], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Ari, Bri, Cri, Dri, the absolute tolerance for the nonzero elements of Eri, and the relative tolerance for the nonzero elements of Ari, Bri, Cri, Dri and Eir. The default relative tolerance is ni*ϵ, where ϵ is the working machine epsilon and ni is the order of the system sysR.sys[i]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
+Building fault detection and isolation related objects · FaultDetectionTools.jl
Edit on GitHub

Building fault detection and isolation related objects

  • FDIModel Fault detection and isolation synthesis model.
  • FDFilter Fault detection filter object.
  • FDIFilter Fault detection and isolation filter object.
  • FDFilterIF Fault detection filter internal form object.
  • FDIFilterIF Fault detection and isolation filter internal form object.
  • fdimodset Setup of synthesis models for solving fault detection and isolation problems.
  • fdIFeval Evaluation of the internal forms of fault detection and isolation filters.
FaultDetectionTools.FDIModel — Type
FDIModel <: AbstractFDDObject

Type for synthesis models employed to solve fault detection and isolation problems.

If sysf::FDIModel is the synthesis model object, the underlying descriptor system model can be obtained via sysf.sys and the dimensions of the control, disturbance, fault, noise and auxiliary vectors are contained in the integers sysf.mu, sysf.md, sysf.mf, sysf.mw and sysf.ma, respectively. The ranges of indices of control, disturbance, fault, noise and auxiliary inputs can be accessed as sysf.controls, sysf.disturbances, sysf.faults, sysf.noise and sysf.aux, respectively.

source
FaultDetectionTools.fdimodset — Function
fdimodset(sys; controls, c, disturbances, d, faults, f, fa, faults_sen, fs, noise, n, aux) -> sysf::FDIModel

Build for a given linear time-invariant system model sys = (A-λE,B,C,D), a synthesis model object sysf::FDIModel to be used in conjunction with the analysis and synthesis functions of FDI filters. If sys is a vector of system models, then sysf results as a vector of synthesis model objects.

The information on the partition of the input components in control, disturbance, fault, noise and auxiliary inputs can be specified using the following keyword arguments:

controls = inpu or c = inpu specifies the indices inpu of the control inputs (default: void)

disturbances = inpd or d = inpd specifies the indices inpd of the disturbance inputs (default: void)

faults = inpf or f = inpf specifies the indices inpf of the fault inputs (default: void)

fa = inpfa specifies the indices inpfa of control inputs subject to actuator fault (default: void)

faults_sen = inpfs or fs = inpfs specifies the indices inpfs of the system outputs subject to sensor fault inputs (default: void)

noise = inpn or noise = inpn specifies the indices inpn of the noise inputs (default: void)

aux = inpa specifies the indices inpa of the auxiliary inputs (default: void)

The indices of inputs or outputs can be specified as integer vectors, integer scalars or integer UnitRanges.

The resulting sysf contains the partitioned system sysf.sys = (A-λE,[Bu Bd Bf Bw Bv],C,[Du Dd Df Dw Dv]), where Bu, Bd, Bf, Bw and Bv are the input matrices from the control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs v, respectively, and Du, Dd, Df, Dw and Dv are the feedthrough matrices from those inputs. The dimensions of control, disturbance, fault, noise and auxiliary input vectors are contained in sysm.mu, sysm.md, sysm.mf, sysm.mw and sysm.ma, respectively.

Method: If G(λ) is the p x m transfer function matrix of sys, then the resulting system sysf has an equivalent input output form [Gu(λ) Gd(λ) Gf(λ) Gw(λ) Gv(λ)], where the following relations define the component matrices: Gu(λ) = G(λ)*Su, Gd(λ) = G(λ)*Sd, Gf(λ) = [G(λ)*Sf Ss], Gw(λ) = G(λ)*Sw, Gv(λ) = G(λ)*Sv, with the selection matrices Su, Sd, Sf, Sw and Sv formed from the columns of the m-th order identity matrix and Ss is formed from the columns of the p-th order identity matrix.

source
FaultDetectionTools.FDFilter — Type
FDFilter <: AbstractFDDObject

Type for fault detection filters resulted as solutions of fault detection problems.

If filter::FDFilter is the fault detection filter object, the underlying descriptor system model can be obtained via filter.sys and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in filter.ny and filter.mu, respectively. The ranges of the indices of output and control inputs can be accessed as filter.outputs and filter.controls, respectively.

source
FaultDetectionTools.FDFilter — Method
FDFilter(sys, ny, mu) -> Q::FDFilter

Build for a given linear time-invariant descriptor system model sys = (A-λE,B,C,D), a fault detection filter object Q, as determined with the synthesis functions of FDI filters. ny and mu are the number of measured outputs and the number of control inputs, respectively. It is assumed that B = [By Bu Bv] and D = [Dy Du Dv] are partitioned matrices such that By and Dy have ny columns, and Bu and Du have mu columns, where By and Bu are the input matrices from the measured outputs y and control inputs u, Dy and Du are the feedthrough matrices from the measured outputs y and control inputs u.

The resulting Q contains the partitioned system Q.sys = (A-λE,[By Bd],C,[Dy Du]) and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in Q.ny and Q.mu, respectively.

source
FaultDetectionTools.FDFilterIF — Type
FDFilterIF <: AbstractFDDObject

Type for the internal form of fault detection filters resulted as solutions of fault detection problems.

If filter::FDFilterIF is the fault detection filter internal form object, the underlying descriptor system model can be obtained via filter.sys and the dimensions of the control, disturbance, fault, noise and auxiliary vectors are contained in the integers filter.mu, filter.md, filter.mf, filter.mw and filter.ma, respectively. The ranges of indices of control, disturbance, fault, noise and auxiliary inputs can be accessed as filter.controls, filter.disturbances, filter.faults, filter.noise and filter.aux, respectively.

source
FaultDetectionTools.FDFilterIF — Method
FDFilterIF(sys; mu = 0, md = 0, mf = 0, mw = 0, ma = 0, moff = 0) -> R::FDFilterIF

Build for a given linear time-invariant descriptor system model sys = (A-λE,B,C,D), a fault detection filter internal form object R, as determined with the synthesis functions of FDI filters. mu, md, mf, mw and maux are the dimensions of control, disturbance, fault, noise and auxiliary input vectors, respectively. It is assumed that B = [Boff Bu Bd Bf Bw Bv] and D = [Doff Du Dd Df Dw Dv] are partitioned matrices such that Boff and Doff have moff columns, Bu and Du have mu columns, Bd and Dd have md columns, Bf and Df have mf columns, Bw and Dw have mw columns, and Bv and Dv have maux columns.

The resulting R contains the partitioned system R.sys = (A-λE,[Bu Bd Bf Bw Bv],C,[Du Dd Df Dw Dv]) and the dimensions of control, disturbance, fault, noise and auxiliary input vectors are contained in R.mu, R.md, R.mf, R.mw and R.ma, respectively.

source
FaultDetectionTools.FDIFilter — Type
FDIFilter <: AbstractFDDObject

Type for fault detection and isolation filters resulted as solutions of fault detection and isolation problems.

If filter::FDIFilter is the fault detection and isolation filter object, the underlying i-th descriptor system model can be obtained via filter.sys[i] and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in filter.ny and filter.mu, respectively. The ranges of the indices of output and control inputs can be accessed as filter.outputs and filter.controls, respectively.

source
FaultDetectionTools.FDIFilter — Method
FDIFilter(sys, ny, mu) -> Q::FDIFilter

Build for a vector of linear time-invariant descriptor system models sys[i] = (Ai-λEi,Bi,Ci,Di) with the same number of inputs, a fault detection and isolation filter object Q, as determined with the synthesis functions of FDI filters. ny and mu are the number of measured outputs and the number of control inputs, respectively. It is assumed that each Bi = [Byi Bui Bvi] and Di = [Dyi Dui Dvi] are partitioned matrices such that Byi and Dyi have ny columns, and Bui and Dui have mu columns, where Byi and Bui are the input matrices from the measured outputs y and control inputs u, Dyi and Dui are the feedthrough matrices from the measured outputs y and control inputs u.

The resulting Q contains the vector of partitioned systems Q.sys[i] = (Ai-λEi,[Byi Bdi],Ci,[Dyi Dui]) and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in Q.ny and Q.mu, respectively.

source
FaultDetectionTools.FDIFilterIF — Type
FDIFilterIF <: AbstractFDDObject

Type for the internal form of fault detection and isolation filters resulted as solutions of fault detection and isolation problems.

If filter::FDIFilterIF is the fault detection and isolation filter internal form object, the underlying i-th descriptor system model can be obtained via filter.sys[i] and the dimensions of the control, disturbance, fault, noise and auxiliary vectors are contained in the integers filter.mu, filter.md, filter.mf, filter.mw and filter.ma, respectively. The ranges of indices of control, disturbance, fault, noise and auxiliary inputs can be accessed as filter.controls, filter.disturbances, filter.faults, filter.noise and filter.aux, respectively. .

source
FaultDetectionTools.FDIFilterIF — Method
FDIFilterIF(sys; mu = 0, md = 0, mf = 0, mw = 0, ma = 0, moff = 0 ) -> R::FDIFilterIF

Build for a vector of linear time-invariant descriptor system models sys[i] = (Ai-λEi,Bi,Ci,Di), a fault detection and isolation filter internal form object R, as determined with the synthesis functions of FDI filters. mu, md, mf, mw and ma are the dimensions of control, disturbance, fault, noise and auxiliary input vectors, respectively. It is assumed that each Bi = [Boffi Bui Bdi Bfi Bwi Bvi] and Di = [Doffi Dui Ddi Dfi Dwi Dvi] are partitioned matrices such that Boffi and Doffi have moff columns, Bui and Dui have mu columns, Bdi and Ddi have md columns, Bfi and Dfi have mf columns, Bwi and Dwi have mw columns, and Bvi and Dvi have ma columns.

The resulting R contains the vector of partitioned systems R.sys[i] = (A-λE,[Bui Bdi Bfi Bwi Bvi],C,[Dui Ddi Dfi Dwi Dvi]) and the dimensions of control, disturbance, fault, noise and auxiliary input vectors are contained in R.mu, R.md, R.mf, R.mw and R.ma, respectively.

source
FaultDetectionTools.fdIFeval — Function
fdIFeval(sysQ::FDFilter, sysf::FDIModel; minimal = false, atol, atol1 = atol, atol2 = atol, rtol, fast = true) -> sysR::FDFilterIF

Compute the internal form sysR of the fault detection filter sysQ applied to the synthesis model sysf. If sysf has the partitioned transfer function matrix G(λ) = [ Gu(λ) Gd(λ) Gf(λ) Gw(λ) Gv(λ) ] in accordance with the partitioned system inputs as controls, disturbances, faults, noise and auxiliary inputs, respectively, and Q(λ) = [ Qy(λ) Qu(λ) ] is the partitioned transfer function matrix of the fault detection filter sysQ in accordance with the partitioned filter inputs as measurable outputs and control inputs, then the transfer function matrix R(λ) of the resulting internal form sysR is given by

 R(λ) = | Qy(λ)  Qu(λ) | * | Gu(λ)  Gd(λ) Gf(λ) Gw(λ) Gv(λ) |
+                           |  I       0     0     0     0   |

A minimal descriptor realization is computed if minimal = true and a possibly non-minimal realization is determined if minimal = false (default).

The minimal realization computation relies on pencil manipulation algorithms which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

If (Ar-λEr,Br,Cr,Dr) is the full order descriptor realization of sysR.sys, then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Ar, Br, Cr, Dr, the absolute tolerance for the nonzero elements of Er, and the relative tolerance for the nonzero elements of Ar, Br, Cr, Dr and Er. The default relative tolerance is nϵ, where ϵ is the working machine epsilon and n is the order of the system sysR. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
fdIFeval(sysQ::FDIFilter, sysf::FDIModel; minimal = false, atol, atol1 = atol, atol2 = atol, rtol, fast = true) -> sysR::FDIFilterIF

Compute the internal form sysR of the fault detection and isolation filter sysQ applied to the synthesis model sysf. If sysf has the partitioned transfer function matrix G(λ) = [ Gu(λ) Gd(λ) Gf(λ) Gw(λ) Gv(λ) ] in accordance with the partitioned system inputs as controls, disturbances, faults, noise and auxiliary inputs, respectively, and Qi(λ) = [ Qyi(λ) Qui(λ) ] is the partitioned transfer function matrix of the i-th filter sysQ.sys[i] in accordance with the partitioned filter inputs as measurable outputs and control inputs, then the transfer function matrix Ri(λ) of the i-th filter in the resulting internal form sysR.sys[i] is given by

 Ri(λ) = | Qyi(λ)  Qui(λ) | * | Gu(λ)  Gd(λ) Gf(λ) Gw(λ) Gv(λ) |
+                              |  I       0     0     0     0   |

Minimal descriptor realizations are computed if minimal = true and a possibly non-minimal realization is determined if minimal = false (default).

The minimal realization computation relies on pencil manipulation algorithms which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

If (Ari-λEri,Bri,Cri,Dri) is the full order descriptor realization of sysR.sys[i], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Ari, Bri, Cri, Dri, the absolute tolerance for the nonzero elements of Eri, and the relative tolerance for the nonzero elements of Ari, Bri, Cri, Dri and Eir. The default relative tolerance is ni*ϵ, where ϵ is the working machine epsilon and ni is the order of the system sysR.sys[i]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
diff --git a/dev/FDIanalysis.html b/dev/FDIanalysis.html index 78b5745..5d88c99 100644 --- a/dev/FDIanalysis.html +++ b/dev/FDIanalysis.html @@ -1,3 +1,3 @@ -Analysis of FDI synthesis models · FaultDetectionTools.jl
Edit on GitHub

Analysis of FDI synthesis models

  • fdigenspec Generation of achievable FDI specifications.
  • fdichkspec Feasibility analysis of a set of FDI specifications.
FaultDetectionTools.fdigenspec — Function
S = fdigenspec(sysf::FDIModel; sdeg, FDtol, FDGainTol, FDfreq, atol, atol1, atol2, atol3, rtol, fast = true)

Generate all achievable specifications S for a given synthesis model sysf with additive faults. Each row of the resulting binary matrix S contains a nonzero specification (or fault signature) which can be achieved using a linear fault detection filter (e.g., as obtainable with the help of function efdisyn).

FDFreq = freq specifies a vector of real frequency values or a scalar real frquency value for strong detectability checks (default: FDFreq = missing).

FDtol = tol1 specifies the threshold tol1 for assessing weak specifications (see also function fditspec) (default: tol1 = 0.0001).

FDGainTol = tol2 specifies the threshold tol2 for assessing strong specifications, i.e., the threshold for nonzero frequency responce gains for all frequency values specified in freq (see also function fdisspec) (default: tol2 = 0.01).

The keyword argument sdeg = β specifies a prescribed stability degree β for the poles of the internally generated candidate filters, such that the real parts of filters poles must be less than or equal to β, in the continuous-time case, and the magnitudes of filter poles must be less than or equal to β, in the discrete-time case. If sdeg = missing then no stabilization is performed if FDFreq = missing. If sdeg = missing and FDFreq = freq, then the following default values are employed : β = -0.05, in continuous-time case, and β = 0.95, in discrete-time case.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

Method: The Procedure GENSPEC from [1] is implemented. The nullspace method [2] is recursively employed to generate candidate fault detection and isolation filters, whose internal forms provide the structure matrices corresponding to the achievable weak specifications, if freq = missing, or strong specifications for the frequencies conatined in freq. The generation method is also described in [3].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.4.

[2] A. Varga, On computing nullspace bases – a fault detection perspective. Proc. IFAC 2008 World Congress, Seoul, Korea, pages 6295–6300, 2008.

[3] A. Varga, On computing achievable fault signatures. Proc. SAFEPROCESS'2009, Barcelona, Spain.

source
FaultDetectionTools.fdichkspec — Function
fdichkspec(sysf::FDIModel, SFDI::BitMatrix; sdeg, FDtol, FDGainTol, FDfreq, 
-             atol, atol1, atol2, atol3, rtol, fast = true, minimal = false) -> (rdims, orders, leastorders)

Check for a given synthesis model sysf::FDIModel the feasibility of a set of fault detection and isolation specifications SFDI. If SFDI has N rows (i.e., contains N specifications), then the N-dimensional integer vectors rdims, orders, leastorders are returned and contain information related to the synthesis of FDI filters to achieve the feasible specifications. For the i-th specification contained in SFDI[i,:], rdims[i] contains the number of residual outputs of a minimal nullspace basis based FDI filter which can be used to achieve this specification. If rdims[i] = 0, then the i-th specification is not feasible. For a feasible i-th specification, orders[i] contains the order of the minimal nullspace basis based FDI filter which can be used to achieve this specification. If the i-th specification is not feasible, then orders[i] is set to -1. If minimal = true, leastorders[i] contains the least achievable order for a scalar output FDI filter which can be used to achieve the i-th specification. If minimal = false or if the i-th specification is not feasible, then leastorders[i] is set to -1.

FDFreq = freq specifies a vector of real frequency values or a scalar real frquency value for strong detectability checks (default: FDFreq = missing).

FDtol = tol1 specifies the threshold tol1 for assessing weak specifications (see also function fditspec) (default: tol1 = 0.0001).

FDGainTol = tol2 specifies the threshold tol2 for assessing strong specifications, i.e., the threshold for nonzero frequency responce gains for all frequency values specified in freq (see also function fdisspec) (default: tol2 = 0.01).

The keyword argument sdeg = β specifies a prescribed stability degree β for the poles of the internally generated candidate filters, such that the real parts of filters poles must be less than or equal to β, in the continuous-time case, and the magnitudes of filter poles must be less than or equal to β, in the discrete-time case. If sdeg = missing then no then no stabilization is performed if and FDFreq = missing. If sdeg = missing and FDFreq = freq, then the fllowing default values are employed : β = -0.05, in continuous-time case, and β = 0.95, in discrete-time case.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

Method: The nullspace method of [1] is successively employed to determine FDI filters as minimal left nullspace bases which solve suitably formulated fault detection problems.

References:

[1] A. Varga, On computing nullspace bases – a fault detection perspective. Proc. IFAC 2008 World Congress, Seoul, Korea, pages 6295–6300, 2008.

source
+Analysis of FDI synthesis models · FaultDetectionTools.jl
Edit on GitHub

Analysis of FDI synthesis models

  • fdigenspec Generation of achievable FDI specifications.
  • fdichkspec Feasibility analysis of a set of FDI specifications.
FaultDetectionTools.fdigenspec — Function
S = fdigenspec(sysf::FDIModel; sdeg, FDtol, FDGainTol, FDfreq, atol, atol1, atol2, atol3, rtol, fast = true)

Generate all achievable specifications S for a given synthesis model sysf with additive faults. Each row of the resulting binary matrix S contains a nonzero specification (or fault signature) which can be achieved using a linear fault detection filter (e.g., as obtainable with the help of function efdisyn).

FDFreq = freq specifies a vector of real frequency values or a scalar real frquency value for strong detectability checks (default: FDFreq = missing).

FDtol = tol1 specifies the threshold tol1 for assessing weak specifications (see also function fditspec) (default: tol1 = 0.0001).

FDGainTol = tol2 specifies the threshold tol2 for assessing strong specifications, i.e., the threshold for nonzero frequency responce gains for all frequency values specified in freq (see also function fdisspec) (default: tol2 = 0.01).

The keyword argument sdeg = β specifies a prescribed stability degree β for the poles of the internally generated candidate filters, such that the real parts of filters poles must be less than or equal to β, in the continuous-time case, and the magnitudes of filter poles must be less than or equal to β, in the discrete-time case. If sdeg = missing then no stabilization is performed if FDFreq = missing. If sdeg = missing and FDFreq = freq, then the following default values are employed : β = -0.05, in continuous-time case, and β = 0.95, in discrete-time case.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

Method: The Procedure GENSPEC from [1] is implemented. The nullspace method [2] is recursively employed to generate candidate fault detection and isolation filters, whose internal forms provide the structure matrices corresponding to the achievable weak specifications, if freq = missing, or strong specifications for the frequencies conatined in freq. The generation method is also described in [3].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.4.

[2] A. Varga, On computing nullspace bases – a fault detection perspective. Proc. IFAC 2008 World Congress, Seoul, Korea, pages 6295–6300, 2008.

[3] A. Varga, On computing achievable fault signatures. Proc. SAFEPROCESS'2009, Barcelona, Spain.

source
FaultDetectionTools.fdichkspec — Function
fdichkspec(sysf::FDIModel, SFDI::BitMatrix; sdeg, FDtol, FDGainTol, FDfreq, 
+             atol, atol1, atol2, atol3, rtol, fast = true, minimal = false) -> (rdims, orders, leastorders)

Check for a given synthesis model sysf::FDIModel the feasibility of a set of fault detection and isolation specifications SFDI. If SFDI has N rows (i.e., contains N specifications), then the N-dimensional integer vectors rdims, orders, leastorders are returned and contain information related to the synthesis of FDI filters to achieve the feasible specifications. For the i-th specification contained in SFDI[i,:], rdims[i] contains the number of residual outputs of a minimal nullspace basis based FDI filter which can be used to achieve this specification. If rdims[i] = 0, then the i-th specification is not feasible. For a feasible i-th specification, orders[i] contains the order of the minimal nullspace basis based FDI filter which can be used to achieve this specification. If the i-th specification is not feasible, then orders[i] is set to -1. If minimal = true, leastorders[i] contains the least achievable order for a scalar output FDI filter which can be used to achieve the i-th specification. If minimal = false or if the i-th specification is not feasible, then leastorders[i] is set to -1.

FDFreq = freq specifies a vector of real frequency values or a scalar real frquency value for strong detectability checks (default: FDFreq = missing).

FDtol = tol1 specifies the threshold tol1 for assessing weak specifications (see also function fditspec) (default: tol1 = 0.0001).

FDGainTol = tol2 specifies the threshold tol2 for assessing strong specifications, i.e., the threshold for nonzero frequency responce gains for all frequency values specified in freq (see also function fdisspec) (default: tol2 = 0.01).

The keyword argument sdeg = β specifies a prescribed stability degree β for the poles of the internally generated candidate filters, such that the real parts of filters poles must be less than or equal to β, in the continuous-time case, and the magnitudes of filter poles must be less than or equal to β, in the discrete-time case. If sdeg = missing then no then no stabilization is performed if and FDFreq = missing. If sdeg = missing and FDFreq = freq, then the fllowing default values are employed : β = -0.05, in continuous-time case, and β = 0.95, in discrete-time case.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

Method: The nullspace method of [1] is successively employed to determine FDI filters as minimal left nullspace bases which solve suitably formulated fault detection problems.

References:

[1] A. Varga, On computing nullspace bases – a fault detection perspective. Proc. IFAC 2008 World Congress, Seoul, Korea, pages 6295–6300, 2008.

source
diff --git a/dev/FDIperformance.html b/dev/FDIperformance.html index d8aef1b..4f16c75 100644 --- a/dev/FDIperformance.html +++ b/dev/FDIperformance.html @@ -1,6 +1,6 @@ Performance evaluation of FDI filters · FaultDetectionTools.jl
Edit on GitHub

Performance evaluation of FDI filters

  • fditspec Computation of the weak or strong structure matrix.
  • fdisspec Computation of the strong structure matrix.
  • fdiscond Computation of the fault detection sensitivity condition.
  • fdif2ngap Computation of the fault-to-noise gap.
  • fdimmperf Computation of the model-matching performace.
FaultDetectionTools.fditspec — Function
S = fditspec(sysr::FDFilterIF; FDfreq = missing, block = false, poleshift = false, 
-             FDtol, FDStol, atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute the weak or strong binary structure matrix S of the transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of a fault detection filter internal form object sysr::FDFilterIF. For a filter sysr with q residual outputs and mf fault inputs, Rf(λ) is the q x mf transfer function matrix of the fault inputs channel with the descriptor system representation sysr.sys[:,sysr.faults] := (Af-lambda*Ef,Bf,Cf,Df).

If FDfreq = missing (default), then S contains the weak structure matrix of Rf(λ). For block = false, S is determined as a q x mf binary matrix (BitMatrix), whose (i,j)-th element is S[i,j] = 1, if the (i,j)-th element of Rf(λ) is nonzero, and otherwise, S[i,j] = 0. For block = true, S is determined as a 1 x mf binary matrix, whose (1,j)-th element is S[1,j] = 1, if the j-th column of Rf(λ) is nonzero, and otherwise, S[1,j] = 0.

If FDfreq = freq specifies a vector freq of nf real frequencies which characterize the classes of persistent fault signals, then for a suitable proper and invertible M(λ) (see below), S contains the strong structure matrix of M(λ)*Rf(λ) with respect to a set of nf complex frequencies Ω, defined as follows: if f is a real frequency in freq, then the corresponding complex frequency in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

FDtol = tol1 specifies an absolute threshold tol1 for the magnitudes of nonzero elements in the system matrices Bf and Df and is used to determine the weak structure matrix. Its default value is tol1 = 0.0001*max(1, norm(Bf,1), norm(Df,1)).

FDStol = tol2 specifies an absolute threshold tol2 for the magnitudes of nonzero elements in the system matrices Af, Ef, Bf, Cf and Df and is used to determine the strong structure matrix. Its default value is tol2 = epsm*max(1, norm(Ef,1), norm(Af,1), norm(Bf,1), norm(Cf,Inf), norm(Df,1))), where epsm is the working machine precision.

For block = false, then, if poleshift = true, M(λ) is chosen diagonal such that M(λ)*Rf(λ) has no poles in Ω and if poleshift = false (default), M(λ) = I is used and an error is issued if Rf(λ) has poles in Ω. S is determined as a q x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the (i,j)-th element of M(λ)*Rf(λ) evaluated for all frequencies in Ω is nonzero, and otherwise, S[i,j] = 0.

For block = true, then, if poleshift = true, M(λ) is chosen such that M(λ)*Rf(λ) as no poles in Ω and if poleshift = false (default), M(λ) = I is used and an error is issued if Rf(λ) has poles in Ω. S is determined as an 1 x mf binary matrix, whose (1,j)-th element is S[1,j] = 1, if the j-th column of M(λ)*Rf(λ) evaluated for all frequencies in Ω is nonzero and otherwise S[1,j] = 0.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Af, Bf, Cf, Df, the absolute tolerance for the nonzero elements of Ef, and the relative tolerance for the nonzero elements of Af, Bf, Cf, Df and Ef. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

Method: For the definition of the structure matrix, see [1]. For the determination of the weak structure matrix, minimal realizations are determined for each column of Rf(λ) if block = true or for each element of Rf(λ) if block = false and the nonzero columns or elements in each column are identified (see Corollary 7.1 of [1]). For the determination of the strong structure matrix, minimal realizations are determined for each column of M(λ)*Rf(λ) if block = true or for each element of M(λ)*Rf(λ) if block = false and the full rank of the corresponding system matrix is checked for all frequencies in FDfreq (see Corollary 7.2 in [1]) (i.e., the lack of zeros in all frequencies).

References:

[1] Varga A. Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec.3.4.

source
S = fditspec(sysr::FDIFilterIF; FDfreq = missing, poleshift = false, 
-             FDtol, FDStol, atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute the weak or strong binary structure matrix S of the global transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of a fault detection and isolation filter internal form object sysr::FDIFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where the fault to residual channel of the i-th filter sysr.sys[i][:,sysr.faults] has qi residual outputs and mf fault inputs, has the descriptor system representation sysr.sys[i][:,sysr.faults] := (Afi-lambda*Efi,Bfi,Cfi,Dfi) and Rfi(λ) is the corresponding qi x mf transfer function matrix. The global transfer function matrix Rf(λ) is formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)]. For the evaluation of the strong structure matrix, the structure matrix of the stable transfer function matrix M(λ)*Rf(λ) is determined, with a M(λ) block-diagonal M(λ) = block-diag(M1(λ), M2(λ), ..., MN(λ)), where Mi(λ) is a suitable square and invertible transfer function matrix (see below).

FDtol = tol1 specifies an absolute threshold tol1 for the magnitudes of nonzero elements in the system matrices Bf and Df and is used to determine the weak structure matrix. Its default value is tol1 = 0.0001*max(1, norm(Bf,1), norm(Df,1)).

FDStol = tol2 specifies an absolute threshold tol2 for the magnitudes of nonzero elements in the system matrices Af, Ef, Bf, Cf and Df and is used to determine the strong structure matrix. Its default value is tol2 = epsm*max(1, norm(Ef,1), norm(Af,1), norm(Bf,1), norm(Cf,Inf), norm(Df,1))), where epsm is the working machine precision.

If FDfreq = missing (default), then S contains the weak structure matrix of Rf(λ). S is determined as a N x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the j-th column of Rfi(λ) is nonzero, and otherwise, S[i,j] = 0.

If FDfreq = freq specifies a vector freq of nf real frequencies which characterize the classes of persistent fault signals, then for a suitable proper and invertible M(λ) (see below), S contains the strong structure matrix of M(λ)*Rf(λ) with respect to a set of nf complex frequencies Ω, defined as follows: if f is a real frequency in freq, then the corresponding complex frequency in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

S is determined as a N x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the j-th column of Mi(λ)*Rfi(λ) is nonzero for all frequencies in Ω, and otherwise, S[i,j] = 0. If poleshift = true, Mi(λ) is chosen such that Mi(λ)*Rfi(λ) has no poles in Ω and if poleshift = false (default), Mi(λ) = I is used and an error is issued if any Rfi(λ) has poles in Ω.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Af, Bf, Cf, Df, the absolute tolerance for the nonzero elements of Ef, and the relative tolerance for the nonzero elements of Af, Bf, Cf, Df and Ef. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

Method: For the definition of the structure matrix, see [1]. For the determination of the weak structure matrix, minimal realizations are determined for each column of Rfi(λ) and the nonzero columns are identified (see Corollary 7.1 of [1]). For the determination of the strong structure matrix, minimal realizations are determined for each column of Mi(λ)*Rfi(λ) and the full rank of the corresponding system matrix is checked for all frequencies in Ω (see Corollary 7.2 in [1]) (i.e., the lack of zeros in all frequencies in Ω).

References:

[1] Varga A. Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec.3.4.

source
FaultDetectionTools.fdisspec — Function
 S = fdisspec(sysr::FDFilterIF, freq; block = false, stabilize = false, FDGainTol = 0.01, 
-                 atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute, for a given set of real frequencies freq, the strong binary structure matrix S of the stable transfer function matrix M(λ)*Rf(λ), where Rf(λ) is the transfer function matrix of the transfer channel from the fault inputs to residuals of the fault detection filter internal form object sysr::FDFilterIF and M(λ) is a suitable proper and invertible stabilizing transfer function matrix (see below). For a filter sysr with q residual outputs and mf fault inputs, Rf(λ) is the q x mf transfer function matrix of the fault inputs channel with the descriptor system representation sysr.sys[:,sysr.faults] := (Af-lambda*Ef,Bf,Cf,Df).

freq must contain a real frequency value or a vector of nf real frequencies which characterize the classes of persistent fault signals (default: freq = 0, i.e., characterizing constant faults). S contains the strong structure matrix of M(λ)*Rf(λ) with respect to a set of nf complex frequencies Ω, defined as follows: if f is a real frequency in freq, then the corresponding complex frequency in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

FDGainTol = tol specifies an absolute threshold tol for the nonzero magnitudes of the frequency response gains (default: tol = 0.01).

For block = false, then, if stabilize = true, M(λ) is chosen diagonal such that M(λ)*Rf(λ) has only stable poles and if stabilize = false (default), M(λ) = I is used and an error is issued if Rf(λ) has poles in Ω. S is determined as a q x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the (i,j)-th element of M(λ)*Rf(λ) evaluated for all frequencies in freq is larger than or equal to tol, and otherwise, S[i,j] = 0.

For block = true, then, if stabilize = true, M(λ) is chosen such that M(λ)*Rf(λ) has only stable poles and if stabilize = false (default), M(λ) = I is used and an error is issued if Rf(λ) has poles in Ω. S is determined as an 1 x mf binary matrix, whose (1,j)-th element is S[1,j] = 1, if the j-th column of M(λ)*Rf(λ) evaluated for all frequencies in Ω is larger than or equal to tol and otherwise, S[1,j] = 0.

The keyword arguments atol1, atol2, atol3, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Af, Bf, Cf, Df, the absolute tolerance for the nonzero elements of Ef, the absolute tolerance for the nonzero elements of Cf, and the relative tolerance for the nonzero elements of Af, Bf, Cf, Df and Ef. The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The computation of minimal realizations of individual input-output channels relies on pencil manipulation algorithms, which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

Method: S is evaluated using the definition of the strong structure matrix in [1].

References:

[1] Varga A. Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 3.4.

source
 S = fdisspec(sysr::FDIFilterIF, freq; stabilize = false, FDGainTol = 0.01, 
-                 atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute, for a given set of real frequencies freq, the strong binary structure matrix S of the stable transfer function matrix M(λ)*Rf(λ), where Rf(λ) is the global transfer function matrix of the transfer channel from the fault inputs to residuals of the fault detection and isolation filter internal form object sysr::FDIFilterIF and M(λ) is a suitable block-diagonal proper and invertible stabilizing transfer function matrix (see below). The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where the fault to residual channel of the i-th filter sysr.sys[i][:,sysr.faults] has qi residual outputs and mf fault inputs, has the descriptor system representation sysr.sys[i][:,sysr.faults] := (Afi-lambda*Efi,Bfi,Cfi,Dfi) and Rfi(λ) is the corresponding qi x mf transfer function matrix. The global transfer function matrix Rf(λ) is formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)]. M(λ) = block-diag(M1(λ), M2(λ), ..., MN(λ)), where Mi(λ) is square and invertible and chosen such that Mi(λ)Rfi(λ) is stable (see below).

freq must contain a real frequency value or a vector of nf real frequencies which characterize the classes of persistent fault signals (default: freq = 0, i.e., characterizing constant faults). S contains the strong structure matrix of M(λ)*Rf(λ) with respect to a set of nf complex frequencies Ω, defined as follows: if f is a real frequency in freq, then the corresponding complex frequency in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

FDGainTol = tol specifies an absolute threshold tol for the nonzero magnitudes of the frequency response gains (default: tol = 0.01).

If stabilize = true, Mi(λ) is chosen such that Mi(λ)*Rfi(λ) has only stable poles and if stabilize = false (default), Mi(λ) = I is used and an error is issued if any Rfi(λ) has poles in Ω.

S is determined as a N x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the norm of the j-th column of Mi(λ)*Rfi(λ) evaluated for all frequencies in Ω is larger than or equal to tol, and otherwise, S[i,j] = 0.

The keyword arguments atol1, atol2, atol3, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Afi, Bfi, Cfi, Dfi, the absolute tolerance for the nonzero elements of Efi, the absolute tolerance for the nonzero elements of Cfi, and the relative tolerance for the nonzero elements of Afi, Bfi, Cfi, Dfi and Efi. The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The computation of minimal realizations of individual input-output channels relies on pencil manipulation algorithms, which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

Method: S is evaluated using the definition of the strong structure matrix in [1].

References:

[1] Varga A. Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 3.4.

source
FaultDetectionTools.fdiscond — Function
 fdiscond(sysr::FDFilterIF,freq) -> (scond, β, γ)

Compute for the stable transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of the fault detection filter internal form object sysr::FDFilterIF the quantities: β - the H∞- index of Rf(λ), γ - the maximum of the columns norms of Rf(λ) and the fault detection sensitivity condition scond evaluated as scond := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq.

source
 fdiscond(sysr::FDFilterIF,SFDI,freq) -> (scond, β, γ)

Compute the detection and isolation sensitivity condition scond (and related quatities β and γ) for the binary structure vector SFDI associated to the stable transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of the fault detection filter internal form object sysr::FDFilterIF. If Rff(λ) is the transfer function matrix formed of those j-th columns of Rf(λ) for which SFDI[j] = 1, then: β - the H∞- index of Rff(λ), γ - the maximum of the columns norms of Rff(λ) and the fault detection sensitivity condition scond evaluated as scond := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq.

source
 fdiscond(sysr::FDFilterIF, SFDI, freq) -> (scond, β, γ)

Compute the detection and isolation sensitivity condition vector scond (and related quatities β and γ) for the q × mf binary structure matrix SFDI associated to the stable transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of the fault detection filter internal form object sysr::FDFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.faults] is the fault to residual channel of the i-th filter and Rfi(λ) is the corresponding transfer function matrix. The global transfer function matrix Rf(λ) is formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)]. The i-th element of the vectors scond, β and γ contain the quantities: β[i] - the H∞- index of the nonzero columns of Rffi(λ), γ - the maximum of the nonzero columns norms of Rfi(λ) and the correspomding fault detection sensitivity condition scond[i] evaluated as scond[i] := β[i]/γ[i], where Rffi(λ) is formed of those j-th columns of the i-th row of Rf(λ) for which S[i,j] = 1 and Rfi(λ) is the i-th row of Rf(λ). It is assumed that for each j such that SFDI[i,j] = 1, the j-th column of Rfi(λ) is nonzero and for each j such that SFDI[i,j] = 0, the j-th column of Rfi(λ) is zero. If freq is a vector of real frequency values, then β[i] and γ[i] are evaluated over the frequencies contained in freq.

source
 fdiscond(sysr::FDIFilterIF, SFDI, freq) -> (scond, β, γ)

Compute the detection and isolation sensitivity condition scond (and related quatities β and γ) for the N × mf binary structure matrix SFDI associated to the stable global transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of the fault detection and isolation filter internal form object sysr::FDIFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.faults] is the fault to residual channel of the i-th filter and Rfi(λ) is the corresponding transfer function matrix. The global transfer function matrix Rf(λ) is formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)]. It is assumed that for each j such that SFDI[i,j] = 1, the j-th column of Rfi(λ) is nonzero and for each j such that SFDI[i,j] = 0, the j-th column of Rfi(λ) is zero. The i-th element of the vectors scond, β and γ contain the quantities: β[i] - the H∞- index of the nonzero columns of Rfi(λ), γ - the maximum of the nonzero columns norms of Rf(λ) and the fault detection sensitivity condition scond evaluated as scond[i] := β[i]/γ[i]. If freq is a vector of real frequency values, then β[i] and γ[i] are evaluated over the frequencies contained in freq.

source
FaultDetectionTools.fdif2ngap — Function
 fdif2ngap(sysr::FDFilterIF, freq) -> (gap, β, γ)

Compute the fault-to-noise gap gap (and the related quantities β and γ) for the stable fault detection filter internal form object sysr::FDFilterIF. For the fault to residual channel of the filter sysr.sys[:,sysr.faults] with the corresponding transfer function matrix Rf(λ) and the noise to residual channel of the filter sysr.sys[:,sysr.noise] with the corresponding transfer function matrix Rw(λ), β is the H∞- index of Rf(λ), γ is the H∞-norm of Rw(λ) and gap is the fault-to-noise gap evaluated as gap := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq. gap = ∞ if there are no noise inputs and gap = 0 if there are no fault inputs.

source
 fdif2ngap(sysr::FDFilterIF, SFDI, freq) -> (gap, β, γ)

Compute the fault-to-noise gap gap (and the related quantities β and γ) for the stable fault detection filter internal form object sysr::FDFilterIF and the associated binary structure vector SFDI. sysr.sys[:,sysr.faults] is the fault to residual channel of the filter with the corresponding transfer function matrix Rf(λ) and sysr.sys[:,sysr.noise] is the noise to residual channel of the filter with the corresponding transfer function matrix Rw(λ). If Rff(λ) is the transfer function matrix formed of those j-th columns of Rf(λ) for which SFDI[j] = 1 and Rdf(λ) is the transfer function matrix formed of those j-th columns of Rf(λ) for which SFDI[j] = false, then: β is the H∞- index of Rff(λ), γ is the H∞-norm of [Rdf(λ) Rw(λ)] and gap is the fault-to-noise gap evaluated as gap := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq. gap = ∞ if [Rdf(λ) Rw(λ)] = 0 and gap = 0 if Rff(λ) = 0.

source
  fdif2ngap(sysr::FDFilterIF, SFDI, freq; atol = √ϵ) -> (gap, β, γ)

Compute the fault-to-noise gap gap (and the related quatities β and γ) for the q × mf binary structure matrix SFDI associated to the stable transfer function matrices Rf(λ) and Rw(λ) of the transfer channels from the fault inputs to residuals and noise inputs to residuals, respectively, of the fault detection filter internal form object sysr::FDFilterIF. The i-th element of the vectors gap, β and γ contain the quantities: β[i] - the H∞- index of Rffi(λ), γ[i] - the H∞-norm of [Rdfi(λ) Rwi(λ)] and the fault-to-noise gap gap evaluated as gap[i] := β[i]/γ[i], where Rffi(λ) is formed of those j-th columns of the i-th row of Rf(λ) for which S[i,j] = 1 and Rdfi(λ) is formed of those j-th columns of the i-th row of Rf(λ) for which S[i,j] = 0. gap[i] = ∞ if [Rdfi(λ) Rwi(λ)] = 0 and gap[i] = 0 if Rffi(λ) = 0. If freq is a vector of real frequency values, then β[i] and γ[i] are evaluated over the frequencies contained in freq. atol is an absolute tolerance for the norms Rwi(λ), such that norm values less than or equal to atol are considered zero (default: √ϵ, where ϵ is the working machine precision.)

source
 fdif2ngap(sysr::FDIFilterIF, SFDI, freq; atol = √ϵ) -> (gap, β, γ)

Compute the fault-to-noise gap gap (and the related quatities β and γ) for the N × mf binary structure matrix SFDI associated to the stable global transfer function matrices Rf(λ) and Rw(λ) of the transfer channels from the fault inputs to residuals and noise inputs to residuals, respectively, of the fault detection and isolation filter internal form object sysr::FDIFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.faults] is the fault to residual channel of the i-th filter with the corresponding transfer function matrix Rfi(λ) and sysr.sys[i][:,sysr.noise] is the noise to residual channel of the i-th filter with the corresponding transfer function matrix Rwi(λ). The global transfer function matrices Rf(λ) and Rw(λ) are formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)] and Rw(λ) := [ Rw1(λ); Rw2(λ); ...; RwN(λ)] Let Rffi(λ) be the transfer function matrix formed of those j-th columns of Rfi(λ) for which SFDI[i,j] = 1 and let Rdfi(λ) be the transfer function matrix formed of those j-th columns of Rfi(λ) for which SFDI[i,j] = 0. The i-th element of the vectors gap, β and γ contain the quantities: β[i] - the H∞- index of Rffi(λ), γ[i] - the H∞-norm of [Rdfi(λ) Rwi(λ)] and the fault-to-noise gap gap evaluated as gap[i] := β[i]/γ[i]. gap[i] = ∞ if [Rdfi(λ) Rwi(λ)] = 0 and gap[i] = 0 if Rffi(λ) = 0. If freq is a vector of real frequency values, then β[i] and γ[i] are evaluated over the frequencies contained in freq. atol is an absolute tolerance for the norms Rwi(λ), such that norm values less than or equal to atol are considered zero (default: √ϵ, where ϵ is the working machine precision.)

source
FaultDetectionTools.fdimmperf — Function
 γ = fdimmperf(sysr::FDFilterIF[, nrmflag])

Compute the model-matching performance γ of the fault detection filter internal form object sysr::FDFilterIF. If Rw(λ) is the transfer function matrix of the transfer channel from the noise inputs to residuals sysr.sys[:,sysr.noise], then γ is the H∞-norm of Rw(λ), if nrmflag = Inf (default) and the H2-norm of Rw(λ), if nrmflag = 2. The value of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix Rw(λ) of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDFilterIF, SFDI[, nrmflag])

Compute the model-matching performance γ of the fault detection filter internal form object sysr::FDFilterIF for a given binary structure vector SFDI. If Rf(λ) is the transfer function matrix of the transfer channel from the fault inputs to residuals sysr.sys[:,sysr.faults] and Rw(λ) is the transfer function matrix of the transfer channel from the noise inputs to residuals sysr.sys[:,sysr.noise], then γ is the H∞-norm of [Rdf(λ) Rw(λ)], if nrmflag = Inf (default) and the H2-norm of [Rdf(λ) Rw(λ)], if nrmflag = 2, where Rdf(λ) is the transfer function matrix formed by those j-th columns of Rf(λ) for which SFDI[j] = 0. The value of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix [Rdf(λ) Rw(λ)] of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDFilterIF, SFDI[, nrmflag])

Compute the model-matching performance γ of the fault detection filter internal form object sysr::FDFilterIF for a given binary structure matrix SFDI. If Rf(λ) is the transfer function matrix of the transfer channel from the fault inputs to residuals sysr.sys[:,sysr.faults] and Rw(λ) is the transfer function matrix of the transfer channel from the noise inputs to residuals sysr.sys[:,sysr.noise], then γ is the H∞-norm of [Rdf(λ) Rw(λ)], if nrmflag = Inf (default) and the H2-norm of [Rdf(λ) Rw(λ)], if nrmflag = 2, where Rdf(λ) = .!SFDI .* Rf(λ) (i.e., the element-wise product of .!SFDI and Rf(λ). The value of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix [Rdf(λ) Rw(λ)] of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDIFilterIF[, nrmflag])

Compute the model-matching performance γ of the stable fault detection and isolation filter internal form object sysr::FDIFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.noise] is the noise to residual channel of the i-th filter with the corresponding transfer function matrix Rwi(λ). Then, γ is an N-dimensional vector whose i-th component is the H∞-norm of Rwi(λ), if nrmflag = Inf (default) and the H2-norm of Rwi(λ), if nrmflag = 2. The i-th component of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix Rwi(λ) of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDIFilterIF, SFDI[, nrmflag])

Compute the model-matching performance γ of the stable fault detection and isolation filter internal form object sysr::FDIFilterIF and the associated binary structure matrix SFDI. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.faults] is the fault to residual channel of the i-th filter with the corresponding transfer function matrix Rfi(λ) and sysr.sys[i][:,sysr.noise] is the noise to residual channel of the i-th filter with the corresponding transfer function matrix Rwi(λ). Then, γ is an N-dimensional vector whose i-th component is the H∞-norm of [Rfdi(λ) Rwi(λ)], if nrmflag = Inf (default) or the H2-norm of [Rfdi(λ) Rwi(λ)], if nrmflag = 2, where Rfdi(λ) is the transfer function matrix whose j-th column is zero if SFDI[i,j] = 1 and is equal to the j-th column of Rfi(λ) if SFDI[i,j] = 0. The i-th component of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix [Rfdi(λ) Rwi(λ)] of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDFilterIF, sysref::Union{FDFilterIF,FDIModel}[, nrmflag])

Compute the model-matching performance γ of the fault detection filter internal form object sysr::FDFilterIF with respect to the fault detection reference filter internal form sysref::FDFilterIF. If R(λ) is the transfer function matrix of the fault detection filter internal form sysr.sys and Mr(λ) is the transfer function matrix of the fault detection reference filter internal form sysref.sys, then γ is the H∞-norm of R(λ)-Mr(λ), if nrmflag = Inf (default) or the H2-norm of R(λ)-Mr(λ), if nrmflag = 2. The value of γ is infinite for an unstable difference R(λ)-Mr(λ) or if nrmflag = 2 and the transfer function matrix R(λ)-Mr(λ) of a continuous-time system is not strictly proper. In general, R(λ) and Mr(λ) are partitioned as R(λ) = [ Ru(λ) Rd(λ) Rf(λ) Rw(λ) Ra(λ) ] and Mr(λ) = [ Mru(λ) Mrd(λ) Mrf(λ) Mrw(λ) Mra(λ) ] in accordance with the partitioning of the inputs in control inputs, disturbance inputs, fault inputs, noise inputs and auxiliary inputs. Void components of Mr(λ) corresponding to non-void components in R(λ) are assumed to be zero.

source
 γ = fdimmperf(sysr::FDIFilterIF, sysref::FDIFilterIF[, nrmflag])

Compute the model-matching performance γ of the fault detection and isolation filter internal form object sysr::FDIFilterIF with respect to the fault detection and isolation reference filter internal form sysref::FDIFilterIF. If Ri(λ) is the transfer function matrix of the i-th fault detection and isolation filter internal form sysr.sys[i] and Mri(λ) is the transfer function matrix of the i-th fault detection and isolation reference filter internal form sysref.sys[i], then γ is a vector whose i-th component γ[i] is the H∞-norm of Ri(λ)-Mri(λ), if nrmflag = Inf (default) or the H2-norm of Ri(λ)-Mri(λ), if nrmflag = 2. The value of γ[i] is infinite for an unstable difference Ri(λ)-Mri(λ) or if nrmflag = 2 and the transfer function matrix Ri(λ)-Mri(λ) of a continuous-time system is not strictly proper. In general, Ri(λ) and Mri(λ) are partitioned as Ri(λ) = [ Rui(λ) Rdi(λ) Rfi(λ) Rwi(λ) Rai(λ) ] and Mri(λ) = [ Mrui(λ) Mrdi(λ) Mrfi(λ) Mrwi(λ) Mrai(λ) ] in accordance with the partitioning of the inputs in control inputs, disturbance inputs, fault inputs, noise inputs and auxiliary inputs. Void components of Mri(λ) corresponding to non-void components in Ri(λ) are assumed to be zero.

source
+ FDtol, FDStol, atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute the weak or strong binary structure matrix S of the transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of a fault detection filter internal form object sysr::FDFilterIF. For a filter sysr with q residual outputs and mf fault inputs, Rf(λ) is the q x mf transfer function matrix of the fault inputs channel with the descriptor system representation sysr.sys[:,sysr.faults] := (Af-lambda*Ef,Bf,Cf,Df).

If FDfreq = missing (default), then S contains the weak structure matrix of Rf(λ). For block = false, S is determined as a q x mf binary matrix (BitMatrix), whose (i,j)-th element is S[i,j] = 1, if the (i,j)-th element of Rf(λ) is nonzero, and otherwise, S[i,j] = 0. For block = true, S is determined as a 1 x mf binary matrix, whose (1,j)-th element is S[1,j] = 1, if the j-th column of Rf(λ) is nonzero, and otherwise, S[1,j] = 0.

If FDfreq = freq specifies a vector freq of nf real frequencies which characterize the classes of persistent fault signals, then for a suitable proper and invertible M(λ) (see below), S contains the strong structure matrix of M(λ)*Rf(λ) with respect to a set of nf complex frequencies Ω, defined as follows: if f is a real frequency in freq, then the corresponding complex frequency in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

FDtol = tol1 specifies an absolute threshold tol1 for the magnitudes of nonzero elements in the system matrices Bf and Df and is used to determine the weak structure matrix. Its default value is tol1 = 0.0001*max(1, norm(Bf,1), norm(Df,1)).

FDStol = tol2 specifies an absolute threshold tol2 for the magnitudes of nonzero elements in the system matrices Af, Ef, Bf, Cf and Df and is used to determine the strong structure matrix. Its default value is tol2 = epsm*max(1, norm(Ef,1), norm(Af,1), norm(Bf,1), norm(Cf,Inf), norm(Df,1))), where epsm is the working machine precision.

For block = false, then, if poleshift = true, M(λ) is chosen diagonal such that M(λ)*Rf(λ) has no poles in Ω and if poleshift = false (default), M(λ) = I is used and an error is issued if Rf(λ) has poles in Ω. S is determined as a q x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the (i,j)-th element of M(λ)*Rf(λ) evaluated for all frequencies in Ω is nonzero, and otherwise, S[i,j] = 0.

For block = true, then, if poleshift = true, M(λ) is chosen such that M(λ)*Rf(λ) as no poles in Ω and if poleshift = false (default), M(λ) = I is used and an error is issued if Rf(λ) has poles in Ω. S is determined as an 1 x mf binary matrix, whose (1,j)-th element is S[1,j] = 1, if the j-th column of M(λ)*Rf(λ) evaluated for all frequencies in Ω is nonzero and otherwise S[1,j] = 0.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Af, Bf, Cf, Df, the absolute tolerance for the nonzero elements of Ef, and the relative tolerance for the nonzero elements of Af, Bf, Cf, Df and Ef. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

Method: For the definition of the structure matrix, see [1]. For the determination of the weak structure matrix, minimal realizations are determined for each column of Rf(λ) if block = true or for each element of Rf(λ) if block = false and the nonzero columns or elements in each column are identified (see Corollary 7.1 of [1]). For the determination of the strong structure matrix, minimal realizations are determined for each column of M(λ)*Rf(λ) if block = true or for each element of M(λ)*Rf(λ) if block = false and the full rank of the corresponding system matrix is checked for all frequencies in FDfreq (see Corollary 7.2 in [1]) (i.e., the lack of zeros in all frequencies).

References:

[1] Varga A. Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec.3.4.

source
S = fditspec(sysr::FDIFilterIF; FDfreq = missing, poleshift = false, 
+             FDtol, FDStol, atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute the weak or strong binary structure matrix S of the global transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of a fault detection and isolation filter internal form object sysr::FDIFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where the fault to residual channel of the i-th filter sysr.sys[i][:,sysr.faults] has qi residual outputs and mf fault inputs, has the descriptor system representation sysr.sys[i][:,sysr.faults] := (Afi-lambda*Efi,Bfi,Cfi,Dfi) and Rfi(λ) is the corresponding qi x mf transfer function matrix. The global transfer function matrix Rf(λ) is formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)]. For the evaluation of the strong structure matrix, the structure matrix of the stable transfer function matrix M(λ)*Rf(λ) is determined, with a M(λ) block-diagonal M(λ) = block-diag(M1(λ), M2(λ), ..., MN(λ)), where Mi(λ) is a suitable square and invertible transfer function matrix (see below).

FDtol = tol1 specifies an absolute threshold tol1 for the magnitudes of nonzero elements in the system matrices Bf and Df and is used to determine the weak structure matrix. Its default value is tol1 = 0.0001*max(1, norm(Bf,1), norm(Df,1)).

FDStol = tol2 specifies an absolute threshold tol2 for the magnitudes of nonzero elements in the system matrices Af, Ef, Bf, Cf and Df and is used to determine the strong structure matrix. Its default value is tol2 = epsm*max(1, norm(Ef,1), norm(Af,1), norm(Bf,1), norm(Cf,Inf), norm(Df,1))), where epsm is the working machine precision.

If FDfreq = missing (default), then S contains the weak structure matrix of Rf(λ). S is determined as a N x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the j-th column of Rfi(λ) is nonzero, and otherwise, S[i,j] = 0.

If FDfreq = freq specifies a vector freq of nf real frequencies which characterize the classes of persistent fault signals, then for a suitable proper and invertible M(λ) (see below), S contains the strong structure matrix of M(λ)*Rf(λ) with respect to a set of nf complex frequencies Ω, defined as follows: if f is a real frequency in freq, then the corresponding complex frequency in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

S is determined as a N x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the j-th column of Mi(λ)*Rfi(λ) is nonzero for all frequencies in Ω, and otherwise, S[i,j] = 0. If poleshift = true, Mi(λ) is chosen such that Mi(λ)*Rfi(λ) has no poles in Ω and if poleshift = false (default), Mi(λ) = I is used and an error is issued if any Rfi(λ) has poles in Ω.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Af, Bf, Cf, Df, the absolute tolerance for the nonzero elements of Ef, and the relative tolerance for the nonzero elements of Af, Bf, Cf, Df and Ef. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

Method: For the definition of the structure matrix, see [1]. For the determination of the weak structure matrix, minimal realizations are determined for each column of Rfi(λ) and the nonzero columns are identified (see Corollary 7.1 of [1]). For the determination of the strong structure matrix, minimal realizations are determined for each column of Mi(λ)*Rfi(λ) and the full rank of the corresponding system matrix is checked for all frequencies in Ω (see Corollary 7.2 in [1]) (i.e., the lack of zeros in all frequencies in Ω).

References:

[1] Varga A. Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec.3.4.

source
FaultDetectionTools.fdisspec — Function
 S = fdisspec(sysr::FDFilterIF, freq; block = false, stabilize = false, FDGainTol = 0.01, 
+                 atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute, for a given set of real frequencies freq, the strong binary structure matrix S of the stable transfer function matrix M(λ)*Rf(λ), where Rf(λ) is the transfer function matrix of the transfer channel from the fault inputs to residuals of the fault detection filter internal form object sysr::FDFilterIF and M(λ) is a suitable proper and invertible stabilizing transfer function matrix (see below). For a filter sysr with q residual outputs and mf fault inputs, Rf(λ) is the q x mf transfer function matrix of the fault inputs channel with the descriptor system representation sysr.sys[:,sysr.faults] := (Af-lambda*Ef,Bf,Cf,Df).

freq must contain a real frequency value or a vector of nf real frequencies which characterize the classes of persistent fault signals (default: freq = 0, i.e., characterizing constant faults). S contains the strong structure matrix of M(λ)*Rf(λ) with respect to a set of nf complex frequencies Ω, defined as follows: if f is a real frequency in freq, then the corresponding complex frequency in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

FDGainTol = tol specifies an absolute threshold tol for the nonzero magnitudes of the frequency response gains (default: tol = 0.01).

For block = false, then, if stabilize = true, M(λ) is chosen diagonal such that M(λ)*Rf(λ) has only stable poles and if stabilize = false (default), M(λ) = I is used and an error is issued if Rf(λ) has poles in Ω. S is determined as a q x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the (i,j)-th element of M(λ)*Rf(λ) evaluated for all frequencies in freq is larger than or equal to tol, and otherwise, S[i,j] = 0.

For block = true, then, if stabilize = true, M(λ) is chosen such that M(λ)*Rf(λ) has only stable poles and if stabilize = false (default), M(λ) = I is used and an error is issued if Rf(λ) has poles in Ω. S is determined as an 1 x mf binary matrix, whose (1,j)-th element is S[1,j] = 1, if the j-th column of M(λ)*Rf(λ) evaluated for all frequencies in Ω is larger than or equal to tol and otherwise, S[1,j] = 0.

The keyword arguments atol1, atol2, atol3, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Af, Bf, Cf, Df, the absolute tolerance for the nonzero elements of Ef, the absolute tolerance for the nonzero elements of Cf, and the relative tolerance for the nonzero elements of Af, Bf, Cf, Df and Ef. The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The computation of minimal realizations of individual input-output channels relies on pencil manipulation algorithms, which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

Method: S is evaluated using the definition of the strong structure matrix in [1].

References:

[1] Varga A. Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 3.4.

source
 S = fdisspec(sysr::FDIFilterIF, freq; stabilize = false, FDGainTol = 0.01, 
+                 atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute, for a given set of real frequencies freq, the strong binary structure matrix S of the stable transfer function matrix M(λ)*Rf(λ), where Rf(λ) is the global transfer function matrix of the transfer channel from the fault inputs to residuals of the fault detection and isolation filter internal form object sysr::FDIFilterIF and M(λ) is a suitable block-diagonal proper and invertible stabilizing transfer function matrix (see below). The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where the fault to residual channel of the i-th filter sysr.sys[i][:,sysr.faults] has qi residual outputs and mf fault inputs, has the descriptor system representation sysr.sys[i][:,sysr.faults] := (Afi-lambda*Efi,Bfi,Cfi,Dfi) and Rfi(λ) is the corresponding qi x mf transfer function matrix. The global transfer function matrix Rf(λ) is formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)]. M(λ) = block-diag(M1(λ), M2(λ), ..., MN(λ)), where Mi(λ) is square and invertible and chosen such that Mi(λ)Rfi(λ) is stable (see below).

freq must contain a real frequency value or a vector of nf real frequencies which characterize the classes of persistent fault signals (default: freq = 0, i.e., characterizing constant faults). S contains the strong structure matrix of M(λ)*Rf(λ) with respect to a set of nf complex frequencies Ω, defined as follows: if f is a real frequency in freq, then the corresponding complex frequency in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

FDGainTol = tol specifies an absolute threshold tol for the nonzero magnitudes of the frequency response gains (default: tol = 0.01).

If stabilize = true, Mi(λ) is chosen such that Mi(λ)*Rfi(λ) has only stable poles and if stabilize = false (default), Mi(λ) = I is used and an error is issued if any Rfi(λ) has poles in Ω.

S is determined as a N x mf binary matrix, whose (i,j)-th element is S[i,j] = 1, if the norm of the j-th column of Mi(λ)*Rfi(λ) evaluated for all frequencies in Ω is larger than or equal to tol, and otherwise, S[i,j] = 0.

The keyword arguments atol1, atol2, atol3, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Afi, Bfi, Cfi, Dfi, the absolute tolerance for the nonzero elements of Efi, the absolute tolerance for the nonzero elements of Cfi, and the relative tolerance for the nonzero elements of Afi, Bfi, Cfi, Dfi and Efi. The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The computation of minimal realizations of individual input-output channels relies on pencil manipulation algorithms, which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

Method: S is evaluated using the definition of the strong structure matrix in [1].

References:

[1] Varga A. Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 3.4.

source
FaultDetectionTools.fdiscond — Function
 fdiscond(sysr::FDFilterIF,freq) -> (scond, β, γ)

Compute for the stable transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of the fault detection filter internal form object sysr::FDFilterIF the quantities: β - the H∞- index of Rf(λ), γ - the maximum of the columns norms of Rf(λ) and the fault detection sensitivity condition scond evaluated as scond := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq.

source
 fdiscond(sysr::FDFilterIF,SFDI,freq) -> (scond, β, γ)

Compute the detection and isolation sensitivity condition scond (and related quatities β and γ) for the binary structure vector SFDI associated to the stable transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of the fault detection filter internal form object sysr::FDFilterIF. If Rff(λ) is the transfer function matrix formed of those j-th columns of Rf(λ) for which SFDI[j] = 1, then: β - the H∞- index of Rff(λ), γ - the maximum of the columns norms of Rff(λ) and the fault detection sensitivity condition scond evaluated as scond := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq.

source
 fdiscond(sysr::FDFilterIF, SFDI, freq) -> (scond, β, γ)

Compute the detection and isolation sensitivity condition vector scond (and related quatities β and γ) for the q × mf binary structure matrix SFDI associated to the stable transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of the fault detection filter internal form object sysr::FDFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.faults] is the fault to residual channel of the i-th filter and Rfi(λ) is the corresponding transfer function matrix. The global transfer function matrix Rf(λ) is formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)]. The i-th element of the vectors scond, β and γ contain the quantities: β[i] - the H∞- index of the nonzero columns of Rffi(λ), γ - the maximum of the nonzero columns norms of Rfi(λ) and the correspomding fault detection sensitivity condition scond[i] evaluated as scond[i] := β[i]/γ[i], where Rffi(λ) is formed of those j-th columns of the i-th row of Rf(λ) for which S[i,j] = 1 and Rfi(λ) is the i-th row of Rf(λ). It is assumed that for each j such that SFDI[i,j] = 1, the j-th column of Rfi(λ) is nonzero and for each j such that SFDI[i,j] = 0, the j-th column of Rfi(λ) is zero. If freq is a vector of real frequency values, then β[i] and γ[i] are evaluated over the frequencies contained in freq.

source
 fdiscond(sysr::FDIFilterIF, SFDI, freq) -> (scond, β, γ)

Compute the detection and isolation sensitivity condition scond (and related quatities β and γ) for the N × mf binary structure matrix SFDI associated to the stable global transfer function matrix Rf(λ) of the transfer channel from the fault inputs to residuals of the fault detection and isolation filter internal form object sysr::FDIFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.faults] is the fault to residual channel of the i-th filter and Rfi(λ) is the corresponding transfer function matrix. The global transfer function matrix Rf(λ) is formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)]. It is assumed that for each j such that SFDI[i,j] = 1, the j-th column of Rfi(λ) is nonzero and for each j such that SFDI[i,j] = 0, the j-th column of Rfi(λ) is zero. The i-th element of the vectors scond, β and γ contain the quantities: β[i] - the H∞- index of the nonzero columns of Rfi(λ), γ - the maximum of the nonzero columns norms of Rf(λ) and the fault detection sensitivity condition scond evaluated as scond[i] := β[i]/γ[i]. If freq is a vector of real frequency values, then β[i] and γ[i] are evaluated over the frequencies contained in freq.

source
FaultDetectionTools.fdif2ngap — Function
 fdif2ngap(sysr::FDFilterIF, freq) -> (gap, β, γ)

Compute the fault-to-noise gap gap (and the related quantities β and γ) for the stable fault detection filter internal form object sysr::FDFilterIF. For the fault to residual channel of the filter sysr.sys[:,sysr.faults] with the corresponding transfer function matrix Rf(λ) and the noise to residual channel of the filter sysr.sys[:,sysr.noise] with the corresponding transfer function matrix Rw(λ), β is the H∞- index of Rf(λ), γ is the H∞-norm of Rw(λ) and gap is the fault-to-noise gap evaluated as gap := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq. gap = ∞ if there are no noise inputs and gap = 0 if there are no fault inputs.

source
 fdif2ngap(sysr::FDFilterIF, SFDI, freq) -> (gap, β, γ)

Compute the fault-to-noise gap gap (and the related quantities β and γ) for the stable fault detection filter internal form object sysr::FDFilterIF and the associated binary structure vector SFDI. sysr.sys[:,sysr.faults] is the fault to residual channel of the filter with the corresponding transfer function matrix Rf(λ) and sysr.sys[:,sysr.noise] is the noise to residual channel of the filter with the corresponding transfer function matrix Rw(λ). If Rff(λ) is the transfer function matrix formed of those j-th columns of Rf(λ) for which SFDI[j] = 1 and Rdf(λ) is the transfer function matrix formed of those j-th columns of Rf(λ) for which SFDI[j] = false, then: β is the H∞- index of Rff(λ), γ is the H∞-norm of [Rdf(λ) Rw(λ)] and gap is the fault-to-noise gap evaluated as gap := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq. gap = ∞ if [Rdf(λ) Rw(λ)] = 0 and gap = 0 if Rff(λ) = 0.

source
  fdif2ngap(sysr::FDFilterIF, SFDI, freq; atol = √ϵ) -> (gap, β, γ)

Compute the fault-to-noise gap gap (and the related quatities β and γ) for the q × mf binary structure matrix SFDI associated to the stable transfer function matrices Rf(λ) and Rw(λ) of the transfer channels from the fault inputs to residuals and noise inputs to residuals, respectively, of the fault detection filter internal form object sysr::FDFilterIF. The i-th element of the vectors gap, β and γ contain the quantities: β[i] - the H∞- index of Rffi(λ), γ[i] - the H∞-norm of [Rdfi(λ) Rwi(λ)] and the fault-to-noise gap gap evaluated as gap[i] := β[i]/γ[i], where Rffi(λ) is formed of those j-th columns of the i-th row of Rf(λ) for which S[i,j] = 1 and Rdfi(λ) is formed of those j-th columns of the i-th row of Rf(λ) for which S[i,j] = 0. gap[i] = ∞ if [Rdfi(λ) Rwi(λ)] = 0 and gap[i] = 0 if Rffi(λ) = 0. If freq is a vector of real frequency values, then β[i] and γ[i] are evaluated over the frequencies contained in freq. atol is an absolute tolerance for the norms Rwi(λ), such that norm values less than or equal to atol are considered zero (default: √ϵ, where ϵ is the working machine precision.)

source
 fdif2ngap(sysr::FDIFilterIF, SFDI, freq; atol = √ϵ) -> (gap, β, γ)

Compute the fault-to-noise gap gap (and the related quatities β and γ) for the N × mf binary structure matrix SFDI associated to the stable global transfer function matrices Rf(λ) and Rw(λ) of the transfer channels from the fault inputs to residuals and noise inputs to residuals, respectively, of the fault detection and isolation filter internal form object sysr::FDIFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.faults] is the fault to residual channel of the i-th filter with the corresponding transfer function matrix Rfi(λ) and sysr.sys[i][:,sysr.noise] is the noise to residual channel of the i-th filter with the corresponding transfer function matrix Rwi(λ). The global transfer function matrices Rf(λ) and Rw(λ) are formed by row concatenation of the transfer function matrices of the N individual filters, i.e., Rf(λ) := [ Rf1(λ); Rf2(λ); ...; RfN(λ)] and Rw(λ) := [ Rw1(λ); Rw2(λ); ...; RwN(λ)] Let Rffi(λ) be the transfer function matrix formed of those j-th columns of Rfi(λ) for which SFDI[i,j] = 1 and let Rdfi(λ) be the transfer function matrix formed of those j-th columns of Rfi(λ) for which SFDI[i,j] = 0. The i-th element of the vectors gap, β and γ contain the quantities: β[i] - the H∞- index of Rffi(λ), γ[i] - the H∞-norm of [Rdfi(λ) Rwi(λ)] and the fault-to-noise gap gap evaluated as gap[i] := β[i]/γ[i]. gap[i] = ∞ if [Rdfi(λ) Rwi(λ)] = 0 and gap[i] = 0 if Rffi(λ) = 0. If freq is a vector of real frequency values, then β[i] and γ[i] are evaluated over the frequencies contained in freq. atol is an absolute tolerance for the norms Rwi(λ), such that norm values less than or equal to atol are considered zero (default: √ϵ, where ϵ is the working machine precision.)

source
FaultDetectionTools.fdimmperf — Function
 γ = fdimmperf(sysr::FDFilterIF[, nrmflag])

Compute the model-matching performance γ of the fault detection filter internal form object sysr::FDFilterIF. If Rw(λ) is the transfer function matrix of the transfer channel from the noise inputs to residuals sysr.sys[:,sysr.noise], then γ is the H∞-norm of Rw(λ), if nrmflag = Inf (default) and the H2-norm of Rw(λ), if nrmflag = 2. The value of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix Rw(λ) of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDFilterIF, SFDI[, nrmflag])

Compute the model-matching performance γ of the fault detection filter internal form object sysr::FDFilterIF for a given binary structure vector SFDI. If Rf(λ) is the transfer function matrix of the transfer channel from the fault inputs to residuals sysr.sys[:,sysr.faults] and Rw(λ) is the transfer function matrix of the transfer channel from the noise inputs to residuals sysr.sys[:,sysr.noise], then γ is the H∞-norm of [Rdf(λ) Rw(λ)], if nrmflag = Inf (default) and the H2-norm of [Rdf(λ) Rw(λ)], if nrmflag = 2, where Rdf(λ) is the transfer function matrix formed by those j-th columns of Rf(λ) for which SFDI[j] = 0. The value of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix [Rdf(λ) Rw(λ)] of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDFilterIF, SFDI[, nrmflag])

Compute the model-matching performance γ of the fault detection filter internal form object sysr::FDFilterIF for a given binary structure matrix SFDI. If Rf(λ) is the transfer function matrix of the transfer channel from the fault inputs to residuals sysr.sys[:,sysr.faults] and Rw(λ) is the transfer function matrix of the transfer channel from the noise inputs to residuals sysr.sys[:,sysr.noise], then γ is the H∞-norm of [Rdf(λ) Rw(λ)], if nrmflag = Inf (default) and the H2-norm of [Rdf(λ) Rw(λ)], if nrmflag = 2, where Rdf(λ) = .!SFDI .* Rf(λ) (i.e., the element-wise product of .!SFDI and Rf(λ). The value of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix [Rdf(λ) Rw(λ)] of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDIFilterIF[, nrmflag])

Compute the model-matching performance γ of the stable fault detection and isolation filter internal form object sysr::FDIFilterIF. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.noise] is the noise to residual channel of the i-th filter with the corresponding transfer function matrix Rwi(λ). Then, γ is an N-dimensional vector whose i-th component is the H∞-norm of Rwi(λ), if nrmflag = Inf (default) and the H2-norm of Rwi(λ), if nrmflag = 2. The i-th component of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix Rwi(λ) of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDIFilterIF, SFDI[, nrmflag])

Compute the model-matching performance γ of the stable fault detection and isolation filter internal form object sysr::FDIFilterIF and the associated binary structure matrix SFDI. The filter sysr consists of N individual FDI filters sysr.sys[i], for i = 1, ..., N, where sysr.sys[i][:,sysr.faults] is the fault to residual channel of the i-th filter with the corresponding transfer function matrix Rfi(λ) and sysr.sys[i][:,sysr.noise] is the noise to residual channel of the i-th filter with the corresponding transfer function matrix Rwi(λ). Then, γ is an N-dimensional vector whose i-th component is the H∞-norm of [Rfdi(λ) Rwi(λ)], if nrmflag = Inf (default) or the H2-norm of [Rfdi(λ) Rwi(λ)], if nrmflag = 2, where Rfdi(λ) is the transfer function matrix whose j-th column is zero if SFDI[i,j] = 1 and is equal to the j-th column of Rfi(λ) if SFDI[i,j] = 0. The i-th component of γ is infinite for an unstable filter or if nrmflag = 2 and the transfer function matrix [Rfdi(λ) Rwi(λ)] of a continuous-time system is not strictly proper.

source
 γ = fdimmperf(sysr::FDFilterIF, sysref::Union{FDFilterIF,FDIModel}[, nrmflag])

Compute the model-matching performance γ of the fault detection filter internal form object sysr::FDFilterIF with respect to the fault detection reference filter internal form sysref::FDFilterIF. If R(λ) is the transfer function matrix of the fault detection filter internal form sysr.sys and Mr(λ) is the transfer function matrix of the fault detection reference filter internal form sysref.sys, then γ is the H∞-norm of R(λ)-Mr(λ), if nrmflag = Inf (default) or the H2-norm of R(λ)-Mr(λ), if nrmflag = 2. The value of γ is infinite for an unstable difference R(λ)-Mr(λ) or if nrmflag = 2 and the transfer function matrix R(λ)-Mr(λ) of a continuous-time system is not strictly proper. In general, R(λ) and Mr(λ) are partitioned as R(λ) = [ Ru(λ) Rd(λ) Rf(λ) Rw(λ) Ra(λ) ] and Mr(λ) = [ Mru(λ) Mrd(λ) Mrf(λ) Mrw(λ) Mra(λ) ] in accordance with the partitioning of the inputs in control inputs, disturbance inputs, fault inputs, noise inputs and auxiliary inputs. Void components of Mr(λ) corresponding to non-void components in R(λ) are assumed to be zero.

source
 γ = fdimmperf(sysr::FDIFilterIF, sysref::FDIFilterIF[, nrmflag])

Compute the model-matching performance γ of the fault detection and isolation filter internal form object sysr::FDIFilterIF with respect to the fault detection and isolation reference filter internal form sysref::FDIFilterIF. If Ri(λ) is the transfer function matrix of the i-th fault detection and isolation filter internal form sysr.sys[i] and Mri(λ) is the transfer function matrix of the i-th fault detection and isolation reference filter internal form sysref.sys[i], then γ is a vector whose i-th component γ[i] is the H∞-norm of Ri(λ)-Mri(λ), if nrmflag = Inf (default) or the H2-norm of Ri(λ)-Mri(λ), if nrmflag = 2. The value of γ[i] is infinite for an unstable difference Ri(λ)-Mri(λ) or if nrmflag = 2 and the transfer function matrix Ri(λ)-Mri(λ) of a continuous-time system is not strictly proper. In general, Ri(λ) and Mri(λ) are partitioned as Ri(λ) = [ Rui(λ) Rdi(λ) Rfi(λ) Rwi(λ) Rai(λ) ] and Mri(λ) = [ Mrui(λ) Mrdi(λ) Mrfi(λ) Mrwi(λ) Mrai(λ) ] in accordance with the partitioning of the inputs in control inputs, disturbance inputs, fault inputs, noise inputs and auxiliary inputs. Void components of Mri(λ) corresponding to non-void components in Ri(λ) are assumed to be zero.

source
diff --git a/dev/FDIsynthesis.html b/dev/FDIsynthesis.html index 28e9abc..6bea893 100644 --- a/dev/FDIsynthesis.html +++ b/dev/FDIsynthesis.html @@ -3,14 +3,14 @@ sdeg, smarg, poles, HDesign, FDtol, FDGainTol, FDfreq, tcond, offset, atol, atol1, atol2, atol3, rtol, fast = true) -> (Q::FDFilter, R::FDFilterIF, info)

Solve the exact fault detection problem (EFDP) for a given synthesis model sysf with additive faults. The computed stable and proper filter objects Q and R contain the fault detection filter, representing the solution of the EFDP, and its internal form, respectively.

The returned named tuple info, with the components info.tcond, info.degs, info.S, and info.HDesign, contains additional synthesis related information (see below).

The continuous- or discrete-time system sysf.sys is in a standard or descriptor state-space form sysf.sys = (A-λE,B,C,D), which corresponds to the input-output form 

   y = Gu(λ)*u + Gd(λ)*d + Gf(λ)*f + Gw(λ)*w + Ga(λ)*aux,

with the Laplace- or Z-transformed plant outputs y, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Gu(λ), Gd(λ), Gf(λ), Gw(λ), and Ga(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysf.controls, sysf.disturbances, sysf.faults, sysf.noise and sysf.aux, respectively.

The fault detection filter object Q, contains in Q.sys the resulting filter in a standard state-space form, which generates the residual signal r. The corresponding input-output (implementation) form is

        r = Qy(λ)*y + Qu(λ)*u

where Qy(λ) and Qu(λ) are the transfer function matrices from the output and control inputs to the residual. The indices of output and control inputs are contained in the integer vectors Q.outputs and Q.controls, respectively.

The fault detection filter in internal form object R, contains R.sys, the resulting internal form of the filter in a standard state-space form, which generates the residual signal r, and corresponds to the input-output form

   r = Ru(λ)*u + Rd(λ)*d + Rf(λ)*f + Rw(λ)*w + Ra(λ)*aux ,

where 

   | Ru(λ) Rd(λ) Rf(λ) Rw(λ) Ra(λ) | = |Qy(λ) Qu(λ)|*| Gu(λ) Gd(λ) Gf(λ) Gw(λ) Ga(λ) |. 
-                                                     |  I     0     0     0     0    |

The solution of the EFDP ensures that Ru(λ) = 0, Rd(λ) = 0, and Rf(λ) has all its columns nonzero. The indices of the inputs u, d, f, w and aux of the resulting filter R.sys are contained in the integer vectors R.controls (void), R.disturbances (void), R.faults, R.noise and R.aux, respectively.

The resulting filters Q.sys and R.sys have observable state-space realizations (AQ,BQ,CQ,DQ) and (AQ,BR,CQ,DR), respectively, and thus share the observable pairs (AQ,CQ).

Various user options can be specified via keyword arguments as follows:

If minimal = true (default), a least order filter synthesis is performed, while with minimal = false a full order synthesis is performed.

If HDesign = H, a full row rank design matrix H is used to build rdim = q linear combinations of the left nullspace basis vectors (default: HDesign = missing)

rdim = q specifies the desired number q of residual outputs for Q and R. The default value of q is chosen as follows: if HDesign = missing, then q = 1, if minimal = true, or q is the number of the nullspace basis vectors used for the initial synthesis, if minimal = false; if HDesign = H specifies a full row rank design matrix H, then q is the row dimension of H.

FDfreq = freq specifies a vector of real frequency values or a scalar real frequency value for strong detectability checks (default: FDfreq = missing).

If nullspace = true (default), a minimal proper nullspace basis is used for the synthesis of the fault detection filter. If nullspace = false, a full-order observer based nullspace basis is used. This option can be only used for a proper system without disturbance inputs.

If simple = true, a simple proper nullspace basis is emplyed for synthesis. The orders of the basis vectors are provided in info.deg. If simple = false (default), then no simple basis is computed.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

FDtol = tol1 specifies the threshold tol1 for fault detectability checks (default: tol1 = 0.0001).

FDGainTol = tol2 specifies the threshold tol2 for strong fault detectability checks (default: tol2 = 0.01).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, S, HDesign), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.S is the binary structure matrix corresponding to the computed left nullspace basis;

info.HDesign is the design matrix H employed for the synthesis of the fault detection filter.

Method: The Procedure EFD from [1] is implemented to solve the exact fault detection problem. For more details on the least order synthesis of fault detection filters see [2].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.2.

[2] A. Varga, On computing least order fault detectors using rational nullspace bases. IFAC SAFEPROCESS'03 Symposium, Washington DC, USA, 2003.

source
efdsyn(sysf::FDIModel, S; rdim, nullspace = true, simple = false, minimal = true, 
+                                                     |  I     0     0     0     0    |

The solution of the EFDP ensures that Ru(λ) = 0, Rd(λ) = 0, and Rf(λ) has all its columns nonzero. The indices of the inputs u, d, f, w and aux of the resulting filter R.sys are contained in the integer vectors R.controls (void), R.disturbances (void), R.faults, R.noise and R.aux, respectively.

The resulting filters Q.sys and R.sys have observable state-space realizations (AQ,BQ,CQ,DQ) and (AQ,BR,CQ,DR), respectively, and thus share the observable pairs (AQ,CQ).

Various user options can be specified via keyword arguments as follows:

If minimal = true (default), a least order filter synthesis is performed, while with minimal = false a full order synthesis is performed.

If HDesign = H, a full row rank design matrix H is used to build rdim = q linear combinations of the left nullspace basis vectors (default: HDesign = missing)

rdim = q specifies the desired number q of residual outputs for Q and R. The default value of q is chosen as follows: if HDesign = missing, then q = 1, if minimal = true, or q is the number of the nullspace basis vectors used for the initial synthesis, if minimal = false; if HDesign = H specifies a full row rank design matrix H, then q is the row dimension of H.

FDfreq = freq specifies a vector of real frequency values or a scalar real frequency value for strong detectability checks (default: FDfreq = missing).

If nullspace = true (default), a minimal proper nullspace basis is used for the synthesis of the fault detection filter. If nullspace = false, a full-order observer based nullspace basis is used. This option can be only used for a proper system without disturbance inputs.

If simple = true, a simple proper nullspace basis is emplyed for synthesis. The orders of the basis vectors are provided in info.deg. If simple = false (default), then no simple basis is computed.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

FDtol = tol1 specifies the threshold tol1 for fault detectability checks (default: tol1 = 0.0001).

FDGainTol = tol2 specifies the threshold tol2 for strong fault detectability checks (default: tol2 = 0.01).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, S, HDesign), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.S is the binary structure matrix corresponding to the computed left nullspace basis;

info.HDesign is the design matrix H employed for the synthesis of the fault detection filter.

Method: The Procedure EFD from [1] is implemented to solve the exact fault detection problem. For more details on the least order synthesis of fault detection filters see [2].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.2.

[2] A. Varga, On computing least order fault detectors using rational nullspace bases. IFAC SAFEPROCESS'03 Symposium, Washington DC, USA, 2003.

source
efdsyn(sysf::FDIModel, S; rdim, nullspace = true, simple = false, minimal = true, 
                        sdeg, smarg, poles, HDesign, FDtol, FDGainTol, FDfreq, 
                        tcond, offset, atol, atol1, atol2, atol3, rtol, fast = true) 
-                       -> (Q::FDFilter, R::FDFilterIF, info)

Solve the exact fault detection and isolation problem (EFDIP) for a given synthesis model sysf with additive faults and a given binary structure vector S. The computed stable and proper filter objects Q and R contain the fault detection filter, representing the solution of the EFDIP, and its internal form, respectively, and are determined such that R.sys[:,faults] has its j-th column nonzero if S[j] = 1 and the j-th column is zero if S[j] = 0. For the description of the keyword parameters see the function efdsyn.

source
FaultDetectionTools.efdisyn — Function
efdisyn(sysf::FDIModel, SFDI; rdim, nullspace = true, simple = false, minimal = true, separate = false,
+                       -> (Q::FDFilter, R::FDFilterIF, info)

Solve the exact fault detection and isolation problem (EFDIP) for a given synthesis model sysf with additive faults and a given binary structure vector S. The computed stable and proper filter objects Q and R contain the fault detection filter, representing the solution of the EFDIP, and its internal form, respectively, and are determined such that R.sys[:,faults] has its j-th column nonzero if S[j] = 1 and the j-th column is zero if S[j] = 0. For the description of the keyword parameters see the function efdsyn.

source
FaultDetectionTools.efdisyn — Function
efdisyn(sysf::FDIModel, SFDI; rdim, nullspace = true, simple = false, minimal = true, separate = false,
                        sdeg, smarg, poles, HDesign, FDtol, FDGainTol, FDfreq, 
                        tcond, offset, atol, atol1, atol2, atol3, rtol, fast = true) 
                        -> (Q::FDFilter, R::FDFilterIF, info)

Solve the exact fault detection and isolation problem (EFDIP) for a given synthesis model sysf with additive faults and a given binary structure matrix SFDI with nb rows (specifications). The computed stable and proper filter objects Q and R contain the fault detection and isolation filter, representing the solution of the EFDIP, and its internal form, respectively.

The returned named tuple info, with the components info.tcond, info.degs and info.HDesign, contains additional synthesis related information (see below).

The continuous- or discrete-time system sysf.sys is in a standard or descriptor state-space form sysf.sys = (A-λE,B,C,D), which corresponds to the input-output form 

   y = Gu(λ)*u + Gd(λ)*d + Gf(λ)*f + Gw(λ)*w + Ga(λ)*aux,

with the Laplace- or Z-transformed plant outputs y, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Gu(λ), Gd(λ), Gf(λ), Gw(λ), and Ga(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysf.controls, sysf.disturbances, sysf.faults, sysf.noise and sysf.aux, respectively.

The fault detection and isolation filter object Q, contains in Q.sys the resulting bank of nb filters. The i-th filter Q.sys[i] is in a standard state-space form and generates r_i, the i-th component (scalar or vector) of the overall residual vector r := [r_1; r_2; ...; r_nb]. The corresponding input-output (implementation) form of the i-th filter is

        r_i = Qyi(λ)*y + Qui(λ)*u   ,

where Qyi(λ) and Qui(λ) are the transfer function matrices from the output and control inputs to the i-th residual component. The indices of output and control inputs are contained in the integer vectors Q.outputs and Q.controls, respectively.

The fault detection and isolation filter in internal form object R, contains R.sys, the resulting bank of nb internal form of the filters. The i-th filter R.sys[i] is in a standard state-space form, which generates the residual signal r_i, and corresponds to the input-output form

   r_i = Rui(λ)*u + Rdi(λ)*d + Rfi(λ)*f + Rwi(λ)*w + Rai(λ)*aux ,

where 

   | Rui(λ) Rdi(λ) Rfi(λ) Rwi(λ) Rai(λ) | := |Qyi(λ) Qui(λ)]*| Gu(λ) Gd(λ) Gf(λ) Gw(λ) Ga(λ) |. 
-                                                             |   I     0     0     0     0   |

The solution of the EFDIP ensures that for the i-th filter, Rui(λ) = 0, Rdi(λ) = 0, and Rfi(λ) has its j-th column nonzero if the (i,j)-th element of SFDI is nonzero. The indices of the inputs u, d, f, w and aux of the resulting filter R.sys are contained in the integer vectors R.controls (void), R.disturbances (void), R.faults, R.noise and R.aux, respectively.

The resulting component filters Q.sys[i] and R.sys[i] have observable state-space realizations (AQi,BQi,CQi,DQi) and (AQi,BRi,CQi,DRi), respectively, and thus share the observable pairs (AQi,CQi).

Various user options can be specified via keyword arguments as follows:

If minimal = true (default), least order filter synthesis is performed to determine each of the component filters Q.sys[i] and R.sys[i] for i = 1, ...,nb, while with minimal = false full order synthesis is performed.

If HDesign = H, then H is an nb-dimensional array of full row rank or empty design matrices H = [H_1, ..., H_nb], where H_i is the design matrix employed for the synthesis of the i-th component filter (default: HDesign = missing)

rdim = q specifies the vector q, whose i-th component q[i] specifies the number of residual outputs for the i-th component filters Q.sys[i] and R.sys[i]. If q is a scalar, then a vector rdim with all components equal to q is assumed. The default value of q[i] is chosen as follows: if HDesign = missing or H_i is empty then q[i] = 1, if minimal = true, or q[i] is the number of the nullspace basis vectors used for the synthesis of Q.sys[i] and R.sys[i], if minimal = false; if H_i specifies a full row rank design matrix, then q[i] is the row dimension of H_i.

FDfreq = freq specifies a vector of real frequency values or a scalar real frequency value for strong detectability checks (default: FDfreq = missing).

If nullspace = true (default), a minimal proper nullspace basis is used at the initial reduction step, if separate = false, or at all synthesis steps, if separate = true. If nullspace = false, a full-order observer based nullspace basis is used at the initial reduction step, if separate = false, or at all synthesis steps, if separate = true. This option can only be used for a proper system without disturbance inputs.

If simple = true, simple proper nullspace bases are emplyed for synthesis. The orders of the basis vectors employed for the synthesis of i-th filter are provided in info.deg[i]. If simple = false (default), then no simple bases are computed.

If separate = false (default), a two-step synthesis procedure is employed, where a minimal proper nullspace basis is used at the initial reduction step. If separate = true, the filter components are separately determined by solving appropriately formulated fault detection problems.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

FDtol = tol1 specifies the threshold tol1 for fault detectability checks (default: tol1 = 0.0001).

FDGainTol = tol2 specifies the threshold tol2 for strong fault detectability checks (default: tol2 = 0.01).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, HDesign), where:

info.tcond is an nb-dimensional vector, whose i-th component is the maximum of the condition numbers of the employed non-orthogonal transformation matrices employed for the synthesis of the i-th filter component; a warning is issued if any info.tcond[i] >= tcmax;

info.degs is an nb-dimensional vector, whose i-th component is an integer vector containing the degrees of the basis vectors of the employed simple nullspace basis for the synthesis of the i-th filter component, if simple = true, and the degrees of the basis vectors of an equivalent polynomial nullspace basis, ifsimple = false`;

info.HDesign is an nb-dimensional vector, whose i-th component is the design matrix H_i employed for the synthesis of the i-th fault detection filter.

Method: The Procedure EFDI from [1] is implemented to solve the exact fault detection and isolation problem. This procedure relies on the nullspace-based synthesis method proposed in [2]. For more details on the least order synthesis of fault detection filters see [3].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.4.

[2] A. Varga, On designing least order residual generators for fault detection and isolation. 16th International Conference on Control Systems and Computer Science, Bucharest, Romania, 2007.

[3] A. Varga, On computing least order fault detectors using rational nullspace bases. IFAC SAFEPROCESS'03 Symposium, Washington DC, USA, 2003.

source
FaultDetectionTools.afdsyn — Function
afdsyn(sysf::FDIModel; rdim, nullspace = true, simple = false, minimal = true, exact = false, 
+                                                             |   I     0     0     0     0   |

The solution of the EFDIP ensures that for the i-th filter, Rui(λ) = 0, Rdi(λ) = 0, and Rfi(λ) has its j-th column nonzero if the (i,j)-th element of SFDI is nonzero. The indices of the inputs u, d, f, w and aux of the resulting filter R.sys are contained in the integer vectors R.controls (void), R.disturbances (void), R.faults, R.noise and R.aux, respectively.

The resulting component filters Q.sys[i] and R.sys[i] have observable state-space realizations (AQi,BQi,CQi,DQi) and (AQi,BRi,CQi,DRi), respectively, and thus share the observable pairs (AQi,CQi).

Various user options can be specified via keyword arguments as follows:

If minimal = true (default), least order filter synthesis is performed to determine each of the component filters Q.sys[i] and R.sys[i] for i = 1, ...,nb, while with minimal = false full order synthesis is performed.

If HDesign = H, then H is an nb-dimensional array of full row rank or empty design matrices H = [H_1, ..., H_nb], where H_i is the design matrix employed for the synthesis of the i-th component filter (default: HDesign = missing)

rdim = q specifies the vector q, whose i-th component q[i] specifies the number of residual outputs for the i-th component filters Q.sys[i] and R.sys[i]. If q is a scalar, then a vector rdim with all components equal to q is assumed. The default value of q[i] is chosen as follows: if HDesign = missing or H_i is empty then q[i] = 1, if minimal = true, or q[i] is the number of the nullspace basis vectors used for the synthesis of Q.sys[i] and R.sys[i], if minimal = false; if H_i specifies a full row rank design matrix, then q[i] is the row dimension of H_i.

FDfreq = freq specifies a vector of real frequency values or a scalar real frequency value for strong detectability checks (default: FDfreq = missing).

If nullspace = true (default), a minimal proper nullspace basis is used at the initial reduction step, if separate = false, or at all synthesis steps, if separate = true. If nullspace = false, a full-order observer based nullspace basis is used at the initial reduction step, if separate = false, or at all synthesis steps, if separate = true. This option can only be used for a proper system without disturbance inputs.

If simple = true, simple proper nullspace bases are emplyed for synthesis. The orders of the basis vectors employed for the synthesis of i-th filter are provided in info.deg[i]. If simple = false (default), then no simple bases are computed.

If separate = false (default), a two-step synthesis procedure is employed, where a minimal proper nullspace basis is used at the initial reduction step. If separate = true, the filter components are separately determined by solving appropriately formulated fault detection problems.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

FDtol = tol1 specifies the threshold tol1 for fault detectability checks (default: tol1 = 0.0001).

FDGainTol = tol2 specifies the threshold tol2 for strong fault detectability checks (default: tol2 = 0.01).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, HDesign), where:

info.tcond is an nb-dimensional vector, whose i-th component is the maximum of the condition numbers of the employed non-orthogonal transformation matrices employed for the synthesis of the i-th filter component; a warning is issued if any info.tcond[i] >= tcmax;

info.degs is an nb-dimensional vector, whose i-th component is an integer vector containing the degrees of the basis vectors of the employed simple nullspace basis for the synthesis of the i-th filter component, if simple = true, and the degrees of the basis vectors of an equivalent polynomial nullspace basis, ifsimple = false`;

info.HDesign is an nb-dimensional vector, whose i-th component is the design matrix H_i employed for the synthesis of the i-th fault detection filter.

Method: The Procedure EFDI from [1] is implemented to solve the exact fault detection and isolation problem. This procedure relies on the nullspace-based synthesis method proposed in [2]. For more details on the least order synthesis of fault detection filters see [3].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.4.

[2] A. Varga, On designing least order residual generators for fault detection and isolation. 16th International Conference on Control Systems and Computer Science, Bucharest, Romania, 2007.

[3] A. Varga, On computing least order fault detectors using rational nullspace bases. IFAC SAFEPROCESS'03 Symposium, Washington DC, USA, 2003.

source
FaultDetectionTools.afdsyn — Function
afdsyn(sysf::FDIModel; rdim, nullspace = true, simple = false, minimal = true, exact = false, 
                        gamma = 1, epsreg = 0.1, sdegzer, nonstd = 1, freq, sdeg, smarg, poles, 
                        HDesign, HDesign2, scale2, FDtol, FDGainTol, FDfreq, 
                        tcond, offset, atol, atol1, atol2, atol3, rtol, fast = true) 
@@ -25,11 +25,11 @@
             stabilization parameter `δ`;
   job = 5 – use the Wiener-Hopf type co-outer-co-inner factorization with
             the regularization of the non-minimum phase factor using the
-            regularization parameter `ϵ`.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, degs2, S, S2, HDesign, HDesign2, freq, gap), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G1(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G1(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal. This information has been used in the case minimal = true to determine the least order of components Q1(λ) and R1(λ) in (1).

info.degs2 is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G2(λ) := [ Gu(λ) Gd(λ) Gw(λ); I 0 0] (also the left Kronecker indices of G2(λ)), if the state-space realization of [Gu(λ) Gd(λ) Gw(λ)] is minimal. This information has been used in the case minimal = true to determine the least order of components Q2(λ) and R2(λ) in (1).

info.S is the binary structure matrix of the reduced system corresponding to the computed left nullspace basis of G1(λ) := [ Gu(λ) Gd(λ); I 0];

info.S2 is the binary structure matrix of the reduced system corresponding to the computed left nullspace basis of G2(λ) := [ Gu(λ) Gd(λ) Gw(λ); I 0 0];

info.HDesign is the design matrix H1 employed for the synthesis of the components Q1(λ) and R1(λ) in (1) of the fault detection filter;

info.HDesign2 is the design matrix H2 employed for the synthesis of the components Q2(λ) and R2(λ) in (1) of the fault detection filter;

info.freq is the frequency value employed to check the full row rank admissibility condition;

info.gap is the achieved gap ∥Rf(λ)∥∞−/∥Rw(λ)∥∞, where the H−minus index is computed over the whole frequency range, if FDfreq = missing, or over the frequency values contained in freq if FDfreq = freq.

Method: An extension of the Procedure AFD from [1] is implemented to solve the approximate fault detection problem (see also [2] and Remark 5.10 of [1]). The employed regularization approach, based on the modified co-outer-co-inner factorization, is discussed in [3], see also Remark 5.8 of [1]. For the details of the implemented method, see the documentation of the afdsyn function in [4].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.3.

[2] A. Varga, General computational approach for optimal fault detection. Proc. IFAC Symposium SAFEPROCESS, Barcelona, Spain, pp. 107–112, 2009.

[3] K. Glover and A. Varga, On solving non-standard H-/H_2/inf fault detection problems. Proc. IEEE CDC, Orlando, FL, USA, pp. 891–896, 2011.

[4] A. Varga, Fault Detection and Isolation Tools (FDITOOLS) User's Guide, arXiv:1703.08480.

source
afdsyn(sysf::FDIModel, SFDI; rdim, nullspace = true, simple = false, minimal = true, exact = false, 
+            regularization parameter `ϵ`.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, degs2, S, S2, HDesign, HDesign2, freq, gap), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G1(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G1(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal. This information has been used in the case minimal = true to determine the least order of components Q1(λ) and R1(λ) in (1).

info.degs2 is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G2(λ) := [ Gu(λ) Gd(λ) Gw(λ); I 0 0] (also the left Kronecker indices of G2(λ)), if the state-space realization of [Gu(λ) Gd(λ) Gw(λ)] is minimal. This information has been used in the case minimal = true to determine the least order of components Q2(λ) and R2(λ) in (1).

info.S is the binary structure matrix of the reduced system corresponding to the computed left nullspace basis of G1(λ) := [ Gu(λ) Gd(λ); I 0];

info.S2 is the binary structure matrix of the reduced system corresponding to the computed left nullspace basis of G2(λ) := [ Gu(λ) Gd(λ) Gw(λ); I 0 0];

info.HDesign is the design matrix H1 employed for the synthesis of the components Q1(λ) and R1(λ) in (1) of the fault detection filter;

info.HDesign2 is the design matrix H2 employed for the synthesis of the components Q2(λ) and R2(λ) in (1) of the fault detection filter;

info.freq is the frequency value employed to check the full row rank admissibility condition;

info.gap is the achieved gap ∥Rf(λ)∥∞−/∥Rw(λ)∥∞, where the H−minus index is computed over the whole frequency range, if FDfreq = missing, or over the frequency values contained in freq if FDfreq = freq.

Method: An extension of the Procedure AFD from [1] is implemented to solve the approximate fault detection problem (see also [2] and Remark 5.10 of [1]). The employed regularization approach, based on the modified co-outer-co-inner factorization, is discussed in [3], see also Remark 5.8 of [1]. For the details of the implemented method, see the documentation of the afdsyn function in [4].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.3.

[2] A. Varga, General computational approach for optimal fault detection. Proc. IFAC Symposium SAFEPROCESS, Barcelona, Spain, pp. 107–112, 2009.

[3] K. Glover and A. Varga, On solving non-standard H-/H_2/inf fault detection problems. Proc. IEEE CDC, Orlando, FL, USA, pp. 891–896, 2011.

[4] A. Varga, Fault Detection and Isolation Tools (FDITOOLS) User's Guide, arXiv:1703.08480.

source
afdsyn(sysf::FDIModel, SFDI; rdim, nullspace = true, simple = false, minimal = true, exact = false, 
                        gamma = 1, epsreg = 0.1, sdegzer, nonstd = 1, freq, sdeg, smarg, poles, 
                        HDesign, HDesign2, scale2, FDtol, FDGainTol, FDfreq, 
                        tcond, offset, atol, atol1, atol2, atol3, rtol, fast = true)  
-                       -> (Q::FDFilter, R::FDFilterIF, info)

Solve the approximate fault detection and isolation problem (AFDIP) for a given synthesis model sysf with additive faults and a given binary structure vector SFDI. The computed stable and proper filter objects Q and R contain the fault detection filter, representing the solution of the AFDIP, and its internal form, respectively, and are determined such that the transfer function matrix of R.sys[:,faults] has its j-th column nonzero if SFDI[j] = 1. If the solution of a strong AFDIP is feasible, then the j-th column is zero if SFDI[j] = 0. If only a the solution of a weak AFDIP is feasible, then the j-th column may be nonzero if SFDI[j] = 0. For the description of the keyword parameters see the function afdsyn.

source
FaultDetectionTools.afdisyn — Function
afdisyn(sysf::FDIModel, SFDI; rdim, nullspace = true, simple = false, minimal = true, separate = false,
+                       -> (Q::FDFilter, R::FDFilterIF, info)

Solve the approximate fault detection and isolation problem (AFDIP) for a given synthesis model sysf with additive faults and a given binary structure vector SFDI. The computed stable and proper filter objects Q and R contain the fault detection filter, representing the solution of the AFDIP, and its internal form, respectively, and are determined such that the transfer function matrix of R.sys[:,faults] has its j-th column nonzero if SFDI[j] = 1. If the solution of a strong AFDIP is feasible, then the j-th column is zero if SFDI[j] = 0. If only a the solution of a weak AFDIP is feasible, then the j-th column may be nonzero if SFDI[j] = 0. For the description of the keyword parameters see the function afdsyn.

source
FaultDetectionTools.afdisyn — Function
afdisyn(sysf::FDIModel, SFDI; rdim, nullspace = true, simple = false, minimal = true, separate = false,
                        gamma = 1, epsreg = 0.1, sdegzer, nonstd = 1, freq, sdeg, smarg, poles, 
                        HDesign, HDesign2, scale2, FDtol, FDGainTol, FDfreq, 
                        tcond, offset, atol, atol1, atol2, atol3, rtol, fast = true) 
@@ -44,30 +44,30 @@
             stabilization parameter `δ`;
   job = 5 – use the Wiener-Hopf type co-outer-co-inner factorization with
             the regularization of the non-minimum phase factor using the
-            regularization parameter `ϵ`.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, HDesign, HDesign2, freq, gap), where:

info.tcond is an nb-dimensional vector, whose i-th component is the maximum of the condition numbers of the employed non-orthogonal transformation matrices employed for the synthesis of the i-th filter component; a warning is issued if any info.tcond[i] >= tcmax;

info.HDesign = H1 is an nb-dimensional vector of design matrices, whose i-th component H1[i] is the design matrix to be employed for the synthesis of the components Q1i(λ) and R1i(λ) in (1) of the i-th fault detection filter.

info.HDesign2 = H2 is an nb-dimensional vector of design matrices, whose i-th component H2[i] is the design matrix to be employed for the synthesis of the components Q2i(λ) and R2i(λ) in (1) of the i-th fault detection filter.

info.freq is the frequency value employed to check the full row rank admissibility condition.

info.gap is an nb-dimensional vector, whose i-th component is the achieved gap for the synthesis of the i-th filter component.

Method: The Procedure AFDI from [1] is implemented to solve the approximate fault detection and isolation problem. For implementation details, see [2].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.5.

[2] A. Varga, Fault Detection and Isolation Tools (FDITOOLS) User's Guide, arXiv:1703.08480.

source
FaultDetectionTools.emmsyn — Function
emmsyn(sysf::FDIModel, sysr::FDFilterIF; nullspace = true, simple = false, minimal = true, regmin = true, normalize = "gain", 
+            regularization parameter `ϵ`.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, HDesign, HDesign2, freq, gap), where:

info.tcond is an nb-dimensional vector, whose i-th component is the maximum of the condition numbers of the employed non-orthogonal transformation matrices employed for the synthesis of the i-th filter component; a warning is issued if any info.tcond[i] >= tcmax;

info.HDesign = H1 is an nb-dimensional vector of design matrices, whose i-th component H1[i] is the design matrix to be employed for the synthesis of the components Q1i(λ) and R1i(λ) in (1) of the i-th fault detection filter.

info.HDesign2 = H2 is an nb-dimensional vector of design matrices, whose i-th component H2[i] is the design matrix to be employed for the synthesis of the components Q2i(λ) and R2i(λ) in (1) of the i-th fault detection filter.

info.freq is the frequency value employed to check the full row rank admissibility condition.

info.gap is an nb-dimensional vector, whose i-th component is the achieved gap for the synthesis of the i-th filter component.

Method: The Procedure AFDI from [1] is implemented to solve the approximate fault detection and isolation problem. For implementation details, see [2].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.5.

[2] A. Varga, Fault Detection and Isolation Tools (FDITOOLS) User's Guide, arXiv:1703.08480.

source
FaultDetectionTools.emmsyn — Function
emmsyn(sysf::FDIModel, sysr::FDFilterIF; nullspace = true, simple = false, minimal = true, regmin = true, normalize = "gain", 
                        sdeg, smarg, poles, freq, HDesign, tcond, offset, 
                        atol, atol1, atol2, atol3, rtol, fast = true) 
                        -> (Q::FDFilter, R::FDFilterIF, info)

Solve the exact model-matching problem (EMMP) for a given synthesis model sysf::FDIModel with additive faults and a given stable reference filter sysr::FDFilterIF. The computed stable and proper filter objects Q and R contain the fault detection filter, representing the solution of the EMMP, and its internal form, respectively.

The returned named tuple info, with the components info.tcond, info.degs, info.M, info.freq and info.HDesign, contains additional synthesis related information (see below).

The continuous- or discrete-time system sysf.sys is in a standard or descriptor state-space form sysf.sys = (A-λE,B,C,D), which corresponds to the input-output form 

   y = Gu(λ)*u + Gd(λ)*d + Gf(λ)*f + Gw(λ)*w + Ga(λ)*aux,

with the Laplace- or Z-transformed plant outputs y, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Gu(λ), Gd(λ), Gf(λ), Gw(λ), and Ga(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysf.controls, sysf.disturbances, sysf.faults, sysf.noise and sysf.aux, respectively.

The continuous- or discrete-time reference filter sysr.sys is in a standard or descriptor state-space form sysr.sys = (Ar-λEr,Br,Cr,Dr), which corresponds to the input-output form 

   yr = Mru(λ)*u + Mrd(λ)*d + Mrf(λ)*f + Mrw(λ)*w + Mra(λ)*aux,

with the Laplace- or Z-transformed reference filter outputs yr, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Mru(λ), Mrd(λ), Mrf(λ), Mrw(λ), and Mra(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysr.controls, sysr.disturbances, sysr.faults, sysr.noise and sysr.aux, respectively. If any of the above vectors is void, then the corresponding transfer function matrix is considered null.

The fault detection filter object Q, contains in Q.sys the resulting filter in a standard state-space form, which generates the residual signal r. The corresponding input-output (implementation) form is

        r = Qy(λ)*y + Qu(λ)*u

where Qy(λ) and Qu(λ) are the transfer function matrices from the output and control inputs to the residual. The indices of output and control inputs are contained in the integer vectors Q.outputs and Q.controls, respectively.

The fault detection filter internal form object R, contains R.sys, the resulting internal form of the filter in a standard state-space form, which generates the residual signal r, and corresponds to the input-output form

   r = Ru(λ)*u + Rd(λ)*d + Rf(λ)*f + Rw(λ)*w + Ra(λ)*aux ,

where 

   | Ru(λ) Rd(λ) Rf(λ) Rw(λ) Ra(λ) | = |Qy(λ) Qu(λ)|*| Gu(λ) Gd(λ) Gf(λ) Gw(λ) Ga(λ) |. 
                                                      |  I     0     0     0     0    |

The solution of the standard EMMP is computed if sysr.noise and sysr.aux are void and ensures that Ru(λ) = M(λ)*Mru(λ), Rd(λ) = M(λ)*Mrd(λ) and Rf(λ) = M(λ)*Mrf(λ), where M(λ) is the transfer function matrix of a stable, diagonal and invertible updating filter returned in info.M. This filter is determined to guarantee the stability of resulting filters Q and R. If sysr.noise and sysr.aux are not both void, then the extended EMMP is solved which additionally ensures Rw(λ) = M(λ)*Mrw(λ) and Ra(λ) = M(λ)*Mra(λ). The indices of the inputs u, d, f, w and aux of the resulting filter R.sys are contained in the integer vectors R.controls, R.disturbances, R.faults, R.noise and R.aux, respectively.

Various user options can be specified via keyword arguments as follows:

If minimal = true (default), a least order filter synthesis is performed, while with minimal = false no least order synthesis is performed.

If regmin = true (default), the regularization (see [1]) is performed for the case when sysr.controls and sysr.disturbances are void with the selection of a least order left annihilator Nl(λ) such that Nl(λ)*[Gu(λ) Gd(λ); I 0 ]. If regmin = false, the regularization is performed by choosing Nl(λ) a minimal left nullspace basis of G(λ) = [Gu(λ) Gd(λ); I 0 ].

If HDesign = H is a full row rank design matrix, then H*Nl(λ) is used instead Nl(λ) (default: HDesign = missing).

An initial reduction step is performed using the nullspace-based approach (see [1]) if sysr.controls, sysr.disturbances, sysr.noise and sysr.aux are void and minimal = false. In this case, if nullspace = true (default), a minimal proper nullspace basis is used at the initial reduction step, while, if nullspace = false, a full-order observer based nullspace basis is used at the initial reduction step. This later option can only be used for a proper system without disturbance inputs. The nullspace option is ignored if any of sysr.controls, sysr.disturbances, sysr.noise or sysr.aux is non-void or if minimal = true

If simple = true, a simple proper nullspace basis Nl(λ) is emplyed as left annihilator for synthesis. The orders of the basis vectors are provided in info.deg. If simple = false (default), then a minimal proper nullspace basis is computed.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

freq = val specifies the value of a test frequency to be employed to check the full column rank (i.e., left-invertibility) solvability condition (default: randomly generated in the interval (0,1)). The employed value of freq is returned in info.freq.

normalize = job specifies the option for the normalization of the diagonal elements of the updating matrix M(λ) as follows:

  job = "gain"    – scale with the gains of the zero-pole-gain representation (default);
   job = "dcgain"  – scale with the DC-gains;
-  job = "infnorm" – scale with the values of infinity-norms.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, M, freq, HDesign), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.M is the employed stable and invertible updating filter used to solve the EMMP, with a diagonal transfer function matrix M(λ);

info.freq is the employed frequency used to check left invertibility (set to missing if no frequency-based left invertibility check was performed)

info.HDesign is the design matrix H employed for the synthesis of the fault detection filter Q; H = missing if no design matrix was involved.

Method: The synthesis Procedures EMM and EMMS from [1] are implemented. Procedure EMM relies on the model-matching synthesis method proposed in [2], while Procedure EMMS uses the inversion-based method proposed in [3]. Procedure EMM is generally employed, unless a strong exact fault detection and isolation problem (strong EFDIP) is solved, in which case Procedure EMMS is used.

The strong EFDIP corresponds to the choice of the reference filter sysr such that Mru(λ) = 0, Mrd(λ) = 0, Mrf(λ) is invertible, Mrw(λ) = 0 and Mra(λ) = 0. In this case, only the indices of fault inputs sysr.faults must be specified and the indices of the rest of inputs must be void. The solution of a fault estimation problem can be targeted by choosing Mrf(λ) = I and checking that the resulting info.M = I.

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.6.

[2] A. Varga, New computational approach for the design of fault detection and isolation filters. In M. Voicu (Ed.), "Advances in Automatic Control", vol. 754 of The Kluwer International Series in Engineering and Computer Science, Kluwer Academic Publishers, pp. 367-381, 2003.

[3] A. Varga. New computational paradigms in solving fault detection and isolation problems. Annual Reviews in Control, 37:25–42, 2013.

source
emmsyn(sysf::FDIModel, sysr::FDIFilterIF; nullspace = true, simple = false, minimal = true, regmin = true, normalize = "gain", 
+  job = "infnorm" – scale with the values of infinity-norms.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, M, freq, HDesign), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.M is the employed stable and invertible updating filter used to solve the EMMP, with a diagonal transfer function matrix M(λ);

info.freq is the employed frequency used to check left invertibility (set to missing if no frequency-based left invertibility check was performed)

info.HDesign is the design matrix H employed for the synthesis of the fault detection filter Q; H = missing if no design matrix was involved.

Method: The synthesis Procedures EMM and EMMS from [1] are implemented. Procedure EMM relies on the model-matching synthesis method proposed in [2], while Procedure EMMS uses the inversion-based method proposed in [3]. Procedure EMM is generally employed, unless a strong exact fault detection and isolation problem (strong EFDIP) is solved, in which case Procedure EMMS is used.

The strong EFDIP corresponds to the choice of the reference filter sysr such that Mru(λ) = 0, Mrd(λ) = 0, Mrf(λ) is invertible, Mrw(λ) = 0 and Mra(λ) = 0. In this case, only the indices of fault inputs sysr.faults must be specified and the indices of the rest of inputs must be void. The solution of a fault estimation problem can be targeted by choosing Mrf(λ) = I and checking that the resulting info.M = I.

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.6.

[2] A. Varga, New computational approach for the design of fault detection and isolation filters. In M. Voicu (Ed.), "Advances in Automatic Control", vol. 754 of The Kluwer International Series in Engineering and Computer Science, Kluwer Academic Publishers, pp. 367-381, 2003.

[3] A. Varga. New computational paradigms in solving fault detection and isolation problems. Annual Reviews in Control, 37:25–42, 2013.

source
emmsyn(sysf::FDIModel, sysr::FDIFilterIF; nullspace = true, simple = false, minimal = true, regmin = true, normalize = "gain", 
                        sdeg, smarg, poles, freq, HDesign, tcond, offset, 
                        atol, atol1, atol2, atol3, rtol, fast = true) 
                        -> (Q::FDIFilter, R::FDIFilterIF, info)

Solve the exact model-matching problem (EMMP) for a given synthesis model sysf::FDIModel with additive faults and a given bank of stable reference filters sysr::FDIFilterIF. The computed stable and proper filter objects Q and R contain the bank of fault detection filters, representing the component-wise solution of the EMMP, and their internal forms, respectively.

The returned named tuple info, with the components info.tcond, info.degs, info.M, info.freq and info.HDesign, contains additional synthesis related information (see below).

The continuous- or discrete-time system sysf.sys is in a standard or descriptor state-space form sysf.sys = (A-λE,B,C,D), which corresponds to the input-output form 

   y = Gu(λ)*u + Gd(λ)*d + Gf(λ)*f + Gw(λ)*w + Ga(λ)*aux,

with the Laplace- or Z-transformed plant outputs y, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Gu(λ), Gd(λ), Gf(λ), Gw(λ), and Ga(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysf.controls, sysf.disturbances, sysf.faults, sysf.noise and sysf.aux, respectively.

The continuous- or discrete-time reference filters packed in sysr are in a standard or descriptor state-space form, where the i-th filter sysr.sys[i] = (Ari-λEri,Bri,Cri,Dri) corresponds to the input-output form 

   yri = Mrui(λ)*u + Mrdi(λ)*d + Mrfi(λ)*f + Mrwi(λ)*w + Mrai(λ)*aux,

with the Laplace- or Z-transformed reference filter outputs yri, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Mrui(λ), Mrdi(λ), Mrfi(λ), Mrwi(λ), and Mrai(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysr.controls, sysr.disturbances, sysr.faults, sysr.noise and sysr.aux, respectively. If any of the above vectors is void, then the corresponding transfer function matrices are considered null.

The fault detection and isolation filter object Q, contains in its i-th component Q.sys[i] the resulting filter in a standard state-space form, which generates the i-th component ri of the residual signal. The corresponding input-output (implementation) form is

        ri = Qyi(λ)*y + Qui(λ)*u

where Qyi(λ) and Qui(λ) are the transfer function matrices from the output and control inputs to the residual. The indices of output and control inputs are contained in the integer vectors Q.outputs and Q.controls, respectively.

The fault detection and isolation filter internal form object R, contains in its i-th component R.sys[i], the resulting internal form of the filter in a standard state-space form, which generates the i-th component ri of residual signal , and corresponds to the input-output form

   ri = Rui(λ)*u + Rdi(λ)*d + Rfi(λ)*f + Rwi(λ)*w + Rai(λ)*aux ,

where 

   | Rui(λ) Rdi(λ) Rfi(λ) Rwi(λ) Rai(λ) | = |Qyi(λ) Qui(λ)|*| Gu(λ) Gd(λ) Gf(λ) Gw(λ) Ga(λ) |. 
                                                             |  I     0     0     0     0    |

The component-wise solution of the standard EMMP is computed if sysr.noise and sysr.aux are void and ensures that Rui(λ) = Mi(λ)*Mrui(λ), Rdi(λ) = Mi(λ)*Mrdi(λ) and Rfi(λ) = Mi(λ)*Mrfi(λ), where Mi(λ) is the transfer function matrix of a stable, diagonal and invertible updating filter returned in the i-th component of the vector info.M. This filter is determined to guarantee the stability of the i-th components of resulting filters Q and R. If sysr.noise and sysr.aux are not both void, then the extended EMMP is component-wise solved which additionally ensures Rwi(λ) = Mi(λ)*Mrwi(λ) and Rai(λ) = Mi(λ)*Mrai(λ). The indices of the inputs u, d, f, w and aux of the resulting filter R.sys are contained in the integer vectors R.controls, R.disturbances, R.faults, R.noise and R.aux, respectively.

Various user options can be specified via keyword arguments as follows:

If minimal = true (default), least order filter syntheses are performed, while with minimal = false no least order synthesis are performed.

If regmin = true (default), the regularization (see [1]) is performed for the case when sysr.controls and sysr.disturbances are void with the selection of a least order left annihilator Nl(λ) such that Nl(λ)*[Gu(λ) Gd(λ); I 0 ]. If regmin = false, the regularization is performed by choosing Nl(λ) a minimal left nullspace basis of G(λ) = [Gu(λ) Gd(λ); I 0 ].

If HDesign = H is a vector of full row rank design matrices, then H[i]*Nl(λ) is used instead Nl(λ) for the synthesis of the i-th filter (default: HDesign = missing).

An initial reduction step is performed using the nullspace-based approach (see [1]) if sysr.controls, sysr.disturbances, sysr.noise and sysr.aux are void and minimal = false. In this case, if nullspace = true (default), a minimal proper nullspace basis is used at the initial reduction step, while, if nullspace = false, a full-order observer based nullspace basis is used at the initial reduction step. This later option can only be used for a proper system without disturbance inputs. The nullspace option is ignored if any of sysr.controls, sysr.disturbances, sysr.noise or sysr.aux is non-void or if minimal = true

If simple = true, a simple proper nullspace basis Nl(λ) is emplyed as left annihilator for synthesis. The orders of the basis vectors are provided in info.deg. If simple = false (default), then a minimal proper nullspace basis is computed.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

freq = val specifies the value of a test frequency to be employed to check the full column rank (i.e., left-invertibility) solvability condition (default: randomly generated in the interval (0,1)). The employed value of freq is returned in info.freq.

normalize = job specifies the option for the normalization of the diagonal elements of the updating matrices Mi(λ) as follows:

  job = "gain"    – scale with the gains of the zero-pole-gain representation (default);
   job = "dcgain"  – scale with the DC-gains;
-  job = "infnorm" – scale with the values of infinity-norms.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, M, freq, HDesign), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.M is a vector of descriptor systems, whose i-th system info.M[i] contains the employed stable and invertible updating filter used to solve the i-th EMMP, with a diagonal transfer function matrix Mi(λ);

info.freq is the employed frequency used to check left invertibility (set to missing if no frequency-based left invertibility check was performed)

info.HDesign is a vector of design matrices H, where H[i] is the design matrix employed for the synthesis of the i-th component of the fault detection filter Q; H[i] is an empty matrix if no design matrix was involved.

Method: The synthesis Procedures EMM and EMMS from [1] are used to determine the component filters. Procedure EMM relies on the model-matching synthesis method proposed in [2], while Procedure EMMS uses the inversion-based method proposed in [3]. Procedure EMM is generally employed, unless a strong exact fault detection and isolation problem (strong EFDIP) is solved, in which case Procedure EMMS is used.

The strong EFDIP corresponds to the choice of each component of the bank of reference filters sysr such that Mrui(λ) = 0, Mrdi(λ) = 0, Mrfi(λ) is invertible, Mrwi(λ) = 0 and Mrai(λ) = 0. In this case, only the indices of fault inputs sysr.faults must be specified and the indices of the rest of inputs must be void. The solution of a fault estimation problem can be targeted by choosing Mrfi(λ) = ei, where ei is the i-th row of the appropriate identity matrix, and checking that the resulting info.M = 1.

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.6.

[2] A. Varga, New computational approach for the design of fault detection and isolation filters. In M. Voicu (Ed.), "Advances in Automatic Control", vol. 754 of The Kluwer International Series in Engineering and Computer Science, Kluwer Academic Publishers, pp. 367-381, 2003.

[3] A. Varga. New computational paradigms in solving fault detection and isolation problems. Annual Reviews in Control, 37:25–42, 2013.

source
FaultDetectionTools.ammsyn — Function
ammsyn(sysf::FDIModel, sysr::FDFilterIF; nullspace = true, simple = false, mindeg = false, 
+  job = "infnorm" – scale with the values of infinity-norms.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, M, freq, HDesign), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.M is a vector of descriptor systems, whose i-th system info.M[i] contains the employed stable and invertible updating filter used to solve the i-th EMMP, with a diagonal transfer function matrix Mi(λ);

info.freq is the employed frequency used to check left invertibility (set to missing if no frequency-based left invertibility check was performed)

info.HDesign is a vector of design matrices H, where H[i] is the design matrix employed for the synthesis of the i-th component of the fault detection filter Q; H[i] is an empty matrix if no design matrix was involved.

Method: The synthesis Procedures EMM and EMMS from [1] are used to determine the component filters. Procedure EMM relies on the model-matching synthesis method proposed in [2], while Procedure EMMS uses the inversion-based method proposed in [3]. Procedure EMM is generally employed, unless a strong exact fault detection and isolation problem (strong EFDIP) is solved, in which case Procedure EMMS is used.

The strong EFDIP corresponds to the choice of each component of the bank of reference filters sysr such that Mrui(λ) = 0, Mrdi(λ) = 0, Mrfi(λ) is invertible, Mrwi(λ) = 0 and Mrai(λ) = 0. In this case, only the indices of fault inputs sysr.faults must be specified and the indices of the rest of inputs must be void. The solution of a fault estimation problem can be targeted by choosing Mrfi(λ) = ei, where ei is the i-th row of the appropriate identity matrix, and checking that the resulting info.M = 1.

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.6.

[2] A. Varga, New computational approach for the design of fault detection and isolation filters. In M. Voicu (Ed.), "Advances in Automatic Control", vol. 754 of The Kluwer International Series in Engineering and Computer Science, Kluwer Academic Publishers, pp. 367-381, 2003.

[3] A. Varga. New computational paradigms in solving fault detection and isolation problems. Annual Reviews in Control, 37:25–42, 2013.

source
FaultDetectionTools.ammsyn — Function
ammsyn(sysf::FDIModel, sysr::FDFilterIF; nullspace = true, simple = false, mindeg = false, 
                        regmin = true, normalize = "infnorm", H2syn = false, reltol = 1.e-4, 
                        sdeg, smarg, poles, freq, HDesign, tcond, offset, 
                        atol, atol1, atol2, atol3, rtol, fast = true) 
                        -> (Q::FDFilter, R::FDFilterIF, info)

Solve the approximate model-matching problem (AMMP) for a given synthesis model sysf::FDIModel with additive faults and a given stable reference filter sysr::FDFilterIF. The computed stable and proper filter objects Q and R contain the fault detection filter, representing a solution of the AMMP, and its internal form, respectively.

The returned named tuple info, with the components info.tcond, info.degs, info.M, info.freq, info.HDesign, info.nonstandard, info.gammaopt0, info.gammaopt and info.gammasub, contains additional synthesis related information (see below).

The continuous- or discrete-time system sysf.sys is in a standard or descriptor state-space form sysf.sys = (A-λE,B,C,D), which corresponds to the input-output form 

   y = Gu(λ)*u + Gd(λ)*d + Gf(λ)*f + Gw(λ)*w + Ga(λ)*aux,

with the Laplace- or Z-transformed plant outputs y, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Gu(λ), Gd(λ), Gf(λ), Gw(λ), and Ga(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysf.controls, sysf.disturbances, sysf.faults, sysf.noise and sysf.aux, respectively.

The continuous- or discrete-time reference filter sysr.sys is in a standard or descriptor state-space form sysr.sys = (Ar-λEr,Br,Cr,Dr), which corresponds to the input-output form 

   yr = Mru(λ)*u + Mrd(λ)*d + Mrf(λ)*f + Mrw(λ)*w + Mra(λ)*aux,

with the Laplace- or Z-transformed reference filter outputs yr, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Mru(λ), Mrd(λ), Mrf(λ), Mrw(λ), and Mra(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysr.controls, sysr.disturbances, sysr.faults, sysr.noise and sysr.aux, respectively. If any of the above vectors is void, then the corresponding transfer function matrix is considered null.

The fault detection filter object Q, contains in Q.sys the resulting filter in a standard state-space form, which generates the residual signal r. The corresponding input-output (implementation) form is

        r = Qy(λ)*y + Qu(λ)*u

where Qy(λ) and Qu(λ) are the transfer function matrices from the output and control inputs to the residual. The indices of output and control inputs are contained in the integer vectors Q.outputs and Q.controls, respectively.

Let define 

  Ge(λ) = | Gu(λ) Gd(λ) Gf(λ) Gw(λ) Ga(λ) |,  Mr(λ) = | Mru(λ) Mrd(λ) Mrf(λ) Mrw(λ) Mra(λ) | . 
           |  I     0     0     0     0    |

In the standard case, Ge(λ) has no zeros on the boundary of the stability domain, and the resulting stable filter Q(λ) := |Qy(λ) Qu(λ)| is Q(λ) = Q0(λ), where Q0(λ) is the optimal solution of the H∞- or H2-norm error minimization problem

gammaopt0 = ||Q0(λ)*Ge(λ)-M(λ)*Mr(λ)|| = min,         (1)

where M(λ) = M0(λ) is an updating factor chosen as follows: M0(λ) = I in the case of emplyoing the H∞ norm, while in the case of employing the H2 norm, M0(λ) = I for a discrete-time system or, for a continuous-time system, M0(λ) is determined a stable, diagonal, and invertible transfer function matrix, which ensures the existence of a finite H2-norm.

In the non-standard case, Ge(λ) has zeros on the boundary of the stability domain, and the resulting optimal filter Q0(λ), which solves the H∞- or H2-norm error minimization problem (1) is a possibly unstable or improper. A second updating factor M1(λ) is determined, with the same properties as M0(λ), which ensures that the computed stable and proper filter Q(λ) := M1(λ)*Q0(λ) represents a suboptimal solution of an updated H∞- or H2-norm error minimization problem, for which the achieved suboptimal model-matching performance is

gammasub = ||Q(λ)*Ge(λ)-M(λ)*Mr(λ)|| ,            (2)

where M(λ) := M1(λ)*M0(λ). The optimal solution Qt(λ) of the updated H∞- or H2-norm error minimization problem 

gammaopt = ||Qt(λ)*Ge(λ)-M(λ)*Mr(λ)|| = min ,     (3)

is still possibly unstable or improper. The values of gammaopt0, gammaopt and gammasub are returned in info.gammaopt0, info.gammaopt and info.gammasub, respectively.

The fault detection filter internal form object R, contains R.sys, the resulting internal form of the filter in a standard state-space form, which generates the residual signal r, and corresponds to the input-output form

   r = Ru(λ)*u + Rd(λ)*d + Rf(λ)*f + Rw(λ)*w + Ra(λ)*aux ,

where 

   | Ru(λ) Rd(λ) Rf(λ) Rw(λ) Ra(λ) | = Q(λ)*Ge(λ).

The indices of the inputs u, d, f, w and aux of the resulting filter R.sys are contained in the integer vectors R.controls, R.disturbances, R.faults, R.noise and R.aux, respectively. The state-space realization of the resulting M(λ) is returned in info.M.

Various user options can be specified via keyword arguments as follows:

If H2syn = false (default), a H∞-norm based synthesis is performed, while if H2syn = true, a H2-norm based synthesis is performed.

reltol = tol specifies the relative tolerance tol for the desired accuracy of γ-iteration (default: tol = 1.e-4).

If mindeg = true, a least order filter synthesis is performed, if possible, while with minimal = false (default) no least order synthesis is performed.

If regmin = true (default), the regularization (see [1]) is performed for the case when sysr.controls and/or sysr.disturbances are void with the selection of a least order left annihilator Nl(λ) of G(λ) = [Gu(λ) Gd(λ); I 0 ]. If regmin = false, the regularization is performed by choosing a left annihilator Nl(λ) as a minimal left nullspace basis of G(λ).

If HDesign = H is a full row rank design matrix, then H*Nl(λ) is used as left annihilator instead Nl(λ) (default: HDesign = missing).

If nullspace = true (default) and sysr.controls and/or sysr.disturbances are void, a minimal proper nullspace basis is used at the initial reduction step. If nullspace = false and sysr.controls and/or sysr.disturbances are void, a full-order observer based nullspace basis is used at the initial reduction step. This option can only be used for a proper system without disturbance inputs. The nullspace option is ignored if both sysr.controls and sysr.disturbances are non-void.

If simple = true, a simple proper nullspace basis is emplyed as left annihilator for synthesis. The orders of the basis vectors are provided in info.deg. If simple = false (default), then a minimal proper nullspace basis is computed.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

freq = val specifies the value of a test frequency to be employed to check the full column rank (i.e., left-invertibility) solvability condition (default: randomly generated in the interval (0,1)). The employed value of freq is returned in info.freq.

normalize = job specifies the option for the normalization of the diagonal elements of the updating matrix M(λ) as follows:

  job = "gain"    – scale with the gains of the zero-pole-gain representation;
   job = "dcgain"  – scale with the DC-gains;
-  job = "infnorm" – scale with the values of infinity-norms (default).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, M, freq, HDesign, gammaopt0, gammaopt, gammasub, nonstandard), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.M is the employed stable and invertible updating filter used to solve the AMMP, with a stable, diagonal and invertible transfer function matrix M(λ);

info.freq is the employed frequency used to check left invertibility (set to missing if no frequency-based left invertibility check was performed)

info.HDesign is the design matrix H employed for the synthesis of the fault detection filter Q; H = missing if no design matrix was involved;

info.gammaopt0 is the optimal performance gammaopt0 for the original problem (1);

info.gammaopt is the optimal performance gammaopt for the updated problem (3);

info.gammasub is the suboptimal performance gammasub in (2);

info.nonstandard is set to true for a non-standard problem (i.e., Ge(λ) has zeros on the boundary of the stability domain), and set to false for a standard problem (i.e., Ge(λ) has no zeros on the boundary of the stability domain).

Method: The synthesis Procedure AMMS from [1] is implemented. The Procedure AMMS relies on the approximate model-matching synthesis method proposed in [2]. For more details on computational aspects see [3].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.6.

[2] A. Varga, Integrated computational algorithm for solving H_inf-optimal FDI problems. In Proc. of the IFAC World Congress, Milano, Italy, pp. 10187–10192, 2011.

[3] A. Varga. Descriptor system techniques in solving H_2/H-Inf-optimal fault detection and isolation problems". In L. T. Biegler, S. L. Campbell, and V. Mehrmann (Eds.), Control and Optimization with Differential-Algebraic Constraints, vol. 23 of Advances in Design and Control, pp. 105–125. SIAM, 2012.

source
ammsyn(sysf::FDIModel, sysr::FDIFilterIF; nullspace = true, simple = false, mindeg = false, 
+  job = "infnorm" – scale with the values of infinity-norms (default).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, M, freq, HDesign, gammaopt0, gammaopt, gammasub, nonstandard), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.M is the employed stable and invertible updating filter used to solve the AMMP, with a stable, diagonal and invertible transfer function matrix M(λ);

info.freq is the employed frequency used to check left invertibility (set to missing if no frequency-based left invertibility check was performed)

info.HDesign is the design matrix H employed for the synthesis of the fault detection filter Q; H = missing if no design matrix was involved;

info.gammaopt0 is the optimal performance gammaopt0 for the original problem (1);

info.gammaopt is the optimal performance gammaopt for the updated problem (3);

info.gammasub is the suboptimal performance gammasub in (2);

info.nonstandard is set to true for a non-standard problem (i.e., Ge(λ) has zeros on the boundary of the stability domain), and set to false for a standard problem (i.e., Ge(λ) has no zeros on the boundary of the stability domain).

Method: The synthesis Procedure AMMS from [1] is implemented. The Procedure AMMS relies on the approximate model-matching synthesis method proposed in [2]. For more details on computational aspects see [3].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.6.

[2] A. Varga, Integrated computational algorithm for solving H_inf-optimal FDI problems. In Proc. of the IFAC World Congress, Milano, Italy, pp. 10187–10192, 2011.

[3] A. Varga. Descriptor system techniques in solving H_2/H-Inf-optimal fault detection and isolation problems". In L. T. Biegler, S. L. Campbell, and V. Mehrmann (Eds.), Control and Optimization with Differential-Algebraic Constraints, vol. 23 of Advances in Design and Control, pp. 105–125. SIAM, 2012.

source
ammsyn(sysf::FDIModel, sysr::FDIFilterIF; nullspace = true, simple = false, mindeg = false, 
                        regmin = true, normalize = "infnorm", H2syn = false, reltol = 1.e-4, 
                        sdeg, smarg, poles, freq, HDesign, tcond, offset, 
                        atol, atol1, atol2, atol3, rtol, fast = true) 
                        -> (Q::FDFilter, R::FDFilterIF, info)

Solve the approximate model-matching problem (AMMP) for a given synthesis model sysf::FDIModel with additive faults and a given bank of stable reference filters sysr::FDIFilterIF. The computed stable and proper filter objects Q and R contain the bank of fault detection filters, representing the component-wise solution of the AMMP, and their internal forms, respectively.

The returned named tuple info, with the components info.tcond, info.degs, info.M, info.freq, info.HDesign, info.nonstandard, info.gammaopt0, info.gammaopt and info.gammasub, contains additional synthesis related information (see below).

The continuous- or discrete-time system sysf.sys is in a standard or descriptor state-space form sysf.sys = (A-λE,B,C,D), which corresponds to the input-output form 

   y = Gu(λ)*u + Gd(λ)*d + Gf(λ)*f + Gw(λ)*w + Ga(λ)*aux,

with the Laplace- or Z-transformed plant outputs y, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Gu(λ), Gd(λ), Gf(λ), Gw(λ), and Ga(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysf.controls, sysf.disturbances, sysf.faults, sysf.noise and sysf.aux, respectively.

The continuous- or discrete-time reference filters packed in sysr are in a standard or descriptor state-space form, where the i-th filter sysr.sys[i] = (Ari-λEri,Bri,Cri,Dri) corresponds to the input-output form 

   yri = Mrui(λ)*u + Mrdi(λ)*d + Mrfi(λ)*f + Mrwi(λ)*w + Mrai(λ)*aux,

with the Laplace- or Z-transformed reference filter outputs yri, control inputs u, disturbance inputs d, fault inputs f, noise inputs w and auxiliary inputs aux, and with Mrui(λ), Mrdi(λ), Mrfi(λ), Mrwi(λ), and Mrai(λ) the corresponding transfer-function matrices. The indices of control, disturbance, fault, noise and auxiliary inputs are contained in the associated integer vectors sysr.controls, sysr.disturbances, sysr.faults, sysr.noise and sysr.aux, respectively. If any of the above vectors is void, then the corresponding transfer function matrices are considered null.

The fault detection and isolation filter object Q, contains in its i-th component Q.sys[i] the resulting filter in a standard state-space form, which generates the i-th component ri of the residual signal. The corresponding input-output (implementation) form is

        ri = Qyi(λ)*y + Qui(λ)*u

where Qyi(λ) and Qui(λ) are the transfer function matrices from the output and control inputs to the residual. The indices of output and control inputs are contained in the integer vectors Q.outputs and Q.controls, respectively.

Let define 

  Ge(λ) = | Gu(λ) Gd(λ) Gf(λ) Gw(λ) Ga(λ) |,  Mri(λ) = | Mrui(λ) Mrdi(λ) Mrfi(λ) Mrwi(λ) Mrai(λ) | . 
           |  I     0     0     0     0    |

In the standard case, Ge(λ) has no zeros on the boundary of the stability domain, and each resulting component stable filter Qi(λ) := |Qyi(λ) Qui(λ)| is Qi(λ) = Q0i(λ), where Q0i(λ) is the optimal solution of the H∞- or H2-norm error minimization problem

gammaopt0i = ||Q0i(λ)*Ge(λ)-Mi(λ)*Mri(λ)|| = min,         (1)

where Mi(λ) = M0i(λ) is an updating factor chosen as follows: M0i(λ) = I in the case of emplyoing the H∞ norm, while in the case of employing the H2 norm, M0i(λ) = I for a discrete-time system or, for a continuous-time system, M0i(λ) is determined a stable, diagonal, and invertible transfer function matrix, which ensures the existence of a finite H2-norm.

In the non-standard case, Ge(λ) has zeros on the boundary of the stability domain, and each resulting optimal component filter Q0i(λ), which solves the H∞- or H2-norm error minimization problem (1) is a possibly unstable or improper. A second updating factor M1i(λ) is determined, with the same properties as M0i(λ), which ensures that the computed stable and proper filter Qi(λ) := M1i(λ)*Q0i(λ) represents a suboptimal solution of an updated H∞- or H2-norm error minimization problem, for which the achieved suboptimal model-matching performance is

gammasubi = ||Qi(λ)*Ge(λ)-Mi(λ)*Mri(λ)|| ,            (2)

where Mi(λ) := M1i(λ)*M0i(λ). The optimal solutions Qti(λ) of the updated H∞- or H2-norm error minimization problem 

gammaopti = ||Qti(λ)*Ge(λ)-Mi(λ)*Mri(λ)|| = min ,     (3)

is still possibly unstable or improper. The values of gammaopt0i, gammaopti and gammasubi are returned in the i-th components of the vectors info.gammaopt0, info.gammaopt and info.gammasub, respectively.

The fault detection and isolation filter internal form object R, contains in its i-th component R.sys[i], the resulting internal form of the filter in a standard state-space form, which generates the i-th component ri of residual signal , and corresponds to the input-output form

   ri = Rui(λ)*u + Rdi(λ)*d + Rfi(λ)*f + Rwi(λ)*w + Rai(λ)*aux ,

where 

   | Rui(λ) Rdi(λ) Rfi(λ) Rwi(λ) Rai(λ) | = Qi(λ)*Ge(λ).

The indices of the inputs u, d, f, w and aux of the resulting filter R.sys are contained in the integer vectors R.controls, R.disturbances, R.faults, R.noise and R.aux, respectively. The state-space realization of the resulting Mi(λ) is returned in the i-th component of the vector info.M.

Various user options can be specified via keyword arguments as follows:

If H2syn = false (default), a H∞-norm based synthesis is performed, while if H2syn = true, a H2-norm based synthesis is performed.

reltol = tol specifies the relative tolerance tol for the desired accuracy of γ-iteration (default: tol = 1.e-4).

If mindeg = true, least order filter syntheses are performed, if possible, while with minimal = false (default) no least order synthesis are performed.

If regmin = true (default), the regularization (see [1]) is performed for the case when sysr.controls and/or sysr.disturbances are void with the selection of a least order left annihilator Nl(λ) of G(λ) = [Gu(λ) Gd(λ); I 0 ]. If regmin = false, the regularization is performed by choosing a left annihilator Nl(λ) as a minimal left nullspace basis of G(λ).

If HDesign = H is a vector of full row rank design matrices, then H[i]*Nl(λ) is used as left annihilator instead Nl(λ) for the synthesis of the i-th filter (default: HDesign = missing).

If nullspace = true (default) and sysr.controls and/or sysr.disturbances are void, a minimal proper nullspace basis is used at the initial reduction step. If nullspace = false and sysr.controls and/or sysr.disturbances are void, a full-order observer based nullspace basis is used at the initial reduction step. This option can only be used for a proper system without disturbance inputs. The nullspace option is ignored if both sysr.controls and sysr.disturbances are non-void.

If simple = true, a simple proper nullspace basis is emplyed as left annihilator for synthesis. The orders of the basis vectors are provided in info.deg. If simple = false (default), then a minimal proper nullspace basis is computed.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

freq = val specifies the value of a test frequency to be employed to check the full column rank (i.e., left-invertibility) solvability condition (default: randomly generated in the interval (0,1)). The employed value of freq is returned in info.freq.

normalize = job specifies the option for the normalization of the diagonal elements of the updating matrices Mi(λ) as follows:

  job = "gain"    – scale with the gains of the zero-pole-gain representation;
   job = "dcgain"  – scale with the DC-gains;
-  job = "infnorm" – scale with the values of infinity-norms (default).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, M, freq, HDesign, gammaopt0, gammaopt, gammasub, nonstandard), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.M is a vector of descriptor systems, whose i-th system info.M[i] contains the employed stable and invertible updating filter used to solve the i-th AMMP, with a diagonal transfer function matrix Mi(λ);

info.freq is the employed frequency used to check left invertibility (set to missing if no frequency-based left invertibility check was performed)

info.HDesign is a vector of design matrices H, where H[i] is the design matrix employed for the synthesis of the i-th component of the fault detection filter Q; H[i] is an empty matrix if no design matrix was involved.

info.gammaopt0 is a vector whose i-th component is the optimal performance gammaopt0i for the i-th original problem (1);

info.gammaopt is a vector whose i-th component is the optimal performance gammaopti for the i-th updated problem (3);

info.gammasub is a vector whose i-th component is the suboptimal performance gammasubi in (2);

info.nonstandard is set to true for a non-standard problem (i.e., Ge(λ) has zeros on the boundary of the stability domain), and set to false for a standard problem (i.e., Ge(λ) has no zeros on the boundary of the stability domain).

Method: The synthesis Procedure AMMS from [1] is used to determine the component filters. The Procedure AMMS relies on the approximate model-matching synthesis method proposed in [2]. For more details on computational aspects see [3].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.6.

[2] A. Varga, Integrated computational algorithm for solving H_inf-optimal FDI problems. In Proc. of the IFAC World Congress, Milano, Italy, pp. 10187–10192, 2011.

[3] A. Varga. Descriptor system techniques in solving H_2/H-Inf-optimal fault detection and isolation problems". In L. T. Biegler, S. L. Campbell, and V. Mehrmann (Eds.), Control and Optimization with Differential-Algebraic Constraints, vol. 23 of Advances in Design and Control, pp. 105–125. SIAM, 2012.

source
+ job = "infnorm" – scale with the values of infinity-norms (default).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of A, B, C, D, the absolute tolerance for the nonzero elements of E, and the relative tolerance for the nonzero elements of A, B, C, D and E. The default relative tolerance is n*ϵ, where ϵ is the working machine epsilon and n is the order of the system sysf.sys. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, M, freq, HDesign, gammaopt0, gammaopt, gammasub, nonstandard), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an integer vector containing the increasingly ordered degrees of a left minimal polynomial nullspace basis of G(λ) := [ Gu(λ) Gd(λ); I 0] (also the left Kronecker indices of G(λ)), if the state-space realization of [Gu(λ) Gd(λ)] is minimal;

info.M is a vector of descriptor systems, whose i-th system info.M[i] contains the employed stable and invertible updating filter used to solve the i-th AMMP, with a diagonal transfer function matrix Mi(λ);

info.freq is the employed frequency used to check left invertibility (set to missing if no frequency-based left invertibility check was performed)

info.HDesign is a vector of design matrices H, where H[i] is the design matrix employed for the synthesis of the i-th component of the fault detection filter Q; H[i] is an empty matrix if no design matrix was involved.

info.gammaopt0 is a vector whose i-th component is the optimal performance gammaopt0i for the i-th original problem (1);

info.gammaopt is a vector whose i-th component is the optimal performance gammaopti for the i-th updated problem (3);

info.gammasub is a vector whose i-th component is the suboptimal performance gammasubi in (2);

info.nonstandard is set to true for a non-standard problem (i.e., Ge(λ) has zeros on the boundary of the stability domain), and set to false for a standard problem (i.e., Ge(λ) has no zeros on the boundary of the stability domain).

Method: The synthesis Procedure AMMS from [1] is used to determine the component filters. The Procedure AMMS relies on the approximate model-matching synthesis method proposed in [2]. For more details on computational aspects see [3].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.6.

[2] A. Varga, Integrated computational algorithm for solving H_inf-optimal FDI problems. In Proc. of the IFAC World Congress, Milano, Italy, pp. 10187–10192, 2011.

[3] A. Varga. Descriptor system techniques in solving H_2/H-Inf-optimal fault detection and isolation problems". In L. T. Biegler, S. L. Campbell, and V. Mehrmann (Eds.), Control and Optimization with Differential-Algebraic Constraints, vol. 23 of Advances in Design and Control, pp. 105–125. SIAM, 2012.

source diff --git a/dev/FDIutils.html b/dev/FDIutils.html index 89975ff..8324c0e 100644 --- a/dev/FDIutils.html +++ b/dev/FDIutils.html @@ -1,4 +1,4 @@ -FDI related utilities · FaultDetectionTools.jl
Edit on GitHub

FDI related utilities

  • fdhinfminus Evaluation of the H∞- index of the transfer function matrix of a descriptor system model.
  • fdhinfmax Evaluation of the maximum of column norm of the transfer function matrix of a descriptor system model.
  • fditspec_ Computation of the weak or strong structure matrix of a descriptor system model.
  • fdisspec_ Computation of the strong structure matrix of a descriptor system model.
  • fdiscond_ Computation of the column-gains sensitivity condition of the transfer function matrix of a descriptor system model.
FaultDetectionTools.fdhinfminus — Function
 fdhinfminus(sys,freq) -> (β, ind, fr)

Compute for a stable descriptor system sys = (A-λE,B,C,D) the H∞- index β of its transfer function matrix G(λ). If freq = missing (default), then β is the minimum H∞-norm of the columns of G, ind is the index of the minimum-norm column and fr is the frequency where the minimum H∞-norm of the columns is achieved. If freq is a real value or a real vector of frequency values, then β is the minimum of the 2-norms of the columns of the frequency responses of G evaluated for all values contained in freq, ind is the index of column for which the minimum is achieved and fr is the corresponding frequency.

source
FaultDetectionTools.fdhinfmax — Function
 fdhinfmax(sys,freq) -> (γ, ind, fr)

Compute for a descriptor system sys = (A-λE,B,C,D), γ - the maximum norm of the columns of its transfer function matrix G(λ). If freq = missing (default), then γ is the maximum H∞-norm of the columns of G, ind is the index of the maximum-norm column and fr is the frequency where the maximum H∞-norm of the columns is achieved. If freq is a real value or a real vector of frequency values, then γ is the maximum of the 2-norms of the columns of the frequency responses of G evaluated for all values contained in freq, ind is the index of column for which the maximum is achieved and fr is the corresponding frequency.

source
FaultDetectionTools.fditspec_ — Function
S = fditspec_(sysrf::DescriptorStateSpace; FDfreq = missing, block = false, poleshift = false, 
-             FDtol, FDStol, atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute the weak or strong binary structure matrix S of the transfer function matrix of a linear time-invariant system sysrf (typically representing the transfer channel from the fault inputs to residuals). sysrf has a descriptor system realization of the form sysrf = (Af-lambda*Ef,Bf,Cf,Df) with a q x mf transfer function matrix Rf(λ). For the description of keyword parameters see the documentation of fditspec.

source
FaultDetectionTools.fdisspec_ — Function
 fdisspec_(sysrf::DescriptorStateSpace, freq; block = false, stabilize = false, FDGainTol = 0.01, 
-                 atol, atol1, atol2, atol3, rtol, fast = true) -> (S, gains)

Compute the strong binary structure matrix S of the transfer function matrix of a linear time-invariant system sysrf (typically representing the transfer channel from the fault inputs to residuals). sysrf has a descriptor system realization of the form sysrf = (Af-lambda*Ef,Bf,Cf,Df) with a q x mf transfer function matrix Rf(λ). For the description of keyword parameters see the documentation of fdisspec.

source
FaultDetectionTools.fdiscond_ — Function
 fdiscond_(sysrf::DescriptorStateSpace, freq) -> (scond, β, γ)

Compute for a stable descriptor system sysrf = (A-λE,B,C,D) with the transfer function matrix Rf(λ), β - the H∞- index of Rf(λ), γ - the maximum of the columns norms of Rf(λ) and scond - the column-gains sensitivity condition evaluated as scond := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq.

source
+FDI related utilities · FaultDetectionTools.jl
Edit on GitHub

FDI related utilities

  • fdhinfminus Evaluation of the H∞- index of the transfer function matrix of a descriptor system model.
  • fdhinfmax Evaluation of the maximum of column norm of the transfer function matrix of a descriptor system model.
  • fditspec_ Computation of the weak or strong structure matrix of a descriptor system model.
  • fdisspec_ Computation of the strong structure matrix of a descriptor system model.
  • fdiscond_ Computation of the column-gains sensitivity condition of the transfer function matrix of a descriptor system model.
FaultDetectionTools.fdhinfminus — Function
 fdhinfminus(sys,freq) -> (β, ind, fr)

Compute for a stable descriptor system sys = (A-λE,B,C,D) the H∞- index β of its transfer function matrix G(λ). If freq = missing (default), then β is the minimum H∞-norm of the columns of G, ind is the index of the minimum-norm column and fr is the frequency where the minimum H∞-norm of the columns is achieved. If freq is a real value or a real vector of frequency values, then β is the minimum of the 2-norms of the columns of the frequency responses of G evaluated for all values contained in freq, ind is the index of column for which the minimum is achieved and fr is the corresponding frequency.

source
FaultDetectionTools.fdhinfmax — Function
 fdhinfmax(sys,freq) -> (γ, ind, fr)

Compute for a descriptor system sys = (A-λE,B,C,D), γ - the maximum norm of the columns of its transfer function matrix G(λ). If freq = missing (default), then γ is the maximum H∞-norm of the columns of G, ind is the index of the maximum-norm column and fr is the frequency where the maximum H∞-norm of the columns is achieved. If freq is a real value or a real vector of frequency values, then γ is the maximum of the 2-norms of the columns of the frequency responses of G evaluated for all values contained in freq, ind is the index of column for which the maximum is achieved and fr is the corresponding frequency.

source
FaultDetectionTools.fditspec_ — Function
S = fditspec_(sysrf::DescriptorStateSpace; FDfreq = missing, block = false, poleshift = false, 
+             FDtol, FDStol, atol = 0, atol1 = atol, atol2 = atol, rtol, fast = true)

Compute the weak or strong binary structure matrix S of the transfer function matrix of a linear time-invariant system sysrf (typically representing the transfer channel from the fault inputs to residuals). sysrf has a descriptor system realization of the form sysrf = (Af-lambda*Ef,Bf,Cf,Df) with a q x mf transfer function matrix Rf(λ). For the description of keyword parameters see the documentation of fditspec.

source
FaultDetectionTools.fdisspec_ — Function
 fdisspec_(sysrf::DescriptorStateSpace, freq; block = false, stabilize = false, FDGainTol = 0.01, 
+                 atol, atol1, atol2, atol3, rtol, fast = true) -> (S, gains)

Compute the strong binary structure matrix S of the transfer function matrix of a linear time-invariant system sysrf (typically representing the transfer channel from the fault inputs to residuals). sysrf has a descriptor system realization of the form sysrf = (Af-lambda*Ef,Bf,Cf,Df) with a q x mf transfer function matrix Rf(λ). For the description of keyword parameters see the documentation of fdisspec.

source
FaultDetectionTools.fdiscond_ — Function
 fdiscond_(sysrf::DescriptorStateSpace, freq) -> (scond, β, γ)

Compute for a stable descriptor system sysrf = (A-λE,B,C,D) with the transfer function matrix Rf(λ), β - the H∞- index of Rf(λ), γ - the maximum of the columns norms of Rf(λ) and scond - the column-gains sensitivity condition evaluated as scond := β/γ. If freq is a vector of real frequency values, then β and γ are evaluated over the frequencies contained in freq.

source
diff --git a/dev/MDObjects.html b/dev/MDObjects.html index 8e9edbe..825763a 100644 --- a/dev/MDObjects.html +++ b/dev/MDObjects.html @@ -1,3 +1,3 @@ -Building model detection related objects · FaultDetectionTools.jl
Edit on GitHub

Building model detection related objects

  • MDModel Model detection component synthesis model.
  • MDMModel Model detection multiple synthesis model.
  • mdmodset Setup of multiple synthesis models for solving model detection problems.
  • MDFilter Model detection filter object.
  • MDFilterIF Model detection filter internal form object.
  • mdIFeval Evaluation of the internal forms of model detection filters.
FaultDetectionTools.MDModel — Type
MDModel <: AbstractFDDObject

Type for component synthesis models employed to solve model detection problems.

If sysc::MDModel is a component synthesis model object, the underlying descriptor system model can be obtained via sysc.sys and the dimensions of the control, disturbance, noise and auxiliary vectors are contained in the integers sysm.mu, sysm.md, sysm.mw and sysm.ma, respectively.

source
FaultDetectionTools.MDModel — Method
MDModel(sys; mu, md, mw, ma) -> sysc::MDModel

Build for a linear time-invariant descriptor system sys = (A-λE,B,C,D) a component synthesis model object sysm::MDModel to be used in conjunction with the analysis and synthesis functions of model detection filters.

The resulting synthesis model object sysc contains the component model with partitioned inputs, sysc.sys = (A-λE,[Bu Bd Bw Bv],C,[Du Dd Dw Dv]), where Bu, Bd, Bw and Bv are formed from the successive columns of B and are the input matrices from the control inputs u, disturbance inputs d, noise inputs w and auxiliary inputs v, respectively, and Du, Dd, Dw and Dv are formed from the successive columns of D and are the feedthrough matrices from those inputs. The dimensions of control, disturbance, noise and auxiliary input vectors are contained in sysm.mu, sysm.md, sysm.mw and sysm.ma, respectively.

The information on the partition of the input components in control, disturbance, noise and auxiliary inputs can be specified using the following keyword arguments:

mu = nu specifies the dimension nu of the control input vector u (default: nu = 0)

md = nd specifies the dimension nd of the disturbance input vector d (default: nd = 0)

mw = nw specifies the dimension nw of the noise input vector w (default: nw = 0)

ma = na specifies the dimension na of the auxiliary input vector v (default: na = 0)

source
FaultDetectionTools.MDMModel — Type
MDMModel <: AbstractFDDObject

Type for multiple synthesis models employed to solve model detection problems.

If sysm::MDMModel is the multiple synthesis model object, the underlying vector of descriptor system models can be obtained via sysm.sys, the common dimension of the control vectors is contained in the integer sysm.mu, and the dimensions of the disturbance, noise and auxiliary input vectors for the i-th model sysm.sys[i] are contained in the i-th components of the integer vectors sysm.md, sysm.mw and sysm.ma, respectively.

source
FaultDetectionTools.MDMModel — Method
MDMModel(sys; mu, md, mw, ma) -> sysm::MDMModel

Build for a vector of linear time-invariant system models sys, with the i-th component model sys[i] = (Ai-λEi,Bi,Ci,Di), a multiple synthesis model object sysm::MDMModel to be used in conjunction with the analysis and synthesis functions of model detection filters.

The resulting multiple synthesis model object sysm contains the vector sysm.sys of component models with partitioned inputs, with the i-th model sysm.sys[i] = (Ai-λEi,[Bui Bdi Bwi Bvi],Ci,[Dui Ddi Dwi Dvi]), where Bui, Bdi, Bwi and Bvi are formed from the successive columns of Bi and are the input matrices from the control inputs u, disturbance inputs di, noise inputs wi and auxiliary inputs vi, respectively, and Dui, Ddi, Dwi and Dvi are formed from the successive columns of Di and are the feedthrough matrices from those inputs. The dimensions of control, disturbance, noise and auxiliary input vectors are contained in sysm.mu, sysm.md[i], sysm.mw[i] and sysm.ma[i], respectively.

If N is the number of component models, the information on the partition of the input components in control, disturbance, noise and auxiliary inputs can be specified using the following keyword arguments:

mu = nu specifies the dimension nu of control input vector u (default: nu = 0)

md = nd specifies the vector nd containing the N dimensions of disturbance input vectors, such that the i-th disturbance vector di has dimension nd[i] (default: nd = zeros(Int,N))

mw = nw specifies the vector nw containing the N dimensions of noise input vectors, such that the i-th noise vector wi has dimension nw[i] (default: nw = zeros(Int,N))

ma = na specifies the vector na containing the N dimensions of auxiliary input vectors, such that the i-th auxiliary vector vi has dimension na[i] (default: na = zeros(Int,N))

source
FaultDetectionTools.mdmodset — Function
mdmodset(sys; controls, c, disturbances, d, noise, n, aux) -> sysm::MDMModel

Build for a vector of linear time-invariant system models sys, with the i-th component model sys[i] = (Ai-λEi,Bi,Ci,Di), a multiple synthesis model object sysm::MDMModel to be used in conjunction with the analysis and synthesis functions of model detection filters.

The information on the partition of the input components in control, disturbance, noise and auxiliary inputs can be specified using the following keyword arguments:

controls = inpu or c = inpu specifies the indices inpu of the control inputs (default: void)

disturbances = inpd or d = inpd specifies the indices or a vector of indices inpd of the disturbance inputs (default: void)

noise = inpn or noise = inpn specifies the indices or a vector of indices inpn of the noise inputs (default: void)

aux = inpa specifies the indices or a vector of indices inpa of the auxiliary inputs (default: void)

The indices of inputs can be specified as integer vectors, integer scalars or integer UnitRanges. For disturbance, noise and auxiliary inputs, vectors of integer vectors or vectors of integer UnitRanges can be used to specify possibly different set of indices for each component model.

The resulting sysm contains the vector sysm.sys of partitioned systems, with the i-th model sysm.sys[i] = (Ai-λEi,[Bui Bdi Bwi Bvi],Ci,[Dui Ddi Dwi Dvi]), where Bui, Bdi, Bwi and Bvi are the input matrices from the control inputs u, disturbance inputs di, noise inputs wi and auxiliary inputs vi, respectively, and Dui, Ddi, Dwi and Dvi are the feedthrough matrices from those inputs. The dimensions of control, disturbance, noise and auxiliary input vectors are contained in sysm.mu, sysm.md[i], sysm.mw[i] and sysm.ma[i], respectively.

Method: If Gi(λ) is the p x mi transfer function matrix of sys[i], then the resulting component system sysm.sys[i] has an equivalent input output form [Gui(λ) Gdi(λ) Gwi(λ) Gvi(λ)], where the following relations define the component matrices: Gui(λ) = Gi(λ)*Su, Gdi(λ) = Gi(λ)*Sdi, Gwi(λ) = G(λ)*Swi, Gvi(λ) = Gi(λ)*Svi, with the selection matrices Su, Sdi, Swi and Svi formed from the columns of the mi-th order identity matrix (note that Su is the same for all component models).

source
mdmodset(sysc::Vector{<:MDModel}) -> sysm::MDMModel

Build for a vector of component synthesis models sysc, a multiple synthesis model object sysm::MDMModel to be used in conjunction with the analysis and synthesis functions of model detection filters.

source
FaultDetectionTools.MDFilter — Type
MDFilter <: AbstractFDDObject

Type for model detection filters resulted as solutions of model detection problems.

If filter::MDFilter is the model detection filter object, the underlying i-th descriptor system model can be obtained via filter.sys[i] and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in filter.ny and filter.mu, respectively.

source
FaultDetectionTools.MDFilterIF — Type
MDFilterIF <: AbstractFDDObject

Type for the internal form of model detection filters resulted as solutions of model detection problems.

If filter::MDFilterIF is the model detection filter internal form object, the underlying (i,j)-th descriptor system model can be obtained via filter.sys[i,j] and the corresponding dimensions of control, disturbance, fault, noise and auxiliary input vectors are contained in sysm.mu, sysm.md[j], sysm.mw[j] and sysm.ma[j], respectively.

source
FaultDetectionTools.mdIFeval — Function
mdIFeval(sysQ::MDFilter, sysm::MDMModel; minimal = false, atol, atol1 = atol, atol2 = atol, rtol, fast = true) -> sysR::MDFilterIF

Compute the internal form sysR of the model detection filter sysQ applied to the multiple synthesis model sysm. If the j-th component model sysm.sys[j] has the partitioned transfer function matrix Gj(λ) = [ Guj(λ) Gdj(λ) Gwj(λ) Gvj(λ) ] in accordance with the partitioned system inputs as controls, disturbances, noise and auxiliary inputs, respectively, and Qi(λ) = [ Qyi(λ) Qui(λ) ] is the partitioned transfer function matrix of the i-th filter sysQ.sys[i] in accordance with the partitioned filter inputs as outputs and controls, then the transfer function matrix Rij(λ) corresponding to the (i-th filter,j-th model) pair in the resulting internal form sysR.sys[i,j] is given by

 Rij(λ) = | Qyi(λ)  Qui(λ) | * | Guj(λ)  Gdj(λ) Gwj(λ) Gvj(λ) |
-                               |  I      0      0      0      |

Minimal descriptor realizations are computed if minimal = true and a (possibly) non-minimal realization is determined if minimal = false (default).

The minimal realization computation relies on pencil manipulation algorithms which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

If (Arij-λErij,Brij,Crij,Drij) is the full order descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
+Building model detection related objects · FaultDetectionTools.jl
Edit on GitHub

Building model detection related objects

  • MDModel Model detection component synthesis model.
  • MDMModel Model detection multiple synthesis model.
  • mdmodset Setup of multiple synthesis models for solving model detection problems.
  • MDFilter Model detection filter object.
  • MDFilterIF Model detection filter internal form object.
  • mdIFeval Evaluation of the internal forms of model detection filters.
FaultDetectionTools.MDModel — Type
MDModel <: AbstractFDDObject

Type for component synthesis models employed to solve model detection problems.

If sysc::MDModel is a component synthesis model object, the underlying descriptor system model can be obtained via sysc.sys and the dimensions of the control, disturbance, noise and auxiliary vectors are contained in the integers sysm.mu, sysm.md, sysm.mw and sysm.ma, respectively.

source
FaultDetectionTools.MDModel — Method
MDModel(sys; mu, md, mw, ma) -> sysc::MDModel

Build for a linear time-invariant descriptor system sys = (A-λE,B,C,D) a component synthesis model object sysm::MDModel to be used in conjunction with the analysis and synthesis functions of model detection filters.

The resulting synthesis model object sysc contains the component model with partitioned inputs, sysc.sys = (A-λE,[Bu Bd Bw Bv],C,[Du Dd Dw Dv]), where Bu, Bd, Bw and Bv are formed from the successive columns of B and are the input matrices from the control inputs u, disturbance inputs d, noise inputs w and auxiliary inputs v, respectively, and Du, Dd, Dw and Dv are formed from the successive columns of D and are the feedthrough matrices from those inputs. The dimensions of control, disturbance, noise and auxiliary input vectors are contained in sysm.mu, sysm.md, sysm.mw and sysm.ma, respectively.

The information on the partition of the input components in control, disturbance, noise and auxiliary inputs can be specified using the following keyword arguments:

mu = nu specifies the dimension nu of the control input vector u (default: nu = 0)

md = nd specifies the dimension nd of the disturbance input vector d (default: nd = 0)

mw = nw specifies the dimension nw of the noise input vector w (default: nw = 0)

ma = na specifies the dimension na of the auxiliary input vector v (default: na = 0)

source
FaultDetectionTools.MDMModel — Type
MDMModel <: AbstractFDDObject

Type for multiple synthesis models employed to solve model detection problems.

If sysm::MDMModel is the multiple synthesis model object, the underlying vector of descriptor system models can be obtained via sysm.sys, the common dimension of the control vectors is contained in the integer sysm.mu, and the dimensions of the disturbance, noise and auxiliary input vectors for the i-th model sysm.sys[i] are contained in the i-th components of the integer vectors sysm.md, sysm.mw and sysm.ma, respectively.

source
FaultDetectionTools.MDMModel — Method
MDMModel(sys; mu, md, mw, ma) -> sysm::MDMModel

Build for a vector of linear time-invariant system models sys, with the i-th component model sys[i] = (Ai-λEi,Bi,Ci,Di), a multiple synthesis model object sysm::MDMModel to be used in conjunction with the analysis and synthesis functions of model detection filters.

The resulting multiple synthesis model object sysm contains the vector sysm.sys of component models with partitioned inputs, with the i-th model sysm.sys[i] = (Ai-λEi,[Bui Bdi Bwi Bvi],Ci,[Dui Ddi Dwi Dvi]), where Bui, Bdi, Bwi and Bvi are formed from the successive columns of Bi and are the input matrices from the control inputs u, disturbance inputs di, noise inputs wi and auxiliary inputs vi, respectively, and Dui, Ddi, Dwi and Dvi are formed from the successive columns of Di and are the feedthrough matrices from those inputs. The dimensions of control, disturbance, noise and auxiliary input vectors are contained in sysm.mu, sysm.md[i], sysm.mw[i] and sysm.ma[i], respectively.

If N is the number of component models, the information on the partition of the input components in control, disturbance, noise and auxiliary inputs can be specified using the following keyword arguments:

mu = nu specifies the dimension nu of control input vector u (default: nu = 0)

md = nd specifies the vector nd containing the N dimensions of disturbance input vectors, such that the i-th disturbance vector di has dimension nd[i] (default: nd = zeros(Int,N))

mw = nw specifies the vector nw containing the N dimensions of noise input vectors, such that the i-th noise vector wi has dimension nw[i] (default: nw = zeros(Int,N))

ma = na specifies the vector na containing the N dimensions of auxiliary input vectors, such that the i-th auxiliary vector vi has dimension na[i] (default: na = zeros(Int,N))

source
FaultDetectionTools.mdmodset — Function
mdmodset(sys; controls, c, disturbances, d, noise, n, aux) -> sysm::MDMModel

Build for a vector of linear time-invariant system models sys, with the i-th component model sys[i] = (Ai-λEi,Bi,Ci,Di), a multiple synthesis model object sysm::MDMModel to be used in conjunction with the analysis and synthesis functions of model detection filters.

The information on the partition of the input components in control, disturbance, noise and auxiliary inputs can be specified using the following keyword arguments:

controls = inpu or c = inpu specifies the indices inpu of the control inputs (default: void)

disturbances = inpd or d = inpd specifies the indices or a vector of indices inpd of the disturbance inputs (default: void)

noise = inpn or noise = inpn specifies the indices or a vector of indices inpn of the noise inputs (default: void)

aux = inpa specifies the indices or a vector of indices inpa of the auxiliary inputs (default: void)

The indices of inputs can be specified as integer vectors, integer scalars or integer UnitRanges. For disturbance, noise and auxiliary inputs, vectors of integer vectors or vectors of integer UnitRanges can be used to specify possibly different set of indices for each component model.

The resulting sysm contains the vector sysm.sys of partitioned systems, with the i-th model sysm.sys[i] = (Ai-λEi,[Bui Bdi Bwi Bvi],Ci,[Dui Ddi Dwi Dvi]), where Bui, Bdi, Bwi and Bvi are the input matrices from the control inputs u, disturbance inputs di, noise inputs wi and auxiliary inputs vi, respectively, and Dui, Ddi, Dwi and Dvi are the feedthrough matrices from those inputs. The dimensions of control, disturbance, noise and auxiliary input vectors are contained in sysm.mu, sysm.md[i], sysm.mw[i] and sysm.ma[i], respectively.

Method: If Gi(λ) is the p x mi transfer function matrix of sys[i], then the resulting component system sysm.sys[i] has an equivalent input output form [Gui(λ) Gdi(λ) Gwi(λ) Gvi(λ)], where the following relations define the component matrices: Gui(λ) = Gi(λ)*Su, Gdi(λ) = Gi(λ)*Sdi, Gwi(λ) = G(λ)*Swi, Gvi(λ) = Gi(λ)*Svi, with the selection matrices Su, Sdi, Swi and Svi formed from the columns of the mi-th order identity matrix (note that Su is the same for all component models).

source
mdmodset(sysc::Vector{<:MDModel}) -> sysm::MDMModel

Build for a vector of component synthesis models sysc, a multiple synthesis model object sysm::MDMModel to be used in conjunction with the analysis and synthesis functions of model detection filters.

source
FaultDetectionTools.MDFilter — Type
MDFilter <: AbstractFDDObject

Type for model detection filters resulted as solutions of model detection problems.

If filter::MDFilter is the model detection filter object, the underlying i-th descriptor system model can be obtained via filter.sys[i] and the dimensions of the partitioned filter input vectors as measured outputs and control inputs, can be accessed as the integers contained in filter.ny and filter.mu, respectively.

source
FaultDetectionTools.MDFilterIF — Type
MDFilterIF <: AbstractFDDObject

Type for the internal form of model detection filters resulted as solutions of model detection problems.

If filter::MDFilterIF is the model detection filter internal form object, the underlying (i,j)-th descriptor system model can be obtained via filter.sys[i,j] and the corresponding dimensions of control, disturbance, fault, noise and auxiliary input vectors are contained in sysm.mu, sysm.md[j], sysm.mw[j] and sysm.ma[j], respectively.

source
FaultDetectionTools.mdIFeval — Function
mdIFeval(sysQ::MDFilter, sysm::MDMModel; minimal = false, atol, atol1 = atol, atol2 = atol, rtol, fast = true) -> sysR::MDFilterIF

Compute the internal form sysR of the model detection filter sysQ applied to the multiple synthesis model sysm. If the j-th component model sysm.sys[j] has the partitioned transfer function matrix Gj(λ) = [ Guj(λ) Gdj(λ) Gwj(λ) Gvj(λ) ] in accordance with the partitioned system inputs as controls, disturbances, noise and auxiliary inputs, respectively, and Qi(λ) = [ Qyi(λ) Qui(λ) ] is the partitioned transfer function matrix of the i-th filter sysQ.sys[i] in accordance with the partitioned filter inputs as outputs and controls, then the transfer function matrix Rij(λ) corresponding to the (i-th filter,j-th model) pair in the resulting internal form sysR.sys[i,j] is given by

 Rij(λ) = | Qyi(λ)  Qui(λ) | * | Guj(λ)  Gdj(λ) Gwj(λ) Gvj(λ) |
+                               |  I      0      0      0      |

Minimal descriptor realizations are computed if minimal = true and a (possibly) non-minimal realization is determined if minimal = false (default).

The minimal realization computation relies on pencil manipulation algorithms which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true, or the SVD-decomposition. The rank decision based on the SVD-decomposition is generally more reliable, but the involved computational effort is higher.

If (Arij-λErij,Brij,Crij,Drij) is the full order descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
diff --git a/dev/MDanalysis.html b/dev/MDanalysis.html index 6acb602..1f9e086 100644 --- a/dev/MDanalysis.html +++ b/dev/MDanalysis.html @@ -3,10 +3,10 @@ sdeg, atol, atol1, atol2, atol3, rtol)

Generate for a given multiple synthesis model sysm::MDMModel the achievable binary structure matrix S of the internal form corresponding to a set of stable model detection filters, chosen such that the i-th residual is insensitive to the i-th model for all control and disturbance inputs. If N is the number of component models, then S is an N×N binary matrix, whose (i,i)-th element is zero for i = 1, ..., N, and its (i,j)-th element is nonzero if there exists a model detection filter such that the corresponding i-th residual is sensitive to the j-th model for certain control inputs (if emtest = false) or for certain control and disturbance inputs (if emtest = true).

MDFreq = freq specifies a vector of real frequency values or a scalar real frquency value for strong model detectability checks (default: MDFreq = missing).

MDtol = tol1 specifies the threshold tol1 for model detectability checks (default: tol1 = 0.0001).

MDGainTol = tol2 specifies the threshold tol2 for strong model detectability checks (default: tol2 = 0.01).

The keyword argument sdeg = β specifies a prescribed stability degree β for the poles of the internally generated candidate filters, such that the real parts of filters poles must be less than or equal to β, in the continuous-time case, and the magnitudes of filter poles must be less than or equal to β, in the discrete-time case. If sdeg = missing then no stabilization is performed if FDFreq = missing. If sdeg = missing and FDFreq = freq, then the following default values are employed : β = -0.05, in continuous-time case, and β = 0.95, in discrete-time case.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true (default) or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2 and rtol, specify, respectively, the absolute tolerance for the nonzero elements of the state-space matrices (see below) Ai, Bi, Ci and Di, the absolute tolerance for the nonzero elements of Ei, and the relative tolerance for the nonzero elements of all above matrices. The default relative tolerance is ni*ϵ, where ϵ is the working machine epsilon and ni is the orders of the system sysm.sys[i]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

Method: For a multiple synthesis model sysm containing N stable component models, the i-th component system sysm.sys[i] has a descriptor realization of the form sysm.sys[i] = (Ai-λEi,Bi,Ci,Di) and the corresponding input-output form is

  yi = Gui(λ)*u + Gdi(λ)*di + Gwi(λ)*wi + Gvi(λ)*vi

with the Laplace- or Z-transformed plant outputs yi, control inputs u, disturbance inputs di, noise inputs wi, and auxiliary inputs vi, and with Gui(λ), Gdi(λ), Gwi(λ) and Gvi(λ), the corresponding transfer function matrices.

To generate the achievable structure matrix S, it is assumed that N model detection filters are used, Q_i(λ), for i = 1, ..., N, where the i-th model detection filter Q_i(λ) generates the i-th residual

        r_i = Q_i(λ)*| y |
                      | u |

and is determined such that it fulfills the nullspace synthesis condition

        Q_i(λ)*|Gui(λ) Gdi(λ)| = 0.
                |  I     0    |

To generate the elements of the i-th row of S, the corresponding internal forms of the i-th filter are determined for j = 1, ..., N as 

   | Ruij(λ) Rdij(λ) | := Q_i(λ)*| Guj(λ) Gdj(λ) | 
-                                 |   I      0    |

and S[i,j] is set as follows:

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.2.

[2] A. Varga, Least order fault and model detection using multi-models. IEEE CDC'09, Shanghai, China, 2009.

source
FaultDetectionTools.mddist — Function
 mddist(sysm; MDfreq, cdinp = false, distance = "nugap",  rtolinf = 0.00001, 
+                                 |   I      0    |

and S[i,j] is set as follows:

  • if MDfreq = missing and emtest = false, then S[i,j] = 1 if Ruij(λ) ̸= 0 or S[i,j] = 0 if Ruij(λ) = 0;
  • if MDfreq = missing and emtest = true, then S[i,j] = 1 if [Ruij(λ) Rdij(λ)] ̸= 0 or S[i,j] = 0 if [Ruij(λ) Rdij(λ)] = 0;
  • if MDfreq = freq and emtest = false, then S[i,j] = 1 if Ruij(λs) ̸= 0 for any λs ∈ freq or S[i,j] = 0 if Ruij(λs) = 0 for all λs ∈ freq ;
  • if MDfreq = freq and emtest = true, then S[i,j] = 1 if [Ruij(λs) Rdij(λs)] ̸= 0 for any λs ∈ freq or S[i,j] = 0 if [Ruij(λs) Rdij(λs)] = 0 for all λs ∈ freq .

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.2.

[2] A. Varga, Least order fault and model detection using multi-models. IEEE CDC'09, Shanghai, China, 2009.

source
FaultDetectionTools.mddist — Function
 mddist(sysm; MDfreq, cdinp = false, distance = "nugap",  rtolinf = 0.00001, 
         offset, atol, atol1 = atol, atol2 = atol, rtol = 0, fast = true) -> (dist, fpeak)

Compute the pairwise distances between the component models of sysm::MDMModel. If sysm contains N component models, then the resulting dist and fpeak are N × N real symmetric matrices, whose [i,j]-th elements contain the distance beetwen the systems sysm.sys[i] and sysm.sys[j], and, respectively, the corresponding peak frequency for which the value of the computed distance is achieved. sysm can be alternatively specified as a vector of component synthesis models.

The i-th component system sysm.sys[i] has a descriptor realization of the form sysm.sys[i] = (Ai-λEi,Bi,Ci,Di) and the corresponding input-output form is

  yi = Gui(λ)*u + Gdi(λ)*di + Gwi(λ)*wi + Gvi(λ)*vi

with the Laplace- or Z-transformed plant outputs yi, control inputs u, disturbance inputs di, noise inputs wi, and auxiliary inputs vi, and with Gui(λ), Gdi(λ), Gwi(λ) and Gvi(λ), the corresponding transfer function matrices.

The distance beetwen the systems sysm.sys[i] and sysm.sys[j] is evaluated as

  dist[i,j] = distf(G1i(λ),G2j(λ)),

where distf(⋅,⋅) is a distance function specified via the option parameter distance (see below) and G1i(λ) and G2j(λ) are suitably defined transfer function matrices via the option parameter cdinp (see below). The corresponding peak frequency fpeak[i,j] is the frequency value for which the distance is achieved.

distance = job specifies the distance function to be used as follows:

job = "nugap"  - use the ν-gap distance ν(G1i(λ),G2j(λ)) defined in [1] (default)
 job = "inf"    - use the H∞-norm of the difference (i.e., ||G1i(λ)-G2j(λ)||_∞)
-job = "2"      - use the H2-norm of the difference (i.e., ||G1i(λ)-G2j(λ)||_2)

If cdinp = false (default), then G1i(λ) = Gui(λ) and G2j(λ) = Guj(λ), while if cdinp = true then G1i(λ) = [Gui(λ) Gdi(λ)] and G2j(λ) = [Guj(λ) Gdj(λ)]. If Gdi(λ) has less columns than Gdj(λ), then [Gdi(λ) 0] (with suitably padded zero columns) is used instead Gdi(λ), while if Gdi(λ) has more columns than Gdj(λ), then [Gdj(λ) 0] is used instead Gdj(λ).

If MDfreq = ω, where ω is a vector of real frequency values, then each distance dist[i,j] is the maximum of pointwise distances evaluated for all frequencies in ω and the corresponding frequency fpeak[i,j] is the value for which the maximum pointwise distance is achieved.

The stability boundary offset, β, to be used to assess the finite poles/zeros which belong to the boundary of the stability domain can be specified via the keyword parameter offset = β. Accordingly, for a continuous-time system, these are the finite poles/zeros having real parts within the interval [-β,β], while for a discrete-time system, these are the finite pole/zeros having moduli within the interval [1-β,1+β]. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

Pencil reduction algorithms are employed to compute range and coimage spaces involved in evaluating the ν-gap or the H∞-norm distances. These algorithms perform rank decisions based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2 and rtol, specify, respectively, the absolute tolerance for the nonzero elements of the state-space matrices Ai, Bi, Ci,Di, Aj, Bj, Cj and Dj, the absolute tolerance for the nonzero elements of Ei and Ej, and the relative tolerance for the nonzero elements of all above matrices. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the maximum of the orders of the systems sysm.sys[i] and sysm.sys[j]. The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol.

The keyword argument rtolinf = tol specifies the relative accuracy tol to be used to compute infinity norms. The default value used is tol = 0.00001.

Method: The evaluation of ν-gap uses the definition proposed in [1], extended to generalized LTI (descriptor) systems.

References:

[1] G. Vinnicombe. Uncertainty and feedback: H∞ loop-shaping and the ν-gap metric. Imperial College Press, London, 2001.

source
FaultDetectionTools.mddist2c — Function
 mddist2c(sysm1, sysm2; MDfreq, cdinp = false, distance = "nugap", 
+job = "2"      - use the H2-norm of the difference (i.e., ||G1i(λ)-G2j(λ)||_2)

If cdinp = false (default), then G1i(λ) = Gui(λ) and G2j(λ) = Guj(λ), while if cdinp = true then G1i(λ) = [Gui(λ) Gdi(λ)] and G2j(λ) = [Guj(λ) Gdj(λ)]. If Gdi(λ) has less columns than Gdj(λ), then [Gdi(λ) 0] (with suitably padded zero columns) is used instead Gdi(λ), while if Gdi(λ) has more columns than Gdj(λ), then [Gdj(λ) 0] is used instead Gdj(λ).

If MDfreq = ω, where ω is a vector of real frequency values, then each distance dist[i,j] is the maximum of pointwise distances evaluated for all frequencies in ω and the corresponding frequency fpeak[i,j] is the value for which the maximum pointwise distance is achieved.

The stability boundary offset, β, to be used to assess the finite poles/zeros which belong to the boundary of the stability domain can be specified via the keyword parameter offset = β. Accordingly, for a continuous-time system, these are the finite poles/zeros having real parts within the interval [-β,β], while for a discrete-time system, these are the finite pole/zeros having moduli within the interval [1-β,1+β]. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

Pencil reduction algorithms are employed to compute range and coimage spaces involved in evaluating the ν-gap or the H∞-norm distances. These algorithms perform rank decisions based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2 and rtol, specify, respectively, the absolute tolerance for the nonzero elements of the state-space matrices Ai, Bi, Ci,Di, Aj, Bj, Cj and Dj, the absolute tolerance for the nonzero elements of Ei and Ej, and the relative tolerance for the nonzero elements of all above matrices. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the maximum of the orders of the systems sysm.sys[i] and sysm.sys[j]. The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol.

The keyword argument rtolinf = tol specifies the relative accuracy tol to be used to compute infinity norms. The default value used is tol = 0.00001.

Method: The evaluation of ν-gap uses the definition proposed in [1], extended to generalized LTI (descriptor) systems.

References:

[1] G. Vinnicombe. Uncertainty and feedback: H∞ loop-shaping and the ν-gap metric. Imperial College Press, London, 2001.

source
FaultDetectionTools.mddist2c — Function
 mddist2c(sysm1, sysm2; MDfreq, cdinp = false, distance = "nugap", 
           rtolinf = 0.00001, offset, atol, atol1 = atol, atol2 = atol, rtol = 0, fast = true) -> (dist, fpeak)

Compute the pairwise distances between two sets of multiple component synthesis models sysm1::MDMModel and sysm2::MDMModel. If sysm1 contains N component models and sysm2 contains M component models, then the resulting dist and fpeak are N × M real matrices, whose [i,j]-th entries contain the distance beetwen the systems sysm1.sys[i] and sysm2.sys[j], and, respectively, the corresponding peak frequency for which the value of the computed distance is achieved. Both sysm1 and sysm2 can be alternatively specified as vectors of component synthesis models.

The i-th component system sysm1.sys[i] has a descriptor realization of the form sysm1.sys[i] = (A1i-λE1i,B1i,C1i,D1i) and the corresponding input-output form is

  y1i = Gu1i(λ)*u + Gd1i(λ)*di + Gw1i(λ)*wi + Gv1i(λ)*vi

with the Laplace- or Z-transformed plant outputs y1i, control inputs u, disturbance inputs di, noise inputs wi, and auxiliary inputs vi, and with Gu1i(λ), Gd1i(λ), Gw1i(λ) and Gv1i(λ), the corresponding transfer function matrices. Similarly, the j-th component system sysm2.sys[j] has a descriptor realization of the form sysm2.sys[j]= (A2j-λE2j,B2j,C2j,D2j) and the corresponding input-output form is

  y2j = Gu2j(λ)*u + Gd2j(λ)*dj + Gw2j(λ)*wj + Gv2j(λ)*vj

with the Laplace- or Z-transformed plant outputs y2j, control inputs u, disturbance inputs dj, noise inputs wj, and auxiliary inputs vj, and with Gu2j(λ), Gd2j(λ), Gw2j(λ) and Gv2j(λ), the corresponding transfer function matrices.

The distance beetwen the systems sysm1.sys[i] and sysm2.sys[j] is evaluated as

  dist[i,j] = distf(G1i(λ),G2j(λ)),

where distf(⋅,⋅) is a distance function specified via the option parameter distance (see below) and G1i(λ) and G2j(λ) are suitably defined transfer function matrices via the option parameter cdinp (see below). The corresponding peak frequency fpeak[i,j] is the frequency value for which the distance is achieved.

distance = job specifies the distance function to be used as follows:

job = "nugap"  - use the ν-gap distance ν(G1i(λ),G2j(λ)) defined in [1] (default)
 job = "inf"    - use the H∞-norm of the difference (i.e., ||G1i(λ)-G2j(λ)||_∞)
-job = "2"      - use the H2-norm of the difference (i.e., ||G1i(λ)-G2j(λ)||_2)

If cdinp = false (default), then G1i(λ) = Gu1i(λ) and G2j(λ) = Gu2j(λ), while if cdinp = true then G1i(λ) = [Gu1i(λ) Gd1i(λ)] and G2j(λ) = [Gu2j(λ) Gd2j(λ)]. If Gd1i(λ) has less columns than Gd2j(λ), then [Gd1i(λ) 0] (with suitably padded zero columns) is used instead Gd1i(λ), while if Gd1i(λ) has more columns than Gd2j(λ), then [Gd2j(λ) 0] is used instead Gd2j(λ).

If MDfreq = ω, where ω is a vector of real frequency values, then each distance dist[i,j] is the maximum of pointwise distances evaluated for all frequencies in ω and the corresponding frequency fpeak[i,j] is the value for which the maximum pointwise distance is achieved.

The stability boundary offset, β, to be used to assess the finite poles/zeros which belong to the boundary of the stability domain can be specified via the keyword parameter offset = β. Accordingly, for a continuous-time system, these are the finite poles/zeros having real parts within the interval [-β,β], while for a discrete-time system, these are the finite pole/zeros having moduli within the interval [1-β,1+β]. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

Pencil reduction algorithms are employed to compute range and coimage spaces involved in evaluating the ν-gap or the H∞-norm distances. These algorithms perform rank decisions based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2 and rtol, specify, respectively, the absolute tolerance for the nonzero elements of the state-space matrices A1i, A2j, B1i, B2j, C1i, C2j, D1i and D2j, the absolute tolerance for the nonzero elements of E1i and E2j, and the relative tolerance for the nonzero elements of all above matrices. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the maximum of the orders of the systems sysm1.sys[i] and sysm2.sys[j]. The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol.

The keyword argument rtolinf = tol specifies the relative accuracy tol to be used to compute infinity norms. The default value used is tol = 0.00001.

Method: The evaluation of ν-gap uses the definition proposed in [1], extended to generalized LTI (descriptor) systems.

References:

[1] G. Vinnicombe. Uncertainty and feedback: H∞ loop-shaping and the ν-gap metric. Imperial College Press, London, 2001.

source
+job = "2" - use the H2-norm of the difference (i.e., ||G1i(λ)-G2j(λ)||_2)

If cdinp = false (default), then G1i(λ) = Gu1i(λ) and G2j(λ) = Gu2j(λ), while if cdinp = true then G1i(λ) = [Gu1i(λ) Gd1i(λ)] and G2j(λ) = [Gu2j(λ) Gd2j(λ)]. If Gd1i(λ) has less columns than Gd2j(λ), then [Gd1i(λ) 0] (with suitably padded zero columns) is used instead Gd1i(λ), while if Gd1i(λ) has more columns than Gd2j(λ), then [Gd2j(λ) 0] is used instead Gd2j(λ).

If MDfreq = ω, where ω is a vector of real frequency values, then each distance dist[i,j] is the maximum of pointwise distances evaluated for all frequencies in ω and the corresponding frequency fpeak[i,j] is the value for which the maximum pointwise distance is achieved.

The stability boundary offset, β, to be used to assess the finite poles/zeros which belong to the boundary of the stability domain can be specified via the keyword parameter offset = β. Accordingly, for a continuous-time system, these are the finite poles/zeros having real parts within the interval [-β,β], while for a discrete-time system, these are the finite pole/zeros having moduli within the interval [1-β,1+β]. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

Pencil reduction algorithms are employed to compute range and coimage spaces involved in evaluating the ν-gap or the H∞-norm distances. These algorithms perform rank decisions based on rank revealing QR-decompositions with column pivoting if fast = true or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2 and rtol, specify, respectively, the absolute tolerance for the nonzero elements of the state-space matrices A1i, A2j, B1i, B2j, C1i, C2j, D1i and D2j, the absolute tolerance for the nonzero elements of E1i and E2j, and the relative tolerance for the nonzero elements of all above matrices. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the maximum of the orders of the systems sysm1.sys[i] and sysm2.sys[j]. The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol.

The keyword argument rtolinf = tol specifies the relative accuracy tol to be used to compute infinity norms. The default value used is tol = 0.00001.

Method: The evaluation of ν-gap uses the definition proposed in [1], extended to generalized LTI (descriptor) systems.

References:

[1] G. Vinnicombe. Uncertainty and feedback: H∞ loop-shaping and the ν-gap metric. Imperial College Press, London, 2001.

source diff --git a/dev/MDbasics.html b/dev/MDbasics.html index 419794c..0301751 100644 --- a/dev/MDbasics.html +++ b/dev/MDbasics.html @@ -37,4 +37,4 @@ \big[\,G_u^{(j)}(\lambda)\;G_d^{(j)}(\lambda)\,\big]\big) .\]

Recall that padding with zeros columns may be necessary if $G_d^{(i)}(\lambda)$ and $G_d^{(j)}(\lambda)$ have different number of columns.

If $\lambda_k$, $k = 1, \ldots, n_f$, is a set of $n_f$ frequency values, then we can define the maximum of the point-wise distances

\[\Delta_{ij} := \max_k\delta_\nu\big(G_u^{(i)}(\lambda_k),G_u^{(j)}(\lambda_k)\big) ,\]

or

\[\Delta_{ij} := \max_k\delta_\nu\big(\big[\,G_u^{(i)}(\lambda_k)\;G_d^{(i)}(\lambda_k)\,\big], \big[\,G_u^{(j)}(\lambda_k)\;G_d^{(j)}(\lambda_k)\,\big]\big) .\]

Besides the $\nu$-gap distance between two transfer function matrices, it is possible to use distances defined in terms of the $\mathcal{H}_\infty$ norm or the $\mathcal{H}_2$ norm of the difference between them:

\[ \Delta_{ij} := \big\|G_u^{(i)}(\lambda)-G_u^{(j)}(\lambda)\big\|_\infty \]

or

\[\Delta_{ij} := \big\|G_u^{(i)}(\lambda)-G_u^{(j)}(\lambda)\big\|_2. \]

If $\lambda_k$, $k = 1, \ldots, n_f$, is a set of $n_f$ frequency values, then, instead of the above norm-based distances, we can use the maximum of the point-wise distances

\[\Delta_{ij} := \max_k\big\|G_u^{(i)}(\lambda_k)-G_u^{(j)}(\lambda_k)\big\|_2. \]

For the evaluation of the above distances between component models the function mddist is available. A second function mddist2c can be employed to compute the pairwise distances between two sets of component models. In particular, this function is usefull to assess the nearness of a current model to the set of component models employed for model detection.

Distance mapping performance

One of the goals of the model detection is to achieve a special mapping of the distances between $N$ component models using $N$ model detection filters such that the norms of the transfer function matrices $R_u^{(i,j)}(\lambda)$ or of $\big[\, R_u^{(i,j)}(\lambda)\; R_d^{(i,j)}(\lambda)\,\big]$ in the internal forms of the filters qualitatively reproduce the $\nu$-gap distances expressed by the $\Delta$ matrix above. The preservation of this distance mapping property is highly desirable, and the choice of model detection filters must be able to ensure this feature (at least partially for the nearest models). For example, the choice of the $i$-th filter $Q^{(i)}(\lambda)$ as a left annihilator of $\left[\begin{smallmatrix} G_u^{(i)}(\lambda) & G_d^{(i)}(\lambda) \\ I & 0 \end{smallmatrix}\right]$ ensures (see Remark 6.1 of [1]) that the norm of $\big[\, R_u^{(i,j)}(\lambda)\; R_d^{(i,j)}(\lambda)\,\big]$ can be interpreted as a weighted distance between the $i$-th and $j$-th component models. It follows that the distance mapping performance of a set of model detection filters $Q^{(i)}(\lambda)$, $i = 1, \ldots, N$ can be assessed by computing the mapped distance matrix $\Gamma$, whose $(i,j)$-th entry is

\[\Gamma_{ij} = \big\| R_u^{(i,j)}(\lambda) \big\|_\infty \]

or, if the disturbance inputs are relevant,

\[\Gamma_{ij} = \big\| \big[\, R_u^{(i,j)}(\lambda)\; R_d^{(i,j)}(\lambda)\,\big]\big\|_\infty .\]

Using the above choice of the filter $Q^{(i)}(\lambda)$, we have that all diagonal elements of $\Gamma$ are zero. Additionally, to guarantee model detectability, any valid design of the model detection filters must guarantee that all off-diagonal elements of $\Gamma$ are nonzero. These two properties of $\Gamma$ allows to unequivocally identify the exact matching of the current model with one (and only one) of the $N$ component models.

Two other properties of $\Gamma$ are desirable, when solving model detection applications. The first property is the symmetry of $\Gamma$. In contrast to $\Delta$, $\Gamma$ is generally not symmetric, excepting for some particular classes of component models and for special choices of model detection filters. For example, this property can be ensured if all component models are stable and have no disturbance inputs, by choosing $Q^{(i)}(\lambda) = \big[\, I \; -G_u^{(i)}(\lambda)\,\big]$, in which case $R_u^{(i,j)}(\lambda) = -R_u^{(j,i)}(\lambda)$. Ensuring the symmetry of $\Gamma$, although very desirable, is in general difficult to be achieved. In practice, it is often sufficient to ensure via suitable scaling that the gains of first row and first column are equal.

The second desirable property of the mapping $\Delta_{ij} \rightarrow \Gamma_{ij}$ is the monotonic mapping property of distances, which is the requirement that for all $i$ and $k$ ($i, k = 1, \ldots, N$), if $\Delta_{ij} < \Delta_{ik}$, then $\Gamma_{ij} < \Gamma_{ik}$. Ensuring this property, makes easier to address model identification problems for which no exact matching between the current model and any one of the component models can be assumed.

If $\lambda_k$, $k = 1, \ldots, n_f$, is a given set of $n_f$ frequency values, then, instead of the peak distances, we can use the maximum of the point-wise distances over the finite set of frequency values, to assess the strong model detectability.

For the evaluation of the distance mapping performance the function mdperf is available.

Distance matching performance

To evaluate the distance matching property of the model detection filters in the case when no exact matching between the current model and any one of the component models can be assumed, we can define the corresponding current internal forms as

\[\big[ \widetilde R_u^{(i)}(\lambda) \mid \widetilde R_d^{(i)}(\lambda) \mid \widetilde R_w^{(i)}(\lambda)\big] := Q^{(i)}(\lambda)\left[ \begin{array}{c|c|c} \widetilde G_u(\lambda) & \widetilde G_d(\lambda) & \widetilde G_w(\lambda) \\ -I_{m_u} & 0 & 0 \end{array} \right]\]

and evaluate the mapped distances $\gamma_i$, for $i = 1, \ldots, N$, defined as

\[\gamma_i := \big\| \widetilde R_u^{(i)}(\lambda) \big\|_\infty \]

or, if the disturbance inputs are relevant,

\[\gamma_i := \big\| \big[\, \widetilde R_u^{(i)}(\lambda)\; \widetilde R_d^{(i)}(\lambda)\,\big]\big\|_\infty .\]

The index $\ell$ of the smallest value $\gamma_\ell$ provides (for a well designed set of model detection filters) the index of the best matching component model of the current model.

If $\lambda_k$, $k = 1, \ldots, n_f$, is a given set of $n_f$ frequency values, then, instead of the above peak distances, we can use the maximum of the point-wise distances over the finite set of frequency values.

For the evaluation of the distance matching performance the function mdmatch is available.

Model detection noise gaps

The noise attenuation performance of model detection filters can be characterized via the noise gaps achieved by individual filters. The noise gap for the $i$-th filter can be defined in terms of the resulting internal forms as the ratio $\eta_i := \beta_i/\gamma_i$, where

\[\beta_i := \min_{j\neq i} \big\|R_u^{(i,j)}(\lambda)\big\|_\infty \]

and

\[\gamma_i := \big\|R_w^{(i,i)}(\lambda)\big\|_\infty .\]

The values of $\beta_i > 0$, for $i = 1, \ldots, N$ characterize the model detectability property of the collection of the $N$ component models, while $\gamma_i$ characterizes the worst-case influence of noise inputs on the $i$-th residual component. If $\gamma_i = 0$ (no noise), then $\eta_i = \infty$.

If the disturbance inputs are relevant for the model detection, then we can use the following alternative definition of $\beta_i$

\[\beta_i := \min_{j\neq i} \big\|\big[\,R_u^{(i,j)}(\lambda)\; R_d^{(i,j)}(\lambda)\,\big]\big\|_\infty .\]

In this case, $\beta_i > 0$, for $i = 1, \ldots, N$ characterize the (extended) model detectability property of the collection of the $N$ component models.

If $\lambda_k$, $k = 1, \ldots, n_f$, is a given set of $n_f$ frequency values, then we can alternatively use the maximum of the point-wise distances over the finite set of frequency values

\[\beta_i := \min_{j\neq i} \max_k\big\|R_u^{(i,j)}(\lambda_k)\big\|_\infty \]

or

\[\beta_i := \min_{j\neq i} \max_k\big\|\big[\,R_u^{(i,j)}(\lambda_k)\; R_d^{(i,j)}(\lambda_k)\,\big]\big\|_\infty .\]

For the evaluation of the detection noise gaps the function mdgap is available.

References

[1] A. Varga, Solving Fault Diagnosis Problems – Linear Synthesis Techniques, Vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

[2] G. Vinnicombe. Uncertainty and feedback: H∞ loop-shaping and the ν-gap metric. Imperial College Press, London, 2001.

+I_{m_u} & 0 & 0 \end{array} \right]\]

and evaluate the mapped distances $\gamma_i$, for $i = 1, \ldots, N$, defined as

\[\gamma_i := \big\| \widetilde R_u^{(i)}(\lambda) \big\|_\infty \]

or, if the disturbance inputs are relevant,

\[\gamma_i := \big\| \big[\, \widetilde R_u^{(i)}(\lambda)\; \widetilde R_d^{(i)}(\lambda)\,\big]\big\|_\infty .\]

The index $\ell$ of the smallest value $\gamma_\ell$ provides (for a well designed set of model detection filters) the index of the best matching component model of the current model.

If $\lambda_k$, $k = 1, \ldots, n_f$, is a given set of $n_f$ frequency values, then, instead of the above peak distances, we can use the maximum of the point-wise distances over the finite set of frequency values.

For the evaluation of the distance matching performance the function mdmatch is available.

Model detection noise gaps

The noise attenuation performance of model detection filters can be characterized via the noise gaps achieved by individual filters. The noise gap for the $i$-th filter can be defined in terms of the resulting internal forms as the ratio $\eta_i := \beta_i/\gamma_i$, where

\[\beta_i := \min_{j\neq i} \big\|R_u^{(i,j)}(\lambda)\big\|_\infty \]

and

\[\gamma_i := \big\|R_w^{(i,i)}(\lambda)\big\|_\infty .\]

The values of $\beta_i > 0$, for $i = 1, \ldots, N$ characterize the model detectability property of the collection of the $N$ component models, while $\gamma_i$ characterizes the worst-case influence of noise inputs on the $i$-th residual component. If $\gamma_i = 0$ (no noise), then $\eta_i = \infty$.

If the disturbance inputs are relevant for the model detection, then we can use the following alternative definition of $\beta_i$

\[\beta_i := \min_{j\neq i} \big\|\big[\,R_u^{(i,j)}(\lambda)\; R_d^{(i,j)}(\lambda)\,\big]\big\|_\infty .\]

In this case, $\beta_i > 0$, for $i = 1, \ldots, N$ characterize the (extended) model detectability property of the collection of the $N$ component models.

If $\lambda_k$, $k = 1, \ldots, n_f$, is a given set of $n_f$ frequency values, then we can alternatively use the maximum of the point-wise distances over the finite set of frequency values

\[\beta_i := \min_{j\neq i} \max_k\big\|R_u^{(i,j)}(\lambda_k)\big\|_\infty \]

or

\[\beta_i := \min_{j\neq i} \max_k\big\|\big[\,R_u^{(i,j)}(\lambda_k)\; R_d^{(i,j)}(\lambda_k)\,\big]\big\|_\infty .\]

For the evaluation of the detection noise gaps the function mdgap is available.

References

[1] A. Varga, Solving Fault Diagnosis Problems – Linear Synthesis Techniques, Vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

[2] G. Vinnicombe. Uncertainty and feedback: H∞ loop-shaping and the ν-gap metric. Imperial College Press, London, 2001.

diff --git a/dev/MDperformance.html b/dev/MDperformance.html index 58c228e..298b3cb 100644 --- a/dev/MDperformance.html +++ b/dev/MDperformance.html @@ -1,6 +1,6 @@ -Performance evaluation of model detection filters · FaultDetectionTools.jl
Edit on GitHub

Performance evaluation of model detection filters

  • mdspec Computation of the weak structure matrix.
  • mdsspec Computation of the strong structure matrix.
  • mdperf Computation of the distance-matching performace.
  • mdmatch Computation of the distance-matching performace to a component model.
  • mdgap Computation of the noise gaps.
FaultDetectionTools.mdspec — Function
 S = mdspec(sysR::MDFilterIF; cdinp = false, atol, atol1 = atol, atol2 = atol, rtol = 0)

Compute the weak binary structure matrix S of a collection of model detection filters using the model detection filter internal form object sysR::MDFilterIF.

For an M × N array of filters sysR, S is an M × N binary array determined as follows. Let the (i,j)-th component filter sysR.sys[i,j] have the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

with the Laplace- or Z-transformed residual output rij, control inputs u, disturbance inputs dj, noise inputs wj, and auxiliary inputs vj, and with Ruij(λ), Rdij(λ), Rwij(λ) and Rvij(λ), the corresponding transfer function matrices. Then, S[i,j] = 1 if Ruij(λ) is nonzero for cdinp = false (default), or if [Ruij(λs) Rdij(λs)] is nonzero for cdinp = true. Otherwise, S[i,j] = 0.

If (Arij-λErij,Brij,Crij,Drij) is the descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system matrix of sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
FaultDetectionTools.mdsspec — Function
 S = mdsspec(sysR::MDFilterIF, freq; cdinp = false, MDGainTol = 0.01, 
-             atol, atol1 = atol, atol2 = atol, rtol = 0, fast = true)

Compute, for a given set of real frequencies freq, the strong binary structure matrix S of a collection of model detection filters using the model detection filter internal form object sysR::MDFilterIF.

freq must contain a real frequency value or a vector of nf real frequencies which characterize the classes of persistent control and disturbance signals (default: freq = 0, i.e., characterizing constant signals) and defines the set Ω of complex frequencies which characterize the classes of persistent signals as follows: if f is a real frequency in freq, then the corresponding complex frequency λ in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

For an M × N array of filters sysR, S is an M × N binary array determined as follows. Let the (i,j)-th component filter sysR.sys[i,j] have the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

with the Laplace- or Z-transformed residual output rij, control inputs u, disturbance inputs dj, noise inputs wj, and auxiliary inputs vj, and with Ruij(λ), Rdij(λ), Rwij(λ) and Rvij(λ), the corresponding transfer function matrices. Then, S[i,j] = 1 if Ruij(λs) is nonzero for any λs ∈ Ω and cdinp = false (default), or if [Ruij(λs) Rdij(λs)] is nonzero for any λs ∈ Ω and cdinp = true. Otherwise, S[i,j] = 0.

MDGainTol = tol specifies an absolute threshold tol for the nonzero magnitudes of the frequency response gains (default: tol = 0.01).

The computation of minimal realizations of individual input-output channels relies on pencil manipulation algorithms, which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true (default) or the more reliable SVD-decompositions if fast = false.

If (Arij-λErij,Brij,Crij,Drij) is the descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
FaultDetectionTools.mdperf — Function
 mdperf(sysR::MDFilterIF; MDfreq, cdinp = false, rtolinf = 0.00001, 
-        offset, atol, atol1 = atol, atol2 = atol, rtol = 0, fast = true) -> (mdgain, fpeak)

Compute the distance-mapping performance of a collection of model detection filters using the model detection filter internal form object sysR::MDFilterIF. For an M × N array of filters sysR, the M × N arrays of model detection performance gains mdgain and the corresponding peak frequencies fpeak are determined as follows. Let the (i,j)-th component filter sysR.sys[i,j] have the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

with the Laplace- or Z-transformed residual output rij, control inputs u, disturbance inputs dj, noise inputs wj, and auxiliary inputs vj, and with Ruij(λ), Rdij(λ), Rwij(λ) and Rvij(λ), the corresponding transfer function matrices. Then, the (i,j)-th performance gain is evaluated as mdgain[i,j] = ||Ruij(λ)||∞ if cdinp = false (default) or mdgain[i,j] = ||[Ruij(λ) Rdij(λ)]||∞ if cdinp = true and fpeak[i,j] contains the corresponding peak frequency.

If MDfreq = ω, where ω is a given vector of real frequency values, then each gain mdgain[i,j] represents the maximum of 2-norm pointwise gains evaluated for all frequencies in ω and fpeak[i,j] is the corresponding peak frequency.

The stability boundary offset, β, to be used to assess the finite poles which belong to the boundary of the stability domain can be specified via the keyword parameter offset = β. Accordingly, for a continuous-time system, these are the finite poles having real parts within the interval [-β,β], while for a discrete-time system, these are the finite pole having moduli within the interval [1-β,1+β]. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

Pencil reduction algorithms are employed to compute the H∞-norms. These algorithms perform rank decisions based on rank revealing QR-decompositions with column pivoting if fast = true (default) or the more reliable SVD-decompositions if fast = false.

If (Arij-λErij,Brij,Crij,Drij) is the descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

The keyword argument rtolinf = tol specifies the relative accuracy tol to be used to compute the infinity norms. The default value used is tol = 0.00001.

source
FaultDetectionTools.mdmatch — Function
mdmatch(sysQ::MDFilter, sysc::MDModel; MDfreq, minimal = false, rtolinf, offset, atol, atol1 = atol, atol2 = atol, rtol, fast = true) -> (mdgain,fpeak,mind)

Compute the distance-mapping performance vector mdgain achieved using the model detection filter object sysQ::MDFilter applied to a component model sysc::MDModel, the corresponding vector of peak frequencies fpeak, and the index mind of the component of mdgain for which the minimum gain value is achieved.

If the i-th filter sysQ.sys[i] has the transfer function matrix Qi(λ) and the component model sysc::MDModel has the partitioned transfer function matrix G(λ) = [Gu(λ) Gd(λ) Gw(λ) Gv(λ)] in accordance with the partitioned system inputs as controls, disturbances, noise and auxiliary inputs, respectively, then the distance-mapping performance of the i-th filter applied to the given component model is computed as mdgain[i] = || Ri(λ) ||∞, where Ri(λ) is the corresponding internal form

 Ri(λ) = Qi(λ) * | Gu(λ)  Gd(λ) Gw(λ) Gv(λ) | .
-                 |  I     0     0     0     |

Minimal descriptor realizations are computed for Ri(λ) if minimal = true and a (possibly) non-minimal realization is determined if minimal = false (default).

The computation of minimal realizations of individual input-output channels relies on pencil manipulation algorithms, which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true (default) or the more reliable SVD-decompositions if fast = false.

If (Ari-λEri,Bri,Cri,Dri) is the full order descriptor realization of Ri(λ), then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Ari, Bri, Cri, Dri, the absolute tolerance for the nonzero elements of Eri, and the relative tolerance for the nonzero elements of Ari, Bri, Cri, Dri and Eir. The default relative tolerance is ni*ϵ, where ϵ is the working machine epsilon and ni is the order of the realitation of Ri(λ). The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
FaultDetectionTools.mdgap — Function
 mdgap(sysR::MDFilterIF; MDfreq, cdinp = false, rtolinf = 0.00001, 
-        offset, atol, atol1 = atol, atol2 = atol, rtol = 0, fast = true) -> (gap, β, γ)

Compute the noise gaps performance of a collection of model detection filters using the model detection filter internal form object sysR::MDFilterIF. For an M × N array of filters sysR, let the (i,j)-th component filter sysR.sys[i,j] have the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

with the Laplace- or Z-transformed residual output rij, control inputs u, disturbance inputs dj, noise inputs wj, and auxiliary inputs vj, and with Ruij(λ), Rdij(λ), Rwij(λ) and Rvij(λ), the corresponding transfer function matrices. Then, gap, β and γ are M-dimensional vectors, such that the i-th noise gap is evaluated as gap[i] = β[i]/γ[i], where β[i] = min(||Rij(λ)||∞ for i $\neq$ j) and γ[i] = ||Rwii(λ)||∞. Rij(λ) is defined as Rij(λ) = Ruij(λ) if cdinp = false (default) or Rij(λ) = [Ruij(λ) Rdij(λ)] if cdinp = true.

If MDfreq = ω, where ω is a given vector of real frequency values, then each gain β[i] represents the minimum of the maximum of 2-norm pointwise gains evaluated for all frequencies in ω.

The stability boundary offset, β, to be used to assess the finite poles which belong to the boundary of the stability domain can be specified via the keyword parameter offset = β. Accordingly, for a continuous-time system, these are the finite poles having real parts within the interval [-β,β], while for a discrete-time system, these are the finite pole having moduli within the interval [1-β,1+β]. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

Pencil reduction algorithms are employed to compute the H∞-norms. These algorithms perform rank decisions based on rank revealing QR-decompositions with column pivoting if fast = true (default) or the more reliable SVD-decompositions if fast = false.

If (Arij-λErij,Brij,Crij,Drij) is the descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

The keyword argument rtolinf = tol specifies the relative accuracy tol to be used to compute the infinity norms. The default value used is tol = 0.00001.

source
+Performance evaluation of model detection filters · FaultDetectionTools.jl
Edit on GitHub

Performance evaluation of model detection filters

  • mdspec Computation of the weak structure matrix.
  • mdsspec Computation of the strong structure matrix.
  • mdperf Computation of the distance-matching performace.
  • mdmatch Computation of the distance-matching performace to a component model.
  • mdgap Computation of the noise gaps.
FaultDetectionTools.mdspec — Function
 S = mdspec(sysR::MDFilterIF; cdinp = false, atol, atol1 = atol, atol2 = atol, rtol = 0)

Compute the weak binary structure matrix S of a collection of model detection filters using the model detection filter internal form object sysR::MDFilterIF.

For an M × N array of filters sysR, S is an M × N binary array determined as follows. Let the (i,j)-th component filter sysR.sys[i,j] have the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

with the Laplace- or Z-transformed residual output rij, control inputs u, disturbance inputs dj, noise inputs wj, and auxiliary inputs vj, and with Ruij(λ), Rdij(λ), Rwij(λ) and Rvij(λ), the corresponding transfer function matrices. Then, S[i,j] = 1 if Ruij(λ) is nonzero for cdinp = false (default), or if [Ruij(λs) Rdij(λs)] is nonzero for cdinp = true. Otherwise, S[i,j] = 0.

If (Arij-λErij,Brij,Crij,Drij) is the descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system matrix of sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
FaultDetectionTools.mdsspec — Function
 S = mdsspec(sysR::MDFilterIF, freq; cdinp = false, MDGainTol = 0.01, 
+             atol, atol1 = atol, atol2 = atol, rtol = 0, fast = true)

Compute, for a given set of real frequencies freq, the strong binary structure matrix S of a collection of model detection filters using the model detection filter internal form object sysR::MDFilterIF.

freq must contain a real frequency value or a vector of nf real frequencies which characterize the classes of persistent control and disturbance signals (default: freq = 0, i.e., characterizing constant signals) and defines the set Ω of complex frequencies which characterize the classes of persistent signals as follows: if f is a real frequency in freq, then the corresponding complex frequency λ in Ω is λ := im*f, for a continuous-time system, or λ := exp(im*f*abs(Ts)), for a discrete-time system with sampling-time Ts.

For an M × N array of filters sysR, S is an M × N binary array determined as follows. Let the (i,j)-th component filter sysR.sys[i,j] have the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

with the Laplace- or Z-transformed residual output rij, control inputs u, disturbance inputs dj, noise inputs wj, and auxiliary inputs vj, and with Ruij(λ), Rdij(λ), Rwij(λ) and Rvij(λ), the corresponding transfer function matrices. Then, S[i,j] = 1 if Ruij(λs) is nonzero for any λs ∈ Ω and cdinp = false (default), or if [Ruij(λs) Rdij(λs)] is nonzero for any λs ∈ Ω and cdinp = true. Otherwise, S[i,j] = 0.

MDGainTol = tol specifies an absolute threshold tol for the nonzero magnitudes of the frequency response gains (default: tol = 0.01).

The computation of minimal realizations of individual input-output channels relies on pencil manipulation algorithms, which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true (default) or the more reliable SVD-decompositions if fast = false.

If (Arij-λErij,Brij,Crij,Drij) is the descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
FaultDetectionTools.mdperf — Function
 mdperf(sysR::MDFilterIF; MDfreq, cdinp = false, rtolinf = 0.00001, 
+        offset, atol, atol1 = atol, atol2 = atol, rtol = 0, fast = true) -> (mdgain, fpeak)

Compute the distance-mapping performance of a collection of model detection filters using the model detection filter internal form object sysR::MDFilterIF. For an M × N array of filters sysR, the M × N arrays of model detection performance gains mdgain and the corresponding peak frequencies fpeak are determined as follows. Let the (i,j)-th component filter sysR.sys[i,j] have the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

with the Laplace- or Z-transformed residual output rij, control inputs u, disturbance inputs dj, noise inputs wj, and auxiliary inputs vj, and with Ruij(λ), Rdij(λ), Rwij(λ) and Rvij(λ), the corresponding transfer function matrices. Then, the (i,j)-th performance gain is evaluated as mdgain[i,j] = ||Ruij(λ)||∞ if cdinp = false (default) or mdgain[i,j] = ||[Ruij(λ) Rdij(λ)]||∞ if cdinp = true and fpeak[i,j] contains the corresponding peak frequency.

If MDfreq = ω, where ω is a given vector of real frequency values, then each gain mdgain[i,j] represents the maximum of 2-norm pointwise gains evaluated for all frequencies in ω and fpeak[i,j] is the corresponding peak frequency.

The stability boundary offset, β, to be used to assess the finite poles which belong to the boundary of the stability domain can be specified via the keyword parameter offset = β. Accordingly, for a continuous-time system, these are the finite poles having real parts within the interval [-β,β], while for a discrete-time system, these are the finite pole having moduli within the interval [1-β,1+β]. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

Pencil reduction algorithms are employed to compute the H∞-norms. These algorithms perform rank decisions based on rank revealing QR-decompositions with column pivoting if fast = true (default) or the more reliable SVD-decompositions if fast = false.

If (Arij-λErij,Brij,Crij,Drij) is the descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

The keyword argument rtolinf = tol specifies the relative accuracy tol to be used to compute the infinity norms. The default value used is tol = 0.00001.

source
FaultDetectionTools.mdmatch — Function
mdmatch(sysQ::MDFilter, sysc::MDModel; MDfreq, minimal = false, rtolinf, offset, atol, atol1 = atol, atol2 = atol, rtol, fast = true) -> (mdgain,fpeak,mind)

Compute the distance-mapping performance vector mdgain achieved using the model detection filter object sysQ::MDFilter applied to a component model sysc::MDModel, the corresponding vector of peak frequencies fpeak, and the index mind of the component of mdgain for which the minimum gain value is achieved.

If the i-th filter sysQ.sys[i] has the transfer function matrix Qi(λ) and the component model sysc::MDModel has the partitioned transfer function matrix G(λ) = [Gu(λ) Gd(λ) Gw(λ) Gv(λ)] in accordance with the partitioned system inputs as controls, disturbances, noise and auxiliary inputs, respectively, then the distance-mapping performance of the i-th filter applied to the given component model is computed as mdgain[i] = || Ri(λ) ||∞, where Ri(λ) is the corresponding internal form

 Ri(λ) = Qi(λ) * | Gu(λ)  Gd(λ) Gw(λ) Gv(λ) | .
+                 |  I     0     0     0     |

Minimal descriptor realizations are computed for Ri(λ) if minimal = true and a (possibly) non-minimal realization is determined if minimal = false (default).

The computation of minimal realizations of individual input-output channels relies on pencil manipulation algorithms, which employ rank determinations based on either the use of rank revealing QR-decomposition with column pivoting, if fast = true (default) or the more reliable SVD-decompositions if fast = false.

If (Ari-λEri,Bri,Cri,Dri) is the full order descriptor realization of Ri(λ), then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Ari, Bri, Cri, Dri, the absolute tolerance for the nonzero elements of Eri, and the relative tolerance for the nonzero elements of Ari, Bri, Cri, Dri and Eir. The default relative tolerance is ni*ϵ, where ϵ is the working machine epsilon and ni is the order of the realitation of Ri(λ). The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

source
FaultDetectionTools.mdgap — Function
 mdgap(sysR::MDFilterIF; MDfreq, cdinp = false, rtolinf = 0.00001, 
+        offset, atol, atol1 = atol, atol2 = atol, rtol = 0, fast = true) -> (gap, β, γ)

Compute the noise gaps performance of a collection of model detection filters using the model detection filter internal form object sysR::MDFilterIF. For an M × N array of filters sysR, let the (i,j)-th component filter sysR.sys[i,j] have the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

with the Laplace- or Z-transformed residual output rij, control inputs u, disturbance inputs dj, noise inputs wj, and auxiliary inputs vj, and with Ruij(λ), Rdij(λ), Rwij(λ) and Rvij(λ), the corresponding transfer function matrices. Then, gap, β and γ are M-dimensional vectors, such that the i-th noise gap is evaluated as gap[i] = β[i]/γ[i], where β[i] = min(||Rij(λ)||∞ for i $\neq$ j) and γ[i] = ||Rwii(λ)||∞. Rij(λ) is defined as Rij(λ) = Ruij(λ) if cdinp = false (default) or Rij(λ) = [Ruij(λ) Rdij(λ)] if cdinp = true.

If MDfreq = ω, where ω is a given vector of real frequency values, then each gain β[i] represents the minimum of the maximum of 2-norm pointwise gains evaluated for all frequencies in ω.

The stability boundary offset, β, to be used to assess the finite poles which belong to the boundary of the stability domain can be specified via the keyword parameter offset = β. Accordingly, for a continuous-time system, these are the finite poles having real parts within the interval [-β,β], while for a discrete-time system, these are the finite pole having moduli within the interval [1-β,1+β]. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

Pencil reduction algorithms are employed to compute the H∞-norms. These algorithms perform rank decisions based on rank revealing QR-decompositions with column pivoting if fast = true (default) or the more reliable SVD-decompositions if fast = false.

If (Arij-λErij,Brij,Crij,Drij) is the descriptor realization of sysR.sys[i,j], then the keyword arguments atol1, atol2, and rtol, specify, respectively, the absolute tolerance for the nonzero elements of matrices Arij, Brij, Crij, Drij, the absolute tolerance for the nonzero elements of Erij, and the relative tolerance for the nonzero elements of Arij, Brij, Crij, Drij and Eirj. The default relative tolerance is nij*ϵ, where ϵ is the working machine epsilon and nij is the order of the system sysR.sys[i,j]. The keyword argument atol can be used to simultaneously set atol1 = atol and atol2 = atol.

The keyword argument rtolinf = tol specifies the relative accuracy tol to be used to compute the infinity norms. The default value used is tol = 0.00001.

source
diff --git a/dev/MDsynthesis.html b/dev/MDsynthesis.html index e6a89c1..d609e45 100644 --- a/dev/MDsynthesis.html +++ b/dev/MDsynthesis.html @@ -4,7 +4,7 @@ sdeg, smarg, poles, HDesign, MDtol, MDGainTol, MDfreq, tcond, offset, atol, atol1, atol2, atol3, rtol) -> (Q::MDFilter, R::MDFilterIF, info)

Solve the exact model detection problem (EMDP) for a given multiple synthesis model sysm::MDMModel. The computed stable and proper filter objects Q and R contain the model detection filter, representing the solution of the EMDP, and its internal form, respectively.

The returned named tuple info, with the components info.tcond, info.degs, info.MDperf, and info.HDesign, contains additional synthesis related information (see below).

For a multiple synthesis model sysm containing N stable component models, the i-th component system sysm.sys[i] has a descriptor realization of the form sysm.sys[i] = (Ai-λEi,Bi,Ci,Di) and the corresponding input-output form is

  yi = Gui(λ)*u + Gdi(λ)*di + Gwi(λ)*wi + Gvi(λ)*vi

with the Laplace- or Z-transformed plant outputs yi, control inputs u, disturbance inputs di, noise inputs wi, and auxiliary inputs vi, and with Gui(λ), Gdi(λ), Gwi(λ) and Gvi(λ), the corresponding transfer function matrices.

The model detection filter object Q, contains in Q.sys the resulting bank of N filters. The i-th filter Q.sys[i] is in a standard state-space form and generates r_i, the i-th component (scalar or vector) of the overall residual vector r := [r_1; r_2; ...; r_N]. The corresponding input-output (implementation) form of the i-th filter is

        r_i = Qyi(λ)*y + Qui(λ)*u   ,

where Qyi(λ) and Qui(λ) are the transfer function matrices from the output and control inputs to the i-th residual component. The dimensions of output and control inputs are contained in the integers Q.ny and Q.mu, respectively.

The model detection filter internal form object R, contains R.sys, the resulting array of N × N internal form of the filters. The (i,j)-th component filter R.sys[i,j] is in a standard state-space form, generates the residual signal r_ij, and corresponds to the input-output form

   r_ij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

where 

   | Ruij(λ) Rdij(λ) Rwij(λ) Raij(λ) | := |Qyi(λ) Qui(λ)]*| Guj(λ) Gdj(λ) Gwj(λ) Gaj(λ) |. 
-                                                          |   I    0      0      0      |

The solution of the EMDP ensures that for the i-th filter, Ruii(λ) = 0, Rdii(λ) = 0, and [Ruij(λ) Rdij(λ)] $\neq$ 0 for j $\neq$ i.

Various user options can be specified via keyword arguments as follows:

MDSelect = ifilt specifies in the vector ifilt the indices of the desired filters to be designed (default: ifilt = 1:N)

If minimal = true (default), least order filter synthesis is performed to determine each of the component filters Q.sys[i] for i = 1, ...,N and R.sys[i,j] for i, j = 1, ...,N while with minimal = false full order synthesis is performed.

If HDesign = H, then H is an N-dimensional array of full row rank or empty design matrices H = [H_1, ..., H_N], where H_i is the design matrix employed for the synthesis of the i-th component filter (default: HDesign = missing)

rdim = q specifies the vector q, whose i-th component q[i] specifies the number of residual outputs for the i-th component filter Q.sys[i]. If q is a scalar, then a vector rdim with all components equal to q is assumed. The default value of q[i] is chosen as follows: if HDesign = missing or H_i is empty then q[i] = 1, if minimal = true, or q[i] is the number of the nullspace basis vectors used for the synthesis of Q.sys [i], if minimal = false; if H_i specifies a full row rank design matrix, then q[i] is the row dimension of H_i.

If emdtest = false (default), only the input channels are used for model detectability tests. If emdtest = true, extended model detectability tests are performed using both control and disturbance input channels.

MDfreq = ω specifies a vector of real frequency values or a scalar real frequency value for strong model detectability checks (default: MDfreq = missing).

If nullspace = false (default), a full-order observer based nullspace basis is used for the synthesis of the i-th filter whenever the i-th component system has no disturbance inputs. Otherwise, minimal proper nullspace bases are used. If nullspace = true, minimal proper nullspace bases are used for the synthesis of the model detection filters.

If simple = true, simple proper nullspace bases are emplyed for synthesis. The orders of the basis vectors employed for the synthesis of the i-th filter are provided in info.deg[i]. If simple = false (default), then no simple bases are computed.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

MDtol = tol1 specifies the threshold tol1 for model detectability checks (default: tol1 = 0.0001).

MDGainTol = tol2 specifies the threshold tol2 for strong model detectability checks (default: tol2 = 0.01).

If normalize = false (default), the i-th component filter Q.sys[i] is scaled such that the minimum gain of R.sys[i,j] for j = 1, ..., N, j $\neq$ i, is equal to one. If normalize = true, the standard normalization of component filters is performed to ensure equal gains for R.sys[1,j] and R.sys[j,1]. This option is only possible if ifilt[1] = 1 (see MDSelect).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true (default) or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2 and rtol, specify, respectively, the absolute tolerance for the nonzero elements of the state-space matrices Ai, Bi, Ci and Di, the absolute tolerance for the nonzero elements of Ei, and the relative tolerance for the nonzero elements of all above matrices. The default relative tolerance is ni*ϵ, where ϵ is the working machine epsilon and ni is the orders of the system sysm.sys[i]. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, MDperf, HDesign), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an N-dimensional vector, whose i-th component is an integer vector containing the degrees of the basis vectors of the employed simple nullspace basis for the synthesis of the i-th filter component, if simple = true, and the degrees of the basis vectors of an equivalent polynomial nullspace basis, if simple = false;

info.MDperf is an N × N array containing the resulting distance-mapping performance, representing the peak gains of the associated internal representations of the model detection filters. If the (i,j)-th component filter R.sys[i,j] has the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

then, the (i,j)-th performance gain is evaluated as info.MDperf[i,j] = ||Ruij(λ)||∞ if emdtest = false (default) or info.MDperf[i,j] = ||[Ruij(λ) Rdij(λ)]||∞ if emdtest = true. If MDfreq = ω, then each gain info.MDperf[i,j] represents the maximum of 2-norm pointwise gains evaluated for all frequencies in ω.

info.HDesign is an N-dimensional vector, whose i-th component is the design matrix H_i employed for the synthesis of the i-th model detection filter.

Method: The Procedure EMD from [1] is implemented to solve the exact model detection problem. For more details on the least order synthesis of model detection filters see [2].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.2.

[2] A. Varga, Least order fault and model detection using multi-models. IEEE CDC'09, Shanghai, China, 2009.

source
FaultDetectionTools.amdsyn — Function
amdsyn(sysm::MDMModel; rdim, MDSelect, nullspace = true, simple = false, minimal = true, 
+                                                          |   I    0      0      0      |

The solution of the EMDP ensures that for the i-th filter, Ruii(λ) = 0, Rdii(λ) = 0, and [Ruij(λ) Rdij(λ)] $\neq$ 0 for j $\neq$ i.

Various user options can be specified via keyword arguments as follows:

MDSelect = ifilt specifies in the vector ifilt the indices of the desired filters to be designed (default: ifilt = 1:N)

If minimal = true (default), least order filter synthesis is performed to determine each of the component filters Q.sys[i] for i = 1, ...,N and R.sys[i,j] for i, j = 1, ...,N while with minimal = false full order synthesis is performed.

If HDesign = H, then H is an N-dimensional array of full row rank or empty design matrices H = [H_1, ..., H_N], where H_i is the design matrix employed for the synthesis of the i-th component filter (default: HDesign = missing)

rdim = q specifies the vector q, whose i-th component q[i] specifies the number of residual outputs for the i-th component filter Q.sys[i]. If q is a scalar, then a vector rdim with all components equal to q is assumed. The default value of q[i] is chosen as follows: if HDesign = missing or H_i is empty then q[i] = 1, if minimal = true, or q[i] is the number of the nullspace basis vectors used for the synthesis of Q.sys [i], if minimal = false; if H_i specifies a full row rank design matrix, then q[i] is the row dimension of H_i.

If emdtest = false (default), only the input channels are used for model detectability tests. If emdtest = true, extended model detectability tests are performed using both control and disturbance input channels.

MDfreq = ω specifies a vector of real frequency values or a scalar real frequency value for strong model detectability checks (default: MDfreq = missing).

If nullspace = false (default), a full-order observer based nullspace basis is used for the synthesis of the i-th filter whenever the i-th component system has no disturbance inputs. Otherwise, minimal proper nullspace bases are used. If nullspace = true, minimal proper nullspace bases are used for the synthesis of the model detection filters.

If simple = true, simple proper nullspace bases are emplyed for synthesis. The orders of the basis vectors employed for the synthesis of the i-th filter are provided in info.deg[i]. If simple = false (default), then no simple bases are computed.

offset = β specifies the boundary offset β to assess the stability of poles. Accordingly, for the stability of a continuous-time system all real parts of poles must be at most -β, while for the stability of a discrete-time system all moduli of poles must be at most 1-β. The default value used for β is sqrt(ϵ), where ϵ is the working machine precision.

smarg = α specifies the stability margin which defines the stability domain Cs of poles, as follows: for a continuous-time system, Cs is the set of complex numbers with real parts at most α, while for a discrete-time system, Cs is the set of complex numbers with moduli at most α < 1 (i.e., the interior of a disc of radius α centered in the origin). If smarg is missing, then the employed default values are α = -β for a continuous-time system and α = 1-β for a discrete-time system, where β is the boundary offset specified by the keyword argument offset = β.

sdeg = γ is the prescribed stability degree for the poles of the filters Q and R (default: γ = -0.05 for the real parts of poles for a continuous-time system and γ = 0.95 for the magnitudes of poles for a discrete-time system).

poles = v specifies a complex vector v containing a complex conjugate set of desired poles within the stability domain Cs to be assigned for the filters Q and R (default: poles = missing).

tcond = tcmax specifies the maximum alowed condition number tcmax of the employed non-orthogonal transformations (default: tcmax = 1.e4).

MDtol = tol1 specifies the threshold tol1 for model detectability checks (default: tol1 = 0.0001).

MDGainTol = tol2 specifies the threshold tol2 for strong model detectability checks (default: tol2 = 0.01).

If normalize = false (default), the i-th component filter Q.sys[i] is scaled such that the minimum gain of R.sys[i,j] for j = 1, ..., N, j $\neq$ i, is equal to one. If normalize = true, the standard normalization of component filters is performed to ensure equal gains for R.sys[1,j] and R.sys[j,1]. This option is only possible if ifilt[1] = 1 (see MDSelect).

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true (default) or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2 and rtol, specify, respectively, the absolute tolerance for the nonzero elements of the state-space matrices Ai, Bi, Ci and Di, the absolute tolerance for the nonzero elements of Ei, and the relative tolerance for the nonzero elements of all above matrices. The default relative tolerance is ni*ϵ, where ϵ is the working machine epsilon and ni is the orders of the system sysm.sys[i]. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, MDperf, HDesign), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an N-dimensional vector, whose i-th component is an integer vector containing the degrees of the basis vectors of the employed simple nullspace basis for the synthesis of the i-th filter component, if simple = true, and the degrees of the basis vectors of an equivalent polynomial nullspace basis, if simple = false;

info.MDperf is an N × N array containing the resulting distance-mapping performance, representing the peak gains of the associated internal representations of the model detection filters. If the (i,j)-th component filter R.sys[i,j] has the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

then, the (i,j)-th performance gain is evaluated as info.MDperf[i,j] = ||Ruij(λ)||∞ if emdtest = false (default) or info.MDperf[i,j] = ||[Ruij(λ) Rdij(λ)]||∞ if emdtest = true. If MDfreq = ω, then each gain info.MDperf[i,j] represents the maximum of 2-norm pointwise gains evaluated for all frequencies in ω.

info.HDesign is an N-dimensional vector, whose i-th component is the design matrix H_i employed for the synthesis of the i-th model detection filter.

Method: The Procedure EMD from [1] is implemented to solve the exact model detection problem. For more details on the least order synthesis of model detection filters see [2].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.2.

[2] A. Varga, Least order fault and model detection using multi-models. IEEE CDC'09, Shanghai, China, 2009.

source
FaultDetectionTools.amdsyn — Function
amdsyn(sysm::MDMModel; rdim, MDSelect, nullspace = true, simple = false, minimal = true, 
                        emtest = false, normalize = false, fast = true, 
                        sdeg, smarg, poles, HDesign, MDtol, MDGainTol, MDfreq, 
                        epsreg = 0.1, sdegzer, nonstd = 1, rtolinf= 0.0001, 
@@ -19,4 +19,4 @@
             stabilization parameter `δ`;
   job = 5 – use the Wiener-Hopf type co-outer-co-inner factorization with
             the regularization of the non-minimum phase factor using the
-            regularization parameter `ϵ`.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true (default) or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2 and rtol, specify, respectively, the absolute tolerance for the nonzero elements of the state-space matrices Ai, Bi, Ci and Di, the absolute tolerance for the nonzero elements of Ei, and the relative tolerance for the nonzero elements of all above matrices. The default relative tolerance is ni*ϵ, where ϵ is the working machine epsilon and ni is the orders of the system sysm.sys[i]. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, MDperf, MDgap, HDesign, nonstandard), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an N-dimensional vector, whose i-th component is an integer vector containing the degrees of the basis vectors of the employed simple nullspace basis for the synthesis of the i-th filter component, if simple = true, and the degrees of the basis vectors of an equivalent polynomial nullspace basis, if simple = false;

info.MDperf is an N × N array containing the resulting distance-mapping performance, representing the peak gains of the associated internal representations of the model detection filters. If the (i,j)-th component filter R.sys[i,j] has the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

then, the (i,j)-th performance gain is evaluated as info.MDperf[i,j] = ||Ruij(λ)||∞ if emdtest = false (default) or info.MDperf[i,j] = ||[Ruij(λ) Rdij(λ)]||∞ if emdtest = true. If MDfreq = ω, then each gain info.MDperf[i,j] represents the maximum of 2-norm pointwise gains evaluated for all frequencies in ω.

info.MDgap is an N-dimensional vector of achieved noise gaps, where the i-th gap is computed as info.MDgap[i] = β[i]/γ[i], where β[i] = min(||Rij(λ)||∞ for i $\neq$ j) and γ[i] = ||Rwii(λ)||∞. Rij(λ) is defined as Rij(λ) = Ruij(λ) if emtest = false (default) or Rij(λ) = [Ruij(λ) Rdij(λ)] if emtest = true. If MDfreq = ω, where ω is a given vector of real frequency values, then each gain β[i] represents the minimum of the maximum of 2-norm pointwise gains evaluated for all frequencies in ω.

info.HDesign is an N-dimensional vector, whose i-th component is the design matrix H_i employed for the synthesis of the i-th model detection filter.

info.nonstandard is an N-dimensional vector, whose i-th component is true if the synthesis of the i-th filter involved a nonstandard optimization problem and is false otherwise.

Method: An extension of the Procedure AMD from [1] is implemented to solve the approximate model detection problem. This procedure relies on the nullspace-based synthesis method of model detection filters proposed in [2].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.2.

[2] A. Varga, Least order fault and model detection using multi-models. IEEE CDC'09, Shanghai, China, 2009.

source
+ regularization parameter `ϵ`.

The rank determinations in the performed reductions are based on rank revealing QR-decompositions with column pivoting if fast = true (default) or the more reliable SVD-decompositions if fast = false.

The keyword arguments atol1, atol2 and rtol, specify, respectively, the absolute tolerance for the nonzero elements of the state-space matrices Ai, Bi, Ci and Di, the absolute tolerance for the nonzero elements of Ei, and the relative tolerance for the nonzero elements of all above matrices. The default relative tolerance is ni*ϵ, where ϵ is the working machine epsilon and ni is the orders of the system sysm.sys[i]. The keyword argument atol3 is an absolute tolerance for observability tests (default: internally determined value). The keyword argument atol can be used to simultaneously set atol1 = atol, atol2 = atol and atol3 = atol.

The resulting named tuple info contains (tcond, degs, MDperf, MDgap, HDesign, nonstandard), where:

info.tcond is the maximum of the condition numbers of the employed non-orthogonal transformation matrices; a warning is issued if info.tcond >= tcmax;

info.degs is an N-dimensional vector, whose i-th component is an integer vector containing the degrees of the basis vectors of the employed simple nullspace basis for the synthesis of the i-th filter component, if simple = true, and the degrees of the basis vectors of an equivalent polynomial nullspace basis, if simple = false;

info.MDperf is an N × N array containing the resulting distance-mapping performance, representing the peak gains of the associated internal representations of the model detection filters. If the (i,j)-th component filter R.sys[i,j] has the input-output form

 rij = Ruij(λ)*u + Rdij(λ)*dj + Rwij(λ)*wj + Rvij(λ)*vj ,

then, the (i,j)-th performance gain is evaluated as info.MDperf[i,j] = ||Ruij(λ)||∞ if emdtest = false (default) or info.MDperf[i,j] = ||[Ruij(λ) Rdij(λ)]||∞ if emdtest = true. If MDfreq = ω, then each gain info.MDperf[i,j] represents the maximum of 2-norm pointwise gains evaluated for all frequencies in ω.

info.MDgap is an N-dimensional vector of achieved noise gaps, where the i-th gap is computed as info.MDgap[i] = β[i]/γ[i], where β[i] = min(||Rij(λ)||∞ for i $\neq$ j) and γ[i] = ||Rwii(λ)||∞. Rij(λ) is defined as Rij(λ) = Ruij(λ) if emtest = false (default) or Rij(λ) = [Ruij(λ) Rdij(λ)] if emtest = true. If MDfreq = ω, where ω is a given vector of real frequency values, then each gain β[i] represents the minimum of the maximum of 2-norm pointwise gains evaluated for all frequencies in ω.

info.HDesign is an N-dimensional vector, whose i-th component is the design matrix H_i employed for the synthesis of the i-th model detection filter.

info.nonstandard is an N-dimensional vector, whose i-th component is true if the synthesis of the i-th filter involved a nonstandard optimization problem and is false otherwise.

Method: An extension of the Procedure AMD from [1] is implemented to solve the approximate model detection problem. This procedure relies on the nullspace-based synthesis method of model detection filters proposed in [2].

References:

[1] A. Varga, Solving Fault Diagnosis Problems - Linear Synthesis Techniques. Springer Verlag, 2017; sec. 5.2.

[2] A. Varga, Least order fault and model detection using multi-models. IEEE CDC'09, Shanghai, China, 2009.

source diff --git a/dev/SynthesisParadigms.html b/dev/SynthesisParadigms.html index d17c158..745a4e4 100644 --- a/dev/SynthesisParadigms.html +++ b/dev/SynthesisParadigms.html @@ -2,4 +2,4 @@ Synthesis paradigms · FaultDetectionTools.jl
Edit on GitHub

Synthesis paradigms

The implemented computational procedures for the synthesis of fault detection filters share several computational paradigms, which are instrumental in developing generally applicable, numerically reliable and computationally efficient synthesis methods. Similar paradigms are also present in the synthesis methods of model detection filters. 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$. This can be done by choosing $Q(\lambda)$ of the form

\[ Q(\lambda) = \overline Q_1(\lambda) Q_1(\lambda) , \]

where the factor $Q_1(\lambda)$ is a left nullspace basis of the rational matrix

\[G(\lambda) := \left[ \begin{array}{cc} G_u(\lambda) & G_d(\lambda) \\ I_{m_u} & 0 \end{array}\right] \, .\]

It follows

\[[\,R_u(\lambda) \; R_d(\lambda)\,] = Q(\lambda)G(\lambda)= 0 \, .\]

The residual generator filter can be rewritten in the alternative form

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

where

\[\overline{\mathbf{y}}(\lambda) := Q_1(\lambda)\left[\begin{array}{c} {\mathbf{y}}(\lambda)\\{\mathbf{u}}(\lambda)\end{array}\right] = \overline G_f(\lambda){\mathbf{f}}(\lambda) + \overline G_w(\lambda){\mathbf{w}}(\lambda) \,,\]

with

\[[\, \overline G_f(\lambda) \; \overline G_w(\lambda) \,] := Q_1(\lambda) -\left[ \begin{array}{cc} G_f(\lambda) & G_w(\lambda) \\ 0 & 0 \end{array}\right]\, .\]

With this first preprocessing step, the original problems formulated for a system with control and disturbance inputs can be reformulated for the above reduced system (without control and disturbance inputs), for which we have to determine the TFM $\overline Q_1(\lambda)$ of the simpler fault detection filter. For the details of the implemented computational approach see Section 7.4 of [1].

For the computation of nullspace bases, functions available in the DescriptorSystems package are employed.

Using filter updating techniques

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

\[Q(\lambda) = Q_K(\lambda) \cdots Q_2(\lambda)Q_1(\lambda) \, , \]

where $Q_1(\lambda)$ is a left nullspace basis of the above defined $G(\lambda)$, 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 can be flexibly used for employing or combining different synthesis techniques.

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

\[R(\lambda) := [\, R_f(\lambda) \; R_w(\lambda)\,] = Q_1(\lambda)\left[ \begin{array}{cc} G_f(\lambda) & G_w(\lambda) \\ 0 & 0 \end{array}\right]\]

as follows: for $k = 2, \ldots, K$, determine $Q_k(\lambda)$ using the current $Q(\lambda)$ and $R(\lambda)$ and then perform the updating as $Q(\lambda) \leftarrow Q_k(\lambda)Q(\lambda)$ and $R(\lambda) \leftarrow Q_k(\lambda)R(\lambda)$. These updating operations are efficiently performed using state-space description based formulas. 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. See Section 7.3 of [1] for a discussion of additional aspects.

Least order synthesis based on admissibility conditions

The least order synthesis of fault detection filters means to determine filters $Q(\lambda)$ with the least possible orders, to help in reducing the computational burden associated with their real-time implementations. The main tool to achieve least order synthesis is the solution of suitable minimal cover problems (see Section 7.5 of [1]). 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

\[X(\lambda) = X_1(\lambda) + Y(\lambda) X_2(\lambda) , \]

and the order of $[\,X(\lambda) \; Y(\lambda) \,]$ is minimal.

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)$). For example, for the solution of the AFDP, the rows of $Q(\lambda) := Q_1(\lambda)$ form a left nullspace basis and the employed admissibility conditions are

\[Q_2(\lambda)R_{f_j}(\lambda) \not = 0, \;\;j = 1, \ldots, m_f, \]

which guarantee the detectability of all fault components, and additionally, the full row rank requirement on $Q_2(\lambda)R_w(\lambda)$. The latter condition is only imposed 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, 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.

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

For the solution of minimal cover problems, functions available in the DescriptorSystems package are employed.

Stabilization via left coprime factorization

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

\[[\, Q(\lambda) \; R(\lambda) \,] = M^{-1}(\lambda) [\, N_Q(\lambda) \; N_R(\lambda) \,] \]

with $M(\lambda)$ and $[\, N_Q(\lambda) \; N_R(\lambda) \,]$ coprime and having arbitrary stable poles, and then performing the updating operations $Q(\lambda) \leftarrow N_Q(\lambda)$ and $R(\lambda) \leftarrow N_R(\lambda)$. The stabilization via a left coprime factorization is usually performed as the last step of the synthesis procedures.

For a detailed discussion of the coprime factorization based stabilization approach see Sections 7.6 and 10.4 of [1], where coprime factorization methods, based on recursive pole dislocation techniques are described, which produce directly the numerator factors $N_Q(\lambda)$ and $N_R(\lambda)$ (thus implicitly perform the updating operations as well).

For the solution of coprime factorizations, functions available in the DescriptorSystems package are employed.

References

[1] A. Varga, Solving Fault Diagnosis Problems – Linear Synthesis Techniques, Vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

+\left[ \begin{array}{cc} G_f(\lambda) & G_w(\lambda) \\ 0 & 0 \end{array}\right]\, .\]

With this first preprocessing step, the original problems formulated for a system with control and disturbance inputs can be reformulated for the above reduced system (without control and disturbance inputs), for which we have to determine the TFM $\overline Q_1(\lambda)$ of the simpler fault detection filter. For the details of the implemented computational approach see Section 7.4 of [1].

For the computation of nullspace bases, functions available in the DescriptorSystems package are employed.

Using filter updating techniques

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

\[Q(\lambda) = Q_K(\lambda) \cdots Q_2(\lambda)Q_1(\lambda) \, , \]

where $Q_1(\lambda)$ is a left nullspace basis of the above defined $G(\lambda)$, 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 can be flexibly used for employing or combining different synthesis techniques.

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

\[R(\lambda) := [\, R_f(\lambda) \; R_w(\lambda)\,] = Q_1(\lambda)\left[ \begin{array}{cc} G_f(\lambda) & G_w(\lambda) \\ 0 & 0 \end{array}\right]\]

as follows: for $k = 2, \ldots, K$, determine $Q_k(\lambda)$ using the current $Q(\lambda)$ and $R(\lambda)$ and then perform the updating as $Q(\lambda) \leftarrow Q_k(\lambda)Q(\lambda)$ and $R(\lambda) \leftarrow Q_k(\lambda)R(\lambda)$. These updating operations are efficiently performed using state-space description based formulas. 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. See Section 7.3 of [1] for a discussion of additional aspects.

Least order synthesis based on admissibility conditions

The least order synthesis of fault detection filters means to determine filters $Q(\lambda)$ with the least possible orders, to help in reducing the computational burden associated with their real-time implementations. The main tool to achieve least order synthesis is the solution of suitable minimal cover problems (see Section 7.5 of [1]). 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

\[X(\lambda) = X_1(\lambda) + Y(\lambda) X_2(\lambda) , \]

and the order of $[\,X(\lambda) \; Y(\lambda) \,]$ is minimal.

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)$). For example, for the solution of the AFDP, the rows of $Q(\lambda) := Q_1(\lambda)$ form a left nullspace basis and the employed admissibility conditions are

\[Q_2(\lambda)R_{f_j}(\lambda) \not = 0, \;\;j = 1, \ldots, m_f, \]

which guarantee the detectability of all fault components, and additionally, the full row rank requirement on $Q_2(\lambda)R_w(\lambda)$. The latter condition is only imposed 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, 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.

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

For the solution of minimal cover problems, functions available in the DescriptorSystems package are employed.

Stabilization via left coprime factorization

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

\[[\, Q(\lambda) \; R(\lambda) \,] = M^{-1}(\lambda) [\, N_Q(\lambda) \; N_R(\lambda) \,] \]

with $M(\lambda)$ and $[\, N_Q(\lambda) \; N_R(\lambda) \,]$ coprime and having arbitrary stable poles, and then performing the updating operations $Q(\lambda) \leftarrow N_Q(\lambda)$ and $R(\lambda) \leftarrow N_R(\lambda)$. The stabilization via a left coprime factorization is usually performed as the last step of the synthesis procedures.

For a detailed discussion of the coprime factorization based stabilization approach see Sections 7.6 and 10.4 of [1], where coprime factorization methods, based on recursive pole dislocation techniques are described, which produce directly the numerator factors $N_Q(\lambda)$ and $N_R(\lambda)$ (thus implicitly perform the updating operations as well).

For the solution of coprime factorizations, functions available in the DescriptorSystems package are employed.

References

[1] A. Varga, Solving Fault Diagnosis Problems – Linear Synthesis Techniques, Vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

diff --git a/dev/index.html b/dev/index.html index 459a689..9a4e0e2 100644 --- a/dev/index.html +++ b/dev/index.html @@ -1,2 +1,2 @@ -Home · FaultDetectionTools.jl
Edit on GitHub

FaultDetectionTools.jl

DocBuild Code on Github.

The FaultDetectionTools.jl package (or shortlyFDITools) is a collection of Julia functions for the analysis and solution of fault detection and isolation (FDI) problems and model detection problems. The functions of this collection rely on the DescriptorSystems package [2], whose underlying computational functions are based on the MatrixPencils.jl [3] and MatrixEquations.jl [4] packages.

The implemented functions are based on the computational procedures described in Chapters 5, 6 and 7 of the book:

Andreas Varga, "Solving Fault Diagnosis Problems, Linear Synthesis Techniques", vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

This book describes the mathematical background of solving synthesis problems of fault detection and model detection filters and gives detailed descriptions of the underlying synthesis procedures.

The targeted functionality parallels the functionality of the MATLAB collection of tools FDITOOLS, whose User's Guide of the version V1.0 is provided in the file fditoolsdoc.pdf. Supplementary information on the targeted functionality is also available on arXiv in the documentation of the companion MATLAB FDITOOLS collection.

The available functions in the current version of the FaultDetectionTools.jl package are:

Building FDI related objects

  • FDIModel Fault detection and isolation synthesis model.
  • FDFilter Fault detection filter object.
  • FDIFilter Fault detection and isolation filter object.
  • FDFilterIF Fault detection filter internal form object.
  • FDIFilterIF Fault detection and isolation filter internal form object.
  • fdimodset Setup of synthesis models for solving fault detection and isolation problems.
  • fdIFeval Evaluation of the internal forms of fault detection and isolation filters.

Analysis of FDI synthesis models

  • fdigenspec Generation of achievable FDI specifications.
  • fdichkspec Feasibility analysis of a set of FDI specifications.

Solving FDI problems

  • efdsyn Exact synthesis of fault detection filters.
  • efdisyn Exact synthesis of fault detection and isolation filters.
  • afdsyn Approximate synthesis of fault detection filters.
  • afdisyn Approximate synthesis of fault detection and isolation filters.
  • emmsyn Exact model-matching based synthesis of fault detection filters.
  • ammsyn Approximate model-matching based synthesis of fault detection filters.

Performance evaluation of FDI filters

  • fditspec Computation of the weak or strong structure matrix.
  • fdisspec Computation of the strong structure matrix.
  • fdiscond Computation of the fault detection sensitivity condition.
  • fdif2ngap Computation of the fault-to-noise gap.
  • fdimmperf Computation of the model-matching performace.

Building model detection related objects

  • MDModel Model detection component synthesis model.
  • MDMModel Model detection multiple synthesis model.
  • mdmodset Setup of multiple synthesis models for solving model detection problems.
  • MDFilter Model detection filter object.
  • MDFilterIF Model detection filter internal form object.
  • mdIFeval Evaluation of the internal forms of model detection filters.

Analysis of model detection synthesis models

  • mdgenspec Generation of achievable model detection specifications.
  • mddist Computation of distances between component models.
  • mddist2c Computation of pairwise distances between two sets of component models.

Solving model detection problems

  • emdsyn Exact synthesis of model detection filters.
  • amdsyn Approximate synthesis of model detection filters.

Performance evaluation of model detection filters

  • mdspec Computation of the weak structure matrix.
  • mdsspec Computation of the strong structure matrix.
  • mdperf Computation of the distance-matching performace.
  • mdmatch Computation of the distance-matching performace to a component model.
  • mdgap Computation of the noise gaps.

Computational utilities

  • fdhinfminus Evaluation of the H∞- index of the transfer function matrix of a descriptor system model.
  • fdhinfmax Evaluation of the maximum of column norm of the transfer function matrix of a descriptor system model.
  • fditspec_ Computation of the weak or strong structure matrix of a descriptor system model.
  • fdisspec_ Computation of the strong structure matrix of a descriptor system model.
  • fdiscond_ Computation of the column-gains sensitivity condition of the transfer function matrix of a descriptor system model.

Release Notes

Main developer

Andreas Varga

License: MIT (expat)

References

[1] A. Varga, Solving Fault Diagnosis Problems – Linear Synthesis Techniques, Vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

[2] A. Varga, DescriptorSystems.jl: Manipulation of generalized state-space (descriptor) system representations. Zenodo: https://doi.org/10.5281/zenodo.5148319.

[3] A. Varga, MatrixPencils.jl: Matrix pencil manipulation using Julia. Zenodo: https://doi.org/10.5281/zenodo.3894503.

[4] A. Varga, MatrixEquations.jl: Solution of Lyapunov, Sylvester and Riccati matrix equations using Julia. Zenodo: https://doi.org/10.5281/zenodo.3556867.

+Home · FaultDetectionTools.jl
Edit on GitHub

FaultDetectionTools.jl

DocBuild Code on Github.

The FaultDetectionTools.jl package (or shortlyFDITools) is a collection of Julia functions for the analysis and solution of fault detection and isolation (FDI) problems and model detection problems. The functions of this collection rely on the DescriptorSystems package [2], whose underlying computational functions are based on the MatrixPencils.jl [3] and MatrixEquations.jl [4] packages.

The implemented functions are based on the computational procedures described in Chapters 5, 6 and 7 of the book:

Andreas Varga, "Solving Fault Diagnosis Problems, Linear Synthesis Techniques", vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

This book describes the mathematical background of solving synthesis problems of fault detection and model detection filters and gives detailed descriptions of the underlying synthesis procedures.

The targeted functionality parallels the functionality of the MATLAB collection of tools FDITOOLS, whose User's Guide of the version V1.0 is provided in the file fditoolsdoc.pdf. Supplementary information on the targeted functionality is also available on arXiv in the documentation of the companion MATLAB FDITOOLS collection.

The available functions in the current version of the FaultDetectionTools.jl package are:

Building FDI related objects

  • FDIModel Fault detection and isolation synthesis model.
  • FDFilter Fault detection filter object.
  • FDIFilter Fault detection and isolation filter object.
  • FDFilterIF Fault detection filter internal form object.
  • FDIFilterIF Fault detection and isolation filter internal form object.
  • fdimodset Setup of synthesis models for solving fault detection and isolation problems.
  • fdIFeval Evaluation of the internal forms of fault detection and isolation filters.

Analysis of FDI synthesis models

  • fdigenspec Generation of achievable FDI specifications.
  • fdichkspec Feasibility analysis of a set of FDI specifications.

Solving FDI problems

  • efdsyn Exact synthesis of fault detection filters.
  • efdisyn Exact synthesis of fault detection and isolation filters.
  • afdsyn Approximate synthesis of fault detection filters.
  • afdisyn Approximate synthesis of fault detection and isolation filters.
  • emmsyn Exact model-matching based synthesis of fault detection filters.
  • ammsyn Approximate model-matching based synthesis of fault detection filters.

Performance evaluation of FDI filters

  • fditspec Computation of the weak or strong structure matrix.
  • fdisspec Computation of the strong structure matrix.
  • fdiscond Computation of the fault detection sensitivity condition.
  • fdif2ngap Computation of the fault-to-noise gap.
  • fdimmperf Computation of the model-matching performace.

Building model detection related objects

  • MDModel Model detection component synthesis model.
  • MDMModel Model detection multiple synthesis model.
  • mdmodset Setup of multiple synthesis models for solving model detection problems.
  • MDFilter Model detection filter object.
  • MDFilterIF Model detection filter internal form object.
  • mdIFeval Evaluation of the internal forms of model detection filters.

Analysis of model detection synthesis models

  • mdgenspec Generation of achievable model detection specifications.
  • mddist Computation of distances between component models.
  • mddist2c Computation of pairwise distances between two sets of component models.

Solving model detection problems

  • emdsyn Exact synthesis of model detection filters.
  • amdsyn Approximate synthesis of model detection filters.

Performance evaluation of model detection filters

  • mdspec Computation of the weak structure matrix.
  • mdsspec Computation of the strong structure matrix.
  • mdperf Computation of the distance-matching performace.
  • mdmatch Computation of the distance-matching performace to a component model.
  • mdgap Computation of the noise gaps.

Computational utilities

  • fdhinfminus Evaluation of the H∞- index of the transfer function matrix of a descriptor system model.
  • fdhinfmax Evaluation of the maximum of column norm of the transfer function matrix of a descriptor system model.
  • fditspec_ Computation of the weak or strong structure matrix of a descriptor system model.
  • fdisspec_ Computation of the strong structure matrix of a descriptor system model.
  • fdiscond_ Computation of the column-gains sensitivity condition of the transfer function matrix of a descriptor system model.

Release Notes

Main developer

Andreas Varga

License: MIT (expat)

References

[1] A. Varga, Solving Fault Diagnosis Problems – Linear Synthesis Techniques, Vol. 84 of Studies in Systems, Decision and Control, Springer International Publishing, 2017.

[2] A. Varga, DescriptorSystems.jl: Manipulation of generalized state-space (descriptor) system representations. Zenodo: https://doi.org/10.5281/zenodo.5148319.

[3] A. Varga, MatrixPencils.jl: Matrix pencil manipulation using Julia. Zenodo: https://doi.org/10.5281/zenodo.3894503.

[4] A. Varga, MatrixEquations.jl: Solution of Lyapunov, Sylvester and Riccati matrix equations using Julia. Zenodo: https://doi.org/10.5281/zenodo.3556867.

diff --git a/dev/makeindex.html b/dev/makeindex.html index 537757a..a3fc984 100644 --- a/dev/makeindex.html +++ b/dev/makeindex.html @@ -1,2 +1,2 @@ -Index · FaultDetectionTools.jl
Edit on GitHub

Index

+Index · FaultDetectionTools.jl
Edit on GitHub

Index

diff --git a/dev/search.html b/dev/search.html index 47e236e..3e38b13 100644 --- a/dev/search.html +++ b/dev/search.html @@ -1,2 +1,2 @@ -Search · FaultDetectionTools.jl

Loading search...

    +Search · FaultDetectionTools.jl

    Loading search...