/// <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."); }
/// <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(); } } }