Model-based fault isolation and identification in hybrid systems is computationally expensive or even unfeasible for complex systems due to the presence of uncertainty concerning the actual state, and also due to the presence of both discrete and parametric faults coupled with changing modes in the system. In this work we improve fault isolation and identification performance for hybrid systems diagnosis using Hybrid Possible Conflicts. The Hybrid Bond Graph modeling approach makes feasible to track system behavior without enumerating the complete set of system modes. Hybrid Possible Conflicts focus the analysis on potential mode changes on those subsystems whose behavior deviates from expected. Moreover, using information derived from the Hybrid Bond Graph model, we can cope with both discrete and parametric faults in a unique framework.
Fault detection with Hybrid Possible Conflicts relied upon an statistical test to decide when a significant deviation in the residual occurs. Fault detection time was later used to start the fault isolation and identification stages. In this work we propose to analyze the evolution of the residual signal using CUSUM to find a more accurate estimation of the time of fault occurrence, which allows to improve both the potential new modes tracking and the parametric fault identification. Moreover, we extend our previous proposal for fault identification in continuous systems to cope with fault identification along a set of mode changes while performing parameter identification. We have tested these ideas in a four-tank hybrid system with satisfactory results. Complex hybrid systems are present in a broad range of engineering applications, such as mechanical systems, electrical circuits, or embedded computation systems. The behavior of these systems is made up of continuous and discrete event dynamics.The main sources of hybrid behavior are discrete actuators, like discrete valves or switches in fluid or electrical systems, respectively. These changes in the continuous behavior increase the difficulties for accurate and timely online fault diagnosis. Our focus in this paper is on developing efficient model-based methodologies for online fault isolation and identification in complex hybrid systems.
Both the DX and the FDI communities have approached
hybrid systems modeling and diagnosis during the last 20
years. They have used different modeling proposals [1; 2;
3], and have approached diagnosis either as hybrid state
estimation [2] or as online state tracking [4; 5; 6], or a
combination of both methods [
In this work we have selected the hybrid system
modeling based on Hybrid Bond Graphs (HBGs) [1; 6], together
with consistency-based diagnosis using Possible Conflicts
(PCs) [8]. HBGs are an extension of Bond Graphs (BG)
[9], which models the discrete changes as ideal switching
junctions that can be set to ON or OFF according to an
automaton. In [
In order to achieve efficient fault identification, it is very important to determine the time of fault occurrence as accurately and quickly as possible. But there is a required trade-off between fast and reliable fault detection. In our approach we relied upon an statistical test to decide when a residual deviates from the current mode, and used this time to start the fault isolation and identification stages, however, the fault detection instant can be delayed from the fault occurrence time and this has some problems (e.g., that the fault identification process is delayed, or that we have to assume that we know the value of the state variables at the beginning of the identification process). In this work we propose to analyze the evolution of the residual signal using the CUSUM algorithm [12; 13] to find a more accurate estimation of the time of fault occurrence, both for potential new modes tracking and for parametric fault identification. Moreover, we extend our previous proposals for fault identification [14; 15] to cope with fault identification along a set of mode changes while performing the parameter identification. The rest of the paper is organized as follows. Section 2 presents the case study used along the paper and introduces the Hybrid Bond Graph (HBG) modeling technique. Section 3 summarizes the Hybrid Possible Conflicts (HPCs) background, while section 4 explains the unified framework for both discrete and parametric faults. Section 5 introduces some concepts related to the CUSUM algorithm required in our approach. Section 6 explains our approach for fault identification. Section 7 introduces some results obtained applying our proposal on our case study. Finally, Section 8 draws some conclusions. 2
The hybrid four-tank system in Figure 1 will be used to show some concepts and to present some results in this work. The system has an input flow which can be sent to tank 1, to tank 3 or to both tanks. Next to tank 1 there is tank 2, once the liquid in tank 1 reaches a level of h it starts to fill also tank 2. The lower part of the system has the same configuration, tank 4 is next to tank 3 connected by a pipe at a distance h above the base of the tanks.
The methodology chosen to model the system in this
work is Hybrid Bond Graph (HBG), which is an
extension of Bond Graphs (BGs). BGs are defined as a
domainindependent energy-based topological modeling language
for physical systems [9]. Several types of primitive elements
are used to build BGs: storage elements (capacitances, C,
and inductances, I), dissipative elements (resistors, R) and
elements to transform energy (transformers, TF, and
gyrators, GY). There are also effort and flow sources (Se and
Sf), which are used to define interactions between the
system and the environment. Elements in a BG are connected
by 0 or 1 junctions (representing ideal parallel or series
connections between components). Each bond has associated
two variables (effort and flow). The power is defined as
effort × flow for each bond. The SCAP algorithm [
To model hybrid systems using BGs we need to use some
kind of connections which allow changes in their state.
Hybrid Bond Graphs (HBGs) [
A finite state machine control specification (CSPEC)
implements those junctions. Transitions between the CSPEC
states can be triggered by endogenous or exogenous
variables, called guards. CSPECs capture controlled and
autonomous changes as described in [
The system has four switching junctions: SW1, SW2,
SW3 and SW4. SW1 and SW3 are controlled ON/OFF
transitions, while SW2 and SW4 are autonomous
transitions. Both kinds of transitions are represented using a finite
state machine. Figure 3 shows: a) the automaton associated
with switching junction SW1 and b) the automaton
representing the autonomous transition in SW2. Since the system
is symmetric, automata for SW3 and SW4 are equivalent to
the ones shown in Figure 3.
Consistency-based diagnosis of continuous systems using
Possible Conflicts (PCs) [8] is based upon a
dependencycompilation technique from the DX community. PCs are
computed offline, finding minimal structurally
overdetermined subsets of equations with sufficient analytical
redundancy to generate fault hypotheses from observed
measurement deviations. Only structural and causal information
about the system description is required. This information
can be obtained from a set of algebraic and/or differential
equations, or can be automatically derived from bond graph
models [18; 19]. Once the set of PCs is found, they can
be implemented as simulation, state-observers or gray-box
models for tracking online actual system behavior [
The PCs approach has been recently extended to cope
with hybrid system dynamics, and the set of PCs for hybrid
systems were called Hybrid Possible Conflicts (HPCs) [
For the four-tank system we have found four HPCs. Each one of them estimates one of the measured variables (p1, p2, p3, or p4). Figure 4 shows the BG fragments of these four HPCs. In this example, the four HPCs were computed assuming that all switching junctions are set to ON.
As mentioned before, when any of these junctions is
switched to OFF, causality in the system needs to be
reassigned, but the HPCs generation process does not need to
be restarted again [
Regarding fault profiles, our current proposal works with single fault, and abrupt fault assumptions. Abrupt faults are modeled as an instantaneous change in a parameter, whose magnitude does not change afterwards (can be modeled as a step function).
Regarding parametric faults, fault isolation is performed
by means of the Reduced Qualitative Fault Signature Matrix
(RQFSM). Table 1 shows the RQFSM for the mode where
each switch is set to ON. For a given mode, the RQFSM can
be computed online from the TCG associated to an HPC [
We also consider discrete faults, i.e. faults in discrete actuators, as commanded mode switches which do not perform the correct action. In our case study, there are four faulty situations to be considered, where SWi denotes the switching junction i of the system.
1. SWi = 11: SWi stuck ON (1). 2. SWi = 00: SWi stuck OFF (0). 3. SWi = 01: Autonomous switch ON (SWi is OFF (0) and it switches to ON itself (1)). 4. SWi = 10: Autonomous switch OFF (SWi is ON (1) and it switches to OFF itself (0)).
CCCC2314++++ R0+1 R0+3 R+
1 R+
2 R+
3 R+
4 R1+2 R3+4 0− 0+ 0+ 0− −+ 0+ 0− −+ 0+ 0− 0+ 0+ −+ 0+ 0−
The relation between the HPCs and their related
switching junctions can be seen in Table 2, which is called Hybrid
Fault Signature Matrix (HFSM). This information can be
used in the unified framework for discrete and parametric
fault isolation and identification[
Discrete faults usually introduce high non-linearities in the system outputs, that should be easily detected if magnitudes related to the failing switch were measured, generating almost instantaneous detection for discrete faults. In this case, exoneration could be applied. But even if those measurements are not available we can still use the qualitative signature of the effects of the discrete faults in the HPC residuals. With this information we can build the socalled Hybrid Qualitative Fault Signature Matrix (HQFSM) that can also be used for exoneration purposes in the fault isolation stage. In our system we can build the following HQFSM for HP C1 and HP C3, which are linked to commanded switches SW1 and SW3, which are the potential source of discrete faults in our system. We do not show SW2 and SW4 in the table since they introduce hybrid dynamics in the system, but they can not be the source of a discrete fault.
Sf 1
Afterwards, the set of models for the HPCs for the actual mode are efficiently built, and they start tracking the system. Whenever a mode change, commanded or autonomous, is detected, a new set of models for the HPCs is computed online.
In case a fault occurs, one or more HPC residuals will trigger. Significant deviations in the residuals are found using the statistical Z-test. Based on the activated residuals for the set of HPCs in the current mode, the structural information in the HQFSM (Table 3), and the RQFSM (Table 1), we build the current set of fault candidates. This set can contain both discrete and parametric faults. Since discrete faults generally have a bigger and potentially more dangerous influence in the system behavior, in our framework we consider discrete faults as preferred candidates before considering the parametric ones. If there is no discrete fault as candidate, then we directly go to the fault identification as described in Section 6.
At this point we run the CUSUM algorithm (described in Section 5) to approximately determine the time of fault occurrence. Once this is done, we create a new simulation model using the HPCs, and starting at the fault time determined by the CUSUM, we begin tracking the system behavior in each one of the hypothesized mode changes (the HQFSM and the qualitative value of the HPC residuals are used to reject those modes that are inconsistent with expected deviations in the HQFSM). If the hypothesized mode is the correct one, the residual for that mode will go to zero after a relatively small period of time (this is possible, as we will show later, thanks to the accurate estimation of the fault time provided by the CUSUM). If the hypothesized mode is not correct, the residual will keep deviating from zero, and after an empirically determined time window without converging, the discrete fault candidate will be discarded. If only one mode has the residual close to zero, this is the new system mode.
If the residual for each hypothesized new mode does not converge to zero, discrete faults (as mode changes) are discarded and we focus on parametric faults, starting the identification stage. As mentioned before, qualitative fault signatures in the RQFSM can be used to reject those parametric faults non consistent with current observations thus focusing even further the fault identification stage.
Finally, once the set of parametric fault candidates is refined through the RQFSM, we perform fault identification for the set of remaining parametric fault candidates. Fault identification is done with hybrid parameter estimators, which are presented in Section 6. 5
In the previous section we have presented our fault isolation approach of discrete faults by hypothesizing the faults compatible with the Hybrid Qualitative Fault Signature Matrix and filtering out those faults whose models do not converge. Divergence of non-current models is usually easy to check when we are dealing with discrete faults. However, the convergence of the current model may be slow if initial values of the state variables of the model are not known or our initial guess is far from the actual value. We are assuming that we are able to track the system dynamic before the occurrence of a fault. In other words, we are assuming that we know -or we are able to estimate- the state variables before the time of fault occurrence. Hence, in order to speed up the convergence of the current model, it is important to have a good estimation of that time.
The cumulative sum algorithm, CUSUM, introduced by
[
On the other hand, the Z-test [
In order to have a robust fault detection mechanism and a good approximation of the fault time, we have opted for combining both tests. We use Z-test to perform fault detection and, afterwards, we estimate the fault time using CUSUM.
CUSUM was designed to detect abrupt changes in the
mean of stochastic signals. In the simple case of a
Gaussian residual, res(i), of constant variance σ2, constant
and known initial mean μ0 and constant and known
fik
nal mean μ1, the decision signal, Sk, is Sk = P si =
i=1
k
P μ1σ−2μ0 (res(i)− μ0 +2μ1 ). Hence, for a window of N
sami=1
ples with a change in mean at 1 ≤ t0 ≤ N , Sk decreases at
the constant rate μ = μ1−μ0 for k < t0 and increases by μ
2
for t0 ≤ k. It can be shown [
When μ1 is unknown, it can be set to the residual corresponding to the smallest fault to be detected, typically some units of the residual noise deviation, σ. This can be done without increasing the fault positive alarm rate because we use Z-test to perform fault detection, and we only use this CUSUM variant to estimate the time of fault occurrence, t0. We have also tried estimating μ as the empirical mean of the residual, with similar results. In all the cases we have tested, the estimated time of fault occurrence, tˆ0, computed by CUSUM, is smaller than the detection time provided by Z-test. 6
Once all the discrete fault candidates have been discarded,
we have to do fault identification for the set of isolated
parametric faults. In previous work [
The fault identification process is done by the following steps: (i) model decomposition by offline computation of the set of HPCs from the hybrid bond graph model; (ii) offline computation and selection of the better hybrid estimator for each fault candidate; (iii) after the fault isolation process, online quantitative parameter estimation procedure over the hybrid estimators related with the set of isolated fault candidates; and (iv) decision procedure to select the faulty candidate.
Using HPCs we can derive the structure of a hybrid parameterized estimator, ehpck , for a hybrid system. The parameterized estimator ehpck can be used as a hybrid estimator as stated in the following proposition:
Proposition 1. A HPC, HP Ck, along with its set of input variables, uhpck , the commanded signals of the switching junctions, swhpck , and initial value of the parameter to identify, θf , can be used as a parameter estimator using yˆhpck = ehpck (uhpck , θf , swhpck (t)), where the measured variable estimated by the HPC, yˆhpci , is solved in terms of the remaining measured variables.
Each estimator is uniquely related to one HPC, hence it contains minimal redundancy required for parameter estimation. In this case, each HPC has an executable model that can be used for simulation purposes. For the four-tank system we have obtained four hybrid parameter estimators shown in table 4, one for each HPC.
Estimator e1 e2 e3 e4
Related
P C HP C1 HP C2 HP C3 HP C4
P arameters Inputs R01, R03, R12, R1, C1 Sf , p2, p3
R12, R2, C2 p1 R01, R03, R34, R3, C3 Sf , p1, p4
R34, R4, C4 p3
Output p1 p2 p3 p4
The basic idea is to use the estimator ehpck to compute estimations for yˆhpck with different values of the parameter θf , so that we can find a value of the parameter that minimizes the least squares (LS) error between the estimation yˆhpck and the measured value yhpck .
Fig. 5 shows the parameter estimation process using the hybrid estimators. A parametrized estimator, ehpck , uses the inputs of the system, uhpck , and a parameter value, θf , to generate an estimation of the output, yˆhpck . This estimated output is compared against the observed output, yhpck , by the quadratic error calculator block. This block computes the quadratic error between yˆhpck and yhpck for the fault candidate f , E2. Then, the iteration engine block, that conf tains a nonlinear optimization algorithm, finds the minimum of the error surface Ef2(θf ), by iteratively invoking the estimator with different parameter values. The value of the parameter and its minimum LS error will be the output of the parameter estimation block (and the input for the decision procedure block).
Fault candidate f (θf initial value)
Inputs: uHPC k
eHPC k estimator (obtained from HPCk) yˆHPCk Output: yHPC k quadratic
error calculator θ*f E2f
<E2f, θ*f> Iteration Engine 50 100 150 200 250 300 350 400 450 500
Time (s)
140 Time (s) 160 180 200
In the first experiment, we assume that the water tanks are initially empty, and start to fill in at constant rate. Hence, the initial configuration of the system is SW1 and SW3 set to ON, and SW2 and SW4 set to OFF. Tanks 1 and 3 start to fill in, and approximately at time 20 s level in both tanks reach the height of the connecting pipes and tanks 2 and 4 start to fill in. At time190 s, a fault occurs in the controlled junction SW1, which switches off (see Fig. 6 for the measured pressures in the four tanks for this experiment).
Four seconds after the fault is introduced, at t = 194 s, both HP C1 and HP C3 trigger, and consequently both SW1 or SW3 are initially considered as discrete fault candidates. At this point, the CUSUM algorithm is run, determining that the fault has occurred at t = 191 s. In this case study we use a CUSUM window of size 100. Figure 7 shows the output of the CUSUM algorithm where the absolute maximum represents the approximate time (due to noise in the system) of fault occurrence.
Once the point of fault occurrence has been determined at t = 191 s, the diagnosis framework takes the values of the simulation at such time instant and launches two parallel diagnosis experiments, one for each hypothesized fault candidate, i.e., SW1(10) and SW3(10). Figs. 8 and 9 show the pp11 -- HmePaCsu1 reesmtiemnattion estimation and the residual for HP C1 when the hypothesized faults are SW1(10) and SW3(10), respectively (we do not show the result for HP C3 since are similar to the results obtained for HP C1). Looking at the results, it is obvious that the residual converges to zero when a fault in SW1(10) is hypothesized, while the residual when SW3(10) is hypothesized does not converge. Hence, SW1(10) is confirmed as the fault. This confirmation is done by continuously analyzing residual signals with the Z-test. Please note that, since the CUSUM algorithm gives a good approximation of the point of failure, the residual is able to converge very quickly when the true fault is hypothesized. For comparison purposes, Fig. 10 shows the estimation and residual for HP C1 when CUSUM is not used to re-initialize the simulation (for the hypothesized fault SW1). By comparing this figure with Fig. 8 it is clear that using CUSUM allows the HPC to converge faster.
As a second diagnosis experiment, we start off from the same situation of the previous experiment, but in this case, we introduce a small parametric fault and after a short while, 50 100 150 200 250 300 350 400 450 500
Time (s) 50 100 150 200 250 300 350 400 450 500
Time (s) 50 100 150 200 250 300 350 400 450 500
Time (s) 100 120
140 Time (s) 160 180 200 a discrete change. Specifically, a 20% blockage in the input pipe of tank 1, R01, is introduced at t = 190 s, and then SW1 is commanded to switch OFF at t = 210 s (Fig. 11 shows the measured pressures in the four tanks for this experiment).
For this experiment, both HP C1 and HP C3 trigger at t = 198 s (as an example, see Fig. 12 with the estimation and residual for HP C1), and consequently both SW1(10) and SW3(10) are initially considered as discrete fault candidates. However, in this scenario, after running the CUSUM (see Fig. 13 for the CUSUM output), which estimated the fault time at t = 191s, and the diagnosis experiments for both fault candidates, none of the residuals was able to converge within a reasonable, empirically determined, amount of time, thus concluding that a parametric fault has occurred. At this point, the fault identification process is triggered for R01, which is the only parametric fault candidates (R03 is discarded due to the qualitative sign in the residuals). The estimated value for parameter R01 was 0.1937, i.e., a 19.37% blockage in the pipe. Please note that the estimator used a total of 60 seconds of data starting from t = 191 s, hence, the estimator was capable of correctly estimating the value of the faulty parameter even if the system transitions from one mode to another during the estimation process.
We run several experiments with different mode configurations and different faults, varying the size, time of fault occurrence (in some of them by introducing faults immediately after the mode change). Results for all these situations were equivalent to the examples shown in this section. 8
In this work we have presented an approach for hybrid systems fault identification using Hybrid Possible Conflicts. Using HBGs we can generate minimal estimators that can be used for fault identification just considering the possible mode changes within the estimators. Additionally, we have proposed the integration of the CUSUM algorithm to accurately determine the time of fault occurrence. A more accurate estimation of the fault instant allows to quickly isolate discrete faults, and to obtain a better approximation of the values of the state variables, which are needed as initial values for the fault identification. Diagnosis results using a four-tank system showed that the proposed approach can be successfully used for fault identification of hybrid systems.
In future work, we will test the approach in more complex systems with real data, and will propose a distributed approach for hybrid systems fault diagnosis.
This work has been funded by the Spanish MINECO DPI2013-45414-R grant.