/// <summary>
/// Process the incoming data. This will screen and average the data.
/// </summary>
/// <param name="data">Data to display.</param>
/// <param name="origDataFormat">Originial Format of the data.</param>
private void ProcessEnsemble(DataSet.Ensemble data, AdcpCodec.CodecEnum origDataFormat)
{
// Distribute the dataset to all subscribers
if (data != null)
{
// Publish the ensemble before it is screened and averaged
_events.PublishOnBackgroundThread(new EnsembleRawEvent(data.Clone(), EnsembleSource.Playback, EnsembleType.Single, origDataFormat));
// Make a copy of the ensemble to pass to all the views
DataSet.Ensemble newEnsemble = data.Clone();
// Lock the ensemble
lock (newEnsemble.SyncRoot)
{
// Vessel Mount Options
VesselMountScreen(ref newEnsemble);
// Screen the data
_screenDataVM.ScreenData(ref newEnsemble, origDataFormat);
// Average the data
_averagingVM.AverageEnsemble(newEnsemble);
// Create and Ensembl event
EnsembleEvent ensEvent = new EnsembleEvent(newEnsemble, EnsembleSource.Playback);
// Publish the ensemble after screening and averging the data
_events.PublishOnBackgroundThread(ensEvent);
// Display the ensemble
_pm.DisplayEnsemble(ensEvent);
}
}
}
/// <summary>
/// Check if the ensemble is in the cache.
/// If it is not in the cache, then query
/// the database for the ensemble. Then
/// update the cache with the next
/// </summary>
/// <param name="project">Project to get the data.</param>
/// <param name="index">Row ID of the data.</param>
/// <returns>Ensemble read from the database or cache.</returns>
private DataSet.Ensemble ReadEnsemble(Project project, long index)
{
// Use a background worker to get
// the ensemble.
if (project != null)
{
// Verify the connection is open
if (_cnn == null && _cnn.State != System.Data.ConnectionState.Open)
{
OpenConnection(project);
}
// Query for ensemble data
DataSet.Ensemble ensemble = _adcpDbCodec.QueryForDataSet(_cnn, project, index);
// Get the NMEA data and add it to the ensemble based off project settings
// Disturbute the dataset to all subscribers
if (ensemble != null)
{
// Create the velocity vectors for the ensemble
DataSet.VelocityVectorHelper.CreateVelocityVector(ref ensemble);
// Create a clone so the ensemble in the
//cache is not modified
return(ensemble.Clone());
}
}
return(null);
}
public void TestCloneEnsembleDataSet()
{
DataSet.Ensemble ensemble = new DataSet.Ensemble();
EnsembleHelper.AddEnsemble(ref ensemble, 20);
ensemble.EnsembleData.EnsembleNumber = 22;
DataSet.Ensemble clone = ensemble.Clone();
Assert.AreEqual(22, ensemble.EnsembleData.EnsembleNumber, "Ensemble Number is incorrect.");
Assert.AreEqual(22, clone.EnsembleData.EnsembleNumber, "Cloned Ensemble Number is incorrect.");
}
public void TestClone()
{
// Generate an Ensemble
DataSet.Ensemble ensemble = EnsembleHelper.GenerateEnsemble(30);
ensemble.EnsembleData.EnsembleNumber = 22;
DataSet.Ensemble clone = ensemble.Clone();
Assert.AreEqual(22, ensemble.EnsembleData.EnsembleNumber, "Ensemble Number is incorrect.");
Assert.AreEqual(22, clone.EnsembleData.EnsembleNumber, "Cloned Ensemble Number is incorrect.");
}
/// <summary>
/// Receive the ensemble from the codec.
/// Then set the ensemble size in bytes
/// so that the next ensemble can be found quicker.
/// Set the flag that the ensemble was found.
/// Then store the ensemble for playback.
/// </summary>
/// <param name="ensembleRaw">Ensemble binary data.</param>
/// <param name="ensemble">Ensemble object.</param>
/// <param name="origDataFormat">Original Data format.</param>
private void _adcpCodec_ProcessDataEvent(byte[] ensembleRaw, DataSet.Ensemble ensemble, AdcpCodec.CodecEnum origDataFormat)
{
// Set the length of an ensemble to find the next ensemble
// quicker
BytesPerEnsemble = ensembleRaw.Length;
// Copy the data
var ens = ensemble.Clone();
byte[] raw = new byte[ensembleRaw.Length];
Buffer.BlockCopy(ensembleRaw, 0, raw, 0, ensembleRaw.Length);
AddEnsemble(raw, ens, origDataFormat);
}
/// <summary>
/// Add an ensemble to the accumulator.
/// Calculate the reference layer and add it
/// to the accumulator.
/// </summary>
/// <param name="ensemble">Ensemble to add to average.</param>
public override void AddEnsemble(DataSet.Ensemble ensemble)
{
// Create worker to do the work
//BackgroundWorker worker = new BackgroundWorker();
//worker.DoWork += delegate(object s, DoWorkEventArgs args)
//{
// Ensure data exist to take an average
if (ensemble.IsEarthVelocityAvail && ensemble.IsEnsembleAvail)
{
// Clone the ensemble
// Modification will be made to the ensemble,
// so the ensemble is cloned.
DataSet.Ensemble cloneEnsemble = ensemble.Clone();
// Get the reference layer average
float[] refLayerAvg = GetReferenceLayerAverage(cloneEnsemble);
// Remove the reference layer average from all the bins
RemoveRefLayerAvgFromEnsemble(refLayerAvg, cloneEnsemble);
// Add the ensemble to the accum
_accumEns.AddLast(cloneEnsemble);
_accumRefLayerAvg.AddLast(refLayerAvg);
// Check the accum size to see if time to average data
if (_accumEns.Count > _numSamples)
{
// UNCOMMENT THIS IF YOU ARE NOT USING THE AVERAGER MANAGER
// THIS WILL AUTOMATICALLY PUBLISH THE AVERAGED ENSEMBLE WHEN
// THE NUMBER OF SAMPLES HAS BEEN MET
// Average the ensembles in the accumulator
//AverageEnsembles();
// If running average, remove the first ensemble
// If not running average, remove all the ensembles
RemoveFirstEnsemble();
}
}
//};
//worker.RunWorkerAsync();
}
public void TestCloneSubsystemConfig()
{
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add data to data set
adcpData.AddEnsembleData(DataSet.Ensemble.DATATYPE_INT, // Type of data stored (Float or Int)
30, // Number of bins
4, // Number of beams
DataSet.Ensemble.DEFAULT_IMAG, // Default Image
DataSet.Ensemble.DEFAULT_NAME_LENGTH, // Default Image length
DataSet.Ensemble.EnsembleDataID, 30, 4); // Dataset ID
adcpData.EnsembleData.SysSerialNumber = new SerialNumber("01300000000000000000000000000001");
adcpData.EnsembleData.SysFirmware = new Firmware(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, 0, 2, 3);
adcpData.EnsembleData.SubsystemConfig = new SubsystemConfiguration(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), 2, 2);
DataSet.Ensemble result = adcpData.Clone();
Assert.AreEqual(2, result.EnsembleData.SubsystemConfig.CepoIndex, "SubsystemConfig config number is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result.EnsembleData.SubsystemConfig.SubSystem.Code, "SubsystemConfig Subsystem code is incorrect.");
Assert.AreEqual(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), result.EnsembleData.SysFirmware.GetSubsystem(result.EnsembleData.SysSerialNumber), "SysFirmware GetSubsystem is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result.EnsembleData.SysFirmware.GetSubsystemCode(result.EnsembleData.SysSerialNumber), "Firmware SubsystemCode is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result.EnsembleData.SubsystemConfig.SubSystem.Code, "SubsystemConfig Subystem Code is incorrect.");
// When recloning the firmware SubsystemCode was changed from SubsystemIndex to SubsystemCode
// But the next time it is cloned, it will see the firmware version and do the change from SubsystemIndex to SubsystemCode again
DataSet.Ensemble result1 = result.Clone();
Assert.AreEqual(2, result1.EnsembleData.SubsystemConfig.CepoIndex, "Result 1 SubsystemConfig config number is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result1.EnsembleData.SubsystemConfig.SubSystem.Code, "Result 1 SubsystemConfig Subsystem code is incorrect.");
Assert.AreEqual(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), result1.EnsembleData.SysFirmware.GetSubsystem(result1.EnsembleData.SysSerialNumber), "Result 1 SysFirmware GetSubsystem is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result1.EnsembleData.SysFirmware.GetSubsystemCode(result1.EnsembleData.SysSerialNumber), "Result 1 Firmware SubsystemCode is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result1.EnsembleData.SubsystemConfig.SubSystem.Code, "Result 1 SubsystemConfig Subystem Code is incorrect.");
}
public void TestCloneEnsembleDataSet()
{
DataSet.Ensemble ensemble = new DataSet.Ensemble();
EnsembleHelper.AddEnsemble(ref ensemble, 20);
ensemble.EnsembleData.EnsembleNumber = 22;
DataSet.Ensemble clone = ensemble.Clone();
Assert.AreEqual(22, ensemble.EnsembleData.EnsembleNumber, "Ensemble Number is incorrect.");
Assert.AreEqual(22, clone.EnsembleData.EnsembleNumber, "Cloned Ensemble Number is incorrect.");
}
/// <summary>
/// Take the last ensemble as the parameter. Fill in
/// the averaged data to the ensemble. Then publish
/// it to all the subscribers.
/// </summary>
/// <param name="ensemble">Last ensemble that was accumulated.</param>
private void PublishAverage(DataSet.Ensemble ensemble)
{
// Clone the ensemble
DataSet.Ensemble avgEnsemble = ensemble.Clone();
// Set the num of samples and the first ping time to the ensemble
SetAveragedEnsembleParameters(ref avgEnsemble);
// Correlation Averaging
if (IsCorrelationAveraging)
{
_correlationAverager.SetAverage(ref avgEnsemble, _options.CorrelationScale);
}
// Amplitude averaging
if (IsAmplitudeAveraging)
{
_amplitudeAverager.SetAverage(ref avgEnsemble, _options.AmplitudeScale);
}
// Beam Velocity Averging
if (IsBeamVelocityAveraging)
{
_beamVelAverager.SetAverage(ref avgEnsemble, _options.BeamVelocityScale);
}
// Instrument Velocity Averging
if (IsInstrumentVelocityAveraging)
{
_instrumentVelAverager.SetAverage(ref avgEnsemble, _options.InstrumentVelocityScale);
}
// Earth Velocity Averging
if (IsEarthVelocityAveraging)
{
_earthVelAverager.SetAverage(ref avgEnsemble, _options.EarthVelocityScale);
}
// Bottom Track Averging
if (IsBottomTrackAveraging)
{
_bottomTrackAverager.SetAverage(ref avgEnsemble, _options.BottomTrackRangeScale, _options.BottomTrackSnrScale,
_options.BottomTrackAmplitudeScale, _options.BottomTrackCorrelationScale,
_options.BottomTrackBeamVelocityScale, _options.BottomTrackInstrumentVelocityScale, _options.BottomTrackEarthVelocityScale);
}
// Reference Layer Averaging
if (IsReferenceLayerAveraging)
{
_refLayerAverager.SetAverage(ref avgEnsemble, 1.0f);
}
// Publish the ensemble to all the subscribers
PublishAveragedEnsemble(avgEnsemble);
// Clear the accumulated data if not a running average
if (!IsSampleRunningAverage)
{
// Clear the accumulated data
ClearAccumulatedData();
}
}
/// <summary>
/// Accumulate ensembles to average. This will pass the ensemble to all the
/// different averagers to accumulate the data. When the NumSamples has been met,
/// an event will be sent with the averaged ensemble.
/// </summary>
/// <param name="ensemble"></param>
public void AddEnsemble(DataSet.Ensemble ensemble)
{
// Clone the ensemble
var cloneEnsemble = ensemble.Clone();
// Correlation averager
if (IsCorrelationAveraging)
{
_correlationAverager.AddEnsemble(cloneEnsemble);
}
// Amplitude averager
if (IsAmplitudeAveraging)
{
_amplitudeAverager.AddEnsemble(cloneEnsemble);
}
// Beam Velocity Averager
if (IsBeamVelocityAveraging)
{
_beamVelAverager.AddEnsemble(cloneEnsemble);
}
// Instrument Velocity Averager
if (IsInstrumentVelocityAveraging)
{
_instrumentVelAverager.AddEnsemble(cloneEnsemble);
}
// Earth Velocity Averager
if (IsEarthVelocityAveraging)
{
_earthVelAverager.AddEnsemble(cloneEnsemble);
}
// Reference layer averaging
if (IsReferenceLayerAveraging)
{
_refLayerAverager.AddEnsemble(cloneEnsemble);
}
// Bottom Track averaging
if (IsBottomTrackAveraging)
{
_bottomTrackAverager.AddEnsemble(cloneEnsemble);
}
// Set the first ping time if it has not been set
if (ensemble.IsAncillaryAvail && _firstPingTime == DEFAULT_FIRST_PING_TIME)
{
_firstPingTime = cloneEnsemble.AncillaryData.FirstPingTime;
}
// Set the previous ensemble
_lastEnsemble = cloneEnsemble;
// Increment the ensemble count
_ensCount++;
// Running average
// This will continously average the incoming data
if (IsAvgRunning)
{
// Publish the averaged data
PublishAverage(cloneEnsemble);
}
// If we have met the number of samples
// Publish the number of samples
else if (IsAvgByNumSamples && _ensCount >= NumSamples)
{
// Publish the averaged data
PublishAverage(cloneEnsemble);
// If we are not doing a running average
// Then clear the ensemble count so we
// can start over counting
if (!IsSampleRunningAverage)
{
ClearCount();
}
else
{
// Set the new first ping time for running average
_firstPingTime = cloneEnsemble.AncillaryData.FirstPingTime;
// Keep the _ensCount the same as the NumSamples so the
// number does not overflow
_ensCount = NumSamples;
// Remove the first ensemble
RemoveFirstEnsemble();
}
}
}
public void TestCloneSubsystemConfig()
{
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add data to data set
adcpData.AddEnsembleData(DataSet.Ensemble.DATATYPE_INT, // Type of data stored (Float or Int)
30, // Number of bins
4, // Number of beams
DataSet.Ensemble.DEFAULT_IMAG, // Default Image
DataSet.Ensemble.DEFAULT_NAME_LENGTH, // Default Image length
DataSet.Ensemble.EnsembleDataID, 30, 4); // Dataset ID
adcpData.EnsembleData.SysSerialNumber = new SerialNumber("01300000000000000000000000000001");
adcpData.EnsembleData.SysFirmware = new Firmware(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, 0, 2, 3);
adcpData.EnsembleData.SubsystemConfig = new SubsystemConfiguration(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), 2, 2);
DataSet.Ensemble result = adcpData.Clone();
Assert.AreEqual(2, result.EnsembleData.SubsystemConfig.CepoIndex, "SubsystemConfig config number is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result.EnsembleData.SubsystemConfig.SubSystem.Code, "SubsystemConfig Subsystem code is incorrect.");
Assert.AreEqual(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), result.EnsembleData.SysFirmware.GetSubsystem(result.EnsembleData.SysSerialNumber), "SysFirmware GetSubsystem is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result.EnsembleData.SysFirmware.GetSubsystemCode(result.EnsembleData.SysSerialNumber), "Firmware SubsystemCode is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result.EnsembleData.SubsystemConfig.SubSystem.Code, "SubsystemConfig Subystem Code is incorrect.");
// When recloning the firmware SubsystemCode was changed from SubsystemIndex to SubsystemCode
// But the next time it is cloned, it will see the firmware version and do the change from SubsystemIndex to SubsystemCode again
DataSet.Ensemble result1 = result.Clone();
Assert.AreEqual(2, result1.EnsembleData.SubsystemConfig.CepoIndex, "Result 1 SubsystemConfig config number is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result1.EnsembleData.SubsystemConfig.SubSystem.Code, "Result 1 SubsystemConfig Subsystem code is incorrect.");
Assert.AreEqual(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), result1.EnsembleData.SysFirmware.GetSubsystem(result1.EnsembleData.SysSerialNumber), "Result 1 SysFirmware GetSubsystem is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result1.EnsembleData.SysFirmware.GetSubsystemCode(result1.EnsembleData.SysSerialNumber), "Result 1 Firmware SubsystemCode is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, result1.EnsembleData.SubsystemConfig.SubSystem.Code, "Result 1 SubsystemConfig Subystem Code is incorrect.");
}
