Vold-Kalman Filter Overview

Overview

The Vold-Kalman filter is a time-domain filter that is useful for extracting order-based signals, which occur in rotating equipment situations. It uses a global estimation scheme, so there are no signal processing artifacts due to arbitrary block and/or window sizes. The extracted orders are estimated without phase bias because the formulation is symmetric in time. It can extract orders that are phase-coherent with the causative shaft in a multi-tach situation.

IMAT implements the third-generation Vold-Kalman filter, which sequences the equations in a different way, providing the ability to filter multiple shaft (tach) results efficiently using direct methods. It can generate either fixed-frequency- or fractional-order-bandwidth filters, and you can specify the number of poles for the filters (higher number of poles means sharper filter, at the expense of computation time).

The principle of the Vold-Kalman filter is that a time signal y(t) is the summation of x(t), the deterministic, harmonic signals that are correlated to the tachometers, and a broadband signal v(t), which corresponds to anything not correlated with the tachometer signals.

y(t) = x(t) + v(t)

The Vold-Kalman filter essentially decomposes the deterministic signal x(t) into the product of a complex envelope Ak(t) and a phasor pk(t) using linear estimation techniques. The phasor is provided by the tachometer signal. The total deterministic signal is the summation of the individual time histories xk(t) over all of the orders and shafts.

xk(t) = Ak(t)pk(t)

x(t) = x1(t) + x2(t) + ... +xn(t),   k = 1:n

 

The complex phasor pk(t) is defined by the equation

where w(t) is the instantaneous shaft speed of a shaft in revolutions per second. Thus the integral in the equation above is the instantaneous position of the shaft in revolutions.

 

More information about the Vold-Kalman filter can be found in the following references:

 

The following sections describe the different filter topics, followed by an example where we contrive some order-based data and then create and apply the Vold-Kalman filter to the data.

Tachometer Signals

One important prerequisite to successful filtering is a clean tachometer signal. Frequently test-measured tach signals contain noise, dropouts, etc. IMAT provides functionality to process tach signals to smooth out noise, dropoff, and other test artifacts.

IMAT provides an IMATTachometer data class that handles tachometer types. Currently only pulse tachometers are supported.

This pulse tachometer class performs a cubic spline fit on the tachometer data. The spline consists of a user-specified number of spline segments that are constrained such that the endpoints and slopes of adjacent spline segments are the same, so the resulting spline fit is continuous.

Filter Parameters

The IMAT Vold-Kalman filter implementation uses a class called VoldKalmanParameters that stores the filter parameters for a given filter operation. The filter parameters that must be set include the order numbers to extract from each tach, the filter bandwidth and type (fixed frequency or order fraction), and the revolutes, which is simply the tach position as a function of time.

Applying the Filter

Once the filter parameters have been specified, you can create and then apply the filter on your time histories. After the data has been filtered, both the filter orders and envelopes are available. The envelopes are complex values, which correspond to the Ak(t) terms of the filtered results. The magnitude is the amplitude envelope, and the phase is the wrapped phase relative to the tachometer. The orders are complex time histories, where the real component is the physical signal, and the angle is the phase of the time response relative to the tachometer. This represents the Ak(t) terms multiplied by the phasors.

IMAT provides an IMATVKFilter class that creates and applies the filter to the supplied input time histories, and returns the resulting envelopes and/or orders.

Example

In this example we will generate some analytical data, and then apply the Vold-Kalman filter to it. This example consists of two shafts (tachs) that are made up of sinusoidal signals that vary in frequency through the run. The signals cross in frequency. We will create three sinusoidal signals at fractional orders of both tachs and sum the individual orders into a total signal. We will then filter these orders out of the total signal and compare the filtered results to the original to evaluate the filter's performance.

First we need to set some sampling parameters.

sf  = 8192;               % Sample rate (1/sec)
T   = 10;                 % Total time
dt  = 1/sf;               % delta T
t   = (0:dt:T).';         % Time values
n_t = numel(t);           % Number of time values

Next we build some tachometer signals. These signals are sinusoidal signals that vary in frequency.

omega1 = linspace(500, 1000, n_t)';          % Shaft 1 spins from 500 to 1000 Hz
omega2 = linspace(600, 900, n_t)';           % Shaft 2 spins from 600 to 900 Hz

tachsig1 = sin(2*pi*dt*cumsum(omega1));      % Tach signal 1, 1 pulse per rev
tachsig2 = sin(2*pi*dt*cumsum(omega2));      % Tach signal 2, 1 pulse per rev

Next we will convert the tachometer signals into imat_fn objects.

it1                   = imat_fn;
it1.FunctionType      = 'Time response';
it1.ReferenceCoord    = '';
it1.ResponseCoord     = '1TACH';
it1.AbscissaSpacing   = 'Even';
it1.AbscissaInc       = dt;
it1.Ordinate          = tachsig1;
it1.OrdNumDataType    = 'General';

it2                   = it1;
it2.ResponseCoord     = '2TACH';
it2.Ordinate          = tachsig2;

Next we need to contrive some order-tracked data. This consists of a unit amplitude sine wave of order 1.3 based on the first tach. The second signal is an amplitude 2 sine wave of order 1.25 based on the second tach. The third signal is an amplitude 3 sine wave of order 1.2502 based on tach 2. The total signal is the summation of these three sine waves.

sig1    = 1*sin(2*pi*dt*1.3*cumsum(omega1));       % Order 1.3 Tach 1
sig2    = 2*sin(2*pi*dt*1.25*cumsum(omega2));      % Order 1.25 Tach 2
sig3    = 3*sin(2*pi*dt*1.2502*cumsum(omega2));    % Order 1.2502 Tach 2
totsig  = sig1 + sig2 + sig3;                      % Total signal is the summation of the individual

The spectrogram plot is a nice way to view the total signal. The orders from the two shafts are clearly visible in the result.

figure;
spectrogram(decimate(totsig, 2),2048, 1800,2048,sf/2);
title('Spectrogram')

The next step is to place the total signal into an imat_fn. We will also place the original signals into an imat_fn so we can compare them to the filtered signal later.

thist                = it1;                        % Copy the tach 1 object to borrow the previously set attributes
thist.ResponseCoord  = '1x';
thist.ordinate       = totsig;

sig              = imat_fn(3);
sig.abscissamin  = t(1);
sig.abscissainc  = dt;
sig.ordinate     = [sig1(:) sig2(:) sig3(:)];
sig.responsenode = 1:3;

The next step involves processing the data. First, the tachometer signals must be processed to extract the shaft speed and position. Creating an IMATTachometer object automatically processes the tachometer signal, so results are immediately available.

level   = 0;         % Signal zero crossing level
ppr     = 1;         % Pulses per revolution
nseg    = 30;        % Number of spline segments

itach1      = IMATTachometer(it1,'pulse',level,ppr,nseg);
itach2      = IMATTachometer(it2,'pulse',level,ppr,nseg);
itach1.name = 'First tach';
itach2.name = 'Second tach';

It is a good idea to look at the tach signal for at least one of the tachs to make sure that the processed signal is as expected. In this case we should see a tach speed that varies from 500 to 1000 Hz over a 10 second interval.

hp = plot(it1.abscissa,itach1.speed);
hp.ylabel('Tach speed (Hz)');

The next major step is to set up the Vold-Kalman filtering parameters to specify which orders to extract, along with the relevant processing parameters.

For this example we want to extract the orders that we used to generate the total signal. First we will define a vector of orders to extract, the corresponding shaft to use as the reference tach, the number of shafts, and the revolutes, which are simply the tach positions as a function of time. These are easily extracted from the IMATTachometer object. After defining this information, we need to create the VoldKalmanParameters object and populate it with the above information. We also need to specify the filter bandwidth and whether it is fixed frequency or proportional to order).

orders     = [1.3  1.25  1.2502];                        % Shaft orders to filter
shaft      = [1    2     2     ];                        % Shaft on which the orders belong
shaftCount = numel(unique(shaft));                       % Number of tachs
revolute   = {itach1.position(t)  itach2.position(t)};   % Revolutes (tach position)

vkpar = VoldKalmanParameters(shaftCount);

IsOrderBW = [];   BW = [];   Orders = [];   Revolute = [];
for ix = 1:shaftCount
    IsOrderBW{ix} = false;                               % TRUE = order-proportional, FALSE = fixed frequency
    BW{ix}        = 1;                                   % Filter bandwidth in units above (order or Hz)
    Orders{ix}    = orders(shaft == ix);                 % Orders for each shaft
    Revolute{ix}  = revolute{ix};                        % Nx1 vector of tach.position(t) for the given shaft
end

vkpar.IsOrderBW = IsOrderBW;
vkpar.BW        = BW;
vkpar.Orders    = Orders;
vkpar.Revolute  = Revolute;

The final step is to filter the signals. We need to specify the number of poles for the filter. A higher number generates a sharper filter at the expense of longer processing times. A value of 2 is recommended.

npoles   = 2;
vkfilter = IMATVKFilter(npoles);      % Create the filter
vkfilter.filter(thist,vkpar);         % Filter the data

We want to compare the filtered results to the original. The orders method of the filter returns a complex time history of the filtered order. The real component of the time history is the physical time response, and the angle is the phase of the time response relative to the tachometer. Comparing the original to the filtered signal shows excellent agreement between the two, demonstrating the effectiveness of the filter.

order1 = vkfilter.orders();
hp = plot(sig(1),real(order1(1)))
hp.title('Order 1');
hp = plot(sig(2),real(order1(2)))
hp.title('Order 2');
hp = plot(sig(3),real(order1(3)))
hp.title('Order 3');