/// <summary>
/// Get the averaged value. This will take the accumulated values and generate
/// an averaged value. It will then multiply the scale value to the averaged
/// value. The average value is then stored to the array.
/// If no data has been accumulated, NULL will be returned.
/// </summary>
/// <param name="scale">Scale value to multiply to the averaged value.</param>
/// <returns>An array of averaged value and a scale value multiplied in.</returns>
public virtual float[,] GetAverage(float scale = 1.0f)
{
// Accumulate the data
AccumulatedData data = AccumulateData();
// Then average the data
return(AverageData(data, scale));
}
/// <summary>
/// Average all the given accumulated data. This will then multiple a
/// scale value to the averaged data.
/// </summary>
/// <param name="accumData">Accumulated values.</param>
/// <param name="scale">Scale value to multiply to averaged value.</param>
/// <returns>Array with the averaged and scaled value.</returns>
protected float[,] AverageData(AccumulatedData accumData, float scale)
{
// Create an array, if no data is accumulated, null will be retruned
float[,] result = null;
if (accumData.AvgAccum != null && accumData.AvgCount != null)
{
// Create the results array based off the accumulated values
result = new float[accumData.AvgAccum.GetLength(0), accumData.AvgAccum.GetLength(1)];
// Set Min and Max bin
int minBin = 0;
int maxBin = accumData.AvgAccum.GetLength(0);
int numBeams = accumData.AvgCount.GetLength(1);
// Average all the accumulated data
for (int bin = minBin; bin < maxBin; bin++)
{
// Check if it has at least 1 beams
if (numBeams > 0)
{
// Calculate the average values
float B0 = 0.0f;
if (accumData.AvgCount[bin, DataSet.Ensemble.BEAM_0_INDEX] > 0)
{
B0 = accumData.AvgAccum[bin, DataSet.Ensemble.BEAM_0_INDEX] / accumData.AvgCount[bin, DataSet.Ensemble.BEAM_0_INDEX]; // Beam 0 Average
// Set results
B0 *= scale;
result[bin, DataSet.Ensemble.BEAM_0_INDEX] = B0;
}
else
{
result[bin, DataSet.Ensemble.BEAM_0_INDEX] = DataSet.Ensemble.BAD_VELOCITY;
}
}
// Check if it has at least 2 beams
if (numBeams > 1)
{
float B1 = 0.0f;
if (accumData.AvgCount[bin, DataSet.Ensemble.BEAM_1_INDEX] > 0)
{
B1 = accumData.AvgAccum[bin, DataSet.Ensemble.BEAM_1_INDEX] / accumData.AvgCount[bin, DataSet.Ensemble.BEAM_1_INDEX]; // Beam 1 Average
// Set Results
B1 *= scale;
result[bin, DataSet.Ensemble.BEAM_1_INDEX] = B1;
}
else
{
result[bin, DataSet.Ensemble.BEAM_1_INDEX] = DataSet.Ensemble.BAD_VELOCITY;
}
}
// Check if it has a least 3 beams
if (numBeams > 2)
{
float B2 = 0.0f;
if (accumData.AvgCount[bin, DataSet.Ensemble.BEAM_2_INDEX] > 0)
{
B2 = accumData.AvgAccum[bin, DataSet.Ensemble.BEAM_2_INDEX] / accumData.AvgCount[bin, DataSet.Ensemble.BEAM_2_INDEX]; // Beam 2 Average
// Set Results
B2 *= scale;
result[bin, DataSet.Ensemble.BEAM_2_INDEX] = B2;
}
else
{
result[bin, DataSet.Ensemble.BEAM_2_INDEX] = DataSet.Ensemble.BAD_VELOCITY;
}
}
// Check if it has a least 4 beams
if (numBeams > 3)
{
float B3 = 0.0f;
if (accumData.AvgCount[bin, DataSet.Ensemble.BEAM_3_INDEX] > 0)
{
B3 = accumData.AvgAccum[bin, DataSet.Ensemble.BEAM_3_INDEX] / accumData.AvgCount[bin, DataSet.Ensemble.BEAM_3_INDEX]; // Beam 3 Average
// Set Result
B3 *= scale;
result[bin, DataSet.Ensemble.BEAM_3_INDEX] = B3;
}
else
{
result[bin, DataSet.Ensemble.BEAM_3_INDEX] = DataSet.Ensemble.BAD_VELOCITY;
}
}
}
}
return result;
}
/// <summary>
/// This will accumulate all the data. THis will go through each
/// accumulated data and accumulate the values. It will check for
/// bad values before accumulating. If the value is bad, it will
/// not be included in the accumulated data. This will keep track
/// of the accumulated data and the number of data points for each bin.
/// The results will then be stored to a struct and returned.
/// </summary>
/// <returns>Struct containing the accumulated data.</returns>
protected AccumulatedData AccumulateData()
{
AccumulatedData result = new AccumulatedData();
if (_accumData.Count > 0)
{
// Get the number of bins and beams
// These values should be the same for all the accumulated data
float[,] firstData = _accumData.First();
int numBins = firstData.GetLength(0);
int numBeams = firstData.GetLength(1);
// Create arrays to accumulate the data
float[,] avgAccum = new float[numBins, numBeams];
int[,] avgCount = new int[numBins, numBeams];
// Accumulate the data for each accumulate array
for (int x = 0; x < _accumData.Count; x++)
{
// Get the data from the list
float[,] data = _accumData[x];
// Accumulate the values
for (int bin = 0; bin < data.GetLength(0); bin++)
{
// Beam 0
if (numBeams > 0)
{
float b0 = data[bin, DataSet.Ensemble.BEAM_0_INDEX];
if (b0 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[bin, DataSet.Ensemble.BEAM_0_INDEX] += b0;
avgCount[bin, DataSet.Ensemble.BEAM_0_INDEX]++;
}
}
// Beam 1
if (numBeams > 1)
{
float b1 = data[bin, DataSet.Ensemble.BEAM_1_INDEX];
if (b1 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[bin, DataSet.Ensemble.BEAM_1_INDEX] += b1;
avgCount[bin, DataSet.Ensemble.BEAM_1_INDEX]++;
}
}
// Beam 2
if (numBeams > 2)
{
float b2 = data[bin, DataSet.Ensemble.BEAM_2_INDEX];
if (b2 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[bin, DataSet.Ensemble.BEAM_2_INDEX] += b2;
avgCount[bin, DataSet.Ensemble.BEAM_2_INDEX]++;
}
}
// Beam 3
if (numBeams > 3)
{
float b3 = data[bin, DataSet.Ensemble.BEAM_3_INDEX];
if (b3 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[bin, DataSet.Ensemble.BEAM_3_INDEX] += b3;
avgCount[bin, DataSet.Ensemble.BEAM_3_INDEX]++;
}
}
}
}
// Set the accumulated data
result.AvgAccum = avgAccum;
result.AvgCount = avgCount;
}
return result;
}
/// <summary>
/// Average all the given accumulated data. This will then multiple a
/// scale value to the averaged data.
/// </summary>
/// <param name="accumData">Accumulated values.</param>
/// <param name="scale">Scale value to multiply to averaged value.</param>
/// <returns>Array with the averaged and scaled value.</returns>
protected float[,] AverageData(AccumulatedData accumData, float scale)
{
// Create an array, if no data is accumulated, null will be retruned
float[,] result = null;
if (accumData.AvgAccum != null && accumData.AvgCount != null)
{
// Create the results array based off the accumulated values
result = new float[accumData.AvgAccum.GetLength(0), accumData.AvgAccum.GetLength(1)];
// Set Min and Max bin
int minBin = 0;
int maxBin = accumData.AvgAccum.GetLength(0);
int numBeams = accumData.AvgCount.GetLength(1);
// Average all the accumulated data
for (int bin = minBin; bin < maxBin; bin++)
{
// Check if it has at least 1 beams
if (numBeams > 0)
{
// Calculate the average values
float B0 = 0.0f;
if (accumData.AvgCount[bin, DataSet.Ensemble.BEAM_0_INDEX] > 0)
{
B0 = accumData.AvgAccum[bin, DataSet.Ensemble.BEAM_0_INDEX] / accumData.AvgCount[bin, DataSet.Ensemble.BEAM_0_INDEX]; // Beam 0 Average
// Set results
B0 *= scale;
result[bin, DataSet.Ensemble.BEAM_0_INDEX] = B0;
}
else
{
result[bin, DataSet.Ensemble.BEAM_0_INDEX] = DataSet.Ensemble.BAD_VELOCITY;
}
}
// Check if it has at least 2 beams
if (numBeams > 1)
{
float B1 = 0.0f;
if (accumData.AvgCount[bin, DataSet.Ensemble.BEAM_1_INDEX] > 0)
{
B1 = accumData.AvgAccum[bin, DataSet.Ensemble.BEAM_1_INDEX] / accumData.AvgCount[bin, DataSet.Ensemble.BEAM_1_INDEX]; // Beam 1 Average
// Set Results
B1 *= scale;
result[bin, DataSet.Ensemble.BEAM_1_INDEX] = B1;
}
else
{
result[bin, DataSet.Ensemble.BEAM_1_INDEX] = DataSet.Ensemble.BAD_VELOCITY;
}
}
// Check if it has a least 3 beams
if (numBeams > 2)
{
float B2 = 0.0f;
if (accumData.AvgCount[bin, DataSet.Ensemble.BEAM_2_INDEX] > 0)
{
B2 = accumData.AvgAccum[bin, DataSet.Ensemble.BEAM_2_INDEX] / accumData.AvgCount[bin, DataSet.Ensemble.BEAM_2_INDEX]; // Beam 2 Average
// Set Results
B2 *= scale;
result[bin, DataSet.Ensemble.BEAM_2_INDEX] = B2;
}
else
{
result[bin, DataSet.Ensemble.BEAM_2_INDEX] = DataSet.Ensemble.BAD_VELOCITY;
}
}
// Check if it has a least 4 beams
if (numBeams > 3)
{
float B3 = 0.0f;
if (accumData.AvgCount[bin, DataSet.Ensemble.BEAM_3_INDEX] > 0)
{
B3 = accumData.AvgAccum[bin, DataSet.Ensemble.BEAM_3_INDEX] / accumData.AvgCount[bin, DataSet.Ensemble.BEAM_3_INDEX]; // Beam 3 Average
// Set Result
B3 *= scale;
result[bin, DataSet.Ensemble.BEAM_3_INDEX] = B3;
}
else
{
result[bin, DataSet.Ensemble.BEAM_3_INDEX] = DataSet.Ensemble.BAD_VELOCITY;
}
}
}
}
return(result);
}
/// <summary>
/// This will accumulate all the data. THis will go through each
/// accumulated data and accumulate the values. It will check for
/// bad values before accumulating. If the value is bad, it will
/// not be included in the accumulated data. This will keep track
/// of the accumulated data and the number of data points for each bin.
/// The results will then be stored to a struct and returned.
/// </summary>
/// <returns>Struct containing the accumulated data.</returns>
protected AccumulatedData AccumulateData()
{
AccumulatedData result = new AccumulatedData();
if (_accumData.Count > 0)
{
// Get the number of bins and beams
// These values should be the same for all the accumulated data
float[,] firstData = _accumData.First();
int numBins = firstData.GetLength(0);
int numBeams = firstData.GetLength(1);
// Create arrays to accumulate the data
float[,] avgAccum = new float[numBins, numBeams];
int[,] avgCount = new int[numBins, numBeams];
// Accumulate the data for each accumulate array
for (int x = 0; x < _accumData.Count; x++)
{
// Get the data from the list
float[,] data = _accumData[x];
// Accumulate the values
for (int bin = 0; bin < data.GetLength(0); bin++)
{
// Beam 0
if (numBeams > 0)
{
float b0 = data[bin, DataSet.Ensemble.BEAM_0_INDEX];
if (b0 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[bin, DataSet.Ensemble.BEAM_0_INDEX] += b0;
avgCount[bin, DataSet.Ensemble.BEAM_0_INDEX]++;
}
}
// Beam 1
if (numBeams > 1)
{
float b1 = data[bin, DataSet.Ensemble.BEAM_1_INDEX];
if (b1 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[bin, DataSet.Ensemble.BEAM_1_INDEX] += b1;
avgCount[bin, DataSet.Ensemble.BEAM_1_INDEX]++;
}
}
// Beam 2
if (numBeams > 2)
{
float b2 = data[bin, DataSet.Ensemble.BEAM_2_INDEX];
if (b2 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[bin, DataSet.Ensemble.BEAM_2_INDEX] += b2;
avgCount[bin, DataSet.Ensemble.BEAM_2_INDEX]++;
}
}
// Beam 3
if (numBeams > 3)
{
float b3 = data[bin, DataSet.Ensemble.BEAM_3_INDEX];
if (b3 != DataSet.Ensemble.BAD_VELOCITY)
{
avgAccum[bin, DataSet.Ensemble.BEAM_3_INDEX] += b3;
avgCount[bin, DataSet.Ensemble.BEAM_3_INDEX]++;
}
}
}
}
// Set the accumulated data
result.AvgAccum = avgAccum;
result.AvgCount = avgCount;
}
return(result);
}