/// <summary>
/// Encode the STA and LTA Status data.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <param name="bs">Bin Selection.</param>
/// <returns>String for STA and LTA Status data.</returns>
private string EncodeStatusData(DataSet.Ensemble ens, BinSelection bs)
{
if (ens.IsEnsembleAvail)
{
StringBuilder sb = new StringBuilder();
sb.Append("5"); // 5 Header
sb.Append("\t" + bs.NumBinsSelected.ToString()); // Number of bins selected
sb.Append(" " + ens.EnsembleData.NumBeams.ToString()); // Number of beams
sb.Append(" " + bs.MinBin.ToString()); // Minimum Bin
sb.Append(" " + bs.MaxBin.ToString()); // Maximum bin
sb.Append("\r\n");
for (int bin = bs.MinBin - 1; bin < bs.NumBinsSelected; bin++)
{
sb.Append("\t");
for (int beam = 0; beam < ens.EnsembleData.NumBeams; beam++)
{
sb.Append(" " + -32768); // Status
}
sb.Append("\r\n");
}
return(sb.ToString());
}
return("");
}
/// <summary>
/// Encode the Percent Good data.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <param name="bs">Bin Selection.</param>
/// <returns>String for Amplitude data.</returns>
private string EncodePgData(DataSet.Ensemble ens, BinSelection bs)
{
if (ens.IsEnsembleAvail)
{
int pingCount = ens.EnsembleData.ActualPingCount;
StringBuilder sb = new StringBuilder();
sb.Append("4"); // 4 Header
sb.Append("\t" + bs.NumBinsSelected.ToString()); // Number of bins selected
sb.Append(" " + ens.EnsembleData.NumBeams.ToString()); // Number of beams
sb.Append(" " + bs.MinBin.ToString()); // Minimum Bin
sb.Append(" " + bs.MaxBin.ToString()); // Maximum bin
sb.Append("\r\n");
for (int bin = bs.MinBin - 1; bin < bs.NumBinsSelected; bin++)
{
sb.Append("\t");
for (int beam = 0; beam < ens.EnsembleData.NumBeams; beam++)
{
sb.Append(" " + ((ens.GoodEarthData.GoodEarthData[bin, beam] / pingCount) * 100).ToString("0")); // PG
}
sb.Append("\r\n");
}
return(sb.ToString());
}
return("");
}
/// <summary>
/// Encode the Amplitude data.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <param name="bs">Bin Selection.</param>
/// <returns>String for Amplitude data.</returns>
private string EncodeAmpData(DataSet.Ensemble ens, BinSelection bs)
{
if (ens.IsAmplitudeAvail)
{
StringBuilder sb = new StringBuilder();
sb.Append("3"); // 3 Header
sb.Append("\t" + bs.NumBinsSelected.ToString()); // Number of bins selected
sb.Append(" " + ens.EnsembleData.NumBeams.ToString()); // Number of beams
sb.Append(" " + bs.MinBin.ToString()); // Minimum Bin
sb.Append(" " + bs.MaxBin.ToString()); // Maximum bin
sb.Append("\r\n");
for (int bin = bs.MinBin - 1; bin < bs.NumBinsSelected; bin++)
{
sb.Append("\t");
for (int beam = 0; beam < ens.EnsembleData.NumBeams; beam++)
{
sb.Append(" " + (ens.AmplitudeData.AmplitudeData[bin, beam]).ToString("0")); // Amp
}
sb.Append("\r\n");
}
return(sb.ToString());
}
return("");
}
/// <summary>
/// Encode the Correlation data.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <param name="bs">Bin Selection</param>
/// <returns>String for Correlation data.</returns>
private string EncodeCorrData(DataSet.Ensemble ens, BinSelection bs)
{
if (ens.IsCorrelationAvail)
{
StringBuilder sb = new StringBuilder();
sb.Append("2"); // 2 Header
sb.Append("\t" + bs.NumBinsSelected.ToString()); // Number of bins selected
sb.Append(" " + ens.EnsembleData.NumBeams.ToString()); // Number of beams
sb.Append(" " + bs.MinBin.ToString()); // Minimum Bin
sb.Append(" " + bs.MaxBin.ToString()); // Maximum bin
sb.Append("\r\n");
for (int bin = bs.MinBin - 1; bin < bs.NumBinsSelected; bin++)
{
sb.Append("\t");
for (int beam = 0; beam < ens.EnsembleData.NumBeams; beam++)
{
sb.Append(" " + (ens.CorrelationData.CorrelationData[bin, beam] * 100).ToString("0")); // Corr
}
sb.Append("\r\n");
}
return(sb.ToString());
}
return("");
}
/// <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 TestScreenAllGood()
{
int bins = 10;
// Generate ensemble with blank data
DataSet.Ensemble ensemble = EnsembleHelper.GenerateEnsemble(bins);
// Populate the data
for (int bin = 0; bin < bins; bin++)
{
ensemble.EarthVelocityData.EarthVelocityData[bin, DataSet.Ensemble.BEAM_EAST_INDEX] = 0.1f;
ensemble.EarthVelocityData.EarthVelocityData[bin, DataSet.Ensemble.BEAM_NORTH_INDEX] = 0.2f;
ensemble.EarthVelocityData.EarthVelocityData[bin, DataSet.Ensemble.BEAM_VERTICAL_INDEX] = 0.01f;
ensemble.EarthVelocityData.EarthVelocityData[bin, DataSet.Ensemble.BEAM_Q_INDEX] = 0.0f;
}
// Make some high Error Velocities
int badBin = (int)bins / 2;
ensemble.EarthVelocityData.EarthVelocityData[badBin, DataSet.Ensemble.BEAM_Q_INDEX] = 1.0f;
// Screen the ensemble
ScreenData.ScreenErrorVelocityThreshold.Screen(ref ensemble, 2.0f);
Assert.AreEqual(0.1f, ensemble.EarthVelocityData.EarthVelocityData[0, DataSet.Ensemble.BEAM_EAST_INDEX], 0.0001, "East Velocity for Good is incorrect.");
Assert.AreEqual(0.2f, ensemble.EarthVelocityData.EarthVelocityData[0, DataSet.Ensemble.BEAM_NORTH_INDEX], 0.0001, "North Velocity for Good is incorrect.");
Assert.AreEqual(0.01f, ensemble.EarthVelocityData.EarthVelocityData[0, DataSet.Ensemble.BEAM_VERTICAL_INDEX], 0.0001, "Veritcal Velocity for Good is incorrect.");
Assert.AreEqual(0.0f, ensemble.EarthVelocityData.EarthVelocityData[0, DataSet.Ensemble.BEAM_Q_INDEX], 0.0001, "Q Velocity for Good is incorrect.");
Assert.AreEqual(0.1f, ensemble.EarthVelocityData.EarthVelocityData[badBin, DataSet.Ensemble.BEAM_EAST_INDEX], 0.0001, "East Velocity for Bad is incorrect.");
Assert.AreEqual(0.2f, ensemble.EarthVelocityData.EarthVelocityData[badBin, DataSet.Ensemble.BEAM_NORTH_INDEX], 0.0001, "North Velocity for Bad is incorrect.");
Assert.AreEqual(0.01f, ensemble.EarthVelocityData.EarthVelocityData[badBin, DataSet.Ensemble.BEAM_VERTICAL_INDEX], 0.0001, "Veritcal Velocity for Bad is incorrect.");
Assert.AreEqual(1.0f, ensemble.EarthVelocityData.EarthVelocityData[badBin, DataSet.Ensemble.BEAM_Q_INDEX], 0.0001, "Q Velocity for Bad is incorrect.");
}
/// <summary>
/// Get the Bin Selection. This will verify the selections are correct.
/// </summary>
/// <param name="ens">Ensemble to get the number of bins.</param>
/// <param name="minBin">Mininum Bin selected.</param>
/// <param name="maxBin">Maximum bin selected.</param>
/// <returns>Bin Selections.</returns>
private BinSelection GetBinSelection(DataSet.Ensemble ens, int minBin, int maxBin)
{
BinSelection bs = new BinSelection(minBin, maxBin);
// Verify min and max bin is possible
if (minBin > maxBin)
{
minBin = maxBin - 1;
if (minBin < 0)
{
minBin = 1;
maxBin = 2;
}
}
if (ens.IsEnsembleAvail)
{
if (maxBin > ens.EnsembleData.NumBins)
{
maxBin = ens.EnsembleData.NumBins;
}
}
bs.MinBin = minBin;
bs.MaxBin = maxBin;
bs.NumBinsSelected = (maxBin - minBin) + 1;
return(bs);
}
/// <summary>
/// Based off the code, call the apporiate update method.
/// Each method will take the approriate data from the
/// ensemble to update the line series.
/// </summary>
/// <param name="ensemble">Latest ensemble data.</param>
/// <param name="maxBin">Maximum number of bins to display.</param>
/// <param name="isFilterData">Filter the data for bad values.</param>
private void UpdateLineSeries(DataSet.Ensemble ensemble, int maxBin, bool isFilterData)
{
switch (Type.Code)
{
case ProfileType.eProfileType.WP_Velocity_BEAM: // Water Profile Beam Velocity data
UpdateWPBeamVelocityPlot(ensemble, Beam, maxBin, isFilterData);
break;
case ProfileType.eProfileType.WP_Velocity_XYZ: // Water Profile Instrument Velocity data
UpdateWPInstrumentVelocityPlot(ensemble, Beam, maxBin, isFilterData);
break;
case ProfileType.eProfileType.WP_Velocity_ENU: // Water Profile Earth Velocity data
UpdateWPEarthVelocityPlot(ensemble, Beam, maxBin, isFilterData);
break;
case ProfileType.eProfileType.WP_Amplitude: // Water Profile Amplitude data
UpdateWPAmplitudePlot(ensemble, Beam, maxBin);
break;
case ProfileType.eProfileType.WP_Correlation: // Water Profile Correlation data
UpdateWPCorrelationPlot(ensemble, Beam, maxBin);
break;
default:
break;
}
}
/// <summary>
/// Encode the data into the VmDas format.
/// </summary>
/// <param name="ens"></param>
/// <param name="bs">Bin selection.</param>
private string EncodeData(DataSet.Ensemble ens, BinSelection bs)
{
StringBuilder sb = new StringBuilder();
sb.Append('\u0002'); // STX
sb.Append(" 0"); // 0 Header
sb.Append("\t" + ens.EnsembleData.EnsembleNumber); // Ensemble number
sb.Append(" " + (ens.EnsembleData.Year - 2000)); // Year
sb.Append(" " + ens.EnsembleData.Month); // Month
sb.Append(" " + ens.EnsembleData.Day); // Day
sb.Append(" " + ens.EnsembleData.Hour); // Hour
sb.Append(" " + ens.EnsembleData.Minute); // Minute
sb.Append(" " + ens.EnsembleData.Second); // Second
sb.Append("\r\n");
sb.Append(EncodeEnuData(ens, bs)); // 1 Header (ENU)
sb.Append(EncodeCorrData(ens, bs)); // 2 Header (Corr)
sb.Append(EncodeAmpData(ens, bs)); // 3 Header (Amp)
sb.Append(EncodePgData(ens, bs)); // 4 Header (PG)
sb.Append(EncodeStatusData(ens, bs)); // 5 Header (Status)
sb.Append(EncodeLeaderData(ens)); // 6 Header (Leader)
sb.Append(EncodeBtData(ens)); // 7 Header (BT)
sb.Append(EncodeNavData(ens)); // 8 Header (NAV)
sb.Append('\u0003'); // ETX
return(sb.ToString());
}
/// <summary>
/// Encode the BS object.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <returns>WI string.</returns>
private string EncodeBS(DataSet.Ensemble ens)
{
float trans = PD0.BAD_VELOCITY;
float lon = PD0.BAD_VELOCITY;
float up = PD0.BAD_VELOCITY;
bool isGood = false;
if (ens.IsBottomTrackAvail)
{
trans = ens.BottomTrackData.ShipVelocity[0] * 1000.0f; // convert to mm/s
lon = ens.BottomTrackData.ShipVelocity[1] * 1000.0f;
up = ens.BottomTrackData.ShipVelocity[2] * 1000.0f;
if (trans == DataSet.Ensemble.BAD_VELOCITY || lon == DataSet.Ensemble.BAD_VELOCITY || up == DataSet.Ensemble.BAD_VELOCITY)
{
isGood = false;
}
else
{
isGood = true;
}
return(new BS(trans, lon, up, isGood).Encode());
}
return("");
}
/// <summary>
/// Encode the BE object.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <returns>WI string.</returns>
private string EncodeBE(DataSet.Ensemble ens)
{
float east = PD0.BAD_VELOCITY;
float north = PD0.BAD_VELOCITY;
float vert = PD0.BAD_VELOCITY;
bool isGood = false;
if (ens.IsBottomTrackAvail)
{
east = ens.BottomTrackData.EarthVelocity[0] * 1000.0f; // convert to mm/s
north = ens.BottomTrackData.EarthVelocity[1] * 1000.0f;
vert = ens.BottomTrackData.EarthVelocity[2] * 1000.0f;
if (east == DataSet.Ensemble.BAD_VELOCITY || north == DataSet.Ensemble.BAD_VELOCITY || vert == DataSet.Ensemble.BAD_VELOCITY)
{
isGood = false;
}
else
{
isGood = true;
}
return(new BE(east, north, vert, isGood).Encode());
}
return("");
}
/// <summary>
/// Encode the WE object.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <returns>WI string.</returns>
private string EncodeWE(DataSet.Ensemble ens)
{
float east = PD0.BAD_VELOCITY;
float north = PD0.BAD_VELOCITY;
float vert = PD0.BAD_VELOCITY;
bool isGood = false;
if (ens.IsInstrumentWaterMassAvail)
{
east = ens.EarthWaterMassData.VelocityEast * 1000.0f; // convert to mm/s
north = ens.EarthWaterMassData.VelocityNorth * 1000.0f;
vert = ens.EarthWaterMassData.VelocityVertical * 1000.0f;
if (east == DataSet.Ensemble.BAD_VELOCITY || north == DataSet.Ensemble.BAD_VELOCITY || vert == DataSet.Ensemble.BAD_VELOCITY)
{
isGood = false;
}
else
{
isGood = true;
}
return(new WE(east, north, vert, isGood).Encode());
}
return("");
}
/// <summary>
/// Encode the BI object.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <returns>WI string.</returns>
private string EncodeBI(DataSet.Ensemble ens)
{
float x = PD0.BAD_VELOCITY;
float y = PD0.BAD_VELOCITY;
float z = PD0.BAD_VELOCITY;
float q = PD0.BAD_VELOCITY;
bool isGood = false;
if (ens.IsBottomTrackAvail)
{
x = ens.BottomTrackData.InstrumentVelocity[0] * 1000.0f; // convert to mm/s
y = ens.BottomTrackData.InstrumentVelocity[1] * 1000.0f;
z = ens.BottomTrackData.InstrumentVelocity[2] * 1000.0f;
q = ens.BottomTrackData.InstrumentVelocity[3] * 1000.0f;
if (x == DataSet.Ensemble.BAD_VELOCITY || y == DataSet.Ensemble.BAD_VELOCITY || z == DataSet.Ensemble.BAD_VELOCITY || q == DataSet.Ensemble.BAD_VELOCITY)
{
isGood = false;
}
else
{
isGood = true;
}
return(new BI(x, y, z, q, isGood).Encode());
}
return("");
}
/// <summary>
/// Encode the WS object.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <returns>WS string.</returns>
private string EncodeWS(DataSet.Ensemble ens)
{
float trans = PD0.BAD_VELOCITY;
float lon = PD0.BAD_VELOCITY;
float norm = PD0.BAD_VELOCITY;
bool isGood = false;
if (ens.IsShipWaterMassAvail)
{
trans = ens.ShipWaterMassData.VelocityTransverse * 1000.0f; // convert to mm/s
lon = ens.ShipWaterMassData.VelocityLongitudinal * 1000.0f;
norm = ens.ShipWaterMassData.VelocityNormal * 1000.0f;
if (trans == DataSet.Ensemble.BAD_VELOCITY || lon == DataSet.Ensemble.BAD_VELOCITY || norm == DataSet.Ensemble.BAD_VELOCITY)
{
isGood = false;
}
else
{
isGood = true;
}
return(new WS(trans, lon, norm, isGood).Encode());
}
return("");
}
/// <summary>
/// Encode the WI object.
/// </summary>
/// <param name="ens">Ensemble.</param>
/// <returns>WI string.</returns>
private string EncodeWI(DataSet.Ensemble ens)
{
float x = PD0.BAD_VELOCITY;
float y = PD0.BAD_VELOCITY;
float z = PD0.BAD_VELOCITY;
float q = PD0.BAD_VELOCITY;
bool isGood = false;
if (ens.IsInstrumentWaterMassAvail)
{
x = ens.InstrumentWaterMassData.VelocityX * 1000.0f; // convert to mm/s
y = ens.InstrumentWaterMassData.VelocityY * 1000.0f;
z = ens.InstrumentWaterMassData.VelocityZ * 1000.0f;
q = ens.InstrumentWaterMassData.VelocityQ * 1000.0f;
if (x == DataSet.Ensemble.BAD_VELOCITY || y == DataSet.Ensemble.BAD_VELOCITY || z == DataSet.Ensemble.BAD_VELOCITY || q == DataSet.Ensemble.BAD_VELOCITY)
{
isGood = false;
}
else
{
isGood = true;
}
return(new WI(x, y, z, q, isGood).Encode());
}
return("");
}
/// <summary>
/// Get the data out of the ensemble to encode the RA message.
/// </summary>
/// <param name="ens">Ensemble data.</param>
/// <returns>RA string.</returns>
private string EncodeRA(DataSet.Ensemble ens)
{
float pressure = 0.0f;
float depthB0 = 0.0f;
float depthB1 = 0.0f;
float depthB2 = 0.0f;
float depthB3 = 0.0f;
if (ens.IsBottomTrackAvail)
{
pressure = ens.BottomTrackData.Pressure * 0.0001f;
depthB0 = ens.BottomTrackData.Range[0];
depthB1 = ens.BottomTrackData.Range[1];
depthB2 = ens.BottomTrackData.Range[2];
depthB3 = ens.BottomTrackData.Range[3];
}
else if (ens.IsDvlDataAvail)
{
pressure = ens.DvlData.Pressure;
depthB0 = ens.DvlData.RangeBeam0;
depthB1 = ens.DvlData.RangeBeam1;
depthB2 = ens.DvlData.RangeBeam2;
depthB3 = ens.DvlData.RangeBeam3;
}
return(new RA(pressure, depthB0, depthB1, depthB2, depthB3).Encode());
}
/// <summary>
/// Get the data out of the ensemble to encode the SA message.
/// </summary>
/// <param name="ens">Ensemble data.</param>
/// <returns>SA string.</returns>
private string EncodeSA(DataSet.Ensemble ens)
{
float heading = 0.0f;
float pitch = 0.0f;
float roll = 0.0f;
if (ens.IsAncillaryAvail)
{
heading = ens.AncillaryData.Heading;
pitch = ens.AncillaryData.Pitch;
roll = ens.AncillaryData.Roll;
}
else if (ens.IsBottomTrackAvail)
{
heading = ens.BottomTrackData.Heading;
pitch = ens.BottomTrackData.Pitch;
roll = ens.BottomTrackData.Roll;
}
else if (ens.IsDvlDataAvail)
{
heading = ens.DvlData.Heading;
pitch = ens.DvlData.Pitch;
roll = ens.DvlData.Roll;
}
return(new SA(heading, pitch, roll).Encode());
}
/// <summary>
/// Update the series with the latest ensemble data.
/// If MAX_BIN is used for maxBins, it will use the number of bins in the ensemble.
/// </summary>
/// <param name="ens">Latest ensemble.</param>
/// <param name="maxBins">Maximum number of bins to display. If MAX_BIN is used, it will use the number of bins in the ensemble.</param>
/// <param name="isFilterData">Filter the data for bad values.</param>
public void UpdateSeries(DataSet.Ensemble ens, int maxBins = MAX_BIN, bool isFilterData = true)
{
// Ensure the Beam and Bin is within the ensemble
// If this is a vertical beam, it only has a single beam
// even though generically the plot could have created 4+ beams
if (ens.IsEnsembleAvail)
{
// Check if the Beam and Bin for this series is within the ensemble
// Check if NumBeams is less then Beam for this series or
// NumBins is less then Bin
if (ens.EnsembleData.NumBeams <= Beam)
{
return;
}
}
else
{
return;
}
// Clear series
ClearSeries();
// Update the line series
UpdateLineSeries(ens, maxBins, isFilterData);
}
/// <summary>
/// Look for the view model for the screen options.
/// Then pass the ensemble to the VM to be screened.
/// </summary>
/// <param name="ensemble">Ensemble to screen.</param>
/// <param name="origDataFormat">Original Data format.</param>
public void ScreenData(ref DataSet.Ensemble ensemble, AdcpCodec.CodecEnum origDataFormat)
{
if (ensemble != null)
{
try
{
// Find the VM that matches the configuration
foreach (ScreenDataViewModel vm in ScreenDataVMList)
{
// Do not rescreen the averaged data
// it already has been screen
if (vm.Config == ensemble.EnsembleData.SubsystemConfig && vm.Config.Source != EnsembleSource.LTA && vm.Config.Source != EnsembleSource.STA)
{
// Screen the data based off the options in the VM
vm.ScreenEnsemble(ref ensemble, origDataFormat);
}
}
}
catch (Exception e)
{
// Ususually an exception occurs here at startup when
// all the VMs are being created.
log.Error("Error screening the data.", e);
}
}
}
/// <summary>
/// Apply the previous heading if the current heading is bad.
/// </summary>
/// <param name="ensemble">Ensemble to screen.</param>
/// <param name="prevHeading">Previous good heading value.</param>
/// <returns>TRUE if screening occured.</returns>
public static bool Screen(ref DataSet.Ensemble ensemble, float prevHeading)
{
// Make sure the previous value is worth using
if (prevHeading != 0.0f)
{
// Ancillary
if (ensemble.IsAncillaryAvail)
{
if (ensemble.AncillaryData.Heading == 0.0f)
{
ensemble.AncillaryData.Heading = prevHeading;
}
}
// Bottom Track
if (ensemble.IsBottomTrackAvail)
{
if (ensemble.BottomTrackData.Heading == 0.0f)
{
ensemble.BottomTrackData.Heading = prevHeading;
}
}
}
return(true);
}
/// <summary>
/// Set the average Beam Velocity data to the Beam Velocity data set array.
/// This will replace the array with an averaged array for the accumulated data.
/// If this is not a running average, it will clear the accumulator.
/// </summary>
/// <param name="ensemble">Set the average data to this ensemble.</param>
/// <param name="scale">Scale value to multiply to the averaged value.</param>
public override void SetAverage(ref DataSet.Ensemble ensemble, float scale)
{
if (ensemble.IsBeamVelocityAvail)
{
ensemble.BeamVelocityData.BeamVelocityData = GetAverage(scale);
}
}
public void TestTiming()
{
// Generate an Ensemble
DataSet.Ensemble ensemble = EnsembleHelper.GenerateEnsemble(30);
Stopwatch watch = new Stopwatch();
// Test Serialize()
watch = new Stopwatch();
watch.Start();
for (int x = 0; x < 1000; x++)
{
string encoded = Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.AncillaryData);
}
watch.Stop();
long resultSerialize = watch.ElapsedMilliseconds;
// Test Deserialize()
string encodedd = Newtonsoft.Json.JsonConvert.SerializeObject(ensemble.AncillaryData);
watch = new Stopwatch();
watch.Start();
for (int x = 0; x < 1000; x++)
{
DataSet.AncillaryDataSet decoded = Newtonsoft.Json.JsonConvert.DeserializeObject <DataSet.AncillaryDataSet>(encodedd);
}
watch.Stop();
long resultDeserialize = watch.ElapsedMilliseconds;
Debug.WriteLine(String.Format("Serialize:{0} Deserialize:{1}", resultSerialize, resultDeserialize));
Debug.WriteLine("Complete");
}
public void TestConstructorPrti02Sentence()
{
string nmea = "$PRTI02,379550,1,1468,-99999,-99999,-99999,0,,,,,0004*0A";
// Create Sentence
Prti02Sentence sent = new Prti02Sentence(nmea);
Assert.AreEqual(true, sent.IsValid, "NMEA sentence incorrect");
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add ancillary data
adcpData.AddAncillaryData(sent);
Assert.AreEqual(true, adcpData.IsAncillaryAvail, "Ancillary data not created");
// Check temperature
Assert.AreEqual(14.68, adcpData.AncillaryData.WaterTemp, 0.00001, "Water Temperature was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.FirstBinRange, "First Bin Range was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.BinSize, "Bin Size was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.FirstPingTime, "First Ping Time was incorrect");
Assert.AreEqual(3795, adcpData.AncillaryData.LastPingTime, "Last Ping Time was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Heading, "Heading was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Pitch, "Pitch was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Roll, "Roll was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.SystemTemp, "System Temp was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Salinity, "Salinity was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Pressure, "Pressure was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.TransducerDepth, "Transducer Depth was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.SpeedOfSound, "Speed Of Sound was incorrect");
}
/// <summary>
/// Fill in missing values if water profile is turned off. If it is turned off, it sets these values to 0 but
/// Bottom Track has the values.
/// </summary>
/// <param name="ensemble">Ensemble to get the data.</param>
public void FillInMissingWpData(ref DataSet.Ensemble ensemble)
{
if (ensemble.IsBottomTrackAvail && ensemble.IsEnsembleAvail)
{
// If these values are zero, then most likely WP is turned off
// Fill in the data
if (ensemble.EnsembleData.NumBeams == 0 && ensemble.EnsembleData.NumBins == 0 && ensemble.BottomTrackData.NumBeams != ensemble.EnsembleData.NumBeams)
{
ensemble.EnsembleData.NumBeams = (int)ensemble.BottomTrackData.NumBeams;
if (ensemble.IsAncillaryAvail)
{
ensemble.AncillaryData.Heading = ensemble.BottomTrackData.Heading;
ensemble.AncillaryData.Pitch = ensemble.BottomTrackData.Pitch;
ensemble.AncillaryData.Roll = ensemble.BottomTrackData.Roll;
ensemble.AncillaryData.WaterTemp = ensemble.BottomTrackData.WaterTemp;
ensemble.AncillaryData.SystemTemp = ensemble.BottomTrackData.SystemTemp;
ensemble.AncillaryData.Salinity = ensemble.BottomTrackData.Salinity;
ensemble.AncillaryData.Pressure = ensemble.BottomTrackData.Pressure;
ensemble.AncillaryData.TransducerDepth = ensemble.BottomTrackData.TransducerDepth;
ensemble.AncillaryData.SpeedOfSound = ensemble.BottomTrackData.SpeedOfSound;
ensemble.AncillaryData.FirstPingTime = ensemble.BottomTrackData.FirstPingTime;
ensemble.AncillaryData.LastPingTime = ensemble.BottomTrackData.LastPingTime;
}
}
}
}
public void TestEmptyConstructor()
{
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Sentence to data set
adcpData.AddAncillaryData(DataSet.Ensemble.DATATYPE_FLOAT, // 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.AncillaryID); // Dataset ID
Assert.IsTrue(adcpData.IsAncillaryAvail, "IsEnsembleAvail is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_FLOAT, adcpData.AncillaryData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, adcpData.AncillaryData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(4, adcpData.AncillaryData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, adcpData.AncillaryData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, adcpData.AncillaryData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.AncillaryID, adcpData.AncillaryData.Name, "Name is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.FirstBinRange, "First Bin Range is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.BinSize, "BinSize is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.FirstPingTime, "FirstPingTime is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.LastPingTime, "LastPingTime is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Heading, "Heading is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Pitch, "Pitch is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Roll, "Roll is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.WaterTemp, "WaterTemp is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.SystemTemp, "SystemTemp is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Salinity, "Salinity is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Pressure, "Pressure is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.TransducerDepth, "TransducerDepth is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.SpeedOfSound, "SpeedOfSound is incorrect.");
}
/// <summary>
/// Set the previous heading so we can always have the last good heading.
/// </summary>
/// <param name="ensemble">Ensemble to get last good heading.</param>
private void SetPreviousHeading(DataSet.Ensemble ensemble)
{
if (ensemble.IsAncillaryAvail && ensemble.AncillaryData.Heading != 0.0f)
{
_prevHeading = ensemble.AncillaryData.Heading;
}
}
/// <summary>
/// Store the previous Ship speed for the different velocity coordinate transforms.
/// </summary>
/// <param name="ens">Ensembles.</param>
private void SetPreviousShipSpeed(DataSet.Ensemble ens)
{
// EARTH
// Record the Bottom for previous values
float[] prevShipSpeed = ScreenData.RemoveShipSpeed.GetPreviousShipSpeed(ens, (float)_Options.RemoveShipSpeedHeadingOffset, _Options.IsRemoveShipSpeedBottomTrack, _Options.IsRemoveShipSpeedGps);
_prevBtEast = prevShipSpeed[0];
_prevBtNorth = prevShipSpeed[1];
_prevBtVert = prevShipSpeed[2];
// Instrument
// Record the Bottom for previous values
float[] prevShipSpeedInstrument = ScreenData.RemoveShipSpeed.GetPreviousShipSpeedInstrument(ens, (float)_Options.RemoveShipSpeedHeadingOffset, _Options.IsRemoveShipSpeedBottomTrack, _Options.IsRemoveShipSpeedGps);
_prevShipSpeedX = prevShipSpeedInstrument[0];
_prevShipSpeedY = prevShipSpeedInstrument[1];
_prevShipSpeedZ = prevShipSpeedInstrument[2];
// Ship
// Record the Bottom for previous values
float[] prevShipSpeedShip = ScreenData.RemoveShipSpeed.GetPreviousShipSpeedShip(ens, (float)_Options.RemoveShipSpeedHeadingOffset, _Options.IsRemoveShipSpeedBottomTrack, _Options.IsRemoveShipSpeedGps);
_prevShipSpeedTransverse = prevShipSpeedShip[0];
_prevShipSpeedLongitudinal = prevShipSpeedShip[1];
_prevShipSpeedNormal = prevShipSpeedShip[2];
if (ens.IsBottomTrackAvail)
{
float range = ens.BottomTrackData.GetAverageRange();
if (range != DataSet.Ensemble.BAD_RANGE)
{
_prevBtRange = range;
}
}
}
/// <summary>
/// Get the data out of the ensemble to encode the TS message.
/// </summary>
/// <param name="ens">Ensemble data.</param>
/// <returns>TA string.</returns>
private string EncodeTS(DataSet.Ensemble ens)
{
DateTime dateAndTime = new DateTime();
byte hundredthSec = 0;
float salinity = 0.0f;
float temperature = 0.0f;
float depthOfTransducer = 0.0f;
float speedOfSound = 0.0f;
int BIT = 0;
RTI.DataSet.DvlDataSet.LeakDetectionOptions leakDetection = RTI.DataSet.DvlDataSet.LeakDetectionOptions.NotInstalled;
if (ens.IsEnsembleAvail && ens.IsAncillaryAvail)
{
dateAndTime = ens.EnsembleData.EnsDateTime;
hundredthSec = (byte)ens.EnsembleData.HSec;
salinity = ens.AncillaryData.Salinity;
temperature = ens.AncillaryData.WaterTemp;
depthOfTransducer = ens.AncillaryData.TransducerDepth;
speedOfSound = ens.AncillaryData.SpeedOfSound;
BIT = ens.EnsembleData.Status.Value;
}
else if (ens.IsBottomTrackAvail)
{
salinity = ens.BottomTrackData.Salinity;
temperature = ens.BottomTrackData.WaterTemp;
depthOfTransducer = ens.BottomTrackData.TransducerDepth;
speedOfSound = ens.BottomTrackData.SpeedOfSound;
BIT = ens.BottomTrackData.Status.Value;
}
return(new TS(dateAndTime, hundredthSec, salinity, temperature, depthOfTransducer, speedOfSound, BIT, leakDetection).Encode());
}
public void DecodePd0Test()
{
PD0 pd0 = new PD0();
pd0.FixedLeader.SetCoordinateTransform(PD0.CoordinateTransforms.Coord_Earth);
pd0.AddDataType(new Pd0Correlation(30));
pd0.AddDataType(new Pd0BottomTrack());
pd0.AddDataType(new Pd0EchoIntensity(30));
pd0.AddDataType(new Pd0PercentGood(30));
pd0.AddDataType(new Pd0Velocity(30));
DataSet.Ensemble ens = new DataSet.Ensemble(pd0);
Assert.IsTrue(ens.IsCorrelationAvail, "IsCorrelationAvail is incorrect.");
Assert.IsTrue(ens.IsBottomTrackAvail, "IsBottomTrackAvail is incorrect.");
Assert.IsTrue(ens.IsAmplitudeAvail, "IsAmplitudeAvail is incorrect.");
Assert.IsTrue(ens.IsGoodEarthAvail, "IsGoodEarthAvail is incorrect.");
Assert.IsFalse(ens.IsGoodBeamAvail, "IsGoodBeamAvail is incorrect.");
Assert.IsFalse(ens.IsBeamVelocityAvail, "IsBeamVelocityAvail is incorrect.");
Assert.IsTrue(ens.IsEarthVelocityAvail, "IsEarthVelocityAvail is incorrect.");
Assert.IsFalse(ens.IsInstrumentVelocityAvail, "IsInstrumentVelocityAvail is incorrect.");
Assert.IsFalse(ens.IsInstrumentWaterMassAvail, "IsInstrumentWaterMassAvail is incorrect.");
Assert.IsFalse(ens.IsNmeaAvail, "IsNmeaAvail is incorrect.");
Assert.IsFalse(ens.IsProfileEngineeringAvail, "IsProfileEngineeringAvail is incorrect.");
Assert.IsFalse(ens.IsBottomTrackEngineeringAvail, "IsBottomTrackEngineeringAvail is incorrect.");
Assert.IsFalse(ens.IsSystemSetupAvail, "IsSystemSetupAvail is incorrect.");
}
/// <summary>
/// Screen the data for any velocities above the surface.
/// This will check if Range Track data exist. If it does not,
/// then we do not know the surface range. It will then check that a
/// Range track range is given. If all the range values are bad,
/// then we do not know the surface. If they are good, take the average
/// of the range. Then determine which bin is located at and surface the water.
/// Then mark all the velocities at and above the surface bad.
/// </summary>
/// <param name="ensemble">Ensemble to screen.</param>
/// <param name="prevSurface">Previous Good range.</param>
/// <returns>True = Screen could be done.</returns>
public static bool Screen(ref DataSet.Ensemble ensemble, double prevSurface = DataSet.Ensemble.BAD_RANGE)
{
if (ensemble != null)
{
// Ensure bottom track data exist
if (ensemble.IsRangeTrackingAvail && // Needed for Range Tracking Range
ensemble.IsAncillaryAvail && // Needed for Blank and Bin Size
ensemble.IsEnsembleAvail // Needed for number of bins
)
{
// Get the bottom
double surface = ensemble.RangeTrackingData.GetAverageRange();
// Ensure we found a bottom
if (surface == DataSet.Ensemble.BAD_RANGE && prevSurface == DataSet.Ensemble.BAD_RANGE)
{
return(false);
}
else if (surface == DataSet.Ensemble.BAD_RANGE && prevSurface != DataSet.Ensemble.BAD_RANGE)
{
// PrevBottom is good, so use it
surface = prevSurface;
}
// Get the bottom bin
int bottomBin = Ensemble.GetBottomBin(ensemble, surface);
// Check if the bottom bin is at or beyond
// the number of bins
if (bottomBin < 0 || bottomBin >= ensemble.EnsembleData.NumBins)
{
return(true);
}
// Set all the velocities bad
// for the bins below the bottom.
// This will also set the Good Pings bad
for (int bin = bottomBin; bin < ensemble.EnsembleData.NumBins; bin++)
{
// Set the velocities bad
EnsembleHelper.SetVelocitiesBad(ref ensemble, bin);
// Set the Correlation bad
EnsembleHelper.SetCorelationBad(ref ensemble, bin);
// Set the Amplitude bad
EnsembleHelper.SetAmplitudeBad(ref ensemble, bin);
}
return(true);
}
else
{
return(false);
}
}
return(false);
}
/// <summary>
/// Screen the ensemble with the given options.
/// </summary>
/// <param name="ensemble">Ensemble to screen.</param>
public void Screen(ref DataSet.Ensemble ensemble)
{
// Vessel Mount Options
//if (_pm.IsProjectSelected && _pm.SelectedProject.Configuration.VesselMountOptions != null)
//{
VesselMount.VesselMountScreen.Screen(ref ensemble, _vmOptions);
//}
}
public void TestConstructorData()
{
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
adcpData.AddEarthWaterMassData(DataSet.Ensemble.DATATYPE_FLOAT, DataSet.EarthWaterMassDataSet.NUM_DATA_ELEMENTS, DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, DataSet.Ensemble.DEFAULT_IMAG, DataSet.Ensemble.DEFAULT_NAME_LENGTH, DataSet.Ensemble.WaterMassInstrumentID,
0.3f,
-0.2f,
0.4f,
0.1f);
Assert.IsTrue(adcpData.IsEarthWaterMassAvail, "Earth Water Mass not added to dataset");
Assert.AreEqual(adcpData.EarthWaterMassData.VelocityEast, (new DotSpatial.Positioning.Speed(300, DotSpatial.Positioning.SpeedUnit.MillimetersPerSecond)).ToMetersPerSecond().Value, 0.00001, "Earth Water Mass East not properly set.");
Assert.AreEqual(adcpData.EarthWaterMassData.VelocityNorth, (new DotSpatial.Positioning.Speed(-200, DotSpatial.Positioning.SpeedUnit.MillimetersPerSecond)).ToMetersPerSecond().Value, 0.00001, "Earth Water Mass North not properly set.");
Assert.AreEqual(adcpData.EarthWaterMassData.VelocityVertical, (new DotSpatial.Positioning.Speed(400, DotSpatial.Positioning.SpeedUnit.MillimetersPerSecond)).ToMetersPerSecond().Value, 0.00001, "Earth Water Mass Vertical not properly set.");
Assert.AreEqual(adcpData.EarthWaterMassData.WaterMassDepthLayer, (new DotSpatial.Positioning.Distance(100, DotSpatial.Positioning.DistanceUnit.Millimeters)).ToMeters().Value, 0.00001, "Earth Water Mass Depth Layer not properly set.");
}
public void TestConstructorPrti01entenceData()
{
string nmea = "$PRTI01,379550,1,1468,-99999,-99999,-99999,0,300,-200,400,100,0004*20";
// Create Sentence
Prti01Sentence sent = new Prti01Sentence(nmea);
Assert.AreEqual(true, sent.IsValid, "NMEA sentence incorrect");
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
adcpData.AddInstrumentWaterMassData(sent);
Assert.IsTrue(adcpData.IsInstrumentWaterMassAvail, "Instrument Water Mass not added to dataset");
Assert.AreEqual((new DotSpatial.Positioning.Speed(300, DotSpatial.Positioning.SpeedUnit.MillimetersPerSecond)).ToMetersPerSecond().Value, adcpData.InstrumentWaterMassData.VelocityX, 0.00001, "Instrument Water Mass East not properly set.");
Assert.AreEqual((new DotSpatial.Positioning.Speed(-200, DotSpatial.Positioning.SpeedUnit.MillimetersPerSecond)).ToMetersPerSecond().Value, adcpData.InstrumentWaterMassData.VelocityY, 0.00001, "Instrument Water Mass North not properly set.");
Assert.AreEqual((new DotSpatial.Positioning.Speed(400, DotSpatial.Positioning.SpeedUnit.MillimetersPerSecond)).ToMetersPerSecond().Value, adcpData.InstrumentWaterMassData.VelocityZ, 0.00001, "Instrument Water Mass Vertical not properly set.");
Assert.AreEqual((new DotSpatial.Positioning.Distance(100, DotSpatial.Positioning.DistanceUnit.Millimeters)).ToMeters().Value, adcpData.InstrumentWaterMassData.WaterMassDepthLayer, 0.00001, "Instrument Water Mass Depth Layer not properly set.");
}
public void TestConstructorPrti02Sentence()
{
string nmea = "$PRTI02,379550,1,1468,-99999,-99999,-99999,0,,,,,0004*0A";
// Create Sentence
Prti02Sentence sent = new Prti02Sentence(nmea);
Assert.AreEqual(true, sent.IsValid, "NMEA sentence incorrect");
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
adcpData.AddEarthWaterMassData(sent);
Assert.IsTrue(adcpData.IsEarthWaterMassAvail, "Earth Water Mass not added to dataset");
Assert.AreEqual(adcpData.EarthWaterMassData.VelocityEast, DataSet.Ensemble.EMPTY_VELOCITY, "Earth Water Mass East not properly set.");
Assert.AreEqual(adcpData.EarthWaterMassData.VelocityNorth, DataSet.Ensemble.EMPTY_VELOCITY, "Earth Water Mass North not properly set.");
Assert.AreEqual(adcpData.EarthWaterMassData.VelocityVertical, DataSet.Ensemble.EMPTY_VELOCITY, "Earth Water Mass Vertical not properly set.");
Assert.AreEqual(adcpData.EarthWaterMassData.WaterMassDepthLayer, 0, "Earth Water Mass Depth Layer not properly set.");
}
public void AddEmptyDataSetTest()
{
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Bottom Track data
adcpData.AddBottomTrackData(DataSet.Ensemble.DATATYPE_FLOAT, // 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.BottomTrackID); // Dataset ID
Assert.IsTrue(adcpData.IsBottomTrackAvail, "IsBottomTrackAvail is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.ActualPingCount, "Actual Ping Count is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.FirstPingTime, "FirstPingTime is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.LastPingTime, "LastPingTime is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.Heading, "Heading is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.Pitch, "Pitch is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.Roll, "Roll is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.WaterTemp, "WaterTemp is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.SystemTemp, "SystemTemp is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.Salinity, "Salinity is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.Pressure, "Pressure is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.TransducerDepth, "TransducerDepth is incorrect.");
Assert.AreEqual(0.0f, adcpData.BottomTrackData.SpeedOfSound, "SpeedOfSound is incorrect.");
Assert.AreEqual(new Status(0), adcpData.BottomTrackData.Status, "Status is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.NumBeams, "NumBeams is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.Range.GetLength(0), "Range Length is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.SNR.GetLength(0), "SNR Length is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.Amplitude.GetLength(0), "Amplitude Length is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.Correlation.GetLength(0), "Correlation Length is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.BeamVelocity.GetLength(0), "BeamVelocity Length is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.BeamGood.GetLength(0), "BeamGood Length is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.InstrumentVelocity.GetLength(0), "InstrumentVelocity Length is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.InstrumentGood.GetLength(0), "InstrumentGood Length is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.EarthVelocity.GetLength(0), "EarthVelocity Length is incorrect.");
Assert.AreEqual(4, adcpData.BottomTrackData.EarthGood.GetLength(0), "EarthGood Length is incorrect.");
}
public void TestEmptyConstructor()
{
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Sentence to data set
adcpData.AddAmplitudeData(DataSet.Ensemble.DATATYPE_FLOAT, // 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.AmplitudeID); // Dataset ID
Assert.IsTrue(adcpData.IsAmplitudeAvail, "IsAmplitude is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_FLOAT, adcpData.AmplitudeData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, adcpData.AmplitudeData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, adcpData.AmplitudeData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, adcpData.AmplitudeData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, adcpData.AmplitudeData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.AmplitudeID, adcpData.AmplitudeData.Name, "Name is incorrect.");
Assert.AreEqual(adcpData.AmplitudeData.AmplitudeData.GetLength(0), 30, "Amplitude Array Dimension 1 is incorrect.");
Assert.AreEqual(adcpData.AmplitudeData.AmplitudeData.GetLength(1), DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, "Amplitude Array Dimension 2 is incorrect.");
}
/// <summary>
/// Generate an ensemble with blank data. Set the number of bins and beams.
/// </summary>
/// <param name="numBins">Number of bins.</param>
/// <param name="numBeams">Number of beams.</param>
/// <param name="createDataSets">Set flag if all the datasets should be created automatically.</param>
/// <returns>Ensemble created.</returns>
public static DataSet.Ensemble GenerateEnsemble(int numBins, int numBeams = DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, bool createDataSets = true)
{
// Create dataset
DataSet.Ensemble ensemble = new DataSet.Ensemble();
// Check if the datasets should be created automatically
if (createDataSets)
{
AddEnsemble(ref ensemble, numBins, numBeams);
AddAncillary(ref ensemble);
AddCorrelation(ref ensemble, numBins, numBeams);
AddAmplitude(ref ensemble, numBins, numBeams);
AddBeamVelocity(ref ensemble, numBins, numBeams);
AddEarthVelocity(ref ensemble, numBins, numBeams);
AddInstrumentVelocity(ref ensemble, numBins, numBeams);
AddBottomTrack(ref ensemble);
AddWaterMassEarth(ref ensemble, numBins, numBeams);
AddWaterMassInstrument(ref ensemble, numBins, numBeams);
AddGoodBeam(ref ensemble, numBins, numBeams);
AddGoodEarth(ref ensemble, numBins, numBeams);
AddNmea(ref ensemble);
}
return ensemble;
}
public void TestConstructorPrti02Sentence()
{
string nmea = "$PRTI02,379550,1,1468,-99999,-99999,-99999,0,,,,,0004*0A";
// Create Sentence
Prti02Sentence sent = new Prti02Sentence(nmea);
Assert.AreEqual(true, sent.IsValid, "NMEA sentence incorrect");
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Bottom Track data
adcpData.AddBottomTrackData(sent);
Assert.AreEqual(true, adcpData.IsBottomTrackAvail);
Assert.AreEqual(0, adcpData.BottomTrackData.Range[0], "Bottom Track Range B1 incorrect");
Assert.AreEqual(0, adcpData.BottomTrackData.Range[1], "Bottom Track Range B2 incorrect");
Assert.AreEqual(0, adcpData.BottomTrackData.Range[2], "Bottom Track Range B3 incorrect");
Assert.AreEqual(0, adcpData.BottomTrackData.Range[3], "Bottom Track Range B4 incorrect");
Assert.AreEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.EarthVelocity[0], "Bottom Track Earth Velocity East incorrect");
Assert.AreEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.EarthVelocity[1], "Bottom Track Earth Velocity North incorrect");
Assert.AreEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.EarthVelocity[2], "Bottom Track Earth Velocity Up incorrect");
Assert.AreEqual(0, adcpData.BottomTrackData.EarthVelocity[3], "Bottom Track Earth Velocity Q incorrect");
Assert.AreEqual(0004, adcpData.BottomTrackData.Status.Value, "Bottom Track Instrument Status incorrect");
Assert.AreEqual(sent.SystemStatus.Value, adcpData.BottomTrackData.Status.Value, "Bottom Track Instrument Status incorrect");
}
public void TestAddAdditional()
{
string nmea1 = "$PRTI01,380250,8,1464,-1205,-24,-347,79380,,,,,0000*05";
string nmea2 = "$PRTI02,380250,8,1464,1142,323,407,79380,,,,,0000*1C";
// Create sentence
Prti01Sentence sent1 = new Prti01Sentence(nmea1);
Prti02Sentence sent2 = new Prti02Sentence(nmea2);
Assert.AreEqual(true, sent1.IsValid, "PRTI01 NMEA sentence incorrect: " + nmea1);
Assert.AreEqual(true, sent2.IsValid, "PRTI02 NMEA sentence incorrect: " + nmea2);
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Bottom Track data
adcpData.AddBottomTrackData(sent1);
adcpData.BottomTrackData.AddAdditionalBottomTrackData(sent2);
Assert.AreEqual(true, adcpData.IsBottomTrackAvail, "Bottom Track DataSet not added");
Assert.AreEqual(new DotSpatial.Positioning.Distance("79380 mm").ToMeters().Value, adcpData.BottomTrackData.Range[0], 0.00001, "Bottom Track Range B1 incorrect");
Assert.AreEqual(new DotSpatial.Positioning.Distance("79380 mm").ToMeters().Value, adcpData.BottomTrackData.Range[1], 0.00001, "Bottom Track Range B2 incorrect");
Assert.AreEqual(new DotSpatial.Positioning.Distance("79380 mm").ToMeters().Value, adcpData.BottomTrackData.Range[2], 0.00001, "Bottom Track Range B3 incorrect");
Assert.AreEqual(new DotSpatial.Positioning.Distance("79380 mm").ToMeters().Value, adcpData.BottomTrackData.Range[3], 0.00001, "Bottom Track Range B4 incorrect");
// Instrument data
Assert.AreNotEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.InstrumentVelocity[0], "Bottom Track Instrument Velocity X incorrect");
Assert.AreNotEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.InstrumentVelocity[1], "Bottom Track Instrument Velocity Y incorrect");
Assert.AreNotEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.InstrumentVelocity[2], "Bottom Track Instrument Velocity Z incorrect");
Assert.AreEqual(0, adcpData.BottomTrackData.InstrumentVelocity[3], "Bottom Track Instrument Velocity Q incorrect");
Assert.AreEqual(Convert.ToSingle(new DotSpatial.Positioning.Speed("-1205 mm/s").ToMetersPerSecond().Value), adcpData.BottomTrackData.InstrumentVelocity[0], "Bottom Track Instrument Velocity X incorrect");
Assert.AreEqual(Convert.ToSingle(new DotSpatial.Positioning.Speed("-24 mm/s").ToMetersPerSecond().Value), adcpData.BottomTrackData.InstrumentVelocity[1], "Bottom Track Instrument Velocity Y incorrect");
Assert.AreEqual(Convert.ToSingle(new DotSpatial.Positioning.Speed("-347 mm/s").ToMetersPerSecond().Value), adcpData.BottomTrackData.InstrumentVelocity[2], "Bottom Track Instrument Velocity Z incorrect");
// Earth data
Assert.AreNotEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.EarthVelocity[0], "Bottom Track Earth Velocity East incorrect");
Assert.AreNotEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.EarthVelocity[1], "Bottom Track Earth Velocity North incorrect");
Assert.AreNotEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.EarthVelocity[2], "Bottom Track Earth Velocity Up incorrect");
Assert.AreEqual(0, adcpData.BottomTrackData.EarthVelocity[3], "Bottom Track Earth Velocity Q incorrect");
Assert.AreEqual(Convert.ToSingle(new DotSpatial.Positioning.Speed("1142 mm/s").ToMetersPerSecond().Value), adcpData.BottomTrackData.EarthVelocity[0], "Bottom Track Earth Velocity East incorrect");
Assert.AreEqual(Convert.ToSingle(new DotSpatial.Positioning.Speed("323 mm/s").ToMetersPerSecond().Value), adcpData.BottomTrackData.EarthVelocity[1], "Bottom Track Earth Velocity North incorrect");
Assert.AreEqual(Convert.ToSingle(new DotSpatial.Positioning.Speed("407 mm/s").ToMetersPerSecond().Value), adcpData.BottomTrackData.EarthVelocity[2], "Bottom Track Earth Velocity Up incorrect");
Assert.AreEqual(0000, adcpData.BottomTrackData.Status.Value, "Bottom Track Instrument Status incorrect");
Assert.AreEqual(sent1.SystemStatus.Value, adcpData.BottomTrackData.Status.Value, "Bottom Track Instrument Status incorrect");
Assert.AreEqual(sent2.SystemStatus.Value, adcpData.BottomTrackData.Status.Value, "Bottom Track Instrument Status incorrect");
}
public void TestConstructorPrti02Sentence()
{
string nmea = "$PRTI02,1000,1,1468,-99999,-99999,-99999,0,,,,,0004*06";
// Create Sentence
Prti02Sentence sent = new Prti02Sentence(nmea);
Assert.AreEqual(true, sent.IsValid, "NMEA sentence incorrect");
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Sentence to data set
adcpData.AddEnsembleData(sent);
// Check Ensemble number
Assert.AreEqual(1, adcpData.EnsembleData.EnsembleNumber);
// Check number of beams
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, adcpData.EnsembleData.NumBeams, "Number of beams is Incorrect");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NUM_BEAMS_NONBEAM, adcpData.EnsembleData.ElementsMultiplier, "Number of beams is Incorrect");
// Check number of bins
Assert.AreEqual(0, adcpData.EnsembleData.NumBins);
// Check time
Assert.AreEqual(1000, sent.StartTime, "NMEA start time incorrect");
Assert.AreEqual(DateTime.Now.Hour, adcpData.EnsembleData.EnsDateTime.Hour, "Incorrect Ensemble time in Hours " + adcpData.EnsembleData.EnsDateTime.ToString());
Assert.AreEqual(DateTime.Now.Minute, adcpData.EnsembleData.EnsDateTime.Minute, "Incorrect Ensemble time in Minutes " + adcpData.EnsembleData.EnsDateTime.ToString());
Assert.AreEqual(DateTime.Now.Second, adcpData.EnsembleData.EnsDateTime.Second, "Incorrect Ensemble time in Seconds " + adcpData.EnsembleData.EnsDateTime.ToString());
Assert.AreEqual(DateTime.Now.Millisecond, adcpData.EnsembleData.EnsDateTime.Millisecond, "Incorrect Ensemble time in Milliseconds " + adcpData.EnsembleData.EnsDateTime.ToString());
}
/// <summary>
/// Process the sentence. Check which
/// type of setntence it is and create the data set.
/// Then publish the data.
/// </summary>
/// <param name="sentence">Sentence to process.</param>
private void ProcessSentence(string sentence)
{
// Flags to know which sentence was found
bool isSA = false;
bool isTS = false;
bool isRA = false;
bool isWI = false;
bool isWS = false;
bool isWE = false;
bool isWD = false;
bool isBI = false;
bool isBS = false;
bool isBE = false;
bool isBD = false;
bool isNMEA = false;
try
{
// If the previous was a NMEA and the new sentence is not
// NMEA data, then a new ensemble will need to be created.
if (sentence.Contains("$"))
{
isNMEA = true;
}
// previous was NMEA and current one is not NMEA
if (_prevNMEA && !isNMEA)
{
_prevEns = new DataSet.Ensemble();
}
// Reset the values
_prevNMEA = isNMEA;
// Create the DVL dataset if it does not exist
if (!_prevEns.IsDvlDataAvail)
{
_prevEns.IsDvlDataAvail = true;
_prevEns.DvlData = new DataSet.DvlDataSet();
}
// Create the Ensemble dataset if it does not exist
if (!_prevEns.IsEnsembleAvail)
{
_prevEns.IsEnsembleAvail = true;
_prevEns.EnsembleData = new DataSet.EnsembleDataSet();
}
// Add Ensemble DataSet
//_prevEns.EnsembleData.EnsembleNumber = _count++;
//_prevEns.EnsembleData.SetTime();
_prevEns.EnsembleData.SysSerialNumber = SerialNumber.DVL;
_prevEns.EnsembleData.NumBeams = 4;
// SA
if (sentence.Contains(SA.ID))
{
// Set SA
SetSA(sentence);
// Set flag that this data type was found
isSA = true;
}
// TS
if (sentence.Contains(TS.ID))
{
// Set TS
SetTS(sentence);
// Set flag that this data type was found
isTS = true;
}
// RA
if (sentence.Contains(RA.ID))
{
// Set RA
SetRA(sentence);
// Set flag that this data type was found
isRA = true;
}
// WI
if (sentence.Contains(WI.ID))
{
// Set WI
SetWI(sentence);
// Set flag that this data type was found
isWI = true;
}
// WS
if (sentence.Contains(WS.ID))
{
// Set WS
SetWS(sentence);
// Set flag that this data type was found
isWS = true;
}
// WE
if (sentence.Contains(WE.ID))
{
// Set WE
SetWE(sentence);
// Set flag that this data type was found
isWE = true;
}
// WD
if (sentence.Contains(WD.ID))
{
// Set WD
SetWD(sentence);
// Set flag that this data type was found
isWD = true;
}
// BI
if (sentence.Contains(BI.ID))
{
// Set BI
SetBI(sentence);
// Set flag that this data type was found
isBI = true;
}
// BS
if (sentence.Contains(BS.ID))
{
// Set BS
SetBS(sentence);
// Set flag that this data type was found
isBS = true;
}
// BE
if (sentence.Contains(BE.ID))
{
// Set BE
SetBE(sentence);
// Set flag that this data type was found
isBE = true;
}
// BD
if (sentence.Contains(BD.ID))
{
// Set BD
SetBD(sentence);
// Set flag that this data type was found
isBD = true;
}
// NMEA
if(sentence.Contains('$'))
{
// Set NMEA
SetNmea(sentence);
// Set flag that this data type was found
isNMEA = true;
}
// Send data to subscriber
// SA
if (isSA)
{
SendData(_prevSA);
}
// TS
if (isTS)
{
SendData(_prevTS);
}
// RA
if (isRA)
{
SendData(_prevRA);
}
// WI
if (isWI)
{
SendData(_prevWI);
}
// WS
if (isWS)
{
SendData(_prevWS);
}
// WE
if (isWE)
{
SendData(_prevWE);
}
// WD
if (isWD)
{
SendData(_prevWD);
}
// BI
if (isBI)
{
SendData(_prevBI);
}
// BS
if (isBS)
{
SendData(_prevBS);
}
// BE
if (isBE)
{
SendData(_prevBE);
}
// BD
if (isBD)
{
SendData(_prevBD);
}
// NMEA
if(isNMEA)
{
//SendData(_prevNMEA);
}
}
catch(Exception e)
{
log.Error("Error processing data.", e);
}
}
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>
/// Create a dataset. Set the bottom track instrument velocity and water mass velocity.
/// </summary>
/// <param name="sentence">Sentence containing DVL data.</param>
/// <returns>Dataset with values set.</returns>
private DataSet.Ensemble CreateDataSet(Prti03Sentence sentence)
{
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add the Ensemble number to EnsembleDataSet
adcpData.AddEnsembleData(sentence);
// Add the Temp to AncillaryDataSet
adcpData.AddAncillaryData(sentence);
// Add Bottom Track data
adcpData.AddBottomTrackData(sentence);
// Add Water Mass data
adcpData.AddInstrumentWaterMassData(sentence);
return adcpData;
}
public void TestSerialNumber()
{
string nmea = "$PRTI02,379550,1,1468,-99999,-99999,-99999,0,,,,,0004*0A";
// Create Sentence
Prti02Sentence sent = new Prti02Sentence(nmea);
Assert.AreEqual(true, sent.IsValid, "NMEA sentence incorrect");
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Sentence to data set
adcpData.AddEnsembleData(sent);
// Create a serial number
string serialStr = "01300000000000000000000000000001";
SerialNumber serialNum = new SerialNumber(serialStr);
// Set the serial number
adcpData.EnsembleData.SysSerialNumber = serialNum;
// Test the serial number
Assert.AreEqual(serialNum, adcpData.EnsembleData.SysSerialNumber, string.Format("Serial numbers did not match"));
Assert.AreEqual(serialStr, adcpData.EnsembleData.SysSerialNumber.ToString(), string.Format("Serial number strings did not match {0} {1}", serialStr, adcpData.EnsembleData.SysSerialNumber.ToString()));
Assert.AreEqual(1, adcpData.EnsembleData.SysSerialNumber.SubSystemsList.Count, string.Format("Number of SubSystems did not match 1 {0}", adcpData.EnsembleData.SysSerialNumber.SubSystemsList.Count));
}
public void SetSubsystemConfigTest()
{
// 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.EMPTY_CODE, 0, 2, 3); // SubsystemCode is SubsystemIndex because of firmware version
adcpData.EnsembleData.SubsystemConfig = new SubsystemConfiguration(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), 2, 2);
byte[] newEns = adcpData.EnsembleData.Encode();
// Create dataset
DataSet.Ensemble newAdcpData = new DataSet.Ensemble();
// Add data to data set
newAdcpData.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, // Dataset ID
newEns); // Encoded ensemble
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, newAdcpData.EnsembleData.SysFirmware.GetSubsystemCode(newAdcpData.EnsembleData.SysSerialNumber), "SysFirmware SubsystemCode is incorrect.");
Assert.AreEqual(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), newAdcpData.EnsembleData.SysFirmware.GetSubsystem(newAdcpData.EnsembleData.SysSerialNumber), "SysFirmware GetSubsystem() is incorrect.");
Assert.AreEqual(2, newAdcpData.EnsembleData.SubsystemConfig.CepoIndex, "SubsystemConfig config number is incorrect.");
Assert.AreEqual(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, newAdcpData.EnsembleData.SubsystemConfig.SubSystem.Code, "SubsystemConfig Subsystem code is incorrect.");
//DataSet.Ensemble result = adcpData.Clone();
//Assert.AreEqual(2, result.EnsembleData.SubsystemConfig.ConfigNumber, "SubsystemConfig config number is incorrect.");
//Assert.AreEqual(0x3, result.EnsembleData.SubsystemConfig.SubSystem.Code, "SubsystemConfig Subsystem code is incorrect.");
}
public void TestEncodeFirmwareSubsystemCodeChange()
{
// Create dataset
DataSet.Ensemble ensemble = new DataSet.Ensemble();
// Add data to data set
ensemble.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
Assert.IsTrue(ensemble.IsEnsembleAvail, "IsEnsembleAvail is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_INT, ensemble.EnsembleData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, ensemble.EnsembleData.NumBins, "Number of bins is incorrect.");
Assert.AreEqual(30, ensemble.EnsembleData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(4, ensemble.EnsembleData.NumBeams, "Number of beams is incorrect.");
Assert.AreEqual(4, ensemble.EnsembleData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, ensemble.EnsembleData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, ensemble.EnsembleData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.EnsembleDataID, ensemble.EnsembleData.Name, "Name is incorrect.");
//Assert.AreEqual(DateTime.Now, adcpData.EnsembleData.EnsDateTime, "Date Time is incorrect.");
Assert.AreEqual(DateTime.Now.Year, ensemble.EnsembleData.Year, "Year is incorrect.");
Assert.AreEqual(DateTime.Now.Month, ensemble.EnsembleData.Month, "Month is incorrect.");
Assert.AreEqual(DateTime.Now.Day, ensemble.EnsembleData.Day, "Day is incorrect.");
Assert.AreEqual(DateTime.Now.Hour, ensemble.EnsembleData.Hour, "Hour is incorrect.");
Assert.AreEqual(DateTime.Now.Minute, ensemble.EnsembleData.Minute, "Minute is incorrect.");
Assert.AreEqual(DateTime.Now.Second, ensemble.EnsembleData.Second, "Second is incorrect.");
Assert.AreEqual(new SerialNumber(), ensemble.EnsembleData.SysSerialNumber, "Serial Number is incorrect.");
Assert.AreEqual(new Firmware(), ensemble.EnsembleData.SysFirmware, "Firmware is incorrect.");
Assert.AreEqual(new SubsystemConfiguration(), ensemble.EnsembleData.SubsystemConfig, "Subsystem Configuration is incorrect.");
Assert.AreEqual(new Status(0), ensemble.EnsembleData.Status, "Status is incorrect.");
ensemble.EnsembleData.SysSerialNumber = new SerialNumber("01370000000000000000000000000001");
ensemble.EnsembleData.SysFirmware = new Firmware(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, 0, 2, 3);
ensemble.EnsembleData.SubsystemConfig = new SubsystemConfiguration(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), 2, 2);
ensemble.EnsembleData.Status = new Status(0x4000);
Assert.AreEqual(new SerialNumber("01370000000000000000000000000001"), ensemble.EnsembleData.SysSerialNumber, "Modded Serial Number is incorrect.");
// The Subsystem.SUB_2MHZ_4BEAM_20DEG_PISTON_1 will be converted from Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3 to Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_45OFFSET_7.
// 0x7 will come from the serial number. Because the firmware version is less
// than 0.2.13, the SubsystemCode is treated as an index. Index 1 in the subsystem from the serial number is 7.
Assert.AreEqual(new Firmware(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, 0, 2, 3), ensemble.EnsembleData.SysFirmware, "Modded Firmware is incorrect.");
Assert.AreEqual(new SubsystemConfiguration(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), 2, 2), ensemble.EnsembleData.SubsystemConfig, "Modded Subsystem Configuration is incorrect.");
Assert.AreEqual(new Status(0x4000), ensemble.EnsembleData.Status, "Modded Status is incorrect.");
// Encode the data
byte[] encoded = ensemble.EnsembleData.Encode();
DataSet.Ensemble ens1 = new DataSet.Ensemble();
// Add encoded data to dataset
ensemble.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, // Dataset ID
encoded); // Data
Assert.AreEqual(((DataSet.EnsembleDataSet.NUM_DATA_ELEMENTS * DataSet.Ensemble.BYTES_IN_FLOAT) + DataSet.Ensemble.PAYLOAD_HEADER_LEN), encoded.Length, "Encoded length is incorrect.");
Assert.AreEqual(DateTime.Now.Year, ensemble.EnsembleData.Year, "ens1 Year is incorrect.");
Assert.AreEqual(DateTime.Now.Month, ensemble.EnsembleData.Month, "ens1 Month is incorrect.");
Assert.AreEqual(DateTime.Now.Day, ensemble.EnsembleData.Day, "ens1 Day is incorrect.");
Assert.AreEqual(DateTime.Now.Hour, ensemble.EnsembleData.Hour, "ens1 Hour is incorrect.");
Assert.AreEqual(DateTime.Now.Minute, ensemble.EnsembleData.Minute, "ens1 Minute is incorrect.");
Assert.AreEqual(DateTime.Now.Second, ensemble.EnsembleData.Second, "ens1 Second is incorrect.");
Assert.AreEqual(new SerialNumber("01370000000000000000000000000001"), ensemble.EnsembleData.SysSerialNumber, "ens1 Serial Number is incorrect.");
Assert.AreEqual(new Firmware(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3, 0, 2, 3), ensemble.EnsembleData.SysFirmware, "ens1 Firmware is incorrect.");
Assert.AreEqual(new SubsystemConfiguration(new Subsystem(Subsystem.SUB_600KHZ_4BEAM_20DEG_PISTON_3), 2, 0), ensemble.EnsembleData.SubsystemConfig, "ens1 Subsystem Configuration is incorrect.");
Assert.AreEqual(new Status(0x4000), ensemble.EnsembleData.Status, "ens1 Status is incorrect.");
}
public void TestEncode()
{
// 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
Assert.IsTrue(adcpData.IsEnsembleAvail, "IsEnsembleAvail is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_INT, adcpData.EnsembleData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, adcpData.EnsembleData.NumBins, "Number of bins is incorrect.");
Assert.AreEqual(30, adcpData.EnsembleData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(4, adcpData.EnsembleData.NumBeams, "Number of beams is incorrect.");
Assert.AreEqual(4, adcpData.EnsembleData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, adcpData.EnsembleData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, adcpData.EnsembleData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.EnsembleDataID, adcpData.EnsembleData.Name, "Name is incorrect.");
//Assert.AreEqual(DateTime.Now, adcpData.EnsembleData.EnsDateTime, "Date Time is incorrect.");
Assert.AreEqual(DateTime.Now.Year, adcpData.EnsembleData.Year, "Year is incorrect.");
Assert.AreEqual(DateTime.Now.Month, adcpData.EnsembleData.Month, "Month is incorrect.");
Assert.AreEqual(DateTime.Now.Day, adcpData.EnsembleData.Day, "Day is incorrect.");
Assert.AreEqual(DateTime.Now.Hour, adcpData.EnsembleData.Hour, "Hour is incorrect.");
Assert.AreEqual(DateTime.Now.Minute, adcpData.EnsembleData.Minute, "Minute is incorrect.");
Assert.AreEqual(DateTime.Now.Second, adcpData.EnsembleData.Second, "Second is incorrect.");
Assert.AreEqual(new SerialNumber(), adcpData.EnsembleData.SysSerialNumber, "Serial Number is incorrect.");
Assert.AreEqual(new Firmware(), adcpData.EnsembleData.SysFirmware, "Firmware is incorrect.");
Assert.AreEqual(new SubsystemConfiguration(), adcpData.EnsembleData.SubsystemConfig, "Subsystem Configuration is incorrect.");
Assert.AreEqual(new Status(0), adcpData.EnsembleData.Status, "Status is incorrect.");
adcpData.EnsembleData.SysSerialNumber = new SerialNumber("01300000000000000000000000000001");
adcpData.EnsembleData.SysFirmware = new Firmware(0x1, 5, 2, 3);
adcpData.EnsembleData.SubsystemConfig = new SubsystemConfiguration(new Subsystem(0x1), 2, 2);
adcpData.EnsembleData.Status = new Status(0x4000);
Assert.AreEqual(new SerialNumber("01300000000000000000000000000001"), adcpData.EnsembleData.SysSerialNumber, "Modded Serial Number is incorrect.");
Assert.AreEqual(new Firmware(0x1, 5, 2, 3), adcpData.EnsembleData.SysFirmware, "Modded Firmware is incorrect.");
Assert.AreEqual(new SubsystemConfiguration(new Subsystem(0x1), 2, 2), adcpData.EnsembleData.SubsystemConfig, "Modded Subsystem Configuration is incorrect.");
Assert.AreEqual(new Status(0x4000), adcpData.EnsembleData.Status, "Modded Status is incorrect.");
// Encode the data
byte[] encoded = adcpData.EnsembleData.Encode();
DataSet.Ensemble ens1 = new DataSet.Ensemble();
// Add encoded data to dataset
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, // Dataset ID
encoded); // Data
Assert.AreEqual(((DataSet.EnsembleDataSet.NUM_DATA_ELEMENTS * DataSet.Ensemble.BYTES_IN_FLOAT) + DataSet.Ensemble.PAYLOAD_HEADER_LEN), encoded.Length, "Encoded length is incorrect.");
Assert.AreEqual(DateTime.Now.Year, adcpData.EnsembleData.Year, "ens1 Year is incorrect.");
Assert.AreEqual(DateTime.Now.Month, adcpData.EnsembleData.Month, "ens1 Month is incorrect.");
Assert.AreEqual(DateTime.Now.Day, adcpData.EnsembleData.Day, "ens1 Day is incorrect.");
Assert.AreEqual(DateTime.Now.Hour, adcpData.EnsembleData.Hour, "ens1 Hour is incorrect.");
Assert.AreEqual(DateTime.Now.Minute, adcpData.EnsembleData.Minute, "ens1 Minute is incorrect.");
Assert.AreEqual(DateTime.Now.Second, adcpData.EnsembleData.Second, "ens1 Second is incorrect.");
Assert.AreEqual(new SerialNumber("01300000000000000000000000000001"), adcpData.EnsembleData.SysSerialNumber, "ens1 Serial Number is incorrect.");
Assert.AreEqual(new Firmware(0x1, 5, 2, 3), adcpData.EnsembleData.SysFirmware, "ens1 Firmware is incorrect.");
Assert.AreEqual(new SubsystemConfiguration(new Subsystem(0x1), 2, 0), adcpData.EnsembleData.SubsystemConfig, "ens1 Subsystem Configuration is incorrect.");
Assert.AreEqual(new Status(0x4000), adcpData.EnsembleData.Status, "ens1 Status is incorrect.");
}
public void TestEmptyConstructor()
{
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Sentence 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
Assert.IsTrue(adcpData.IsEnsembleAvail, "IsEnsembleAvail is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_INT, adcpData.EnsembleData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, adcpData.EnsembleData.NumBins, "Number of bins is incorrect.");
Assert.AreEqual(30, adcpData.EnsembleData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(4, adcpData.EnsembleData.NumBeams, "Number of beams is incorrect.");
Assert.AreEqual(4, adcpData.EnsembleData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, adcpData.EnsembleData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, adcpData.EnsembleData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.EnsembleDataID, adcpData.EnsembleData.Name, "Name is incorrect.");
//Assert.AreEqual(DateTime.Now, adcpData.EnsembleData.EnsDateTime, "Date Time is incorrect.");
Assert.AreEqual(DateTime.Now.Year, adcpData.EnsembleData.Year, "Year is incorrect.");
Assert.AreEqual(DateTime.Now.Month, adcpData.EnsembleData.Month, "Month is incorrect.");
Assert.AreEqual(DateTime.Now.Day, adcpData.EnsembleData.Day, "Day is incorrect.");
Assert.AreEqual(DateTime.Now.Hour, adcpData.EnsembleData.Hour, "Hour is incorrect.");
Assert.AreEqual(DateTime.Now.Minute, adcpData.EnsembleData.Minute, "Minute is incorrect.");
Assert.AreEqual(DateTime.Now.Second, adcpData.EnsembleData.Second, "Second is incorrect.");
Assert.AreEqual(new SerialNumber(), adcpData.EnsembleData.SysSerialNumber, "Serial Number is incorrect.");
Assert.AreEqual(new Firmware(), adcpData.EnsembleData.SysFirmware, "Firmware is incorrect.");
Assert.AreEqual(new SubsystemConfiguration(), adcpData.EnsembleData.SubsystemConfig, "Subsystem Configuration is incorrect.");
Assert.AreEqual(new Status(0), adcpData.EnsembleData.Status, "Status is incorrect.");
}
public void TestEncodeDecode()
{
// Create dataset
DataSet.Ensemble ensemble = new DataSet.Ensemble();
// Add Sentence to data set
ensemble.AddGoodBeamData(DataSet.Ensemble.DATATYPE_FLOAT, // 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.GoodBeamID); // Dataset ID
Assert.IsTrue(ensemble.IsGoodBeamAvail, "IsGoodBeamAvail is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_FLOAT, ensemble.GoodBeamData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, ensemble.GoodBeamData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, ensemble.GoodBeamData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, ensemble.GoodBeamData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, ensemble.GoodBeamData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.GoodBeamID, ensemble.GoodBeamData.Name, "Name is incorrect.");
Assert.AreEqual(ensemble.GoodBeamData.GoodBeamData.GetLength(0), 30, "Good Beam Array Dimension 1 is incorrect.");
Assert.AreEqual(ensemble.GoodBeamData.GoodBeamData.GetLength(1), DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, "Good Beam Array Dimension 2 is incorrect.");
// Modify the array
ensemble.GoodBeamData.GoodBeamData[0, 0] = 2;
ensemble.GoodBeamData.GoodBeamData[0, 1] = 3;
ensemble.GoodBeamData.GoodBeamData[0, 2] = 4;
ensemble.GoodBeamData.GoodBeamData[0, 3] = 5;
ensemble.GoodBeamData.GoodBeamData[1, 0] = 6;
ensemble.GoodBeamData.GoodBeamData[1, 1] = 7;
ensemble.GoodBeamData.GoodBeamData[1, 2] = 8;
ensemble.GoodBeamData.GoodBeamData[1, 3] = 9;
ensemble.GoodBeamData.GoodBeamData[2, 0] = 10;
ensemble.GoodBeamData.GoodBeamData[2, 1] = 11;
ensemble.GoodBeamData.GoodBeamData[2, 2] = 12;
// Encode the data
byte[] encode = ensemble.GoodBeamData.Encode();
// Create dataset
DataSet.Ensemble ens0 = new DataSet.Ensemble();
// Add Sentence to data set
ens0.AddGoodBeamData(DataSet.Ensemble.DATATYPE_FLOAT, // Type of data stored (Float or Int)
30, // Number of bins
DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, // Number of beams
DataSet.Ensemble.DEFAULT_IMAG, // Default Image
DataSet.Ensemble.DEFAULT_NAME_LENGTH, // Default Image length
DataSet.Ensemble.GoodBeamID, // Dataset ID
encode); // Encoded data
Assert.IsTrue(ens0.IsGoodBeamAvail, "IsGoodBeamAvail is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_FLOAT, ens0.GoodBeamData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, ens0.GoodBeamData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, ens0.GoodBeamData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, ens0.GoodBeamData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, ens0.GoodBeamData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.GoodBeamID, ens0.GoodBeamData.Name, "Name is incorrect.");
Assert.AreEqual(ens0.GoodBeamData.GoodBeamData.GetLength(0), 30, "Beam Velocity Array Dimension 1 is incorrect.");
Assert.AreEqual(ens0.GoodBeamData.GoodBeamData.GetLength(1), DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, "Beam Velocity Array Dimension 2 is incorrect.");
Assert.AreEqual(2, ens0.GoodBeamData.GoodBeamData[0, 0], "0,0 Data is incorrect.");
Assert.AreEqual(3, ens0.GoodBeamData.GoodBeamData[0, 1], "0,1 Data is incorrect.");
Assert.AreEqual(4, ens0.GoodBeamData.GoodBeamData[0, 2], "0,2 Data is incorrect.");
Assert.AreEqual(5, ens0.GoodBeamData.GoodBeamData[0, 3], "0,3 Data is incorrect.");
Assert.AreEqual(6, ens0.GoodBeamData.GoodBeamData[1, 0], "1,0 Data is incorrect.");
Assert.AreEqual(7, ens0.GoodBeamData.GoodBeamData[1, 1], "1,1 Data is incorrect.");
Assert.AreEqual(8, ens0.GoodBeamData.GoodBeamData[1, 2], "1,2 Data is incorrect.");
Assert.AreEqual(9, ens0.GoodBeamData.GoodBeamData[1, 3], "1,3 Data is incorrect.");
Assert.AreEqual(10, ens0.GoodBeamData.GoodBeamData[2, 0], "2,0 Data is incorrect.");
Assert.AreEqual(11, ens0.GoodBeamData.GoodBeamData[2, 1], "2,1 Data is incorrect.");
Assert.AreEqual(12, ens0.GoodBeamData.GoodBeamData[2, 2], "2,2 Data is incorrect.");
}
/// <summary>
/// Reinitialize the values.
/// </summary>
private void Clear()
{
// Initialize all the sentences
_prevSA = null;
_prevTS = null;
_prevRA = null;
_prevWI = null;
_prevWS = null;
_prevWE = null;
_prevWD = null;
_prevBI = null;
_prevBS = null;
_prevBE = null;
_prevBD = null;
_prevEns = new DataSet.Ensemble();
_count = 0;
}
/// <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();
}
}
}
/// <summary>
/// Receive decoded data from the PD0 codec. This will be
/// the latest data decoded. It will include the complete
/// binary array of the data and the ensemble object.
/// </summary>
/// <param name="binaryEnsemble">Binary data of the ensemble.</param>
/// <param name="ensemble">Ensemble object.</param>
void _pd0Codec_ProcessDataEvent(byte[] binaryEnsemble, PD0 ensemble)
{
// Convert to a RTI ensemble
DataSet.Ensemble rtiEns = new DataSet.Ensemble(ensemble);
DataSet.VelocityVectorHelper.CreateVelocityVector(ref rtiEns);
if (ProcessDataEvent != null)
{
// Pass the data to the subscribers
ProcessDataEvent(binaryEnsemble, rtiEns);
}
_pd0Counter++;
// Check which buffers to clear
CheckCodecBuffers(CodecEnum.PD0);
}
public void TestEncodeDecode()
{
// Create dataset
DataSet.Ensemble ensemble = new DataSet.Ensemble();
// Add Sentence to data set
ensemble.AddAmplitudeData(DataSet.Ensemble.DATATYPE_FLOAT, // 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.CorrelationID); // Dataset ID
Assert.IsTrue(ensemble.IsAmplitudeAvail, "IsAmplitude is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_FLOAT, ensemble.AmplitudeData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, ensemble.AmplitudeData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, ensemble.AmplitudeData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, ensemble.AmplitudeData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, ensemble.AmplitudeData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.CorrelationID, ensemble.AmplitudeData.Name, "Name is incorrect.");
Assert.AreEqual(ensemble.AmplitudeData.AmplitudeData.GetLength(0), 30, "Amplitude Array Dimension 1 is incorrect.");
Assert.AreEqual(ensemble.AmplitudeData.AmplitudeData.GetLength(1), DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, "Amplitude Array Dimension 2 is incorrect.");
// Modify the array
ensemble.AmplitudeData.AmplitudeData[0, 0] = 2.3f;
ensemble.AmplitudeData.AmplitudeData[0, 1] = 3.4f;
ensemble.AmplitudeData.AmplitudeData[0, 2] = 4.5f;
ensemble.AmplitudeData.AmplitudeData[0, 3] = 5.6f;
ensemble.AmplitudeData.AmplitudeData[1, 0] = 6.7f;
ensemble.AmplitudeData.AmplitudeData[1, 1] = 7.8f;
ensemble.AmplitudeData.AmplitudeData[1, 2] = 8.9f;
ensemble.AmplitudeData.AmplitudeData[1, 3] = 9.10f;
ensemble.AmplitudeData.AmplitudeData[2, 0] = 10.11f;
ensemble.AmplitudeData.AmplitudeData[2, 1] = 11.12f;
ensemble.AmplitudeData.AmplitudeData[2, 2] = 12.13f;
// Encode the data
byte[] encode = ensemble.AmplitudeData.Encode();
// Create dataset
DataSet.Ensemble ens0 = new DataSet.Ensemble();
// Add Sentence to data set
ens0.AddAmplitudeData(DataSet.Ensemble.DATATYPE_FLOAT, // Type of data stored (Float or Int)
30, // Number of bins
DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, // Number of beams
DataSet.Ensemble.DEFAULT_IMAG, // Default Image
DataSet.Ensemble.DEFAULT_NAME_LENGTH, // Default Image length
DataSet.Ensemble.CorrelationID, // Dataset ID
encode); // Encoded data
Assert.IsTrue(ens0.IsAmplitudeAvail, "IsAmplitude is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_FLOAT, ens0.AmplitudeData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, ens0.AmplitudeData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, ens0.AmplitudeData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, ens0.AmplitudeData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, ens0.AmplitudeData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.CorrelationID, ens0.AmplitudeData.Name, "Name is incorrect.");
Assert.AreEqual(ens0.AmplitudeData.AmplitudeData.GetLength(0), 30, "Correlation Array Dimension 1 is incorrect.");
Assert.AreEqual(ens0.AmplitudeData.AmplitudeData.GetLength(1), DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM, "Correlation Array Dimension 2 is incorrect.");
Assert.AreEqual(2.3f, ens0.AmplitudeData.AmplitudeData[0, 0], "0,0 Data is incorrect.");
Assert.AreEqual(3.4f, ens0.AmplitudeData.AmplitudeData[0, 1], "0,1 Data is incorrect.");
Assert.AreEqual(4.5f, ens0.AmplitudeData.AmplitudeData[0, 2], "0,2 Data is incorrect.");
Assert.AreEqual(5.6f, ens0.AmplitudeData.AmplitudeData[0, 3], "0,3 Data is incorrect.");
Assert.AreEqual(6.7f, ens0.AmplitudeData.AmplitudeData[1, 0], "1,0 Data is incorrect.");
Assert.AreEqual(7.8f, ens0.AmplitudeData.AmplitudeData[1, 1], "1,1 Data is incorrect.");
Assert.AreEqual(8.9f, ens0.AmplitudeData.AmplitudeData[1, 2], "1,2 Data is incorrect.");
Assert.AreEqual(9.10f, ens0.AmplitudeData.AmplitudeData[1, 3], "1,3 Data is incorrect.");
Assert.AreEqual(10.11f, ens0.AmplitudeData.AmplitudeData[2, 0], "2,0 Data is incorrect.");
Assert.AreEqual(11.12f, ens0.AmplitudeData.AmplitudeData[2, 1], "2,1 Data is incorrect.");
Assert.AreEqual(12.13f, ens0.AmplitudeData.AmplitudeData[2, 2], "2,2 Data is incorrect.");
}
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 EncodeDecodeTest()
{
// Create dataset
DataSet.Ensemble ensemble = new DataSet.Ensemble();
// Add Bottom Track data
ensemble.AddBottomTrackData(DataSet.Ensemble.DATATYPE_FLOAT, // Type of data stored (Float or Int)
1, // Number of bins
4, // Number of beams
DataSet.Ensemble.DEFAULT_IMAG, // Default Image
DataSet.Ensemble.DEFAULT_NAME_LENGTH, // Default Image length
DataSet.Ensemble.BottomTrackID); // Dataset ID
Assert.IsTrue(ensemble.IsBottomTrackAvail, "IsBottomTrackAvail is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.ActualPingCount, "Actual Ping Count is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.FirstPingTime, "FirstPingTime is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.LastPingTime, "LastPingTime is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.Heading, "Heading is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.Pitch, "Pitch is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.Roll, "Roll is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.WaterTemp, "WaterTemp is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.SystemTemp, "SystemTemp is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.Salinity, "Salinity is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.Pressure, "Pressure is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.TransducerDepth, "TransducerDepth is incorrect.");
Assert.AreEqual(0.0f, ensemble.BottomTrackData.SpeedOfSound, "SpeedOfSound is incorrect.");
Assert.AreEqual(new Status(0), ensemble.BottomTrackData.Status, "Status is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.NumBeams, "NumBeams is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.Range.GetLength(0), "Range Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.SNR.GetLength(0), "SNR Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.Amplitude.GetLength(0), "Amplitude Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.Correlation.GetLength(0), "Correlation Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.BeamVelocity.GetLength(0), "BeamVelocity Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.BeamGood.GetLength(0), "BeamGood Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.InstrumentVelocity.GetLength(0), "InstrumentVelocity Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.InstrumentGood.GetLength(0), "InstrumentGood Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.EarthVelocity.GetLength(0), "EarthVelocity Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.EarthGood.GetLength(0), "EarthGood Length is incorrect.");
#region Set Values
// Set the values
ensemble.BottomTrackData.ActualPingCount = 1.2f;
ensemble.BottomTrackData.FirstPingTime = 2.3f;
ensemble.BottomTrackData.LastPingTime = 3.4f;
ensemble.BottomTrackData.Heading = 4.5f;
ensemble.BottomTrackData.Pitch = 5.6f;
ensemble.BottomTrackData.Roll = 6.7f;
ensemble.BottomTrackData.WaterTemp = 7.8f;
ensemble.BottomTrackData.SystemTemp = 8.9f;
ensemble.BottomTrackData.Salinity = 9.10f;
ensemble.BottomTrackData.Pressure = 10.11f;
ensemble.BottomTrackData.TransducerDepth = 11.12f;
ensemble.BottomTrackData.SpeedOfSound = 12.13f;
ensemble.BottomTrackData.Status = new Status(4);
ensemble.BottomTrackData.NumBeams = 4;
ensemble.BottomTrackData.Range[DataSet.Ensemble.BEAM_0_INDEX] = 1.2f;
ensemble.BottomTrackData.Range[DataSet.Ensemble.BEAM_1_INDEX] = 2.3f;
ensemble.BottomTrackData.Range[DataSet.Ensemble.BEAM_2_INDEX] = 3.4f;
ensemble.BottomTrackData.Range[DataSet.Ensemble.BEAM_3_INDEX] = 4.5f;
ensemble.BottomTrackData.SNR[DataSet.Ensemble.BEAM_0_INDEX] = 1.2f;
ensemble.BottomTrackData.SNR[DataSet.Ensemble.BEAM_1_INDEX] = 2.3f;
ensemble.BottomTrackData.SNR[DataSet.Ensemble.BEAM_2_INDEX] = 3.4f;
ensemble.BottomTrackData.SNR[DataSet.Ensemble.BEAM_3_INDEX] = 4.5f;
ensemble.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_0_INDEX] = 1.2f;
ensemble.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_1_INDEX] = 2.3f;
ensemble.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_2_INDEX] = 3.4f;
ensemble.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_3_INDEX] = 4.5f;
ensemble.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_0_INDEX] = 1.2f;
ensemble.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_1_INDEX] = 2.3f;
ensemble.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_2_INDEX] = 3.4f;
ensemble.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_3_INDEX] = 4.5f;
ensemble.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_0_INDEX] = 1.2f;
ensemble.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_1_INDEX] = 2.3f;
ensemble.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_2_INDEX] = 3.4f;
ensemble.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_3_INDEX] = 4.5f;
ensemble.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_0_INDEX] = 1;
ensemble.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_1_INDEX] = 1;
ensemble.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_2_INDEX] = 1;
ensemble.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_3_INDEX] = 1;
ensemble.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_0_INDEX] = 1.2f;
ensemble.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_1_INDEX] = 2.3f;
ensemble.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_2_INDEX] = 3.4f;
ensemble.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_3_INDEX] = 4.5f;
ensemble.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_0_INDEX] = 1;
ensemble.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_1_INDEX] = 1;
ensemble.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_2_INDEX] = 1;
ensemble.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_3_INDEX] = 1;
ensemble.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_0_INDEX] = 1.2f;
ensemble.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_1_INDEX] = 2.3f;
ensemble.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_2_INDEX] = 3.4f;
ensemble.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_3_INDEX] = 4.5f;
ensemble.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_0_INDEX] = 1;
ensemble.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_1_INDEX] = 1;
ensemble.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_2_INDEX] = 1;
ensemble.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_3_INDEX] = 1;
#endregion
#region Verify Values
Assert.IsTrue(ensemble.IsBottomTrackAvail, "IsBottomTrackAvail is incorrect.");
Assert.AreEqual(1.2f, ensemble.BottomTrackData.ActualPingCount, "Actual Ping Count is incorrect.");
Assert.AreEqual(2.3f, ensemble.BottomTrackData.FirstPingTime, "FirstPingTime is incorrect.");
Assert.AreEqual(3.4f, ensemble.BottomTrackData.LastPingTime, "LastPingTime is incorrect.");
Assert.AreEqual(4.5f, ensemble.BottomTrackData.Heading, "Heading is incorrect.");
Assert.AreEqual(5.6f, ensemble.BottomTrackData.Pitch, "Pitch is incorrect.");
Assert.AreEqual(6.7f, ensemble.BottomTrackData.Roll, "Roll is incorrect.");
Assert.AreEqual(7.8f, ensemble.BottomTrackData.WaterTemp, "WaterTemp is incorrect.");
Assert.AreEqual(8.9f, ensemble.BottomTrackData.SystemTemp, "SystemTemp is incorrect.");
Assert.AreEqual(9.10f, ensemble.BottomTrackData.Salinity, "Salinity is incorrect.");
Assert.AreEqual(10.11f, ensemble.BottomTrackData.Pressure, "Pressure is incorrect.");
Assert.AreEqual(11.12f, ensemble.BottomTrackData.TransducerDepth, "TransducerDepth is incorrect.");
Assert.AreEqual(12.13f, ensemble.BottomTrackData.SpeedOfSound, "SpeedOfSound is incorrect.");
Assert.AreEqual(new Status(4), ensemble.BottomTrackData.Status, "Status is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.NumBeams, "NumBeams is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.Range.GetLength(0), "Range Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.SNR.GetLength(0), "SNR Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.Amplitude.GetLength(0), "Amplitude Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.Correlation.GetLength(0), "Correlation Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.BeamVelocity.GetLength(0), "BeamVelocity Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.BeamGood.GetLength(0), "BeamGood Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.InstrumentVelocity.GetLength(0), "InstrumentVelocity Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.InstrumentGood.GetLength(0), "InstrumentGood Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.EarthVelocity.GetLength(0), "EarthVelocity Length is incorrect.");
Assert.AreEqual(4, ensemble.BottomTrackData.EarthGood.GetLength(0), "EarthGood Length is incorrect.");
Assert.AreEqual(1.2f, ensemble.BottomTrackData.Range[DataSet.Ensemble.BEAM_0_INDEX], "Range 0 is incorrect.");
Assert.AreEqual(2.3f, ensemble.BottomTrackData.Range[DataSet.Ensemble.BEAM_1_INDEX], "Range 1 is incorrect.");
Assert.AreEqual(3.4f, ensemble.BottomTrackData.Range[DataSet.Ensemble.BEAM_2_INDEX], "Range 2 is incorrect.");
Assert.AreEqual(4.5f, ensemble.BottomTrackData.Range[DataSet.Ensemble.BEAM_3_INDEX], "Range 3 is incorrect.");
Assert.AreEqual(1.2f, ensemble.BottomTrackData.SNR[DataSet.Ensemble.BEAM_0_INDEX], "SNR 0 is incorrect.");
Assert.AreEqual(2.3f, ensemble.BottomTrackData.SNR[DataSet.Ensemble.BEAM_1_INDEX], "SNR 1 is incorrect.");
Assert.AreEqual(3.4f, ensemble.BottomTrackData.SNR[DataSet.Ensemble.BEAM_2_INDEX], "SNR 2 is incorrect.");
Assert.AreEqual(4.5f, ensemble.BottomTrackData.SNR[DataSet.Ensemble.BEAM_3_INDEX], "SNR 3 is incorrect.");
Assert.AreEqual(1.2f, ensemble.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_0_INDEX], "Amplitude 0 is incorrect.");
Assert.AreEqual(2.3f, ensemble.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_1_INDEX], "Amplitude 1 is incorrect.");
Assert.AreEqual(3.4f, ensemble.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_2_INDEX], "Amplitude 2 is incorrect.");
Assert.AreEqual(4.5f, ensemble.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_3_INDEX], "Amplitude 3 is incorrect.");
Assert.AreEqual(1.2f, ensemble.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_0_INDEX], "Correlation 0 is incorrect.");
Assert.AreEqual(2.3f, ensemble.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_1_INDEX], "Correlation 1 is incorrect.");
Assert.AreEqual(3.4f, ensemble.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_2_INDEX], "Correlation 2 is incorrect.");
Assert.AreEqual(4.5f, ensemble.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_3_INDEX], "Correlation 3 is incorrect.");
Assert.AreEqual(1.2f, ensemble.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_0_INDEX], "BeamVelocity 0 is incorrect.");
Assert.AreEqual(2.3f, ensemble.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_1_INDEX], "BeamVelocity 1 is incorrect.");
Assert.AreEqual(3.4f, ensemble.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_2_INDEX], "BeamVelocity 2 is incorrect.");
Assert.AreEqual(4.5f, ensemble.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_3_INDEX], "BeamVelocity 3 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_0_INDEX], "BeamGood 0 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_1_INDEX], "BeamGood 1 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_2_INDEX], "BeamGood 2 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_3_INDEX], "BeamGood 3 is incorrect.");
Assert.AreEqual(1.2f, ensemble.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_0_INDEX], "InstrumentVelocity 0 is incorrect.");
Assert.AreEqual(2.3f, ensemble.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_1_INDEX], "InstrumentVelocity 1 is incorrect.");
Assert.AreEqual(3.4f, ensemble.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_2_INDEX], "InstrumentVelocity 2 is incorrect.");
Assert.AreEqual(4.5f, ensemble.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_3_INDEX], "InstrumentVelocity 3 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_0_INDEX], "InstrumentGood 0 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_1_INDEX], "InstrumentGood 1 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_2_INDEX], "InstrumentGood 2 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_3_INDEX], "InstrumentGood 3 is incorrect.");
Assert.AreEqual(1.2f, ensemble.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_0_INDEX], "EarthVelocity 0 is incorrect.");
Assert.AreEqual(2.3f, ensemble.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_1_INDEX], "EarthVelocity 1 is incorrect.");
Assert.AreEqual(3.4f, ensemble.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_2_INDEX], "EarthVelocity 2 is incorrect.");
Assert.AreEqual(4.5f, ensemble.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_3_INDEX], "EarthVelocity 3 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_0_INDEX], "EarthGood 0 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_1_INDEX], "EarthGood 1 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_2_INDEX], "EarthGood 2 is incorrect.");
Assert.AreEqual(1, ensemble.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_3_INDEX], "EarthGood 3 is incorrect.");
#endregion
// Encode the data
byte[] encode = ensemble.BottomTrackData.Encode();
// Add Bottom Track data
DataSet.Ensemble ens1 = new DataSet.Ensemble();
ens1.AddBottomTrackData(DataSet.Ensemble.DATATYPE_FLOAT, // Type of data stored (Float or Int)
1, // Number of bins
4, // Number of beams
DataSet.Ensemble.DEFAULT_IMAG, // Default Image
DataSet.Ensemble.DEFAULT_NAME_LENGTH, // Default Image length
DataSet.Ensemble.BottomTrackID, // Dataset ID
encode); // Encoded data
#region Check Encode data Values
Assert.IsTrue(ens1.IsBottomTrackAvail, "IsBottomTrackAvail is incorrect.");
Assert.AreEqual(1.2f, ens1.BottomTrackData.ActualPingCount, "Actual Ping Count is incorrect.");
Assert.AreEqual(2.3f, ens1.BottomTrackData.FirstPingTime, "FirstPingTime is incorrect.");
Assert.AreEqual(3.4f, ens1.BottomTrackData.LastPingTime, "LastPingTime is incorrect.");
Assert.AreEqual(4.5f, ens1.BottomTrackData.Heading, "Heading is incorrect.");
Assert.AreEqual(5.6f, ens1.BottomTrackData.Pitch, "Pitch is incorrect.");
Assert.AreEqual(6.7f, ens1.BottomTrackData.Roll, "Roll is incorrect.");
Assert.AreEqual(7.8f, ens1.BottomTrackData.WaterTemp, "WaterTemp is incorrect.");
Assert.AreEqual(8.9f, ens1.BottomTrackData.SystemTemp, "SystemTemp is incorrect.");
Assert.AreEqual(9.10f, ens1.BottomTrackData.Salinity, "Salinity is incorrect.");
Assert.AreEqual(10.11f, ens1.BottomTrackData.Pressure, "Pressure is incorrect.");
Assert.AreEqual(11.12f, ens1.BottomTrackData.TransducerDepth, "TransducerDepth is incorrect.");
Assert.AreEqual(12.13f, ens1.BottomTrackData.SpeedOfSound, "SpeedOfSound is incorrect.");
Assert.AreEqual(new Status(4), ens1.BottomTrackData.Status, "Status is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.NumBeams, "NumBeams is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.Range.GetLength(0), "Range Length is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.SNR.GetLength(0), "SNR Length is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.Amplitude.GetLength(0), "Amplitude Length is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.Correlation.GetLength(0), "Correlation Length is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.BeamVelocity.GetLength(0), "BeamVelocity Length is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.BeamGood.GetLength(0), "BeamGood Length is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.InstrumentVelocity.GetLength(0), "InstrumentVelocity Length is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.InstrumentGood.GetLength(0), "InstrumentGood Length is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.EarthVelocity.GetLength(0), "EarthVelocity Length is incorrect.");
Assert.AreEqual(4, ens1.BottomTrackData.EarthGood.GetLength(0), "EarthGood Length is incorrect.");
Assert.AreEqual(1.2f, ens1.BottomTrackData.Range[DataSet.Ensemble.BEAM_0_INDEX], "Range 0 is incorrect.");
Assert.AreEqual(2.3f, ens1.BottomTrackData.Range[DataSet.Ensemble.BEAM_1_INDEX], "Range 1 is incorrect.");
Assert.AreEqual(3.4f, ens1.BottomTrackData.Range[DataSet.Ensemble.BEAM_2_INDEX], "Range 2 is incorrect.");
Assert.AreEqual(4.5f, ens1.BottomTrackData.Range[DataSet.Ensemble.BEAM_3_INDEX], "Range 3 is incorrect.");
Assert.AreEqual(1.2f, ens1.BottomTrackData.SNR[DataSet.Ensemble.BEAM_0_INDEX], "SNR 0 is incorrect.");
Assert.AreEqual(2.3f, ens1.BottomTrackData.SNR[DataSet.Ensemble.BEAM_1_INDEX], "SNR 1 is incorrect.");
Assert.AreEqual(3.4f, ens1.BottomTrackData.SNR[DataSet.Ensemble.BEAM_2_INDEX], "SNR 2 is incorrect.");
Assert.AreEqual(4.5f, ens1.BottomTrackData.SNR[DataSet.Ensemble.BEAM_3_INDEX], "SNR 3 is incorrect.");
Assert.AreEqual(1.2f, ens1.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_0_INDEX], "Amplitude 0 is incorrect.");
Assert.AreEqual(2.3f, ens1.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_1_INDEX], "Amplitude 1 is incorrect.");
Assert.AreEqual(3.4f, ens1.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_2_INDEX], "Amplitude 2 is incorrect.");
Assert.AreEqual(4.5f, ens1.BottomTrackData.Amplitude[DataSet.Ensemble.BEAM_3_INDEX], "Amplitude 3 is incorrect.");
Assert.AreEqual(1.2f, ens1.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_0_INDEX], "Correlation 0 is incorrect.");
Assert.AreEqual(2.3f, ens1.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_1_INDEX], "Correlation 1 is incorrect.");
Assert.AreEqual(3.4f, ens1.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_2_INDEX], "Correlation 2 is incorrect.");
Assert.AreEqual(4.5f, ens1.BottomTrackData.Correlation[DataSet.Ensemble.BEAM_3_INDEX], "Correlation 3 is incorrect.");
Assert.AreEqual(1.2f, ens1.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_0_INDEX], "BeamVelocity 0 is incorrect.");
Assert.AreEqual(2.3f, ens1.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_1_INDEX], "BeamVelocity 1 is incorrect.");
Assert.AreEqual(3.4f, ens1.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_2_INDEX], "BeamVelocity 2 is incorrect.");
Assert.AreEqual(4.5f, ens1.BottomTrackData.BeamVelocity[DataSet.Ensemble.BEAM_3_INDEX], "BeamVelocity 3 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_0_INDEX], "BeamGood 0 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_1_INDEX], "BeamGood 1 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_2_INDEX], "BeamGood 2 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.BeamGood[DataSet.Ensemble.BEAM_3_INDEX], "BeamGood 3 is incorrect.");
Assert.AreEqual(1.2f, ens1.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_0_INDEX], "InstrumentVelocity 0 is incorrect.");
Assert.AreEqual(2.3f, ens1.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_1_INDEX], "InstrumentVelocity 1 is incorrect.");
Assert.AreEqual(3.4f, ens1.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_2_INDEX], "InstrumentVelocity 2 is incorrect.");
Assert.AreEqual(4.5f, ens1.BottomTrackData.InstrumentVelocity[DataSet.Ensemble.BEAM_3_INDEX], "InstrumentVelocity 3 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_0_INDEX], "InstrumentGood 0 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_1_INDEX], "InstrumentGood 1 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_2_INDEX], "InstrumentGood 2 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.InstrumentGood[DataSet.Ensemble.BEAM_3_INDEX], "InstrumentGood 3 is incorrect.");
Assert.AreEqual(1.2f, ens1.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_0_INDEX], "EarthVelocity 0 is incorrect.");
Assert.AreEqual(2.3f, ens1.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_1_INDEX], "EarthVelocity 1 is incorrect.");
Assert.AreEqual(3.4f, ens1.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_2_INDEX], "EarthVelocity 2 is incorrect.");
Assert.AreEqual(4.5f, ens1.BottomTrackData.EarthVelocity[DataSet.Ensemble.BEAM_3_INDEX], "EarthVelocity 3 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_0_INDEX], "EarthGood 0 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_1_INDEX], "EarthGood 1 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_2_INDEX], "EarthGood 2 is incorrect.");
Assert.AreEqual(1, ens1.BottomTrackData.EarthGood[DataSet.Ensemble.BEAM_3_INDEX], "EarthGood 3 is incorrect.");
#endregion
}
public void TestEmptyConstructor()
{
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Sentence to data set
adcpData.AddAncillaryData(DataSet.Ensemble.DATATYPE_FLOAT, // 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.AncillaryID); // Dataset ID
Assert.IsTrue(adcpData.IsAncillaryAvail, "IsEnsembleAvail is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_FLOAT, adcpData.AncillaryData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, adcpData.AncillaryData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(4, adcpData.AncillaryData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, adcpData.AncillaryData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, adcpData.AncillaryData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.AncillaryID, adcpData.AncillaryData.Name, "Name is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.FirstBinRange, "First Bin Range is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.BinSize, "BinSize is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.FirstPingTime, "FirstPingTime is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.LastPingTime, "LastPingTime is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Heading, "Heading is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Pitch, "Pitch is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Roll, "Roll is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.WaterTemp, "WaterTemp is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.SystemTemp, "SystemTemp is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Salinity, "Salinity is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Pressure, "Pressure is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.TransducerDepth, "TransducerDepth is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.SpeedOfSound, "SpeedOfSound is incorrect.");
}
public void TestEncode()
{
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add to data set
adcpData.AddAncillaryData(DataSet.Ensemble.DATATYPE_FLOAT, // 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.AncillaryID); // Dataset ID
Assert.IsTrue(adcpData.IsAncillaryAvail, "IsEnsembleAvail is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DATATYPE_FLOAT, adcpData.AncillaryData.ValueType, "DataType is incorrect.");
Assert.AreEqual(30, adcpData.AncillaryData.NumElements, "Number of Elements is incorrect.");
Assert.AreEqual(4, adcpData.AncillaryData.ElementsMultiplier, "Element Multiplies are incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_IMAG, adcpData.AncillaryData.Imag, "Imag is incorrect.");
Assert.AreEqual(DataSet.Ensemble.DEFAULT_NAME_LENGTH, adcpData.AncillaryData.NameLength, "Name length is incorrect.");
Assert.AreEqual(DataSet.Ensemble.AncillaryID, adcpData.AncillaryData.Name, "Name is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.FirstBinRange, "First Bin Range is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.BinSize, "BinSize is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.FirstPingTime, "FirstPingTime is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.LastPingTime, "LastPingTime is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Heading, "Heading is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Pitch, "Pitch is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Roll, "Roll is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.WaterTemp, "WaterTemp is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.SystemTemp, "SystemTemp is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Salinity, "Salinity is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.Pressure, "Pressure is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.TransducerDepth, "TransducerDepth is incorrect.");
Assert.AreEqual(0, adcpData.AncillaryData.SpeedOfSound, "SpeedOfSound is incorrect.");
adcpData.AncillaryData.FirstBinRange = 1.2f;
adcpData.AncillaryData.BinSize = 2.3f;
adcpData.AncillaryData.FirstPingTime = 3.4f;
adcpData.AncillaryData.LastPingTime = 4.5f;
adcpData.AncillaryData.Heading = 5.6f;
adcpData.AncillaryData.Pitch = 6.7f;
adcpData.AncillaryData.Roll = 7.8f;
adcpData.AncillaryData.WaterTemp = 8.9f;
adcpData.AncillaryData.SystemTemp = 9.10f;
adcpData.AncillaryData.Salinity = 10.11f;
adcpData.AncillaryData.Pressure = 11.12f;
adcpData.AncillaryData.TransducerDepth = 12.13f;
adcpData.AncillaryData.SpeedOfSound = 13.14f;
Assert.AreEqual(1.2f, adcpData.AncillaryData.FirstBinRange, "First Bin Range is incorrect.");
Assert.AreEqual(2.3f, adcpData.AncillaryData.BinSize, "BinSize is incorrect.");
Assert.AreEqual(3.4f, adcpData.AncillaryData.FirstPingTime, "FirstPingTime is incorrect.");
Assert.AreEqual(4.5f, adcpData.AncillaryData.LastPingTime, "LastPingTime is incorrect.");
Assert.AreEqual(5.6f, adcpData.AncillaryData.Heading, "Heading is incorrect.");
Assert.AreEqual(6.7f, adcpData.AncillaryData.Pitch, "Pitch is incorrect.");
Assert.AreEqual(7.8f, adcpData.AncillaryData.Roll, "Roll is incorrect.");
Assert.AreEqual(8.9f, adcpData.AncillaryData.WaterTemp, "WaterTemp is incorrect.");
Assert.AreEqual(9.10f, adcpData.AncillaryData.SystemTemp, "SystemTemp is incorrect.");
Assert.AreEqual(10.11f, adcpData.AncillaryData.Salinity, "Salinity is incorrect.");
Assert.AreEqual(11.12f, adcpData.AncillaryData.Pressure, "Pressure is incorrect.");
Assert.AreEqual(12.13f, adcpData.AncillaryData.TransducerDepth, "TransducerDepth is incorrect.");
Assert.AreEqual(13.14f, adcpData.AncillaryData.SpeedOfSound, "SpeedOfSound is incorrect.");
// Encode the data
byte[] encoded = adcpData.AncillaryData.Encode();
DataSet.Ensemble ens1 = new DataSet.Ensemble();
// Add encoded data to dataset
ens1.AddAncillaryData(DataSet.Ensemble.DATATYPE_FLOAT, // 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.AncillaryID, // Dataset ID
encoded); // Data
Assert.AreEqual(((DataSet.AncillaryDataSet.NUM_DATA_ELEMENTS * DataSet.Ensemble.BYTES_IN_FLOAT) + DataSet.Ensemble.PAYLOAD_HEADER_LEN), encoded.Length, "Encoded length is incorrect.");
Assert.AreEqual(1.2f, ens1.AncillaryData.FirstBinRange, "First Bin Range is incorrect.");
Assert.AreEqual(2.3f, ens1.AncillaryData.BinSize, "BinSize is incorrect.");
Assert.AreEqual(3.4f, ens1.AncillaryData.FirstPingTime, "FirstPingTime is incorrect.");
Assert.AreEqual(4.5f, ens1.AncillaryData.LastPingTime, "LastPingTime is incorrect.");
Assert.AreEqual(5.6f, ens1.AncillaryData.Heading, "Heading is incorrect.");
Assert.AreEqual(6.7f, ens1.AncillaryData.Pitch, "Pitch is incorrect.");
Assert.AreEqual(7.8f, ens1.AncillaryData.Roll, "Roll is incorrect.");
Assert.AreEqual(8.9f, ens1.AncillaryData.WaterTemp, "WaterTemp is incorrect.");
Assert.AreEqual(9.10f, ens1.AncillaryData.SystemTemp, "SystemTemp is incorrect.");
Assert.AreEqual(10.11f, ens1.AncillaryData.Salinity, "Salinity is incorrect.");
Assert.AreEqual(11.12f, ens1.AncillaryData.Pressure, "Pressure is incorrect.");
Assert.AreEqual(12.13f, ens1.AncillaryData.TransducerDepth, "TransducerDepth is incorrect.");
Assert.AreEqual(13.14f, ens1.AncillaryData.SpeedOfSound, "SpeedOfSound is incorrect.");
}
public void TestConstructorPrti01Sentence()
{
string nmea = "$PRTI01,379550,1,1468,-99999,-99999,-99999,0,,,,,0004*09";
// Create Sentence
Prti01Sentence sent = new Prti01Sentence(nmea);
Assert.AreEqual(true, sent.IsValid, "NMEA sentence incorrect");
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add ancillary data
adcpData.AddAncillaryData(sent);
Assert.AreEqual(true, adcpData.IsAncillaryAvail, "Ancillary data not created");
// Check temperature
Assert.AreEqual(14.68, adcpData.AncillaryData.WaterTemp, 0.00001, "Water Temperature was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.FirstBinRange, "First Bin Range was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.BinSize, "Bin Size was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.FirstPingTime, "First Ping Time was incorrect");
Assert.AreEqual(3795, adcpData.AncillaryData.LastPingTime, "Last Ping Time was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Heading, "Heading was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Pitch, "Pitch was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Roll, "Roll was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.SystemTemp, "System Temp was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Salinity, "Salinity was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.Pressure, "Pressure was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.TransducerDepth, "Transducer Depth was incorrect");
Assert.AreEqual(0, adcpData.AncillaryData.SpeedOfSound, "Speed Of Sound was incorrect");
}
public void TestConstructorPrti02Sentence1()
{
string nmea = "$PRTI02,380250,8,1464,1142,323,407,79380,,,,,0000*1C";
// Create sentence
Prti02Sentence sent = new Prti02Sentence(nmea);
Assert.AreEqual(true, sent.IsValid, "NMEA sentence incorrect");
// Create dataset
DataSet.Ensemble adcpData = new DataSet.Ensemble();
// Add Bottom Track data
adcpData.AddBottomTrackData(sent);
Assert.AreEqual(true, adcpData.IsBottomTrackAvail, "Bottom Track DataSet not added");
Assert.AreEqual(new DotSpatial.Positioning.Distance("79380 mm").ToMeters().Value, adcpData.BottomTrackData.Range[0], 0.00001, "Bottom Track Range B1 incorrect");
Assert.AreEqual(new DotSpatial.Positioning.Distance("79380 mm").ToMeters().Value, adcpData.BottomTrackData.Range[1], 0.00001, "Bottom Track Range B2 incorrect");
Assert.AreEqual(new DotSpatial.Positioning.Distance("79380 mm").ToMeters().Value, adcpData.BottomTrackData.Range[2], 0.00001, "Bottom Track Range B3 incorrect");
Assert.AreEqual(new DotSpatial.Positioning.Distance("79380 mm").ToMeters().Value, adcpData.BottomTrackData.Range[3], 0.00001, "Bottom Track Range B4 incorrect");
Assert.AreNotEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.EarthVelocity[0], "Bottom Track Earth Velocity East incorrect");
Assert.AreNotEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.EarthVelocity[1], "Bottom Track Earth Velocity North incorrect");
Assert.AreNotEqual(DataSet.Ensemble.BAD_VELOCITY, adcpData.BottomTrackData.EarthVelocity[2], "Bottom Track Earth Velocity Up incorrect");
Assert.AreEqual(0, adcpData.BottomTrackData.EarthVelocity[3], "Bottom Track Earth Velocity Q incorrect");
Assert.AreEqual(Convert.ToSingle(new DotSpatial.Positioning.Speed("1142 mm/s").ToMetersPerSecond().Value), adcpData.BottomTrackData.EarthVelocity[0], "Bottom Track Earth Velocity East incorrect");
Assert.AreEqual(Convert.ToSingle(new DotSpatial.Positioning.Speed("323 mm/s").ToMetersPerSecond().Value), adcpData.BottomTrackData.EarthVelocity[1], "Bottom Track Earth Velocity North incorrect");
Assert.AreEqual(Convert.ToSingle(new DotSpatial.Positioning.Speed("407 mm/s").ToMetersPerSecond().Value), adcpData.BottomTrackData.EarthVelocity[2], "Bottom Track Earth Velocity Up incorrect");
Assert.AreEqual(0000, adcpData.BottomTrackData.Status.Value, "Bottom Track Instrument Status incorrect");
Assert.AreEqual(sent.SystemStatus.Value, adcpData.BottomTrackData.Status.Value, "Bottom Track Instrument Status incorrect");
}
/// <summary>
/// Decode the PD6 and PD13 ASCII data.
/// </summary>
public Pd6_13Codec()
{
_prevEns = new DataSet.Ensemble();
// Clear the values
Clear();
// Initialize the thread
_continue = true;
_eventWaitData = new EventWaitHandle(false, EventResetMode.AutoReset);
_processDataThread = new Thread(ProcessDataThread);
_processDataThread.Name = "PD6 PD13 Codec";
_processDataThread.Start();
}
