NOAA/ OERD T-Phase Project: Ocean Noise Levels

The document below shows only the steps needed to obtain the noise levels. Not all the details or the mathematical concept will be shown. Also please read the disclaimer below.

Noise Level Calculations

There are 2 ways to compute the average nosie levels. They can de done by either in Time Domain or Frequency Domain. Both have their advantages and disadvantages.

Their calculational steps are described below, and the steps will be using the following syntax. Common programming codes will be used such as N = N + 1 means the value in the veriable: N is increased by 1. Also the variable enclosed by the "[...]" indicates that is a 1-D Array variable or a vector with number of elements or values. When [C] = [A] + [B] is shown, it means the sizes of the arrays in [A] and [B] are the same and [A] + [B] will be like adding 2 vectors together to form a new vertor or array [C]. When [C] = [A] x [B] is used, the [C] is the vector of the product from [A] and [B] elements by elements. When [C] = [A] + or - N is used, it means each element in [A] is added or substracted by the value in the variable: N. The results: [C] from all the examples above will have the same elements or size as the array [A] and [B].

Compute Noise Levels in Time the Domain

Let [DATA] = Array of the data, e.g. 1 hour long data. The data unit must be in or can be converted into Voltage. Then a mathematical FILTER must be created to filter the unwanted signals from DATA. The [FILTER] can be either High-Pass (keep only the high frequency component), Low-Pass (keep only the low frequence part of the signals), or Notch (keep the specified mid-range of the frequency component).

The [FILTER] itself can be created by the Butterworth or other methods. Its length of the [FILTER] should be long enough to create a good filter. The Butterworth method is used in this project. The descriptions of the Butterworth method is not shown here. Also by no means that other filter construction method cannot be used. It is up to the individual to determine which method will yeild the best results. For this project, the filter length: 51 points and 4 pole order: 4 were used to create a [FILTER] by the Butterworth method.

Once the [FILTER] is ready, the following steps can be applied.

 1) Let M = the Sample Mean of the DATA containing 1 hour lone data, e.g.
 2) Convolve the DATA after its Mean is removed with the [FILTER], i.e.
    [CONVOLVED_DATA] = CONVOL( ( [DATA] - M ), [FILTER] )  ; in a pseudo IDL syntax.
 3) Let V = Varaince of the [CONVOLVED_DATA].
 4) Convert the Varaince: V into the  dB = 10 x Log10( V/( j - i ) )
    where the dB is the Average Noise Level between the specified
    Frequency Range: i and j Hz, e.g. i = 9 Hz and j = 11 Hz.
    The condition for i & j are
    0 <= i < j <= Nyquist (Half of the Sample Rate). 
 5) Adjust the dB by Removing the System Gain: dB = dB + GAIN
    where GAIN = +/- Hydrophone Sensitivilty value and the Average Level
    of the Frequency Range of Interest from the pre-amp curve.
 6) Repeat 1) to 5) again for the next set of the DATA to get the next dB
    if it is needed; otherwise, it is done.

As long as the programming software to be used has the function: Convolve. The 6 steps above can be implemented relatively straight forward to obtain the average noise level in dB. No FFT is required. These are the Adventages.

The Disadvantages are: the speed of the Convolution function and the dependency of the [FILTER] construction plus the GAIN definition in step 5). The Convolve function could be slow to finish; because, it is depended on the lenght of the DATA and the computer speed. The building of the [FILTER] and GAIN for different Frequency Range of Interest can be programmed in general. However, once they are built, they can be only used for the defined Frequency Range. If noise levels for 2 or more Frequency Ranges of the same DATA set are needed, the step 1) to 5) must be repeated 2 or more times to obtain the dB values. This is the Major Disadvantage beside the expensive Convolution process.

Compute Noise Levels in the Frequency Domain

Same in the Time Domain, let [DATA] = Array of the data, e.g. 1 hour long data. The data unit must be in or can be converted into Voltage. Then a mathematical filer: [TAPER], e.g. Cosine Taper, is needed to be applied to [DATA] before the FFT (Fast Fourier Transform) process. The Taper function is to minimize the Gibbs affect after the FFT. There are other filter can be used to do the same task. In this project a simple Cosine Taper filter is used and the size of the filter is 1 sample rate long or 1 seconds long.

Once the [TAPER] is ready, the following steps can be applied.

 1) Let M = the Sample Mean of the [DATA] containing 1 hour long data.
    Note that total number points in [DATA] will be Sample Rate x 3600 seconds,
    e.g. Sample Rate = 250 Hz & 1 Hour = 3600 seconds, [DATA] = 900000 points.

 2) Let [POWER] = 1-D array or vector of zeros, 0.5 second long, and Set the 
    indexes i = 0 & j = 249 so that [DATA[i:j]] will be 1st second long data.
    Do the following Steps 2-1) to 2-4) for each Second long of data from [DATA] 
    3600 times; because, [DATA] is 1 hour long and with 1 second increment = 3600.
    2-1) Convert the data into the Frequency Domain:
         [FFT_DATA] = FFT( ( [DATA[i:j]] - M ) x [TAPER] )
         Note that the Mean of the DATA[i:j] is Removed 1st before
         the [TAPER] is applied, then do the FFT(...).
         The indexes: i & j indicate each consective 1 second data points in [DATA].
    2-2) Compute the Power Spectrum:
         [PWR] = | [FFT_DATA[0:Nyquist]] |2
         Note that use only the Real-Part of the [FFT_DATA] from the DC
         term: 0 to the Nyquist (Half of the Sample Rate) frequency (Hz)
         range and take the Absolute values & Square.
    2-3) Accumulate the Power Spectrum: [POWER] = [POWER] + [PWR]
    2-4) Move the i & j to the next second of the data,
         i.e., i = i + 250 and j = j + 250.
 3) Get Average Power Spectrum: [POWER] = ( Σ[POWER] )/3600

 4) Compute the dB values from the 0 to Nyquist frequency:
    [dB] = 10 x Log10( 2 x [POWER] ) where 2 x [POWER] is needed to account for
    the conjugate part of the FFT results.
    Note that [dB] = 1-D array of numbers.
 5) Remove the System Gain: [ADJUST_dB] = [dB] + [GAIN]
    where [GAIN] = +/- Hydrophone Sensitivilty value and the 
    db values from the pre-amp curve.  Note that be sure the 
    pre-amp curve's frequency bin is same as the dB's frequency bin, 
    i.e., the [GAIN] must have the same number of the elements in [dB].
 6) Convert the System Gain Removed dB back to linear scale:
    [MAGNITUDE] = 10( [ADJUST_dB]/10 )
    Since [ADJUST_dB] is in Log Scale, Linear Scale is needed so that the
    Average Nosie Levels can be calculated correctly.
    Note that both [ADJUST_dB] & [MAGNITUDE] are 1-D arrays of the same sizes.
 7) Compute the Average Noise Level in dB unit between Frequency Range: f & g Hz.
    Let  A = ( Σ[MAGNITUDE[f:g]] )/( g - f )  then  Ave_dB = 10 x Log10( A )
    where condition for f & g are 0 <= f < g <= Nyquist.
 8) Repeat 7) if the different Frequency Range of interests, 
    i.e. different sets of ( f & g ) are needed; otherwise, continue.
 9) Repeat 1) to 7) again for the next set of the DATA to get the next set of the
    average noise levels: Ave_dB until the end of data.

In term of implementing the steps above, the software to be used for programming must have the FFT function available to the users. When implementing the steps, especially steps 2) and 7), Care must be taken for counting the looping indexes: i and j correctly for getting the data segment: [DATA[i:j]] in the step 2 ) and keeping track of the Frequency Range indexes f and g to get the correct range of the [MAGNITUDE[f:g]] in step 7).

So the programming steps for Computing the Noise Levels in Frequency Domain can be quite involved and the FFT process is also required. That can be considered the Disadventage.

However once the [MAGNITUDE] is computed in step 6), the different average noise levels between different Frequency Range of interests can be calculated within steps 7) and 8). This is the Major Adventage for Computing the Noise Levels in Frequency Domain and over come the major disadventages when compute the same noise levels in the Time Domain. See Settings used for Computing the Noise Levels in the Frequency Domain below, it shows how the steps 2), 7) and 8) are applied.

Computational Speeds between the Frequency Domain and Time Domain Methods

Both methods have been implemented by IDL. Both IDL programs work well and their speeds are relatively the same in general. In one test, the Frequency Domain Method is close to 4.1 seconds faster than the Time Domain Method.

This could be due to the speeds of the CONVOL and FFT functions. At least in IDL, the CONVOL function will take longer because each value computed by the CONVOL function required a looping process and no short cut. However, the FFT process can be speeded up if the data size is shorter or it is 2^N for N is an integer > 0.

For this project, the IDL program is using the Frequency Domain Method. The [DATA] are processed repeatedly in 1 second long segment from an hour long data, see Step 2) above. The sample rate is either 100 or 250 Hz. Therefore, the FFT speed is reasonable fast.

The IDL program using the Time Domain requires to using an hour long data with and a 51 point filter for computing the convolution results. Almost all the points require a summing of 51 points of product of 2 numbers. That uses up more time.

Settings used for Computing the Noise Levels in the Frequency Domain

The examples listed in steps 1) and 2) above are the settings used in this project. The reason 1 second long data is choisen to processed the data, so that the frequency range for all the array or vector variables in the steps 4) to 7) will be in 1 Hz resolutions.

This makes the programming codes more simpler to count the frequency range f & g in step 7). Care is still needed to implement the step 5) to remove the System Gain. If the System Gain Curve is not provided with the same frequency resolutions, in this case 1 Hz, the System Gain Curve must be interpolated so that the frequency resolutions will match with the array variable: [dB]. In this project IDL cubic spline function: SPLINE(...) is used.

Disclaimer:

The contents of this page are intened as a documentation for the Noise Levels project and what methods are used for the noise level calculations.  It is neither a tutorial nor an introduction of noise levels for the public.  The method described here serve the project well; however, it may not work well for other purposes.