Comparison of Fault Detection Strategies on a Low Bypass Turbofan Engine Model

A thesis submitted to the Graduate School of the University of Cincinnati in partial fulllment of the requirements for the degree of

Master of Science

in the Department of Aerospace of the College of Engineering by

Mark Aull B.S. University of Cincinnati June 2006

Committee Chair: B. Walker, Sc.D.

Abstract Current diagnostics on most gas turbine engines involve o-line processing only. Since failures can cause serious safety and eciency problems, such as elevated turbine temperatures or compressor stall, it is desirable to diagnose problems in as close to real-time as possible. This project applies some of the methodology of Rausch, et. al. to a simulation of a low bypass turbofan. The model uses 9 health parameters to simulate faults or degradation of engine components. Sensor residuals from an extended Kalman lter were used with a nonlinear engine model to estimate the engine health parameters. Other methods for generating health parameter estimates were also implemented and compared, including a tracking lter based on Newtons method and a back-propagation neural network. An implementation of a Bayesian network to engine fault diagnostics is demonstrated and a fuzzy diagnostic system is developed using a similar method, avoiding many of the diculties traditionally encountered while developing fuzzy systems (the eectively innite design degrees of freedom available while designing the system). Finally, the results of the diagnostic systems are compared in terms of accuracy of fault diagnosed, accuracy of the health parameter estimates produced, (simulation) time taken to produce a correct diagnosis, and time needed for the computation. The Bayesian network and fuzzy system have the best overall performance: both systems correctly diagnose each component fault, while the LKF and tracking lter fail for some cases and the neural network fails under some conditions. The Bayesian network diagnoses faults in about half the time from the introduction of the fault, while the fuzzy system estimates the health parameters more accurately and is less computationally intensive.

III

Acknowledgments

The author would like to thank my colleagues at General Electric Aircraft Engines for the use of their engine model as well as their support through GE P.O. #200-1-14U36188 which developed the simulation results on which this paper is based.

Contents
1 Acknowledgments 2 Terminology 3 Introduction 3.1 Approaches Examined Here . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . V XI 1 5 7 7 8 9 10 11 12 14 17 21 21 25 28 32 34 38 41 45 47

4 Methodology 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fault Diagnoses from Parameter Estimates . . . . . . . . . . . . . . . . . . . . . . . Sensor Dot Product . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tracking Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kalman Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Back-Propagation Neural Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bayesian Belief Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fuzzy Logic System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5 Results 5.1 5.2 5.3 5.4 5.5 5.6 5.7 Sensor Dot Product . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tracking Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Linearized Kalman Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Back-propagation Neural Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bayesian Belief Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fuzzy Logic System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Comparison of methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6 Conclusion 6.1 Future Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

VI

List of Tables
5.1 5.2 Diagnostic Results for Each Fault Case Using the Dot Product of Sensor Outputs . Health Parameter Estimates for Each Fault Case Using the Dot Product of Sensor Outputs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 Health Parameter Estimate Percent Errors for Each Fault Case Using the Dot Product of Sensor Outputs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4 5.5 Diagnostic Results for Each Fault Case Using Newtons Method Tracking Filter . . Health Parameter Estimates for Each Fault Case Using Newtons Method Tracking Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6 Health Parameter Estimate Percent Error for Each Fault Case Using Newtons Method Tracking Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.7 5.8 5.9 Diagnostic Results for Each Fault Case Using Linearized Kalman Filter . . . . . . . Health Parameter Estimates for Each Fault Case Using LKF . . . . . . . . . . . . . Health Parameter Estimate Percent Errors for Each Fault Case Using LKF . . . . . 26 29 29 29 32 32 26 23 25 22 22

5.10 Diagnostic Results for Each Fault Case Using Neural Network . . . . . . . . . . . . 5.11 Health Parameter Estimates for Each Fault Case Using Neural Network . . . . . . .

5.12 Health Parameter Estimate Percent Errors for Each Fault Case Using Neural Network 33 5.13 Health Parameter Estimates for Deteriorated Engine for Each Fault Case Using Neural Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.14 Health Parameter Estimate Percent Errors for Deteriorated Engine for Each Fault Case Using Neural Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.15 Health Parameter Estimates for Each Fault Case Using a Bayesian Belief Network . 5.16 Health Parameter Estimate Percent Errors for Each Fault Case Using a Bayesian Belief Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 39 33 36 33

5.17 Health Parameter Estimates for Each Fault Case Using Fuzzy Logic System . . . . 5.18 Health Parameter Estimate Percent Errors for Each Fault Case Using Fuzzy Logic System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.19 Sum of Squared Errors in Diagnostic Results for Each Fault Case for All Algorithms 5.20 Sum of Squared Errors in Health Parameter Estimates Across all Fault Cases . . . . 5.21 Certainty of Diagnosis: Diagnostic Value for Correct Fault/Next Highest Diagnostic Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VII

39 41 41

42

5.22 Diagnostic Success (% of samples) in the Presence of Noise . . . . . . . . . . . . . . 5.23 Algorithm Computational Requirements . . . . . . . . . . . . . . . . . . . . . . . . 5.24 Iterations Required for Convergence to Correct Diagnosis for Each Case . . . . . . .

43 44 44

VIII

List of Figures
4.1 4.2 4.3 4.4 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 Generating CPT part 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Generating CPT part 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . FLS example input membership functions. . . . . . . . . . . . . . . . . . . . . . . . FLS example output membership functions. . . . . . . . . . . . . . . . . . . . . . . Sensor Dot Product Health Parameter Estimates for Noiseless Fan Fault Cases . . . Sensor Dot Product Health Parameter Estimates for Fan Fault Cases with Noise . . Sensor Dot Product Health Parameter Estimates for Noiseless HPT Fault Cases . . Sensor Dot Product Health Parameter Estimates for HPT Fault Cases with Noise . Tracking Filter Health Parameter Estimates for Noiseless Fan Fault Cases . . . . . . Tracking Filter Health Parameter Estimates for Fan Fault Cases with Noise . . . . . Tracking Filter Health Parameter Estimates for Noiseless HPC Fault Cases . . . . . Tracking Filter Health Parameter Estimates for Noiseless HPT Fault Cases . . . . . Tracking Filter Health Parameter Estimates for HPT Fault Cases with Noise . . . . 15 15 18 19 23 24 24 24 26 27 27 27 28 30 30 30 31 31 31 34 35 35 35 37 37 37 38 39 40 40

5.10 LKF Health Parameter Estimates for Noiseless Fan Fault Cases . . . . . . . . . . . 5.11 LKF Health Parameter Estimates for Fan Fault Cases with Noise . . . . . . . . . . 5.12 LKF Health Parameter Estimates for Noiseless HPT Fault Cases . . . . . . . . . . . 5.13 LKF Health Parameter Estimates for HPT Fault Cases with Noise . . . . . . . . . . 5.14 LKF Health Parameter Estimates for Noiseless LPT Fault Cases . . . . . . . . . . . 5.15 LKF Health Parameter Estimates for LPT Fault Cases with Noise . . . . . . . . . . 5.16 Neural Net Health Parameter Estimates for Noiseless Fan Fault Cases . . . . . . . . 5.17 Neural Net Health Parameter Estimates for Fan Fault Cases with Noise . . . . . . . 5.18 Neural Net Health Parameter Estimates for Noiseless HPT Fault Cases . . . . . . . 5.19 Neural Net Health Parameter Estimates for HPT Fault Cases with Noise . . . . . . 5.20 Bayesian Network Health Parameter Estimates for Noiseless Fan Fault Cases . . . . 5.21 Bayesian Network Health Parameter Estimates for Fan Fault Cases with Noise . . . 5.22 Bayesian Network Health Parameter Estimates for Noiseless HPT Fault Cases . . . 5.23 Bayesian Network Health Parameter Estimates for HPT Fault Cases with Noise . . 5.24 FLS Health Parameter Estimates for Noiseless Fan Fault Cases . . . . . . . . . . . . 5.25 FLS Health Parameter Estimates for Fan Fault Cases with Noise . . . . . . . . . . . 5.26 FLS Health Parameter Estimates for Noiseless HPT Fault Cases . . . . . . . . . . . IX

5.27 FLS Health Parameter Estimates for HPT Fault Cases with Noise . . . . . . . . . .

40

Terminology

A= linearized state dynamics matrix B = linearized input dynamics matrix BBN= Bayesian Belief Network C = linearized output matrix CLM= component level model CPT= conditional probability table Ey =health parameter: eciency delta at station y = (neural network) learning rate f = health parameter vector f 0= nominal health parameter vector FADEC= Full Authority Digital Engine Controller FLS= Fuzzy Logic System HPC= high pressure compressor HPT= high pressure turbine I = identity matrix of appropriate dimensions J = weighted error (Newtons method or Neural Network) to be minimized k = (Newtons method) gain parameter K = (Newtons method or Kalman lter) gain matrix l= (BBN) possible fault type LPC= low pressure compressor LPT= low pressure turbine m= (BBN) possible fault magnitude N 2= speed of low pressure shaft N 25= speed of high pressure shaft P = (Kalman lter) state covariance P [A]= probability of A P [A|B ]= conditional probability of A given B [A]= prior probability of A PDF= Probability Density Function P Sy = static pressure at station y XI

P S 14= inlet static pressure P S 3= HPC exit static pressure P T y = total pressure at station y P T 25= HPC total pressure = state transition matrix Q= (Kalman lter) process noise covariance R= (Kalman lter) measurement noise covariance rij = jth possible (BBN) state for sensor i = standard deviation of noise si = value of sensor i T y = temperature at station y T 25= HPC temperature T 4B = turbine blade temperature T 56= turbine exit temperature u= commands to engine (fuel ow, guide vane angle, exit area) W = weighting matrix for Newtons method or neural network W y = health parameter: ow delta at station y Xk = quantity X at time tk x= expected or exact state values, especially health parameter values x = state/health parameter estimates y = raw sensor values (with noise) y = sensor values after noise averaged out y = expected or calculated sensor values y 0= nominal sensor values for operating condition

Station numbers: 12 bypass ow at fan location 13 at bypass just after fan 2 LPC 26 HPC entrance 3 HPC exit, combustor entrance 4 combustor exit XII

41 HPT 49 LPT 6 mixing between hot ow and bypass 8 nozzle throat

XIII

Introduction

Fault tolerance is a desirable characteristic for control systems in general, and can be accomplished by using either a suciently robust controller or by detecting and accommodating faults.[7] Gas turbine engine health monitoring is critical for both safety and economic reasons. It is obviously desirable to avoid problems requiring in-ight shut-downs or emergency landings. However, it is also desirable from an economics standpoint to minimize engine down-time.[14] The most eective way of accomplishing this objective is by diagnosing problems in the engine early enough that maintenance can be performed when it is convenient, before these problems become serious enough to require emergency service, interrupting ight schedules and causing costly delays.[8] The process of detecting faults involves determining that a fault has occurred, determining the location (which component has failed), and then determining the size of the fault[7]. Types of faults that can occur include parameter changes, discrepancies in states caused by dynamics of the system that were not included in the model, sensor or actuator failures, and other hardware failures. One method for detecting and accommodating sensor faults is hardware redundancy, basically using multiple sensors, which should normally produce similar readings. An error can be detected when the reading from one sensor is dierent from others by more than just the noise level. However, analytically redundant systems, which use the expected relationships between dierent sensors, or dierent types of sensors, to determine when a fault has occurred, are cheaper and lighter because they use hardware that is already present in the system [7]. Sensors are included in an engine design to allow feedback control to achieve desired performance. Adding more sensors to aid in the detection of failures increases the weight, complexity, and cost of the engine, while possibly decreasing its eciency and introducing more possible sources of failures and more instrumentation that must be checked out and calibrated before each ight. Thus, diagnosing engine faults requires that the health of the engine be determined from the relatively small number of sensors that are needed for engine control. Therefore, ecient health monitoring algorithms must be developed to extract more detailed information about the state of the engine from a limited number of measurements of rotational speeds, temperatures and pressures that are typically sensed in the engine. These algorithms must also be optimized for eciency so that they

can be run on the engines on-board processors quickly enough to provide a prompt and accurate alert when a problem occurs[13]. Methods for fault detection in dynamic systems applications are classied as model based, qualitative model based, or history-based (i.e. data-based). Model-based fault detection schemes are based essentially on analytical redundancy: the sensor outputs are not independent from each other nor from the inputs to the system, and, given suciently accurate knowledge about these relationships, they can be used to detect discrepancies. Clearly, model-based methods require an accurate analytical model of the system. Many model-based methods involve linearizing the model (if it is non-linear) about an operating condition and putting it into state space form (continuous or discrete), then calculating a residual vector from the measurements. The size of the residual can be compared to a threshold to determine if a fault has occurred. Other properties of the residual vector are then evaluated to determine what fault has occurred and the magnitude of the fault. This can be accomplished by either designing the residual generation process such that each element of the residual vector corresponds only to one particular fault, or by comparing the direction of the residual vector to the direction expected for each fault[7]. Parity relations use variants of the state space description of the system to detect dierences between the outputs of the model and the behavior of the measured outputs of the system. They produce a residual that is zero, to within a noise level, for perfect agreement between the model and the real system, and non-zero in the presence of a fault. This residual can then be used to diagnose faults if the residual directions are distinct for dierent fault types[13]. Parameter estimation is often used for fault detection in gas turbine engines. In this approach, the eects of faults are characterized by parameters representing eciencies and ow corrections in the models of the engine components. These parameters are often called health parameters. Various methods, including Newton-Raphson optimization, can be used to estimate these health parameters, but the method most commonly used is some variation of the Kalman lter. These parameters generally vary slowly with the normal aging of the engine, but change suddenly when faults occur. Therefore, the health parameters are assumed to be static in the dynamic model, but a nonzero entry in the state covariance matrix (a pseudo-noise) is included to allow the Kalman lter to continue modifying the parameter estimates after they initially converge.[8] 2

The characteristics of any measurement noise that may be present require the Kalman lter to converge slowly to avoid being severely aected by that noise. This often results in a system that is good at tracking normal (slow) engine degradation, but slow to respond to sudden faults. The lter will then modify the health parameter estimates that correspond to the engine component that has experienced a fault, but because these estimates change relatively slowly, the residual often remains signicantly non-zero for a long enough period that other health parameter estimates are also modied. This can lead to incorrect diagnoses.[8] One approach that has been used to correct for this eect is to use multiple Kalman lters: one for normal operation, and one for each possible failure condition. Then, some internal logic is used to decide whether the parameters are changing too quickly to be just normal degradation, and whichever Kalman lter best tracks the changes measured in the output values is assumed to correspond to the fault that has most likely occurred. This method has the disadvantage of requiring multiple Kalman lters to be implemented on-line, and the added computational requirements of running all of them simultaneously. This approach is also sensitive to modeling errors that may be present.[8] Another approach to parameter estimation for turbine engines is to use an adaptive Kalman lter to modify the health parameters. The most recent N sets of sensor outputs are stored, and their means and covariances are calculated. When changes occur, the process covariance for the health parameter model (pseudo-noise) in the Kalman lter model is set higher, which places more weight on recent data, so that the health parameter estimates can vary more quickly. The authors [8] tested this algorithm on a simulated engine, and tracked the RMS error of the output estimate. The standard Kalman lter was able to track the parameters well enough to produce below 0.15% error for degradation, but higher than 0.4% error after a fault, because the lter spread the eects of a fault to the health parameter estimates for multiple components. The adaptive lter was able to keep the error below 0.15% for the entire simulation. This allowed it to correctly diagnose all but one failure case (a drop in ow and eciency on the low pressure turbine (LPT)), while the standard algorithm failed to diagnose 9 of the 13 test cases. The adaptive Kalman Filter may be helpful for parameter estimation applications where slow parameter changes are occasionally interrupted by sudden changes, such as those caused by faults. 3

The use of averaging to eliminate noise should make it suitable for use in on-line engine diagnostics. However, it has not been tested on real hardware. The use of an adaptive process covariance in a Kalman lter therefore helps solve the problem of picking a ratio between process and noise covariances that is both able to lter out noise and quickly modify the health parameter estimates after a fault.[8] When an analytical model or even quantitative outputs are unavailable, a qualitative model can be used to connect symptoms to faults, using, for example, an expert system or a Markov model based observer [7]. Model free methods are based on collecting system output samples (training data) under known fault conditions in order to train a classier to distinguish between those fault conditions. This classier may be a Bayesian classier, nearest neighbor scheme, a neural network, etc. The classier produces a likely fault condition as output given measurements from a system.[7] A Bayesian Network was successfully applied to diagnostics on an engine model by Romessis and Mathioudakis[12]. The system correctly diagnosed the health parameter that was varied in each of several benchmark cases that involved varying a single parameter. For cases where multiple parameters were varied, the system was able to correctly identify the section of the engine (the fans and compressors are referred to as the cold section, the combustor and turbines the hot section and there is also a nozzle section) where the fault occurred, though not necessarily the specic component. Fuzzy Logic Systems are universal approximators which map a vector input to a scalar or vector output using fuzzy logic. They are composed of a fuzzier, some rules to be applied, an inference engine, and a defuzzier. The fuzzier maps an input number onto membership levels in fuzzy sets, and the defuzzier maps fuzzy output, again in the form of degrees of membership in fuzzy sets, to numerical output. The rules are of IF-THEN form and can be derived from data or linguistic instructions. They are applied in the inference engine to the fuzzy inputs to produce the fuzzy outputs.[10] Fuzzy logic systems have been used in engine diagnostics work. Diao and Passino used fuzzy systems to approximate a CLM at various ight and power conditions and then interpolate between them to form a simplied non-linear model. This was used rst to develop a neuro-fuzzy fault tol4

erant controller.[4] Later, a bank of these fuzzy models running dierent fault conditions generated residuals that were used to detect and isolate faults simulated in the CLM.[5] Yu et. al. designed a fuzzy system to go through engine records (samples are stored for takeo, climb, and cruise for each ight) to detect and identify faults from performance changes.[17] Whitehead et. al. [16] trained a Kohonen neural network to detect anomalies on the Space Shuttle Main Engine. They did not focus heavily on diagnostics, since most potential problems have either never occurred or have occurred only once. They used power spectrum coecients rather than raw or ltered sensor data as the input to the network, because many of their sensors in this case are strain gages and accelerometers. For training data, they used only samples of normal operating data, then tested the network using two data sets that included anomalies, and found that the network detected a problem at times corresponding to the failure occurrence times indicated in the NASA Investigative Board reports. Hybrid methods have also been developed. Any diagnostic scheme based on an analytical model will interpret modeling error as a fault because the dierence between the predicted and actual outputs will cause non-zero residuals. Luppold et. al. [9] started with a pure model based fault detection system, STORM (Self Tuning On-board Real-time engine Model), based on a piecewise linearized component level model, with a Kalman lter used to estimate engine health parameters, and enhanced the engine model by adding a neural network to learn the errors between the model and engine data, and therefore compensate for modeling errors, mitigating or even eliminating their eects on the fault identication residuals.[9]

3.1

Approaches Examined Here

This paper will compare dierent fault detection strategies applied to a component level model (CLM) of a low bypass turbofan, but with the long term goal of producing an algorithm that can run in real time on a Full Authority Digital Engine Controller (FADEC) with an embedded engine model. A CLM simulates an engine using physical equations and empirically derived maps for compressor, turbine, etc. performance. Nine health parameters are used to simulate engine degradation and damage. They represent an eciency loss and a ow delta for the fan, high

pressure compressor (HPC), high pressure turbine (HPT), and low pressure turbine (LPT), and a sensor bias for the fuel ow sensor. Parameter estimation methods involve tuning the health parameter estimates on an engine model to match its outputs to those from a real engine, and using the models estimated health parameters to infer the condition of the real engine. The engine currently uses a fault detection strategy involving storing a sensor sample once for each ight, usually during takeo, for oine processing. Therefore, this paper will focus on a ight condition at an altitude of 2000ft, and a speed of Mach 0.125, consistent with a terminal condition like takeo or landing. The contribution of this paper is to compare various fault detection strategies on a single engine model. Fault detection strategies will be evaluated based on several criteria: correct diagnoses of faults and avoidance of false alarms, accuracy of the health parameter estimates produced, (simulation) time taken to produce a correct diagnosis (number of engine model iterations before diagnosis), and time taken for the diagnostic system to run (computational eciency).

4
4.1

Methodology
Model

This paper focuses on the problem of detecting gas path faults in a two-spool turbofan engine. A nonlinear component level model of the engine in Simulink was provided by GE Aviation. The model uses nine health parameters, representing ow deltas and eciency changes in the fan, HPC, HPT, and LPT components, as well as a fuel ow bias. The engine has eight sensed variables available: low pressure spool speed (N 2), high pressure spool speed (N 25), inlet static pressure (P S 14), HPC total pressure (P T 25), HPC exit static pressure (P S 3), HPC exit temperature (T 25), turbine blade surface temperature (T 4B ), and turbine exit temperature (T 56)[15]. Failures are simulated by setting the health parameter values for the true engine model such that: a compressor or fan failure is associated with a decrease in eciency and a decrease in ow delta for that component, a turbine failure is associated with a decrease in eciency and an increase in ow delta. The nine health parameters that are given as input to the real engine can be set to values corresponding to large and small magnitude component faults for the fan, HPC, HPT, LPT, and fuel ow. These values are also provided by GE Aviation. The health parameter changes applied for each large fault case are normalized to 1 in the results shown here and the parameters for the small faults are 25% of those for the large faults for turbomachinery and 40% for the fuel ow fault. Including a no-fault baseline run, this results in 11 fault cases for each condition tested.[15] The health parameter values can also be used to emulate new or degraded engines. The parameters used by the engine model are initialized with values consistent with either a new or very degraded engine (where any more degradation would trigger maintenance), as provided by GE Aviation. The parameter values corresponding to the appropriate component fault are then added at the desired time to begin simulating the fault.[15] For cases with noise, MATLAB is used to generate pseudo-random numbers in a Gaussian distribution with the standard deviation expected for each sensor. These values are added to the sensor values generated by the engine model. To develop some of the fault detection systems, the CLM is linearized about the operating condition of Mach 0.125 at 2000ft and put in the state space form: 7

x[k + 1] = x[k ] + B u[k ] + E 1 d[k ] + R1 f [k ] y [k ] =C x[k ] + D u[k ] + E 2 d[k ] + R2 f [k ]

(1) (2)

If the health parameters are treated as states, the corresponding part of the state transition matrix, , is an identity matrix, and the health parameter values at the next time step are not sensitive to any of the other states. Therefore, the health parameters (f [k ] below) are static, so a calculation of f [k + 1] is not required, and they are not required to be included as states in x[k ] for the purpose of modeling the engine behavior (they are included as states in the tracking lters that are intended to estimate their values).

4.2

Fault Diagnoses from Parameter Estimates

Several parameter estimation approaches were used, producing estimates for each of the health parameters. The errors in the parameter estimates at steady state relative to the known true values used by the simulation that produced the sensor data and the speed of convergence of the parameter estimates are used to evaluate these approaches. However, the primary concern here is the ability to diagnose faults using these estimates. For the methods that produce estimates for the health parameters, the fault is diagnosed from ve fault indices created by computing the dot product of the vector of the estimated health parameter changes with the known vector of health parameter changes for each simulated fault type. The largest such fault index is then interpreted as the diagnosed fault for that set of estimates. The margin between the largest and next largest fault index is evaluated as a measure of the certainty of diagnosis for each algorithm. For methods that produce fault indices directly, the health parameter estimates are created from the expected pattern of health parameters for the indicated fault.

4.3

Sensor Dot Product

For the simplest fault detection scheme considered, a linear operator is applied to a vector containing the normalized dierences between the sensor outputs and the nominal sensor outputs,
yi y 0i . y 0i

In

order to build this system, the model is rst run to steady state under a fault condition corresponding to each fault type (fan, HPC, fuel ow, HPT, LPT). Then, the steady state sensor values are collected, and a matrix (5x8) is constructed from the normalized dierences. The nominal sensor values are the steady state values for the no-fault case, for either the new or degraded case, as applicable. For use with a real engine, the sensor outputs from the previous ight could be used to compensate for degradation and individual engine dierences. Multiplying this matrix onto the normalized dierences between a set of sensor values and the appropriate nominal condition values yields a 5x1 vector. The element of that vector with the highest positive value corresponds to the most likely fault condition. Another 9x5 matrix can be constructed to generate health parameter estimates by calculating coecients to scale the 5x1 vector of diagnostic results to the values of the health parameters in the simulation. Since this matrix is rank 5, the 9-dimensional health parameter estimates are a projection from the 5-dimensional diagnostic results. This means the estimates for ow and eciency changes for a component will be identical. In practice, this method is modied by setting all values of the diagnostic vector except the highest to zero before applying the projection. This results in higher accuracy of the parameter estimates, as long as the fault is correctly diagnosed.

4.4

Tracking Filter

The tracking lter algorithm uses a Newton-Raphson step to minimize the weighted squared error in the output estimate: 1 J = (y y [x]) W (y y [x]) 2 J = y [x] W (y y [x]) x L 2J y [ x ] W y [ x ] Hyi [x] Wi,i (yi yi [x]) = x2 i=1 x k+1 = x k K K =k 2J x2 J x
1

(3) (4) (5) (6) (7)

Making a small change to the state in the opposite direction of the derivative of the weighted error, J (which is the sum of squares of y y [x], weighted by W ) should decrease this weighted error. Using the Hessian of the weighted error, eq(5), to scale the change to the state (gain matrix K ) makes this a Newtons method, which is optimal in terms of the number of iterations until convergence, but takes more operations per iteration and is less stable than a steepest descent method, which uses a constant matrix for K . For the Newtons method, k is a gain parameter that is raised to decrease iterations to convergence and lowered to increase stability. For this project, the gains were selected by trial and error and evaluated on their ability to accurately estimate health parameters for all fault conditions (the results shown later in section 5.2 use k = .5). The linearized output equation (eq(2)) can be substituted into eq(3)-eq(7) to simplify the implementation of this algorithm producing:

10

1 ) W (y C x ) J = (y C x 2 J = C W (y C x ) x 2J =C W C x2 K = k (C W C )
1

(8) (9) (10) (11)

Since the number of outputs is less than the number of states, a pseudo-inverse is used to calculate the gain matrix for the tracking lter (eq(11)). Fault indices are created as described in Fault Diagnoses from Parameter Estimates, section 4.2.

4.5

Kalman Filter

The linearized and extended Kalman Filters use a Kalman lter algorithm:

x + k+1 = k x k + Bk uk
+ T Pk +1 = k Pk k + Qk T T 1 K k = Pk +1 Ck (Ck Pk+1 Ck + Rk )

(12) (13) (14) (15) (16)

x + k = x k + Kk (yk Ck x k)
+ T = (I Kk Ck )Pk (I Kk Ck )T + Kk Rk Kk Pk

Eq(12) is the familiar discrete time state space equation, which is used to propagate the state estimate, i.e. predict where it will be at the next time step given the current inputs to the system and the estimate of its value at the current time step. k , Bk , and Ck are, respectively, the state transition matrix, the input dynamics matrix, and the output matrix at time step k . x k is the state estimate and uk is the input, both at time step k. Eq(13) shows the error covariance update, where Pk is the error covariance at time step k , and Qk is the process noise covariance. The or + superscripts on the state estimate and covariance indicate whether the quantity represents an 11

estimate before or after it is updated by the sensor reading at the current time step, yk . Eq(14) calculates the Kalman gain at time tk , Kk , using the measurement noise covariance, Rk . Eq(15) and eq(16) update the state estimate and error covariance, respectively, using the measurements at time tk . The lter algorithm has been augmented by making the health parameters states in the linearized model. The dynamics for the added states are static, but pseudo-noises are included in the process noise covariance matrix for these static states to prevent the algorithm from holding the parameter estimates constant after they initially converge. Since the lter is not expected to perfectly estimate the health parameters, the fault is diagnosed by creating 5 fault indices from the dot products of the vector of health parameter estimates with the expected pattern of health parameters for each of the 5 fault types (fan, HPC, HPT, LPT,and fuel ow), as in section 4.2. Since the CLM is inherently nonlinear, and the Kalman lter algorithm requires a linearization, there are two approaches: the Linearized Kalman Filter, and the Extended Kalman Filter. The LKF uses a linearization of the system dynamics and output equation about a pre-specied nominal condition for and C , while the EKF re-linearizes the system about the current state estimate, x + k at each time step. The EKF is expected to have better performance because it should model the system dynamics more accurately, but requires many more on-line computations to implement due to the need for a new linearization of the model after each state estimate is computed.

4.6

Back-Propagation Neural Network

A back-propagation neural network is a network composed of elements called neurons, because their function was inspired by biological neurons, and trained to emulate a desired function using the back-propagation algorithm. Each neuron has an input x, which is an n-dimensional column vector, n weights stored in row vector wi , and a scalar output yi , where the output is a dierentiable nonlinear function, called the activation function, of the weighted sum of the inputs (yi = sig (wi x)). Usually either the arctangent function (y = T an1 [x]), or exponential sigmoid function (y =
1 ) 1+ex

is used for the activation function because both of them approximate a step function and have
1 relatively simple derivatives ( 1+ and x2 ex (1+ex )2

= y (1 y ) respectively). A bias can be added

12

to the neuron by appending a constant input of 1 to the input vector, which then multiplies a corresponding value in wi as one term in the linear combination used by the activation function. A layer of neurons is a group of neurons that all have the same input vector, but independent weight vectors. The layer produces a vector of outputs, with each element of this vector corresponding to the output of one of the neurons in the layer: y = sig (W x), where the ith element of y is yi and W is a matrix such that wi is its ith row.[6] A single-layer network can only perform classications that are linear in the input space and a multi-layer network without a nonlinear function in the neuron reduces to a single layer.[6] However, a network with two layers is a universal approximator.[3] Back-propagation is a supervised learning algorithm, meaning that the network is trained with known input/output sets until it can reproduce the outputs in this training set from the corresponding inputs. In the case of engine diagnostics, the training inputs to the neural network are the expected steady state sensor outputs from the engine for a given fault case, y , and the training outputs are the health parameter values, x, corresponding to that fault case. After training, the inputs to the network are the sensor outputs including transients and noise, y , and the outputs are the health parameter estimates x . For a two-layer network with L inputs, yk , M hidden neurons with output zj , and N output neurons with output x i , the equations for the output of the network are:

s1j =
k=1

W 1jk yk

(17) (18) (19) (20) (21)

zj = sig [s1j ]
M

s2i =
j =1

W 2ij zj

x i = sig [s2i ] e i = xi x i

It is dicult to determine a physical signicance for the weights, wi,j and intermediate outputs,

13

z . The variables 1 and 2, referred to as the learning rates, are gains that determine the speed of convergence vs. stability (see eq(6) and the relevant comments in section 4.4). The variables s1, s2, 1, and 2 are intermediate variables used to simplify the back-propagation equations. The error, J , is calculated from a sum of squared dierences between the desired and observed outputs (eq(22)). A gradient descent method is used to modify the weights to reduce the error, i.e. the derivatives of J with respect to W 1 and W 2 (eq(23) and eq(25), respectively) are used to modify the weights (eq(27) and eq(28), respectively).[6]

1 J= 2

e2 i
i=1

(22) (23) (24) (25)

J ei x i s2i J = = ei (1)sig [s2i ]zj = 2i zj W 2ij ei x i s2i W 2ij 2i = ei sig [s2i ] J = W 1jk 1j =
i=1 N

i=1 N

J ei x i s2i zj s1j = 1j yk ei x i s2i zj s1j W 1jk ei sig [s2i ]W 2ij sig [s1j ] = (W 2 2)j sig [s1j ]

(26) (27) (28)

W 2ij = W 2ij 2 W 1jk

J W 2ij J = W 1jk 1 W 1jk

4.7

Bayesian Belief Network

P [A B ] P [B ]

A Bayesian Network uses Bayes Rule (P [A|B ] =

P [B |A]P [A] ) P [B ]

and P [B |A] =

P [A B ] P [A ]

so P [A|B ] =

to calculate the joint probability and then conditional probabilities of the states of the

variables in the network. The architecture of the network is described by a directed acyclic graph structure, which means that a group of nodes, which represent states, are connected directionally (indicating that a state aects another), such that there are no closed paths. The connections represent the assumptions of conditional dependence or independence of the variables, and a table of local conditional probabilities (CPT) contains the probability that each node will take on each possible state based on each possible state of its parent nodes, which are the nodes that aect 14

Figure 4.1: Generating CPT part 1

Figure 4.2: Generating CPT part 2

15

the node of interest. There must also be prior probabilities assumed on the state of each parent node.[11]. The nodes used in a diagnostic BBN for a gas turbine engine are the health parameters and the percent dierences between the sensed values and their nominal values (sensor deltas). The architecture of the diagnostic network has a conditional probability table (CPT) linking each health parameter to each sensor. Here, the range of possible values for each health parameter is discretized, and a prior probability distribution for each section of the range is provided. Three states are available for each sensor delta: the range within 3 of the nominal value which includes 99.73% of measurements that could be generated randomly during a no-fault condition, the range above 3 and the range below 3 [12]. In order to generate the CPT, the endpoints of each health parameter section are mapped (using the engine model) to the expected sensor deltas for those health parameter changes (see g. 4.1). Next, a probability distribution for each of the sensor values given a health parameter value in that range is constructed. The probability distribution for each sensor value is assumed to be trapezoidal such that it is uniform between the expected sensor deltas corresponding to the endpoints of the health parameter range, and tapers to zero over the 3 of possible noise outside of these expected values (see g. 4.2). This probability distribution is then discretized by integrating the sections that correspond to the three possible states for each sensor delta[12]. Since the health parameters for each components eciency and ow are so strongly correlated, (the fault cases have them perfectly correlated between small and large faults), the parent nodes used for this paper were the fault types, each of which could take a range of magnitudes (5 nonzero magnitudes). The fault magnitude was then mapped to the health parameters which the engine model maps to sensor values. This results in a table of probabilities that each sensor delta (si ) is in the low, nominal or high state (ri,1 , ri,2 , ri,3 ) given each fault type and magnitude (l, m): P [si rij |l m] (see g. 4.1 and g. 4.2 for an example). Lacking any information of fault magnitude likelihood, the prior probabilities for the faults ( [l m]) were chosen by assuming that it is most likely that a fault has not occurred, but that there is a uniform probability distribution on the fault size if a fault has occurred (50% no-fault, 2% chance of each of the 5 faults at each of 5 possible magnitudes).[2] 16

Once a set of sensor readings is obtained, Bayes Rule is used to move backwards through the network to obtain probabilities for each of the fault cases: for each fault case (fault type and magnitude), the joint probability of that fault case and the current sensor readings is P [s l m] =
nsens i=1

P [si rij |l m] [l m], where rij is the range occupied by each sensor delta. Because the

fault combinations are mutually exclusive and exhaustive, the probability that the vector of sensor deltas falls into the states that are actually observed (marginal probability) is the sum of these joint probabilities over all of the fault cases, i.e. P [s] =
l m

P [s l m]. The conditional probability

of each fault case given the states of the sensor deltas is then the ratio of the joint probability for that fault case to the marginal probability of the sensor deltas occupying their current states, which is P [l m|s] =
P [slm] .[2] P [s ]

4.8

Fuzzy Logic System

Fuzzy logic (created by Zadeh [18]) is used to produce universal approximators, the local behavior of which can be easily modied without aecting global behavior, and which operate in a humanintuitive way. Numerical input values are categorized (fuzzied) into qualitative categories (fuzzy sets), where their degree of membership in each of several possible sets can be any value between 0 and 1. Rules are constructed on the categories, making it straightforward to describe what they are doing linguistically. Each rule is evaluated by how applicable the categories are to the values used as inputs: the degrees of membership of each input value in the corresponding set used in the rule are ANDed (evaluated by a minimum) or ORed (evaluated by a maximum). The outputs of the rules are then weighted and added (defuzzied) and the overall output of the rules is the output of the Fuzzy Logic System.[10] For this paper, the MATLAB Fuzzy Toolbox[1] was used to perform the necessary computations. One of the biggest sources of diculty in developing a fuzzy system is tuning the membership functions to produce desirable results. In order to produce a fuzzy system without this diculty, the method used for producing the BBN above was modied to produce the fuzzy system. Like the BBN, the numerical inputs are the normalized values of the available sensors at each sample time. The three states for each sensor variable in the BBN (nominal, high, and low) become three

17

membership functions for each sensor input to the fuzzy system. As an example, the membership functions for the low spool speed delta are shown below in gure 4.3. The center membership functions are trapezoidal, taking a value of 1 between 1.5 of the input value, and going to zero at 3 of the input value, approximating a Gaussian PDF of the values the sensor could take while operating at no-fault conditions. The membership functions for high and low values are dened by trapezoids that are zero at 1.5 of the input value, cross the center membership function at a membership value of .5, and reach 1 at 3 of the input value, such that the sum of the membership functions for any sensor value is exactly 1. The ability of the FLS to diagnose the correct fault condition was found to be robust to changes in the membership functions (Gaussian and sigmoid functions were used as well), but membership functions that sum to 1 were found to produce the most accurate magnitudes for the health parameters.[2]

Figure 4.3: FLS example input membership functions. The outputs of the FLS are the health parameter values. For each health parameter, there are 7 possible output membership functions spanning the range that that health parameter is expected to take. In order to generate the CPTs for the BBN, the engine model was run using health parameter values at the endpoints of the range dening each BBN state. These values of the health parameters

18

are also used to produce triangular output membership functions for the fuzzy diagnostic system such that each result is the peak of one membership function, and the neighboring results are the other vertices of the triangular function shape. As an example, the output membership functions for fan ow are shown in gure 4.4.[2]

Figure 4.4: FLS example output membership functions. Each engine simulation run used to build the CPTs for the BBN (health parameters corresponding to each fault condition at each degree) is also used to produce one rule for the fuzzy system: the sensor delta values are classied by which membership function they best t (low, nominal, or high), and a rule is constructed whereby that set of sensor deltas produces as output the health parameter membership functions corresponding to the health parameter values that generated those sensor deltas. Each rule is an AND rule, evaluated by the minimum of the membership values, with a centroid defuzzication method for producing the numerical value of the health parameter estimates. Centroid defuzzication involves generating the sum of the output member functions weighted by the activation value of each rule and then using the center of mass of that sum as the output. The resulting rule for each case can be stated linguistically as: If the sensor values are classied in the same way as the result from a run with given health parameter values, then the health parameter values are classied the same as the values actually used for that run. This results in a fuzzy diagnostic system with 8 inputs, 9 outputs and 26 rules (a fault in each of 5 components, with 5 nonzero magnitudes plus 1 no-fault rule). For example, two rules in the fuzzy engine diagnostic system are as follows: 19

If N 2 is nominal and N 25 is nominal and P S 14 is nominal and P T 25 is nominal and P S 3 is nominal and T 25 is nominal and T 4B is nominal and T 56 is nominal then the fan eciency parameter is zero, the fan ow parameter is zero, the HPC eciency parameter is zero, the HPC ow parameter is zero, the fuel ow parameter is zero, the HPT eciency parameter is zero, the HPT ow parameter is zero, the LPT eciency parameter is zero, and the LPT ow parameter is zero. and If N 2 is high and N 25 is high and P S 14 is nominal and P T 25 is nominal and P S 3 is low and T 25 is high and T 4B is nominal and T 56 is high then the fan eciency parameter is small, the fan ow parameter is small, the HPC eciency parameter is zero, the HPC ow parameter is zero, the fuel ow parameter is zero, the HPT eciency parameter is zero, the HPT ow parameter is zero, the LPT eciency parameter is zero, and the LPT ow parameter is zero. Therefore, if the sensor values fall in the 100% nominal range for P S 14, P T 25, and T 4B , between the 100% nominal and 100% high range for N 2, N 25, T 25, and T 56, and between the nominal and low range for P S 3, then the two rules are both activated with a strength equal to the lowest membership value of any input in the corresponding class specied in that rule. If the delta for normalized N 2 is .002, the membership value in nominal is about .6, and in high is about .4. If every other input delta is 0, then the rst rule will be activated with strength 0.6, whereas if N 25, T 25, and T 56 are 100% high and P S 3 is 100% low, then the second rule will be activated with strength 0.4.[2]

20

Results

In order to evaluate the diagnostic algorithms, the engine model was used to generate sensor values for brief periods of operation at a constant ight condition. In each simulation, the health parameters for the engine start at a no-fault condition, and then switch to one of the fault conditions after 500 iterations. The simulations are all run for a xed duration, corresponding to the time necessary for all sensor readings to reach approximately steady state values for all of the fault cases. Starting in a no-fault condition means that the health parameters for the engine model are initially set to values corresponding to either a new or maximally degraded engine, and the health parameter values for the large and small faults in each of the 5 components are added to those initial no-fault values, resulting in 22 cases, including the no-fault case for each initial condition. Each diagnostic scheme produces diagnostic results and health parameter estimates. The diagnostic results, as explained in section 4.3, consist of a 5x1 vector for each case, such that the highest (most positive) value corresponds to the component most likely to have experienced a fault. The health parameter estimates, as specied in section 4.1, are normalized such that the expected results for the large faults are 1, for the small turbo-machinery faults are 0.25, and for the small fuel ow fault is 0.4. Because of this normalization, the values for the ow and eciency parameters for a parameter are often identical, resulting in identical rows of results in some tables. The tables with health parameter estimate percent errors show the percent errors measured from these numbers. Often, the tables for the new and degraded engine cases are identical (to the 3rd or 4th decimal place). This indicates that the behavior of the model is nearly linear with respect to the health parameters when their values are in the range investigated, or at least that the linearization of the model for a new engine no-fault case is almost identical to that for the degraded no-fault case. Therefore, in many cases, the tables for the degraded engines are omitted.

5.1

Sensor Dot Product

Due to its simplicity, this method is by far the fastest algorithm tested in terms of the time it takes to run each iteration (less than 20s for all cases together). Unsurprisingly, given that the simulations used to generate the correct outputs are the same simulations used to generate the outputs being 21

dot prod No diag Fault Fan 0.0000 HPC 0.0000 fuel 0.0000 HPT 0.0000 LPT 0.0000

Small Fan 3.0562 1.0357 0.3593 0.5398 0.8414

Large Fan 14.8259 6.7872 2.8373 3.5890 6.0861

Small HPC 3.0069 7.3156 3.6341 5.6468 6.2471

Large Small HPC Fuel Flow 13.6066 1.6201 30.6606 4.8819 14.8987 10.2858 23.6593 5.9686 26.0612 4.7389

Large Fuel Flow 4.9040 12.9284 26.2102 15.4235 12.5219

Small HPT 0.7372 4.2931 4.1541 7.4714 0.7896

Large HPT 9.4939 29.9019 21.8193 36.8402 16.0932

Small LPT 3.8518 8.8128 4.5537 3.7844 10.3201

Large LPT 11.7235 25.3919 14.4615 11.5338 29.8853

Table 5.1: Diagnostic Results for Each Fault Case Using the Dot Product of Sensor Outputs dot prod No HPs Fault W2 0.0000 E21 0.0000 W25 0.0000 E3 0.0000 Fuel bias0.0000 W41 0.0000 E42 0.0000 W49 0.0000 E5 0.0000 Small Fan 0.1367 0.1367 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 Large Fan 0.6630 0.6630 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 Small HPC 0.0000 0.0000 0.2586 0.2586 0.0000 0.0000 0.0000 0.0000 0.0000 Large Small Large HPC Fuel Flow Fuel Flow 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0840 0.0000 0.0000 1.0840 0.0000 0.0000 0.0000 0.4114 1.0484 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 Small HPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.3341 0.3341 0.0000 0.0000 Large HPT 0.0000 0.0000 0.0000 0.0000 0.0000 1.6475 1.6475 0.0000 0.0000 Small LPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.4615 0.4615 Large LPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.3365 1.3365

Table 5.2: Health Parameter Estimates for Each Fault Case Using the Dot Product of Sensor Outputs evaluated, this method produces correct results for each fault type. However, some of the results are very close to each other. For example, the small and large HPC faults are diagnosed correctly, but the index value for an LPT diagnosis is only 15% lower than for an HPC diagnosis in the case of an HPC fault. For the HPT faults, the value for an HPC diagnosis is only 19% lower than for an HPT diagnosis.

Since the diagnostic values for dierent components for given fault cases are so close, this method of diagnosis is suspect in the presence of noise. This is shown in Figures 5.2 and 5.4, which plot the time series of the health parameters for the fan and HPT fault cases with noise present in the measurements. Given a perfect model, the noise can be ltered out to whatever degree one desires by averaging some length of the time series.

As mentioned in section 5, the tables of fault indices and health parameter estimates for new 22

dot prod No error Fault W2 0.0000 E21 0.0000 W25 0.0000 E3 0.0000 Fuel bias0.0000 W41 0.0000 E42 0.0000 W49 0.0000 E5 0.0000

Small Fan -0.4533 -0.4533 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

Large Fan -0.3370 -0.3370 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

Small HPC 0.0000 0.0000 0.0346 0.0346 0.0000 0.0000 0.0000 0.0000 0.0000

Large Small Large HPC Fuel Flow Fuel Flow 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0840 0.0000 0.0000 0.0840 0.0000 0.0000 0.0000 0.0286 0.0484 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

Small HPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.3365 0.3365 0.0000 0.0000

Large HPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.6475 0.6475 0.0000 0.0000

Small LPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.8461 0.8461

Large LPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.3365 0.3365

Table 5.3: Health Parameter Estimate Percent Errors for Each Fault Case Using the Dot Product of Sensor Outputs

Figure 5.1: Sensor Dot Product Health Parameter Estimates for Noiseless Fan Fault Cases and degraded engines are almost identical for this method, so the degraded engine tables have been omitted. Also, the health parameter estimates for health parameters corresponding to the same component are identical because they are the result of a projection, where the same value is used to scale the diagnostic result for that component to produce the two health parameter estimates. This algorithm converges quickly. No case required more than 15 iterations to reach the correct diagnosis. Figures 5.1 and 5.3 show the time series of health parameter estimates for the fan and HPT faults. Figures 5.2 and 5.4 show the same results with simulated noise. These gures show that the health parameter estimates converge to steady state values relatively quickly as well. The health parameter estimates are based on the magnitude of the highest diagnostic value only, and their accuracy is therefore dependent on the diagnosed fault being correct, as well as the accuracy of the estimate of that faults magnitude. The largest errors in the parameter estimates

23

Figure 5.2: Sensor Dot Product Health Parameter Estimates for Fan Fault Cases with Noise

Figure 5.3: Sensor Dot Product Health Parameter Estimates for Noiseless HPT Fault Cases

Figure 5.4: Sensor Dot Product Health Parameter Estimates for HPT Fault Cases with Noise

24

lter No diag Fault Fan 0.0000 HPC 0.0000 fuel 0.0000 HPT-0.0000 LPT 0.0000

Small Fan 9.2688 -3.5803 -1.7977 2.4051 2.8291

Large Fan 34.1727 -16.9687 -8.6697 12.7442 14.0588

Small HPC -21.9359 3.9568 -2.2314 8.1055 5.3687

Large HPC -88.1972 13.3120 -10.2693 34.8386 23.8137

Small Fuel Flow -12.1003 13.3501 16.7463 -9.3548 -10.7360

Large Fuel Flow -30.9872 32.9857 41.6400 -22.8535 -26.4007

Small HPT -6.5629 3.0738 1.4530 4.3398 -2.0350

Large HPT -63.4427 7.0308 2.0371 31.0874 0.9481

Small LPT -35.4003 2.4613 0.3627 6.2108 7.4481

Large LPT -107.3503 10.9395 2.9401 15.6447 24.8351

Table 5.4: Diagnostic Results for Each Fault Case Using Newtons Method Tracking Filter (see Table 5.3) are around 80% for both new and degraded simulated engines (tables for degraded engines are not shown because the values are almost identical), but there does not appear to be a pattern overall (the errors are much lower for the HPC and fuel ow faults than the other faults, and the errors are larger for the small LPT fault than for the large LPT fault, but the opposite is true for HPT faults).

5.2

Tracking Filter

The tracking lter can drive the output errors to zero without exactly matching the states or health parameters. This is expected: given the number of outputs and the number of states, the output matrix necessarily has a large nullspace, any element of which can be added to the state estimate to produce an equally good (in terms of the output error) state estimate. In spite of this, the health parameters are still usually good enough for diagnostics; the highest fault index corresponds to the correct fault for each case except for the high pressure compressor faults, which are detected as HPT faults (see Figure 5.7 and Table 5.4).

The largest errors in the parameter estimates are extremely high, between 200% and 600% (see Table 5.6, table for degraded engines not shown because the values are almost identical), but since these errors occur only for the fan parameters in cases not involving fan faults, and are negative, they dont adversely aect the diagnostic ability of the algorithm, though they do predict a betterthan-perfect fan. Some of the other turbomachinery components produce positive errors up to 150% in some cases, resulting a bad diagnoses for the HPC fault cases.

25

lter No HPs Fault W2 0.0000 E21 0.0000 W25 0.0000 E3 0.0000 Fuel bias 0.0000 W41 -0.0000 E42 -0.0000 W49 0.0000 E5 0.0000

Small Fan 0.4145 0.4145 -0.1266 -0.1266 -0.0719 0.1076 0.1076 0.1265 0.1265

Large Fan 1.5282 1.5282 -0.5999 -0.5999 -0.3468 0.5699 0.5699 0.6287 0.6287

Small HPC -0.9810 -0.9810 0.1399 0.1399 -0.0893 0.3625 0.3625 0.2401 0.2401

Large HPC -3.9443 -3.9443 0.4707 0.4707 -0.4108 1.5580 1.5580 1.0650 1.0650

Small Fuel Flow -0.5411 -0.5411 0.4720 0.4720 0.6699 -0.4184 -0.4184 -0.4801 -0.4801

Large Fuel Flow -1.3858 -1.3858 1.1662 1.1662 1.6656 -1.0220 -1.0220 -1.1807 -1.1807

Small HPT -0.2935 -0.2935 0.1087 0.1087 0.0581 0.1941 0.1941 -0.0910 -0.0910

Large HPT -2.8372 -2.8372 0.2486 0.2486 0.0815 1.3903 1.3903 0.0424 0.0424

Small LPT -1.5832 -1.5832 0.0870 0.0870 0.0145 0.2778 0.2778 0.3331 0.3331

Large LPT -4.8009 -4.8009 0.3868 0.3868 0.1176 0.6997 0.6997 1.1107 1.1107

Table 5.5: Health Parameter Estimates for Each Fault Case Using Newtons Method Tracking Filter lter No error Fault W2 0.0000 E21 0.0000 W25 0.0000 E3 0.0000 Fuel bias 0.0000 W41 -0.0000 E42 -0.0000 W49 0.0000 E5 0.0000 Small Fan 0.6581 0.6581 -0.5063 -0.5063 -0.1798 0.4302 0.4302 0.5061 0.5061 Large Fan 0.5282 0.5282 -0.5999 -0.5999 -0.3468 0.5699 0.5699 0.6287 0.6287 Small HPC -3.9240 -3.9240 -0.4404 -0.4404 -0.2231 1.4500 1.4500 0.9604 0.9604 Large HPC -3.9443 -3.9443 -0.5293 -0.5293 -0.4108 1.5580 1.5580 1.0650 1.0650 Small Fuel Flow -2.1646 -2.1646 1.8880 1.8880 0.6746 -1.6734 -1.6734 -1.9205 -1.9205 Large Fuel Flow -1.3858 -1.3858 1.1662 1.1662 0.6656 -1.0220 -1.0220 -1.1807 -1.1807 Small HPT -1.1740 -1.1740 0.4347 0.4347 0.1453 -0.2237 -0.2237 -0.3640 -0.3640 Large HPT -2.8372 -2.8372 0.2486 0.2486 0.0815 0.3903 0.3903 0.0424 0.0424 Small LPT -6.3326 -6.3326 0.3481 0.3481 0.0363 1.1110 1.1110 0.3324 0.3324 Large LPT -4.8009 -4.8009 0.3868 0.3868 0.1176 0.6997 0.6997 0.1107 0.1107

Table 5.6: Health Parameter Estimate Percent Error for Each Fault Case Using Newtons Method Tracking Filter

The tracking lter diagnoses errors very quickly, though not reliably. With the exception of the HPC error, it obtains the correct diagnosis within 20 simulation iterations of when the simulated

Figure 5.5: Tracking Filter Health Parameter Estimates for Noiseless Fan Fault Cases 26

Figure 5.6: Tracking Filter Health Parameter Estimates for Fan Fault Cases with Noise

Figure 5.7: Tracking Filter Health Parameter Estimates for Noiseless HPC Fault Cases

Figure 5.8: Tracking Filter Health Parameter Estimates for Noiseless HPT Fault Cases

27

Figure 5.9: Tracking Filter Health Parameter Estimates for HPT Fault Cases with Noise fault is introduced, with an average simulation time to correct diagnosis of around 10 iterations. To run the simulation for all fault cases for their entire timespans takes about 400s on the computer used, which compares favorably with most of the other algorithms tested. Figures 5.5, 5.7, and 5.8 show the time histories of the health parameter estimates for the fan, HPC, and HPT fault cases. Figures 5.6 and 5.9 show the same results with simulated noise, which appears to result in noise on the parameter estimates. Using other noise ltering is unnecessary because this algorithm already performs that function.

5.3

Linearized Kalman Filter

The linearized Kalman Filter is the most computationally intensive method investigated, requiring about 150000s to run all fault cases (the extended Kalman Filter proved too computationally intensive to be feasible) because it requires running the engine model to propagate the current state estimate to produce the next state estimate prior to the sensor update. It is able to estimate the fan fault parameters very well, but misdiagnoses LPT faults as HPC or fuel ow faults. There are also oscillations in the lter results for the large HPT fault case. It should be noted that the pseudonoises are arbitrarily chosen for the parameters and these values have signicant eects on the results. The noises used produced the best results of any values tried, however some of the cases misdiagnose dierent faults, and there may be pseudo-noise values that produce better results.

28

LKF No diag Fault Fan -0.0000 HPC-0.0005 fuel 0.0002 HPT-0.0005 LPT -0.0006

Small Fan 5.5822 -0.1711 0.0451 -0.1476 -0.1334

Large Fan 22.1209 -3.0680 0.3872 -1.3143 -1.1918

Small HPC 0.0386 8.0304 -0.4188 1.4288 1.3084

Large HPC 0.2166 24.6121 -1.0870 3.8669 3.5860

Small Fuel Flow -0.0688 -5.5596 10.9779 -3.3357 -3.0777

Large Fuel Flow -0.0877 -29.2977 27.9562 -10.6419 -9.8086

Small HPT 0.0531 -6.4067 -0.5159 1.6254 0.2797

Large HPT 0.4715 -10.8661 -3.4793 11.3432 5.5181

Small LPT -0.2130 2.7745 2.2883 -0.3826 1.1635

Large LPT -1.5296 -11.4763 10.2452 -5.4834 0.9269

Table 5.7: Diagnostic Results for Each Fault Case Using Linearized Kalman Filter LKF No HPs Fault W2 0.0000 E21 -0.0000 W25 0.0000 E3 -0.0001 Fuel bias 0.0000 W41 -0.0000 E42 -0.0000 W49 -0.0000 E5 -0.0000 Small Fan 0.2510 0.2441 0.0123 -0.0244 0.0018 -0.0068 -0.0066 -0.0014 -0.0071 Large Fan 0.9990 0.9504 -0.0206 -0.1964 0.0155 -0.0599 -0.0585 -0.0123 -0.0635 Small HPC -0.0047 0.0273 0.1198 0.4480 -0.0168 0.0625 0.0642 0.0135 0.0698 Large HPC -0.0007 0.0514 0.3139 1.4264 -0.0435 0.1603 0.1761 0.0371 0.1912 Small Fuel Flow 0.0137 -0.0701 0.1479 -0.5410 0.4391 -0.1540 -0.1480 -0.0322 -0.1640 Large Fuel Flow 0.0402 -0.1805 0.1881 -2.2598 1.1182 -0.4844 -0.4738 -0.1023 -0.5228 Small HPT 0.0025 0.0020 0.0097 -0.4627 -0.0206 0.3100 0.0134 0.0029 0.0149 Large HPT 0.0080 0.0733 0.4849 -1.2532 -0.1392 1.4589 0.2694 0.0573 0.2942 Small LPT 0.0115 -0.0937 0.2608 -0.0647 0.0915 -0.3186 0.0583 0.0119 0.0621 Large LPT 0.0063 -0.3671 0.7211 -1.5326 0.4098 -1.4262 0.0500 0.0092 0.0495

Table 5.8: Health Parameter Estimates for Each Fault Case Using LKF

The largest errors in the parameter estimates for the HPT and LPT are around 100% (see Figures 5.12 and 5.14), while the errors for the HPC estimates are 40%-80% and the fan and fuel estimate errors are less than 12% (see Figure 5.10), indicating that the Kalman lter is much better at tracking some faults than others, generally performing worse for faults further back in the engine (see Table 5.9). Tables for degraded engines are not shown because the values are almost identical.

LKF No error Fault W2 0.0000 E21 -0.0001 W25 0.0002 E3 -0.0003 Fuel bias 0.0000 W41 -0.0001 E42 -0.0001 W49 -0.0001 E5 -0.0001

Small Fan 0.0041 -0.0235 0.0492 -0.0976 0.0045 -0.0272 -0.0262 -0.0055 -0.0285

Large Fan -0.0010 -0.0496 -0.0206 -0.1964 0.0155 -0.0599 -0.0585 -0.0123 -0.0635

Small HPC -0.0187 0.1093 -0.5207 0.7920 -0.0419 0.2502 0.2569 0.0542 0.2790

Large HPC -0.0007 0.0514 -0.6861 0.4264 -0.0435 0.1603 0.1761 0.0371 0.1912

Small Fuel Flow 0.0547 -0.2805 0.5917 -2.1642 0.0978 -0.6158 -0.5919 -0.1286 -0.6560

Large Fuel Flow 0.0402 -0.1805 0.1881 -2.2598 0.1182 -0.4844 -0.4738 -0.1023 -0.5228

Small HPT 0.0099 0.0080 0.0387 -1.8508 -0.0516 0.2401 -0.9466 0.0117 0.0596

Large HPT 0.0080 0.0733 0.4849 -1.2532 -0.1392 0.4589 -0.7306 0.0573 0.2942

Small LPT 0.0460 -0.3746 1.0434 -0.2586 0.2288 -1.2744 0.2330 -0.9522 -0.7518

Large LPT 0.0063 -0.3671 0.7211 -1.5326 0.4098 -1.4262 0.0500 -0.9908 -0.9505

Table 5.9: Health Parameter Estimate Percent Errors for Each Fault Case Using LKF 29

Figure 5.10: LKF Health Parameter Estimates for Noiseless Fan Fault Cases

Figure 5.11: LKF Health Parameter Estimates for Fan Fault Cases with Noise

Figure 5.12: LKF Health Parameter Estimates for Noiseless HPT Fault Cases

30

Figure 5.13: LKF Health Parameter Estimates for HPT Fault Cases with Noise

Figure 5.14: LKF Health Parameter Estimates for Noiseless LPT Fault Cases Figures 5.11 and 5.13 show the same results with simulated noise. The results with noise show a sawtooth wave pattern of pulses. For the large faults, the lter is sucient to minimize the variations, but additional ltering is probably necessary to catch and correctly diagnose the small

Figure 5.15: LKF Health Parameter Estimates for LPT Fault Cases with Noise 31

NN No diag Fault Fan 0.9939 HPC-1.1611 fuel -3.2236 HPT 0.7000 LPT 0.6254

Small Fan 4.9351 -0.7689 -3.8031 0.3348 -0.4906

Large Fan 18.5710 1.2745 -5.6072 -1.1869 -3.5658

Small HPC 0.9781 3.0331 -4.2904 2.7120 2.6041

Large Small HPC Fuel Flow 1.8713 -0.5340 15.0398 -1.4540 -8.1567 5.8586 8.4688 0.7919 7.9778 0.1023

Large Fuel Flow -2.1769 -1.9243 18.9203 0.7663 -0.8143

Small HPT -0.3619 0.0296 -3.2550 6.1461 -2.1753

Large HPT -3.0971 5.4308 -2.6379 17.8950 -5.6518

Small LPT -0.3156 1.6634 -2.5938 -1.9058 5.7643

Large LPT -4.7985 6.7078 -3.4847 -4.2432 14.1748

Table 5.10: Diagnostic Results for Each Fault Case Using Neural Network NN No HPs Fault W2 0.0262 E21 0.1174 W25 -0.0518 E3 -0.0303 Fuel bias-0.1289 W41 0.0329 E42 0.0309 W49 0.0424 E5 0.0244 Small Fan 0.1992 0.3066 -0.0454 -0.0089 -0.1521 0.0160 0.0147 -0.0089 -0.0252 Large Fan 0.7965 0.9667 -0.0030 0.0931 -0.2243 -0.0548 -0.0527 -0.1514 -0.1615 Small HPC 0.0168 0.1517 0.0752 0.1393 -0.1716 0.1220 0.1211 0.1307 0.1129 Large HPC 0.0322 0.2895 0.4397 0.6238 -0.3263 0.3770 0.3792 0.3710 0.3532 Small Fuel Flow -0.0468 0.0676 -0.0725 -0.0304 0.2343 0.0359 0.0353 0.0153 0.0019 Large Fuel Flow -0.1270 0.0211 -0.1041 -0.0319 0.7568 0.0331 0.0346 -0.0323 -0.0374 Small HPT -0.0366 0.0655 -0.0155 0.0176 -0.1302 0.2770 0.2743 -0.0811 -0.1013 Large HPT -0.1670 -0.0244 0.1528 0.2312 -0.1055 0.7997 0.8004 -0.2323 -0.2579 Small LPT -0.0364 0.0749 0.0375 0.0801 -0.1038 -0.0853 -0.0852 0.2724 0.2541 Large LPT -0.2421 -0.1044 0.2016 0.2727 -0.1394 -0.1914 -0.1894 0.6498 0.6299

Table 5.11: Health Parameter Estimates for Each Fault Case Using Neural Network faults.

5.4

Back-propagation Neural Network

The back-propagation neural network method is very quick and very reliable: it correctly diagnoses each component fault, and obtains this correct diagnosis in an average of 10 simulation iterations of when the simulated fault is introduced. The small HPC fault takes longest to diagnose at 26 iterations. For a simulated new engine, the errors in the parameter estimates are between 40% and 70% for the HPC and fuel faults, but below 40% for the other fault cases (see Table 5.12). For a simulated degraded engine the errors are generally higher (see Table 5.14). Small faults almost always have larger errors than large faults, and for the large faults the network usually underestimates the parameters (see Table 5.12).

32

NN No error Fault W2 0.1048 E21 0.4697 W25 -0.2072 E3 -0.1212 Fuel bias-0.3224 W41 0.1318 E42 0.1236 W49 0.1698 E5 0.0974

Small Fan -0.2031 0.2265 -0.1817 -0.0357 -0.3803 0.0641 0.0588 -0.0356 -0.1008

Large Fan -0.2035 -0.0333 -0.0030 0.0931 -0.2243 -0.0548 -0.0527 -0.1514 -0.1615

Small HPC 0.0670 0.6068 -0.6993 -0.4429 -0.4290 0.4882 0.4844 0.5227 0.4516

Large HPC 0.0322 0.2895 -0.5603 -0.3762 -0.3263 0.3770 0.3792 0.3710 0.3532

Small Fuel Flow -0.1870 0.2706 -0.2898 -0.1214 -0.4141 0.1436 0.1412 0.0610 0.0076

Large Fuel Flow -0.1270 0.0211 -0.1041 -0.0319 -0.2432 0.0331 0.0346 -0.0323 -0.0374

Small HPT -0.1465 0.2621 -0.0619 0.0703 -0.3255 0.1078 0.0974 -0.3243 -0.4053

Large HPT -0.1670 -0.0244 0.1528 0.2312 -0.1055 -0.2003 -0.1996 -0.2323 -0.2579

Small LPT -0.1455 0.2995 0.1499 0.3206 -0.2594 -0.3414 -0.3408 0.0896 0.0165

Large LPT -0.2421 -0.1044 0.2016 0.2727 -0.1394 -0.1914 -0.1894 -0.3502 -0.3701

Table 5.12: Health Parameter Estimate Percent Errors for Each Fault Case Using Neural Network NN d No HPs Fault W2 0.0902 E21 0.2673 W25 0.1158 E3 0.2152 Fuel bias-0.1777 W41 0.1677 E42 0.1656 W49 0.1009 E5 0.0889 Small Fan 0.2626 0.4556 0.1217 0.2359 -0.2006 0.1505 0.1492 0.0495 0.0392 Large Fan 0.8551 1.1082 0.1582 0.3290 -0.2700 0.0763 0.0788 -0.0953 -0.0999 Small HPC 0.0807 0.3012 0.2421 0.3837 -0.2201 0.2562 0.2552 0.1887 0.1770 Large Small Large HPC Fuel Flow Fuel Flow 0.0955 0.0170 -0.0659 0.4359 0.2169 0.1656 0.5999 0.0942 0.0572 0.8588 0.2140 0.2053 -0.3722 0.1857 0.7105 0.5063 0.1701 0.1646 0.5083 0.1694 0.1656 0.4251 0.0731 0.0225 0.4135 0.0659 0.0232 Small HPT 0.0268 0.2143 0.1509 0.2613 -0.1787 0.4094 0.4069 -0.0222 -0.0361 Large HPT -0.1084 0.1160 0.3107 0.4623 -0.1519 0.9187 0.9203 -0.1713 -0.1891 Small LPT 0.0279 0.2247 0.2040 0.3241 -0.1528 0.0493 0.0493 0.3295 0.3173 Large LPT -0.1763 0.0449 0.3618 0.5074 -0.1894 -0.0599 -0.0586 0.7014 0.6878

Table 5.13: Health Parameter Estimates for Deteriorated Engine for Each Fault Case Using Neural Network

NN d No error Fault W2 0.3607 E21 1.0691 W25 0.4633 E3 0.8608 Fuel bias-0.4441 W41 0.6706 E42 0.6623 W49 0.4035 E5 0.3555

Small Fan 0.0503 0.8225 0.4869 0.9436 -0.5015 0.6018 0.5966 0.1980 0.1570

Large Fan -0.1449 0.1082 0.1582 0.3290 -0.2700 0.0763 0.0788 -0.0953 -0.0999

Small HPC 0.3227 1.2048 -0.0317 0.5349 -0.5502 1.0248 1.0209 0.7547 0.7080

Large Small Large HPC Fuel Flow Fuel Flow 0.0955 0.0679 -0.0659 0.4359 0.8677 0.1656 -0.4001 0.3769 0.0572 -0.1412 0.8559 0.2053 -0.3722 -0.5358 -0.2895 0.5063 0.6804 0.1646 0.5083 0.6775 0.1656 0.4251 0.2925 0.0225 0.4135 0.2635 0.0232

Small HPT 0.1070 0.8571 0.6036 1.0450 -0.4467 0.6376 0.6275 -0.0887 -0.1443

Large HPT -0.1084 0.1160 0.3107 0.4623 -0.1519 -0.0813 -0.0797 -0.1713 -0.1891

Small LPT 0.1116 0.8986 0.8160 1.2962 -0.3819 0.1973 0.1972 0.3180 0.2692

Large LPT -0.1763 0.0449 0.3618 0.5074 -0.1894 -0.0599 -0.0586 -0.2986 -0.3122

Table 5.14: Health Parameter Estimate Percent Errors for Deteriorated Engine for Each Fault Case Using Neural Network

33

Figure 5.16: Neural Net Health Parameter Estimates for Noiseless Fan Fault Cases Figures 5.16 and 5.18 show the output of the neural network for the simulation of faults in the fan and HPT, respectively. Figure 5.17 and Figure 5.19 show the same results with simulated noise. For cases with sensor noise, averaging is usually not required to produce an interpretable result, with the exception of the small HPC fault which continues to jump to other diagnoses for dierent values of noise. This is unsurprising because the noiseless diagnostic result for the small HPC fault is only about 12% higher than for the HPT and LPT faults for that case. It may be possible to train a higher performance network that would not have this issue, but it is likely that if the network spent more time learning HPC faults, it would show similar problems on other fault cases. Similarly, the network could have been trained with more degraded engine cases, but likely would have performed worse with new engine cases. To run the diagnostic system for all fault cases for their entire timespans takes about 120s on the computer used, not counting the time to train the neural network, which takes a little longer (on the order of minutes), but must only be done once.

5.5

Bayesian Belief Network

The Bayesian Belief Network method is quick and very reliable: it correctly diagnoses each component fault, and always obtains this correct diagnosis within 100 simulation iterations of when the simulated fault is introduced. The average simulation time to correct diagnosis is around 20 iterations. The largest errors in the parameter estimates are around 80% for both new and degraded simulated engines (tables for degraded engines not shown because the values are almost identical). 34

Figure 5.17: Neural Net Health Parameter Estimates for Fan Fault Cases with Noise

Figure 5.18: Neural Net Health Parameter Estimates for Noiseless HPT Fault Cases

Figure 5.19: Neural Net Health Parameter Estimates for HPT Fault Cases with Noise

35

BBN No HPs Fault W2 0.0000 E21 0.0000 W25 0.0000 E3 0.0000 Fuel bias0.0300 W41 0.0000 E42 0.0000 W49 0.0000 E5 0.0000

Small Fan 0.0625 0.0625 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

Large Fan 1.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

Small HPC 0.0000 0.0000 0.0625 0.0625 0.0000 0.0000 0.0000 0.0000 0.0000

Large Small Large HPC Fuel Flow Fuel Flow 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.3125 0.0000 0.0000 1.3125 0.0000 0.0000 0.0000 0.6000 0.9000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000

Small HPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.0500 0.0625 0.0000 0.0000

Large HPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.8750 0.7500 0.0000 0.0000

Small LPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0500 0.0625

Large LPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.1250 1.0000

Table 5.15: Health Parameter Estimates for Each Fault Case Using a Bayesian Belief Network BBN HP No error Fault W2 0.0000 E21 0.0000 W25 0.0000 E3 0.0000 Fuel bias0.0750 W41 0.0000 E42 0.0000 W49 0.0000 E5 0.0000 Small Fan -0.7500 -0.7500 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 Large Fan 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 Small HPC 0.0000 0.0000 -0.7500 -0.7500 0.0000 0.0000 0.0000 0.0000 0.0000 Large Small Large HPC Fuel Flow Fuel Flow 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.3125 0.0000 0.0000 0.3125 0.0000 0.0000 0.0000 0.5000 -0.1000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 Small HPT 0.0000 0.0000 0.0000 0.0000 0.0000 -0.8000 -0.7500 0.0000 0.0000 Large HPT 0.0000 0.0000 0.0000 0.0000 0.0000 -0.1250 -0.2500 0.0000 0.0000 Small LPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 -0.8000 -0.7500 Large LPT 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.1250 0.0000

Table 5.16: Health Parameter Estimate Percent Errors for Each Fault Case Using a Bayesian Belief Network However, the health parameter estimates for small faults are regularly 75%-80% lower than the faults simulated (see Table 5.16). For the larger faults, the errors are between 0 and 30% and do not show the same bias toward underestimating the health parameters that is seen in the small faults (see Figure 5.20 and 5.22 for examples of outputs using the fan and HPT fault cases). Figures 5.21 and 5.23 show the same results with simulated noise. The eect is basically a transition between the most likely fault sizes of the same fault condition. Averaging the inputs to the BBN can produce a more stable output, which would be more useful in practice. To run the simulation for all fault cases for their entire timespans takes about 10000s on the computer used, not counting the time to set up the conditional probability tables, which takes longer, but must only be done once.[2]

36

Figure 5.20: Bayesian Network Health Parameter Estimates for Noiseless Fan Fault Cases

Figure 5.21: Bayesian Network Health Parameter Estimates for Fan Fault Cases with Noise

Figure 5.22: Bayesian Network Health Parameter Estimates for Noiseless HPT Fault Cases

37

Figure 5.23: Bayesian Network Health Parameter Estimates for HPT Fault Cases with Noise Unlike for many of the other diagnostic methods, the dot product results used to diagnose the fault are not shown here. This is because all of the diagnoses were correct and all of the health parameters that are not related to the fault are left at 0, so only one element of the table would be non-zero for each case.

5.6

Fuzzy Logic System

The Fuzzy Logic System method is fairly quick and very reliable: it correctly diagnoses each component fault, and always obtains this correct diagnosis within 200 simulation iterations of when the simulated fault is introduced. The largest errors in the parameter estimates are around 30% for both new and degraded simulated engines (tables for degraded engines not shown because the values are almost identical). Small faults almost always have larger errors than large faults but neither is biased toward over- or underestimating the parameters (see Table 5.18). Figures 5.24 and 5.26 show the outputs of the fuzzy system for the simulation of faults in the fan and the HPT, respectively. Figures 5.25 and 5.27 show the same results with simulated noise. For cases with sensor noise, averaging either the inputs or outputs of the fuzzy system is required to produce an interpretable result. To run the diagnostic system for all fault cases for their entire timespans takes about 1000s on the computer used, not counting the time to set up the fuzzy sets and create the rules, which takes much longer, but must only be done once.[2]

38

FLS No HPs Fault W2 0.0369 E21 0.0369 W25 0.0369 E3 0.0369 Fuel bias0.0157 W41 0.0286 E42 0.0369 W49 0.0286 E5 0.0369

Small Fan 0.1763 0.1763 0.0476 0.0476 0.0212 0.0374 0.0476 0.0374 0.0476

Large Fan 0.9903 0.9903 0.0392 0.0392 0.0171 0.0306 0.0392 0.0306 0.0392

Small HPC 0.0408 0.0408 0.2941 0.2941 0.0179 0.0319 0.0408 0.0319 0.0408

Large Small Large HPC Fuel Flow Fuel Flow 0.0410 0.0396 0.0407 0.0410 0.0396 0.0407 1.0442 0.0396 0.0407 1.0442 0.0396 0.0407 0.0180 0.4011 0.9527 0.0320 0.0309 0.0318 0.0410 0.0396 0.0407 0.0320 0.0309 0.0318 0.0410 0.0396 0.0407

Small HPT 0.0446 0.0446 0.0446 0.0446 0.0199 0.1775 0.1733 0.0349 0.0446

Large HPT 0.0432 0.0432 0.0432 0.0432 0.0192 0.7828 0.7697 0.0339 0.0432

Small LPT 0.0369 0.0369 0.0369 0.0369 0.0157 0.0286 0.0369 0.3335 0.2919

Large LPT 0.0402 0.0402 0.0402 0.0402 0.0176 0.0314 0.0402 1.0287 0.9768

Table 5.17: Health Parameter Estimates for Each Fault Case Using Fuzzy Logic System

FLS HP No error Fault W2 0.1477 E21 0.1477 W25 0.1477 E3 0.1477 Fuel bias0.0394 W41 0.1145 E42 0.1477 W49 0.1145 E5 0.1477

Small Fan -0.2949 -0.2949 0.1905 0.1905 0.0531 0.1497 0.1905 0.1497 0.1905

Large Fan -0.0097 -0.0097 0.0392 0.0392 0.0171 0.0306 0.0392 0.0306 0.0392

Small HPC 0.1632 0.1632 0.1765 0.1765 0.0448 0.1275 0.1632 0.1275 0.1632

Large Small Large HPC Fuel Flow Fuel Flow 0.0410 0.1582 0.0407 0.0410 0.1582 0.0407 0.0442 0.1582 0.0407 0.0442 0.1582 0.0407 0.0180 0.0028 -0.0473 0.0320 0.1236 0.0318 0.0410 0.1582 0.0407 0.0320 0.1236 0.0318 0.0410 0.1582 0.0407

Small HPT 0.1783 0.1783 0.1783 0.1783 0.0496 -0.2899 -0.3066 0.1396 0.1783

Large HPT 0.0432 0.0432 0.0432 0.0432 0.0192 -0.2172 -0.2303 0.0339 0.0432

Small LPT 0.1477 0.1477 0.1477 0.1477 0.0394 0.1145 0.1477 0.3338 0.1675

Large LPT 0.0402 0.0402 0.0402 0.0402 0.0176 0.0314 0.0402 0.0287 -0.0232

Table 5.18: Health Parameter Estimate Percent Errors for Each Fault Case Using Fuzzy Logic System

Figure 5.24: FLS Health Parameter Estimates for Noiseless Fan Fault Cases

39

Figure 5.25: FLS Health Parameter Estimates for Fan Fault Cases with Noise

Figure 5.26: FLS Health Parameter Estimates for Noiseless HPT Fault Cases

Figure 5.27: FLS Health Parameter Estimates for HPT Fault Cases with Noise

40

5.7

Comparison of methods

Table 5.19 displays the sum of the health parameter percent errors for each fault case. Most algorithms do much better for some of the cases than the other algorithms, for example the LKF estimates the small fan fault extremely well, the BBN does so for the large fan fault, and the fuzzy system does so for the large HPC fault. No single algorithm consistently shows the best performance. Table 5.20 reduces this data by summing the error over all fault cases, in order to compare the estimation error of the algorithms over all of the fault cases. This shows that the dot product method, neural net, BBN, and fuzzy system show at least an order of magnitude better performance than the tracking lter or LKF. However, both the neural net and LKF show signicant drops in performance for the degraded engine cases.

algorithm

No Fault dot product 0.00 Tracking Filter 0.00 LKF 0.00 Neural Network 0.46 BBN 0.01 FLS 0.16

Small Fan 0.41 2.29 0.01 0.29 1.13 0.37

Large Fan 0.23 2.84 0.05 0.16 0.00 0.01

Small HPC 0.00 37.28 1.12 2.19 1.13 0.20

Large Small Large HPC Fuel Flow Fuel Flow 0.01 0.00 0.00 38.97 29.93 11.88 0.75 6.30 5.93 1.20 0.42 0.09 0.20 0.25 0.01 0.01 0.18 0.01

Small HPT 0.23 3.52 4.39 0.50 1.20 0.36

Large HPT 0.84 16.54 2.66 0.32 0.08 0.11

Small LPT 1.43 83.14 4.50 0.54 1.20 0.26

Large LPT 0.23 47.41 7.09 0.54 0.02 0.01

Table 5.19: Sum of Squared Errors in Diagnostic Results for Each Fault Case for All Algorithms

algorithm new degraded dot product 3.38 3.38 Tracking Filter 273.8 273.8 LKF 32.82 525.58 Neural Network 6.71 24.5 BBN 5.21 4.5 FLS 1.69 1.69 Table 5.20: Sum of Squared Errors in Health Parameter Estimates Across all Fault Cases Table 5.21 shows how the parameter estimation errors aect the diagnostic capability of each of the tested systems by looking at the ratio of the diagnostic index value for the component which has a fault to the next highest diagnostic value. A value lower than unity for this ratio indicates that

41

the system has misdiagnosed that fault and a value near unity indicates that a misdiagnosis is likely given a small amount of noise, modeling error, etc. Ideally, all of these ratio values should be innite, indicating that only the parameters corresponding to the component which has a fault are nonzero. The BBN demonstrates this ideal level of certainty, and the FLS also has fairly high results. The LKF has very high results for the cases that it correctly diagnoses, while the neural network and tracking lter have cases that are close to the threshold (the HPC fault cases for the neural network, and several cases for the tracking lter). For the sensor dot product method, unsurprisingly, almost every case is close to this threshold. This indicates that the BBN and fuzzy system will produce the most accurate parameter estimates and the most reliable diagnoses. Between these two, the Bayesian Networks largest errors in parameter estimates are around 80% for both new and degraded simulated engines, while the fuzzy systems largest errors in parameter estimates are around 30%, and the fuzzy system also produces lower errors overall.

algorithm

Small Fan dot product 2.95 Tracking Filter 3.28 LKF 123.64 Neural Network 14.74 BBN Inf FLS 2.93

Large Fan 2.18 2.43 57.13 14.57 Inf 19.96

Small HPC 1.17 0.49 5.62 1.12 Inf 9.12

Large Small Large HPC Fuel Flow Fuel Flow 1.18 1.72 1.7 0.38 1.25 1.26 6.36 159.61 318.64 1.78 7.4 24.69 Inf Inf Inf 32.22 8.96 20.67

Small HPT 1.74 1.41 5.81 207.75 Inf 3.09

Large HPT 1.23 4.42 2.06 3.3 Inf 14.14

Small LPT 1.17 1.2 0.42 3.47 Inf 6.43

Large LPT 1.18 1.59 0.09 2.11 Inf 19.4

min avg 1.17 0.38 0.09 1.12 Inf 2.93 1.62 1.77 67.94 7.92 Inf 13.69

Table 5.21: Certainty of Diagnosis: Diagnostic Value for Correct Fault/Next Highest Diagnostic Value Table 5.21 was expected to indicate how well the algorithms would perform with noisy data; for the low ratios, noise should more frequently modify the sensor values such that they look like a dierent fault condition. This expectation, as indicated by Table 5.22 did not hold: the sensor dot product method, which produced consistently poor results in Table 5.21 produced correct diagnoses in the presence of noise more than 90% of the time, while the fuzzy system averaged only 85% diagnostic accuracy and was accurate for only 58% of the samples for a small HPT fault. The Bayesian network performed very well, it was accurate for more than 90% of the samples for all except three fault cases, where its performance was less than 50%. The neural network performed

42

almost as well, better than 88% on all but four fault cases. The tracking lter and LKF were hit-or-miss, scoring very well on some fault cases, and very poorly on others, averaging below 70% accuracy.

algorithm No Fault dot new 75.5 dot det 75.2 TF new 57.9 TF det 58.4 LKF new 3.7 LKF det 0 NN new 95.4 NN det 1.2 BBN new 100 BBN det 99.9 FLS new 97.8 FLS det 96.6

Small Fan 83.4 83.9 77.2 78.5 85.3 22.2 97.4 88.5 90.7 97.7 66.1 65.6

Large Fan 96.2 95.8 96.6 95.7 95.5 94 97.4 95.4 95.1 98.7 84.7 84.4

Small HPC 79.1 78.5 3 2.5 87.9 99.5 49.1 97.9 94.8 96.1 99.7 99.6

Large Small Large HPC Fuel Flow Fuel Flow 95.3 94.5 95.7 95.2 94.6 95.8 0.4 92.1 95.2 0.6 91.9 95.3 96.3 95.9 96.3 87.6 69 95.1 95 95 95 97.7 51.6 95 95 99.9 99.9 96 31 93.2 100 91.1 85.9 99.9 90.9 86.1

Small HPT 92.6 93.5 62.7 65.4 58.3 1.1 96.4 96.7 93.7 45.5 58.3 58

Large HPT 96.9 97.2 96.1 96.9 95.6 21.1 96.5 96.8 94.5 93 70.3 71.2

Small LPT 91.3 91.3 63.5 63.2 22.4 0 96 35.4 94.3 94.3 93.4 93.4

Large LPT 95.9 95.6 95.4 95.4 1.2 0 95.8 94.6 94.9 94.8 93.9 94.1

min avg 75.5 75.2 0.4 0.6 1.2 0 49.1 1.2 90.7 31 58.3 58 90.6 90.6 67.3 67.6 67.1 44.5 91.7 77.3 95.7 85.5 85.6 85.4

Table 5.22: Diagnostic Success (% of samples) in the Presence of Noise

Since a Kalman lter requires running an engine model at each time step in order to produce a state update, it takes signicantly more processing power (and time) to run than the other methods. Running an extended Kalman lter requires running the engine model for each state and health parameter in order to re-linearize the model at each iteration, so it requires about 70x as much time as the linearized Kalman lter. The neural network, BBN, and fuzzy system are faster, but require some additional time to set up the systems before they can be used. The neural network requires a few minutes for training. Both the BBN and fuzzy system are created using engine model simulation results (actually, the same simulations were used to produce both the BBN and FLS), but during operation, this is not needed, so running both systems is not computationally intensive compared to the model-based diagnostic approaches (i.e. the Kalman lter). However, the BBN computation, requiring nested for-loops, is about an order of magnitude slower than the fuzzy computation. The neural network is also about an order of magnitude faster than the fuzzy system, though this is likely due to the centroid defuzzication method used. A dierent type of fuzzy system could demonstrate a

43

signicant performance increase. The tracking lter and dot product are fast, and do not have a setup time as the other methods do.

algorithm time(s) Dot Product 20 Neural Network 130 Tracking Filter 360 FLS 905 BBN 9900 LKF 151000 Table 5.23: Algorithm Computational Requirements Table 5.24 shows the number of iterations required to correctly diagnose the fault in the absence of noise. The values of 9600 indicate a misdiagnosis or a failure of the algorithm to converge. The sensor dot product, interestingly, is able to diagnose the fault in the fewest iterations, followed by the neural net, BBN, and fuzzy system, respectively, though once again, the neural network shows lower performance for the degraded engine.

algorithm Small Large Small Large Small Large iter Fan Fan HPC HPC Fuel Flow Fuel Flow dot prod 6 5 1 1 1 1 dot prod d 5 5 1 1 1 1 NM-TF 22 21 9502 9502 4 4 NM-TF d 22 21 9502 9502 5 4 LKF 52 40 8 9 2 1 LKF d 9600 48 0 0 7 3 BP-NN 2 2 25 8 3 1 BP-NN d 12 2 0 0 582 1 BBN 34 1 2 14 1 1 BBN d 32 1 2 5 0 0 FLS 87 8 0 0 22 8 FLS d 65 8 0 0 20 8

Small Large Small Large avg max HPT HPT LPT LPT 6 6 10 14 5.1 14 6 6 11 15 5.2 15 0 0 10 10 1907.5 9502 3 3 11 11 1908.4 9502 4 2 9600 9600 1931.8 9600 9600 9600 9600 9600 4805.8 9600 21 19 4 4 8.9 25 32 20 9600 48 1029.7 9600 20 55 74 21 22.3 74 19 55 77 22 21.3 77 200 55 67 15 46.2 200 195 55 70 16 43.7 195

Table 5.24: Iterations Required for Convergence to Correct Diagnosis for Each Case Overall, the Bayesian Belief Network and the Fuzzy Logic System consistently show up among the best algorithms for each performance metric. The Fuzzy Logic System was able to achieve higher 44

accuracy than the BBN in the estimation of the fault parameter values, and was less computationally intensive, while the Bayesian Belief Network was able to diagnose errors sooner after they had occurred.

Conclusion

This project applied several diagnostic strategies to a simulation of a low bypass turbofan that uses 9 health parameters to simulate component faults and degradation. The algorithms, which diagnose component faults by estimating the health parameter values, were a simple linear operator applied to the sensor values, a Newtons Method based tracking lter, a linearized Kalman lter, a back-propagation neural network, a Bayesian network, and a novel fuzzy logic system. The results of the diagnostic systems were compared in terms of accuracy of fault diagnosed, accuracy of the health parameter estimates produced, (simulation) time taken to produce a correct diagnosis, time needed for the computation, and eects of noise on the results. The algorithms all correctly diagnose most fault cases; the dot product method, neural network, Bayesian network and fuzzy system diagnose all faults correctly with no noise present, while the other systems misdiagnose faults involving one of the components. Relatedly, the dot product, Bayesian network, and fuzzy system show the lowest errors in estimating the health parameters. As expected, the dot product method is most computationally ecient, along with the neural network and tracking lter. The fuzzy system is about an order of magnitude slower than the tracking lter, but should be able to be signicantly improved because the MATLAB Fuzzy Toolbox is not very ecient. The Bayesian network, involving several nested for-loops to calculate conditional probabilities, takes another order of magnitude more time that the fuzzy system, and the linearized Kalman lter, requiring the engine model to propagate the state estimate, is by far the most computationally intensive algorithm investigated. All of the algorithms diagnosed faults relatively quickly, in terms of iterations from the introduction of the fault. The fuzzy system was one of the slowest, at 200 iterations to obtain the correct diagnosis for a few cases, with the Bayesian network next at 75 iterations. In fact, the results appear to show an inverse relationship between the simulation time needed for diagnosis and the error 45

in diagnosis and health parameter estimation. The dot product, which diagnoses errors relatively quickly and accurately, is the only outlier in this relationship. The dot product method was included in this analysis as a baseline to which other algorithms could be compared. Surprisingly, it rated better than average on all of the performance indicators used. This method appeared close to failure on almost every case (judged by a value less than 2 in 5.21), but handled noise surprisingly well. It is denitely worthy of further study with real engine data. Overall, the Bayesian network and fuzzy system demonstrated the most promise for diagnostic systems that can provide accurate results quickly in the event of engine damage. They are also relatively straightforward to set up, requiring only input and output information, since both have been created according to a xed, step-by-step setup process. This means that modifying them to work for real engines given engine data would be a quick process, especially relative to characterizing and compensating for modeling errors that would be necessary for using the linearized Kalman lter or tracking lter. As has been demonstrated, a noise lter will improve their diagnostic abilities and health parameter estimation accuracies. In this analysis, the methods that instantaneously analyze one set of sensor readings (dot product, neural network, Bayesian network, and fuzzy system) appeared to perform better than methods that have memory, modifying a vector of estimates at each time step (the tracking lter and linearized Kalman lter). However, it should be noted that both the tracking lter and LKF use a linearization of the engine model about its no-fault condition. Therefore, they recognize faults based on the sensor readings the linearized model predicts for those faults. The other methods, which are history based, use the full nonlinear CLM to generate sensor readings corresponding to each fault type. An extended Kalman lter, which uses a linearization of the system about the current state estimate, would not be limited by a linearization about the no-fault condition, and is expected to outperform both the tracking lter and LKF.

46

6.1

Future Work

Due to the importance of engine diagnostics, future work in this area is necessary. Much of that work should be devoted to collecting ight data from real engines and validating algorithms against it, because the systems used here were developed using a computer model, and the eects of modeling errors are unknown. Work must also be performed to begin running diagnostic algorithms on actual engine controllers. In parallel to the hardware validation work, future work with improving algorithm performance is also desirable. Since none of the systems demonstrated here have been proven to be optimal, it is unlikely that any of them are. It should be checked whether the accuracy of parameter estimation can be improved for all systems, whether the diagnoses can be obtained sooner after errors are introduced, and whether there is a trade-o between these two performance indicators. Also, all of the algorithms have some potential for computational optimization, most notably the fuzzy system. A hybrid method is a possible way of producing an improved diagnostic system. The Kalman lter and Bayesian network explicitly handle noise, and though the fuzzy system was modeled on the Bayesian network, it did not diagnose faults in noisy data as well. Also, as mentioned, the history based methods had an advantage over model based methods using a linear model. This advantage will be stronger when working with hardware due to the presence of modeling errors. An ideal hybrid method would be trained and validated with real data, have memory, and be able to handle noise.

References
[1] Matlab, fuzzy logic toolbox 2, version 2.2.12 (release 2010b), September 2010. [2] Mark Aull and Bruce Walker. Development of a fuzzy system for jet engine diagnostics and comparison with a bayesian diagnostic system. In AIAA Infotech@Aerospace, number AIAA2011-1452, 2011. [3] G. Cybenko. Approximation by superpositions of a sigmoidal function. Mathematics of Control Signals and Systems, 2(303-314), 1989. 47

[4] Yixin Diaoa and Kevin Passino. a turbine engine.

Stable fault-tolerant adaptive fuzzy/neural control for

IEEE TRANSACTIONS ON CONTROL SYSTEMS TECHNOLOGY,

9(10636536/01), 2001. [5] Yixin Diaoa and Kevin Passino. Fault diagnosis for a turbine engine. Control Engineering Practice, 12((2004) 11511165), 2004. [6] J. Henseler. Back propagation. In G. Goos, J. Hartmanis, and J. van Leeuwen, editors, Articial Neural Networks An introduction to ANN Theory and Practice, volume 931 of Lecture Notes in Computer Science. Springer, 1991. [7] Ying Huo, Petros Ioannou, and Mirmirani Majdedin. Fault tolerant control and reconguration for high performance aircraft: Review. Technical report, CATT Technical Report, 01-11-01. [8] O. Leonard, S. Borguet, and P. Dewallef. An adaptive estimation algorithm for aircraft engine performance monitoring. 2006. [9] R. Luppold, T. Brotherton, and A. Volponi. Adaptive on-wing gas turbine engine performance estimation. In IEEE Aerospace Conference, number 1112, 2007. [10] Jerry Mendel. Fuzzy logic systems for engineering: A tutorial. IEEE, 93(3), 1995. [11] Daryle Niedermayer. An introduction to bayesian networks and their contemporary applications. In Dawn Holmes and Lakhmi Jain, editors, Innovations in Bayesian Networks, volume 156 of Studies in Computational Intelligence, pages 117130. Springer Berlin / Heidelberg, 2008. [12] C. Romessis and K. Mathioudakis. Bayesian network approach for gas path fault diagnosis. Transactions of the ASME, 128, 2006. [13] V. Venkatasubramanian, R. Rengaswamy, Kewen Yin, and S. Kavuri. A review of process fault detection and diagnosis; part 1: Quantitative model-based methods. Computers and Chemical Engineering, 27(293-311), 2003.

48

[14] D. Viassolo, S. Adibhatla, B. Brunell, J. Down, N. Gibson, A. Kumar, H. Mathews, and L. Holcomb. Advanced estimation for aircraft engines. In American Control Conference, number 1-4244-0989-6/07, 2007. [15] B.K. Walker, K. Chen, and M. Aull. Generating and detecting the signatures of gas path anomalies in f110 engine tracking lter outputs. Final Project Report under GE P.O. 200-114U36188: Jet Engine Diagnostics, Dept. of Aerospace Engineering and Engineering Mechanics, U. Cincinnati, (GE Proprietary), August 2008. [16] B. Whitehead, H. Ferber, and M. Ali. Neural network approach to space shuttle main engine health monitoring. In 26th Joint Propulsion Conference, number 90-2259, 1990. [17] LiJie Yu, Daniel Cleary, and Paul Cuddihy. A novel approach to aircraft engine anomaly detection and diagnostics. In IEEE Aerospace Conference, number 0-7803-8155-6/04, 2004. [18] L.A. Zadeh. Fuzzy sets. Information Control, 8:338353, 1965.

49