A model-based condition indicator is a quantity derived from fitting system data to a model and performing further processing using the model. The condition indicator captures aspects of the model that change as system performance degrades. Model based-condition indicators can be useful when:

It is difficult to identify suitable condition indicators using features from signal analysis alone. This situation can occur when other factors affect the signal apart from the fault condition of the machine. For instance, the signals you measure might vary depending upon one or more input signals elsewhere in the system.

You have knowledge of the system or underlying processes such that you can model some aspect of the system's behavior. For instance, you might know from system knowledge that there is a system parameter, such as a time constant, that will change as the system degrades.

You want to do some forecasting or simulation of future system behavior based upon current system conditions. (See Models for Predicting Remaining Useful Life.)

In such cases, it can be useful and efficient to fit the data to some model and use condition indicators extracted from the model rather than from direct analysis of the signal. Model-based condition indicators can be based on any type of model that is suitable for your data and system, including both static and dynamic models. Condition indicators you extract from models can be quantities such as:

Model parameters, such as the coefficients of a linear fit. A change in such a parameter value can be indicative of a fault condition.

Statistical properties of model parameters, such as the variance. A model parameter that falls outside the statistical range expected from healthy system performance can be indicative of a fault.

Dynamic properties, such as system state values obtained by state estimation, or the pole locations or damping coefficient of an estimated dynamic model.

Quantities derived from simulation of a dynamic model.

In practice, you might need to explore different models and experiment with different condition indicators to find the ones that best suit your machine, your data, and your fault conditions. There are many approaches that you can take to identifying model-based condition indicators. The following sections summarize common approaches.

When you have data obtained from steady-state system operation, you can try fitting the data to a static model, and using parameters of that model to extract condition indicators. For example, suppose that you generate an ensemble of data by measuring some characteristic curve in different machines, at different times, or under different conditions. You can then fit a polynomial model to the characteristic curves, and use the resulting polynomial coefficients as condition indicators.

The example Fault Diagnosis of Centrifugal Pumps Using Steady State Experiments takes this approach. The data in that example describes the characteristic relation between pump head and flow rate, measured in an ensemble of pumps during healthy steady-state operation. The example performs a simple linear fit to describe this characteristic curve. Because there is some variation in the best-fit parameters across the ensemble, the example uses the resulting parameters to determine a distribution and confidence region for the fit parameters. Performing the same fit with a test data set yields parameters, and comparison of these parameters with the distribution yields the likelihood of a fault.

You can also use static models to generate grouped distributions of healthy and faulty data. When you obtain a new point from test data, you can use hypothesis tests to determine which distribution the point most likely belongs to.

For dynamic systems, changes in measured signals (outputs) depend on changes in signals elsewhere in the system (inputs). You can use a dynamic model of such a system to generate condition indicators. Some dynamic models are based on both input and output data, while others can be fit based on time-series output data alone. You do not necessarily need a known model of the underlying dynamic processes to perform such model fitting. However, system knowledge can help you choose the type or structure of model to fit.

Some functions you can use for model fitting include:

`ssest`

— Estimate a state-space model from time-domain input-output data or frequency-response data.`ar`

— Estimate a least-squares autorecursive (AR) model from time-series data.`nlarx`

— Model nonlinear behavior using dynamic nonlinearity estimators such as wavelet networks, tree-partitioning, and sigmoid networks.

There are also recursive estimation functions that let you fit models in real time
as you collect the data, such as `recursiveARX`

. The example
Detect Abrupt System Changes Using Identification Techniques
illustrates this approach.

For more functions you can use for model fitting, see Identify Condition Indicators.

Any parameter of a model might serve as a useful condition indicator. As with
static models, changes in model parameters or values outside of statistical
confidence bounds can be indicative of fault conditions. For example, if you
identify a state-space model using `ssest`

, the pole
locations or damping coefficients might change as a fault condition develops.
You can use linear analysis functions such as `damp`

, `pole`

, and `zero`

to extract dynamics from
the estimated model.

Another approach is `modalfit`

, which identifies
dynamic characteristics by separating a signal into multiple modes with distinct
frequency-response functions.

Sometimes, you understand some of your system dynamics and can represent them
using differential equations or model structures with unknown parameters. For
instance, you might be able to derive a model of your system in terms of
physical parameters such as time constants, resonant frequencies, or damping
coefficients, but the precise values of such parameters are unknown. In this
case, you can use linear or nonlinear *grey-box* models to
estimate parameter values, and track how those parameter values change with
different fault conditions. Some functions for you can use for grey-box
estimation include `pem`

and `nlarx`

.

A Simulink^{®} model can also serve as a grey-box model for parameter estimation.
You can use Simulink to model your system under both healthy and faulty conditions
using physically meaningful parameters, and estimate the values of those
parameters based on system data (for instance, using the tools in Simulink
Design Optimization™).

Another way to use a dynamic model is to simulate the model and compare the
result to the real data on which the model was based. The difference between
system data and the results of simulating an estimated model is called the
*residual signal*. The example Fault Diagnosis of Centrifugal Pumps Using Residual Analysis analyzes
the residual signal of an estimated `nlarx`

model. The
example computes several statistical and spectral features of the residual
signal. It tests these candidate condition indicators to determine which provide
the clearest distinction between healthy operation and several different faulty
states.

Another residual-based approach is to identify multiple models for ensemble data representing different healthy and fault conditions. For test data, you then compute the residuals for each of these models. The model that yields the smallest residual signal (and therefore the best fit) indicates which healthy or fault condition most likely applies to the test data.

For residual analysis of an identified model obtained using commands such as
`nlarx`

, `ar`

, or
`ssest`

, use:

As in the case parameter-based condition indicators, you can also use Simulink to construct models for residual analysis. The example Fault Detection Using Data Based Models also illustrates the residual-analysis approach, using a model identified from simulated data.

The values of system states can also serve as condition indicators. System states
correspond to physical parameters, and abrupt or unexpected changes in state values
can therefore indicate fault conditions. State estimators such as `unscentedKalmanFilter`

, `extendedKalmanFilter`

, and `particleFilter`

let you track the values of system states in real
time, to monitor for such changes. The following examples illustrate the use of
state estimators for fault detection: