def test_encode_decode(): num_bins = 30 num_beams = 4 vel = EarthVelocity(num_bins, num_beams) # Populate data val = 1.0 for beam in range(vel.element_multiplier): for bin_num in range(vel.num_elements): vel.Velocities[bin_num][beam] = val val += 1.1 vel.Magnitude, vel.Direction = EarthVelocity.generate_vectors( vel.Velocities) result = vel.encode() vel1 = EarthVelocity(num_bins, num_beams) vel1.decode(bytearray(result)) for beam in range(vel1.element_multiplier): for bin_num in range(vel1.num_elements): assert vel.Velocities[bin_num][beam] == pytest.approx( vel1.Velocities[bin_num][beam], 0.1) assert vel.Magnitude[bin_num] == pytest.approx( vel1.Magnitude[bin_num], 0.1) assert vel.Direction[bin_num] == pytest.approx( vel1.Direction[bin_num], 0.1)
def test_encode_csv_vector_no_gen(): num_bins = 30 num_beams = 4 vel = EarthVelocity(num_bins, num_beams) # Populate data val = 2.0 for beam in range(vel.element_multiplier): for bin_num in range(vel.num_elements): vel.Velocities[bin_num][beam] = val vel.Magnitude, vel.Direction = EarthVelocity.generate_vectors( vel.Velocities) vel.remove_vessel_speed(-1.3, -1.4, 0.3) dt = datetime.datetime.now() # Create CSV lines result = vel.encode_csv(dt, 'A', 1, 1.3, 1.0) # Check the csv data for line in result: if bool(re.search(Ensemble.CSV_MAG, line[0])): assert bool(re.search(str(2.477), line[0])) assert bool(re.search(Ensemble.CSV_MAG, line[0])) elif bool(re.search(Ensemble.CSV_DIR, line[0])): assert bool(re.search(str(49.3987), line[0])) assert bool(re.search(Ensemble.CSV_DIR, line[0])) elif bool(re.search(Ensemble.CSV_EARTH_VEL, line[0])): assert True else: assert False
def test_encode_csv(): num_bins = 30 num_beams = 4 vel = EarthVelocity(num_bins, num_beams) # Populate data val = 1.0 for beam in range(vel.element_multiplier): for bin_num in range(vel.num_elements): vel.Velocities[bin_num][beam] = val val += 1.1 vel.Magnitude, vel.Direction = EarthVelocity.generate_vectors( vel.Velocities) dt = datetime.datetime.now() # Create CSV lines result = vel.encode_csv(dt, 'A', 1, 1.3, 1.0) # Check the csv data test_value = 1.0 for line in result: if bool(re.search(Ensemble.CSV_EARTH_VEL, line[0])): assert bool(re.search(str(test_value), line[0])) assert bool(re.search(Ensemble.CSV_EARTH_VEL, line[0])) test_value += 1.1
def test_avg_mag_dir_nan(): num_bins = 30 num_beams = 4 vel = EarthVelocity(num_bins, num_beams) vel.Magnitude = [np.NaN, np.NaN] vel.Direction = [np.NaN, np.NaN] avg_mag, avg_dir = vel.average_mag_dir() assert avg_mag is None assert avg_dir is None
def test_avg_mag_dir_nan(): num_bins = 30 num_beams = 4 vel = EarthVelocity(num_bins, num_beams) vel.Magnitude = [5.0, 5.0, 5.0, 5.0, np.NaN] vel.Direction = [1.2, 1.2, 1.2, 1.2, np.NaN] avg_mag, avg_dir = vel.average_mag_dir() assert avg_mag == pytest.approx(5, 0.001) assert avg_dir == pytest.approx(1.2, 0.001)
def test_vectors(): earth = EarthVelocity(3, 4) earth.Velocities.clear() earth.Velocities.append([1.33, 1.45, 0.3, 0.0]) earth.Velocities.append([1.33, 1.45, 0.3, 0.0]) earth.Velocities.append([1.33, 1.45, 0.3, 0.0]) earth.remove_vessel_speed(-1.1, -1.2, -0.1) mag, dir = EarthVelocity.generate_vectors(earth.Velocities) assert 3 == len(mag) assert 3 == len(dir) assert 0.394 == pytest.approx(mag[0], 0.01) assert 42.614 == pytest.approx(dir[0], 0.01) assert 0.394 == pytest.approx(mag[1], 0.01) assert 42.614 == pytest.approx(dir[1], 0.01) assert 0.394 == pytest.approx(mag[2], 0.01) assert 42.614 == pytest.approx(dir[2], 0.01)
def test_encode_decode(): num_bins = 33 num_beams = 4 ens = Ensemble() ens_ds = EnsembleData() ens_ds.EnsembleNumber = 2668 ens_ds.NumBins = 33 ens_ds.NumBeams = 4 ens_ds.DesiredPingCount = 45 ens_ds.ActualPingCount = 46 ens_ds.SerialNumber = "01H00000000000000000000000999999" ens_ds.SysFirmwareMajor = 2 ens_ds.SysFirmwareMinor = 11 ens_ds.SysFirmwareRevision = 5 ens_ds.SysFirmwareSubsystemCode = "A" ens_ds.SubsystemConfig = 3 ens_ds.Status = 9 ens_ds.Year = 2019 ens_ds.Month = 3 ens_ds.Day = 9 ens_ds.Hour = 12 ens_ds.Minute = 23 ens_ds.Second = 24 ens_ds.HSec = 33 anc = AncillaryData() anc.FirstBinRange = 1.0 # Blank. Depth to the first bin in meters. anc.BinSize = 3.0 # Size of a bin in meters. anc.FirstPingTime = 1.2 # First Ping Time in seconds. anc.LastPingTime = 2.3 # Last Ping Time in seconds. (If averaging pings, this will be the last ping) anc.Heading = 23.5 # Heading in degrees. anc.Pitch = 13.6 # Pitch in degrees. anc.Roll = 11.25 # Roll in degrees. anc.WaterTemp = 25.3 # Water Temperature in fahrenheit anc.SystemTemp = 54.6 # System Temperature in fahrenheit anc.Salinity = 35.0 # Water Salinity set by the user in PPT anc.Pressure = 23.78 # Pressure from pressure sensor in Pascals anc.TransducerDepth = 45.69 # Transducer Depth, used by Pressure sensor in meters anc.SpeedOfSound = 1400.23 # Speed of Sound in m/s. anc.RawMagFieldStrength = 3.0 # Raw magnetic field strength anc.PitchGravityVector = 4.0 # Pitch Gravity Vector anc.RollGravityVector = 5.0 # Roll Gravity Vector anc.VerticalGravityVector = 6.0 # Vertical Gravity Vector amp = Amplitude(num_bins, num_beams) corr = Correlation(num_bins, num_beams) beam_vel = BeamVelocity(num_bins, num_beams) inst_vel = InstrumentVelocity(num_bins, num_beams) earth_vel = EarthVelocity(num_bins, num_beams) gb = GoodBeam(num_bins, num_beams) ge = GoodEarth(num_bins, num_beams) val = 1.0 for beam in range(amp.element_multiplier): for bin_num in range(amp.num_elements): amp.Amplitude[bin_num][beam] = val corr.Correlation[bin_num][beam] = val beam_vel.Velocities[bin_num][beam] = val inst_vel.Velocities[bin_num][beam] = val earth_vel.Velocities[bin_num][beam] = val gb.GoodBeam[bin_num][beam] = 1 * int(beam) ge.GoodEarth[bin_num][beam] = 1 * int(beam) val += 1.1 bt = BottomTrack() bt.FirstPingTime = 12.5 bt.LastPingTime = 12.8 bt.Heading = 152.36 bt.Pitch = 12.6 bt.Roll = 223.1 bt.WaterTemp = 15.23 bt.SystemTemp = 78.58 bt.Salinity = 35.0 bt.Pressure = 23.36 bt.TransducerDepth = 156.2 bt.SpeedOfSound = 1402.36 bt.Status = 9.0 bt.NumBeams = 4.0 bt.ActualPingCount = 23 bt.Range = [1.1, 2.2, 3.3, 4.4] bt.SNR = [1.1, 2.2, 3.3, 4.4] bt.Amplitude = [1.1, 2.2, 3.3, 4.4] bt.Correlation = [1.1, 2.2, 3.3, 4.4] bt.BeamVelocity = [1.1, 2.2, 3.3, 4.4] bt.BeamGood = [1, 2, 3, 4] bt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4] bt.InstrumentGood = [1, 2, 3, 4] bt.EarthVelocity = [1.1, 2.2, 3.3, 4.4] bt.EarthGood = [1, 2, 3, 4] bt.SNR_PulseCoherent = [1, 2, 3, 4] bt.Amp_PulseCoherent = [1, 2, 3, 4] bt.Vel_PulseCoherent = [1, 2, 3, 4] bt.Noise_PulseCoherent = [1, 2, 3, 4] bt.Corr_PulseCoherent = [1, 2, 3, 4] rt = RangeTracking() rt.NumBeams = 4.0 rt.Range = [1.1, 2.2, 3.3, 4.4] rt.Pings = [1, 2, 3, 4] rt.SNR = [1.1, 2.2, 3.3, 4.4] rt.Amplitude = [1.1, 2.2, 3.3, 4.4] rt.Correlation = [1.1, 2.2, 3.3, 4.4] rt.BeamVelocity = [1.1, 2.2, 3.3, 4.4] rt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4] rt.EarthVelocity = [1.1, 2.2, 3.3, 4.4] nmea = NmeaData() nmea.add_nmea("$HEHDT,244.39,T*17\n") nmea.add_nmea( "$GPGGA,195949.00,3254.8103248,N,11655.5779629,W,2,08,1.1,222.174,M,-32.602,M,6.0,0138*75\n" ) nmea.add_nmea("$GPVTG,306.20,T,294.73,M,0.13,N,0.24,K,D*2E\n") nmea.add_nmea("$HEHDT,244.36,T*18\n") ss = SystemSetup() ss.BtSamplesPerSecond = 1.0 ss.BtSystemFreqHz = 3.0 ss.BtCPCE = 1.2 ss.BtNCE = 2.3 ss.BtRepeatN = 23.5 ss.WpSamplesPerSecond = 13.6 ss.WpSystemFreqHz = 11.25 ss.WpCPCE = 25.3 ss.WpNCE = 54.6 ss.WpRepeatN = 35.0 ss.WpLagSamples = 23.78 ss.Voltage = 45.69 ss.XmtVoltage = 1400.23 ss.BtBroadband = 3.0 ss.BtLagLength = 4.0 ss.BtNarrowband = 5.0 ss.BtBeamMux = 6.0 ss.WpBroadband = 6.0 ss.WpLagLength = 6.0 ss.WpTransmitBandwidth = 6.0 ss.WpReceiveBandwidth = 6.0 ens.AddAmplitude(amp) ens.AddCorrelation(corr) ens.AddBeamVelocity(beam_vel) ens.AddInstrumentVelocity(inst_vel) ens.AddEarthVelocity(earth_vel) ens.AddGoodBeam(gb) ens.AddGoodEarth(ge) ens.AddAncillaryData(anc) ens.AddEnsembleData(ens_ds) ens.AddBottomTrack(bt) ens.AddRangeTracking(rt) ens.AddSystemSetup(ss) ens.AddNmeaData(nmea) # Encode the ensemble to binar binary_ens = ens.encode() # Use the codec to decode the data ens1 = BinaryCodec.decode_data_sets(binary_ens[:-4]) # Remove the checksum assert ens.EnsembleData.EnsembleNumber == ens1.EnsembleData.EnsembleNumber assert ens.EnsembleData.NumBins == ens1.EnsembleData.NumBins assert ens.EnsembleData.NumBeams == ens1.EnsembleData.NumBeams assert ens.EnsembleData.DesiredPingCount == ens1.EnsembleData.DesiredPingCount assert ens.EnsembleData.ActualPingCount == ens1.EnsembleData.ActualPingCount assert ens.EnsembleData.SerialNumber == ens1.EnsembleData.SerialNumber assert ens.EnsembleData.SysFirmwareMajor == ens1.EnsembleData.SysFirmwareMajor assert ens.EnsembleData.SysFirmwareMinor == ens1.EnsembleData.SysFirmwareMinor assert ens.EnsembleData.SysFirmwareRevision == ens1.EnsembleData.SysFirmwareRevision assert ens.EnsembleData.SysFirmwareSubsystemCode == ens1.EnsembleData.SysFirmwareSubsystemCode assert ens.EnsembleData.SubsystemConfig == ens1.EnsembleData.SubsystemConfig assert ens.EnsembleData.Status == ens1.EnsembleData.Status assert ens.EnsembleData.Year == ens1.EnsembleData.Year assert ens.EnsembleData.Month == ens1.EnsembleData.Month assert ens.EnsembleData.Day == ens1.EnsembleData.Day assert ens.EnsembleData.Hour == ens1.EnsembleData.Hour assert ens.EnsembleData.Minute == ens1.EnsembleData.Minute assert ens.EnsembleData.Second == ens1.EnsembleData.Second assert ens.EnsembleData.HSec == ens1.EnsembleData.HSec assert anc.FirstBinRange == pytest.approx(ens1.AncillaryData.FirstBinRange, 0.1) assert anc.BinSize == pytest.approx(ens1.AncillaryData.BinSize, 0.1) assert anc.FirstPingTime == pytest.approx(ens1.AncillaryData.FirstPingTime, 0.1) assert anc.LastPingTime == pytest.approx(ens1.AncillaryData.LastPingTime, 0.1) assert anc.Heading == pytest.approx(ens1.AncillaryData.Heading, 0.1) assert anc.Pitch == pytest.approx(ens1.AncillaryData.Pitch, 0.1) assert anc.Roll == pytest.approx(ens1.AncillaryData.Roll, 0.1) assert anc.WaterTemp == pytest.approx(ens1.AncillaryData.WaterTemp, 0.1) assert anc.SystemTemp == pytest.approx(ens1.AncillaryData.SystemTemp, 0.1) assert anc.Salinity == pytest.approx(ens1.AncillaryData.Salinity, 0.1) assert anc.Pressure == pytest.approx(ens1.AncillaryData.Pressure, 0.1) assert anc.TransducerDepth == pytest.approx( ens1.AncillaryData.TransducerDepth, 0.1) assert anc.SpeedOfSound == pytest.approx(ens1.AncillaryData.SpeedOfSound, 0.1) assert anc.RawMagFieldStrength == pytest.approx( ens1.AncillaryData.RawMagFieldStrength, 0.1) assert anc.PitchGravityVector == pytest.approx( ens1.AncillaryData.PitchGravityVector, 0.1) assert anc.RollGravityVector == pytest.approx( ens1.AncillaryData.RollGravityVector, 0.1) assert anc.VerticalGravityVector == pytest.approx( ens1.AncillaryData.VerticalGravityVector, 0.1) for beam in range(amp.element_multiplier): for bin_num in range(amp.num_elements): assert amp.Amplitude[bin_num][beam] == pytest.approx( ens1.Amplitude.Amplitude[bin_num][beam], 0.1) for beam in range(corr.element_multiplier): for bin_num in range(corr.num_elements): assert corr.Correlation[bin_num][beam] == pytest.approx( ens1.Correlation.Correlation[bin_num][beam], 0.1) for beam in range(beam_vel.element_multiplier): for bin_num in range(beam_vel.num_elements): assert beam_vel.Velocities[bin_num][beam] == pytest.approx( ens1.Wt.Velocities[bin_num][beam], 0.1) for beam in range(beam_vel.element_multiplier): for bin_num in range(beam_vel.num_elements): assert inst_vel.Velocities[bin_num][beam] == pytest.approx( ens1.InstrumentVelocity.Velocities[bin_num][beam], 0.1) for beam in range(beam_vel.element_multiplier): for bin_num in range(beam_vel.num_elements): assert earth_vel.Velocities[bin_num][beam] == pytest.approx( ens1.EarthVelocity.Velocities[bin_num][beam], 0.1) #for beam in range(gb.element_multiplier): # for bin_num in range(gb.num_elements): # assert gb.GoodBeam[bin_num][beam] == pytest.approx(ens1.GoodBeam.GoodBeam[bin_num][beam], 0.1) for beam in range(ge.element_multiplier): for bin_num in range(ge.num_elements): assert ge.GoodEarth[bin_num][beam] == pytest.approx( ens1.GoodEarth.GoodEarth[bin_num][beam], 0.1) assert bt.FirstPingTime == pytest.approx(ens1.BottomTrack.FirstPingTime) assert bt.LastPingTime == pytest.approx(ens1.BottomTrack.LastPingTime) assert bt.Heading == pytest.approx(ens1.BottomTrack.Heading) assert bt.Pitch == pytest.approx(ens1.BottomTrack.Pitch) assert bt.Roll == pytest.approx(ens1.BottomTrack.Roll) assert bt.WaterTemp == pytest.approx(ens1.BottomTrack.WaterTemp) assert bt.SystemTemp == pytest.approx(ens1.BottomTrack.SystemTemp) assert bt.Salinity == pytest.approx(ens1.BottomTrack.Salinity) assert bt.Pressure == pytest.approx(ens1.BottomTrack.Pressure) assert bt.TransducerDepth == pytest.approx( ens1.BottomTrack.TransducerDepth) assert bt.SpeedOfSound == pytest.approx(ens1.BottomTrack.SpeedOfSound) assert bt.Status == pytest.approx(ens1.BottomTrack.Status) assert bt.NumBeams == pytest.approx(ens1.BottomTrack.NumBeams) assert bt.ActualPingCount == pytest.approx( ens1.BottomTrack.ActualPingCount) assert bt.Range == pytest.approx(ens1.BottomTrack.Range) assert bt.SNR == pytest.approx(ens1.BottomTrack.SNR) assert bt.Amplitude == pytest.approx(ens1.BottomTrack.Amplitude) assert bt.Correlation == pytest.approx(ens1.BottomTrack.Correlation) assert bt.BeamVelocity == pytest.approx(ens1.BottomTrack.Wt) assert bt.BeamGood == pytest.approx(ens1.BottomTrack.BeamGood, 0.1) assert bt.InstrumentVelocity == pytest.approx( ens1.BottomTrack.InstrumentVelocity) assert bt.InstrumentGood == pytest.approx(ens1.BottomTrack.InstrumentGood, 0.1) assert bt.EarthVelocity == pytest.approx(ens1.BottomTrack.EarthVelocity) assert bt.EarthGood == pytest.approx(ens1.BottomTrack.EarthGood, 0.1) assert bt.SNR_PulseCoherent == pytest.approx( ens1.BottomTrack.SNR_PulseCoherent, 0.1) assert bt.Amp_PulseCoherent == pytest.approx( ens1.BottomTrack.Amp_PulseCoherent, 0.1) assert bt.Vel_PulseCoherent == pytest.approx( ens1.BottomTrack.Vel_PulseCoherent, 0.1) assert bt.Noise_PulseCoherent == pytest.approx( ens1.BottomTrack.Noise_PulseCoherent, 0.1) assert bt.Corr_PulseCoherent == pytest.approx( ens1.BottomTrack.Corr_PulseCoherent, 0.1) assert rt.NumBeams == ens1.RangeTracking.NumBeams assert rt.Range == pytest.approx(ens1.RangeTracking.Range) assert rt.SNR == pytest.approx(ens1.RangeTracking.SNR) assert rt.Amplitude == pytest.approx(ens1.RangeTracking.Amplitude) assert rt.Correlation == pytest.approx(ens1.RangeTracking.Correlation) assert rt.BeamVelocity == pytest.approx(ens1.RangeTracking.Wt) assert rt.InstrumentVelocity == pytest.approx( ens1.RangeTracking.InstrumentVelocity) assert rt.EarthVelocity == pytest.approx(ens1.RangeTracking.EarthVelocity) assert nmea.nmea_sentences == ens1.NmeaData.nmea_sentences assert ss.BtSamplesPerSecond == pytest.approx( ens1.SystemSetup.BtSamplesPerSecond, 0.1) assert ss.BtSystemFreqHz == pytest.approx(ens1.SystemSetup.BtSystemFreqHz, 0.1) assert ss.BtCPCE == pytest.approx(ens1.SystemSetup.BtCPCE, 0.1) assert ss.BtNCE == pytest.approx(ens1.SystemSetup.BtNCE, 0.1) assert ss.BtRepeatN == pytest.approx(ens1.SystemSetup.BtRepeatN, 0.1) assert ss.WpSamplesPerSecond == pytest.approx( ens1.SystemSetup.WpSamplesPerSecond, 0.1) assert ss.WpSystemFreqHz == pytest.approx(ens1.SystemSetup.WpSystemFreqHz, 0.1) assert ss.WpCPCE == pytest.approx(ens1.SystemSetup.WpCPCE, 0.1) assert ss.WpNCE == pytest.approx(ens1.SystemSetup.WpNCE, 0.1) assert ss.WpRepeatN == pytest.approx(ens1.SystemSetup.WpRepeatN, 0.1) assert ss.WpLagSamples == pytest.approx(ens1.SystemSetup.WpLagSamples, 0.1) assert ss.Voltage == pytest.approx(ens1.SystemSetup.Voltage, 0.1) assert ss.XmtVoltage == pytest.approx(ens1.SystemSetup.XmtVoltage, 0.1) assert ss.BtBroadband == pytest.approx(ens1.SystemSetup.BtBroadband, 0.1) assert ss.BtLagLength == pytest.approx(ens1.SystemSetup.BtLagLength, 0.1) assert ss.BtNarrowband == pytest.approx(ens1.SystemSetup.BtNarrowband, 0.1) assert ss.BtBeamMux == pytest.approx(ens1.SystemSetup.BtBeamMux, 0.1) assert ss.WpBroadband == pytest.approx(ens1.SystemSetup.WpBroadband, 0.1) assert ss.WpLagLength == pytest.approx(ens1.SystemSetup.WpLagLength, 0.1) assert ss.WpTransmitBandwidth == pytest.approx( ens1.SystemSetup.WpTransmitBandwidth, 0.1) assert ss.WpReceiveBandwidth == pytest.approx( ens1.SystemSetup.WpReceiveBandwidth, 0.1)
def test_encode_csv_no_anc(): num_bins = 33 num_beams = 4 ens = Ensemble() amp = Amplitude(num_bins, num_beams) corr = Correlation(num_bins, num_beams) beam_vel = BeamVelocity(num_bins, num_beams) inst_vel = InstrumentVelocity(num_bins, num_beams) earth_vel = EarthVelocity(num_bins, num_beams) gb = GoodBeam(num_bins, num_beams) ge = GoodEarth(num_bins, num_beams) anc = AncillaryData() ensData = EnsembleData() ss = SystemSetup() bt = BottomTrack() bt.NumBeams = 4 bt.Range = [1.1, 2.2, 3.3, 4.4] bt.SNR = [1.1, 2.2, 3.3, 4.4] bt.Amplitude = [1.1, 2.2, 3.3, 4.4] bt.Correlation = [1.1, 2.2, 3.3, 4.4] bt.BeamVelocity = [1.1, 2.2, 3.3, 4.4] bt.BeamGood = [1, 2, 3, 4] bt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4] bt.InstrumentGood = [1, 2, 3, 4] bt.EarthVelocity = [1.1, 2.2, 3.3, 4.4] bt.EarthGood = [1, 2, 3, 4] bt.SNR_PulseCoherent = [1, 2, 3, 4] bt.Amp_PulseCoherent = [1, 2, 3, 4] bt.Vel_PulseCoherent = [1, 2, 3, 4] bt.Noise_PulseCoherent = [1, 2, 3, 4] bt.Corr_PulseCoherent = [1, 2, 3, 4] rt = RangeTracking() rt.NumBeams = 4.0 rt.Range = [1.1, 2.2, 3.3, 4.4] rt.Pings = [1, 2, 3, 4] rt.SNR = [1.1, 2.2, 3.3, 4.4] rt.Amplitude = [1.1, 2.2, 3.3, 4.4] rt.Correlation = [1.1, 2.2, 3.3, 4.4] rt.BeamVelocity = [1.1, 2.2, 3.3, 4.4] rt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4] rt.EarthVelocity = [1.1, 2.2, 3.3, 4.4] ens.AddAmplitude(amp) ens.AddCorrelation(corr) ens.AddBeamVelocity(beam_vel) ens.AddInstrumentVelocity(inst_vel) ens.AddEarthVelocity(earth_vel) ens.AddGoodBeam(gb) ens.AddGoodEarth(ge) ens.AddAncillaryData(anc) ens.AddEnsembleData(ensData) ens.AddBottomTrack(bt) ens.AddRangeTracking(rt) ens.AddSystemSetup(ss) results = ens.encode_csv(is_ancillary_data=False) total_lines = num_bins * num_beams * 7 total_lines += num_bins * 2 # Mag and Direction in EarthVelocity total_lines += 6 + (num_beams * 7) # Bottom Track total_lines += 1 # Ensemble Data #total_lines += 10 # Ancillary Data total_lines += 5 * num_beams # Range Tracking total_lines += 1 # System Settings assert len(results) == total_lines
def decode_data_sets(ens): """ Decode the datasets in the ensemble. Use verify_ens_data if you are using this as a static method to verify the data is correct. :param ens: Ensemble data. Decode the dataset. :return: Return the decoded ensemble. """ #print(ens) packetPointer = Ensemble().HeaderSize type = 0 numElements = 0 elementMultiplier = 0 imag = 0 nameLen = 0 name = "" dataSetSize = 0 ens_len = len(ens) # Create the ensemble ensemble = Ensemble() # Add the raw data to the ensemble #ensemble.AddRawData(ens) try: # Decode the ensemble datasets for x in range(Ensemble().MaxNumDataSets): # Check if we are at the end of the payload if packetPointer >= ens_len - Ensemble.ChecksumSize - Ensemble.HeaderSize: break try: # Get the dataset info ds_type = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 0), Ensemble().BytesInInt32, ens) num_elements = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 1), Ensemble().BytesInInt32, ens) element_multiplier = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 2), Ensemble().BytesInInt32, ens) image = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 3), Ensemble().BytesInInt32, ens) name_len = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 4), Ensemble().BytesInInt32, ens) name = str(ens[packetPointer+(Ensemble.BytesInInt32 * 5):packetPointer+(Ensemble.BytesInInt32 * 5)+8], 'UTF-8') except Exception as e: logging.warning("Bad Ensemble header" + str(e)) break # Calculate the dataset size data_set_size = Ensemble.GetDataSetSize(ds_type, name_len, num_elements, element_multiplier) # Beam Velocity if "E000001" in name: logging.debug(name) bv = BeamVelocity(num_elements, element_multiplier) bv.decode(ens[packetPointer:packetPointer+data_set_size]) ensemble.AddBeamVelocity(bv) # Instrument Velocity if "E000002" in name: logging.debug(name) iv = InstrumentVelocity(num_elements, element_multiplier) iv.decode(ens[packetPointer:packetPointer+data_set_size]) ensemble.AddInstrumentVelocity(iv) # Earth Velocity if "E000003" in name: logging.debug(name) ev = EarthVelocity(num_elements, element_multiplier) ev.decode(ens[packetPointer:packetPointer+data_set_size]) ensemble.AddEarthVelocity(ev) # Amplitude if "E000004" in name: logging.debug(name) amp = Amplitude(num_elements, element_multiplier) amp.decode(ens[packetPointer:packetPointer+data_set_size]) ensemble.AddAmplitude(amp) # Correlation if "E000005" in name: logging.debug(name) corr = Correlation(num_elements, element_multiplier) corr.decode(ens[packetPointer:packetPointer+data_set_size]) ensemble.AddCorrelation(corr) # Good Beam if "E000006" in name: logging.debug(name) gb = GoodBeam(num_elements, element_multiplier) gb.decode(ens[packetPointer:packetPointer+data_set_size]) ensemble.AddGoodBeam(gb) # Good Earth if "E000007" in name: logging.debug(name) ge = GoodEarth(num_elements, element_multiplier) ge.decode(ens[packetPointer:packetPointer+data_set_size]) ensemble.AddGoodEarth(ge) # Ensemble Data if "E000008" in name: logging.debug(name) ed = EnsembleData(num_elements, element_multiplier) ed.decode(ens[packetPointer:packetPointer+data_set_size]) ensemble.AddEnsembleData(ed) # Ancillary Data if "E000009" in name: logging.debug(name) ad = AncillaryData(num_elements, element_multiplier) ad.decode(ens[packetPointer:packetPointer+data_set_size]) ensemble.AddAncillaryData(ad) # Bottom Track if "E000010" in name: logging.debug(name) bt = BottomTrack(num_elements, element_multiplier) bt.decode(ens[packetPointer:packetPointer + data_set_size]) ensemble.AddBottomTrack(bt) # NMEA data if "E000011" in name: logging.debug(name) nd = NmeaData(num_elements, element_multiplier) nd.decode(ens[packetPointer:packetPointer + data_set_size]) ensemble.AddNmeaData(nd) # System Setup if "E000014" in name: logging.debug(name) ss = SystemSetup(num_elements, element_multiplier) ss.decode(ens[packetPointer:packetPointer + data_set_size]) ensemble.AddSystemSetup(ss) # Range Tracking if "E000015" in name: logging.debug(name) rt = RangeTracking(num_elements, element_multiplier) rt.decode(ens[packetPointer:packetPointer + data_set_size]) ensemble.AddRangeTracking(rt) # Move to the next dataset packetPointer += data_set_size except Exception as e: logging.warning("Error decoding the ensemble. " + str(e)) return None return ensemble
def test_velocities(): vels = EarthVelocity(30, 4) # Populate data val = 1.0 for beam in range(vels.element_multiplier): for bin_num in range(vels.num_elements): vels.Velocities[bin_num][beam] = val val += 1.1 result = vels.encode() # Value type assert 0xA == result[0] assert 0x0 == result[1] assert 0x0 == result[2] assert 0x0 == result[3] # Num Elements assert 0x1E == result[4] assert 0x0 == result[5] assert 0x0 == result[6] assert 0x0 == result[7] # Element Multiplier assert 0x4 == result[8] assert 0x0 == result[9] assert 0x0 == result[10] assert 0x0 == result[11] # Imag assert 0x0 == result[12] assert 0x0 == result[13] assert 0x0 == result[14] assert 0x0 == result[15] # Name Length assert 0x8 == result[16] assert 0x0 == result[17] assert 0x0 == result[18] assert 0x0 == result[19] # Name assert ord('E') == result[20] assert ord('0') == result[21] assert ord('0') == result[22] assert ord('0') == result[23] assert ord('0') == result[24] assert ord('0') == result[25] assert ord('3') == result[26] assert ord('\0') == result[27] # Length assert len(result) == 28 + ( (vels.element_multiplier * vels.num_elements) * Ensemble.BytesInFloat) # Beam Velocities data result_val = 1.0 index = 28 # 28 = Header size for beam in range(vels.element_multiplier): for bin_num in range(vels.num_elements): test_val = Ensemble.GetFloat(index, Ensemble().BytesInFloat, bytearray(result)) assert result_val == pytest.approx(test_val, 0.1) result_val += 1.1 index += Ensemble().BytesInFloat
def test_calc_discharge(): ens = Ensemble() ens_data = EnsembleData() ens_data.NumBeams = 4 ens_data.NumBins = 4 ens.AddEnsembleData(ens_data) anc = AncillaryData() anc.BinSize = 1 anc.FirstBinRange = 0.5 ens.AddAncillaryData(anc) vel = EarthVelocity(4, 4) vel.Velocities[0][0] = 1.0 vel.Velocities[0][1] = 1.1 vel.Velocities[0][2] = 0.2 vel.Velocities[0][3] = 0.0 vel.Velocities[1][0] = 1.1 vel.Velocities[1][1] = 1.2 vel.Velocities[1][2] = 0.3 vel.Velocities[1][3] = 0.0 vel.Velocities[2][0] = 1.2 vel.Velocities[2][1] = 1.3 vel.Velocities[2][2] = 0.4 vel.Velocities[2][3] = 0.0 vel.Velocities[3][0] = 1.4 vel.Velocities[3][1] = 1.5 vel.Velocities[3][2] = 0.6 vel.Velocities[3][3] = 0.0 ens.AddEarthVelocity(vel) bt = BottomTrack() bt.NumBeams = 4 bt.Range = [23.5, 24.2, 22.4, 26.1] ens.AddBottomTrack(bt) discharge = CalcDischarge() boat_draft = 0.1 beam_angle = 20 pulse_length = 0.8 pulse_lag = 0.1 bt_east = 0.9 bt_north = 0.9 bt_vert = 0.1 delta_time = 0.15 top_flow_mode = FlowMode.Constants top_pwr_func_exponent = CalcDischarge.ONE_SIXTH_POWER_LAW bottom_flow_mode = FlowMode.PowerFunction result = discharge.calculate_ensemble_flow(ens, boat_draft, beam_angle, pulse_length, pulse_lag, bt_east, bt_north, bt_vert, delta_time, top_flow_mode, top_pwr_func_exponent, bottom_flow_mode) assert result.valid == True assert -0.2284 == pytest.approx(result.bottom_flow, 0.001) assert -0.00135 == pytest.approx(result.top_flow, 0.001) assert -0.054 == pytest.approx(result.measured_flow, 0.001)
def test_write_binary(): num_bins = 33 num_beams = 4 ens = Ensemble() ens_ds = EnsembleData() ens_ds.EnsembleNumber = 2668 ens_ds.NumBins = 33 ens_ds.NumBeams = 4 ens_ds.DesiredPingCount = 45 ens_ds.ActualPingCount = 46 ens_ds.SerialNumber = "01H00000000000000000000000999999" ens_ds.SysFirmwareMajor = 2 ens_ds.SysFirmwareMinor = 11 ens_ds.SysFirmwareRevision = 5 ens_ds.SysFirmwareSubsystemCode = "A" ens_ds.SubsystemConfig = 3 ens_ds.Status = 9 ens_ds.Year = 2019 ens_ds.Month = 3 ens_ds.Day = 9 ens_ds.Hour = 12 ens_ds.Minute = 23 ens_ds.Second = 24 ens_ds.HSec = 33 anc = AncillaryData() anc.FirstBinRange = 1.0 # Blank. Depth to the first bin in meters. anc.BinSize = 3.0 # Size of a bin in meters. anc.FirstPingTime = 1.2 # First Ping Time in seconds. anc.LastPingTime = 2.3 # Last Ping Time in seconds. (If averaging pings, this will be the last ping) anc.Heading = 23.5 # Heading in degrees. anc.Pitch = 13.6 # Pitch in degrees. anc.Roll = 11.25 # Roll in degrees. anc.WaterTemp = 25.3 # Water Temperature in fahrenheit anc.SystemTemp = 54.6 # System Temperature in fahrenheit anc.Salinity = 35.0 # Water Salinity set by the user in PPT anc.Pressure = 23.78 # Pressure from pressure sensor in Pascals anc.TransducerDepth = 45.69 # Transducer Depth, used by Pressure sensor in meters anc.SpeedOfSound = 1400.23 # Speed of Sound in m/s. anc.RawMagFieldStrength = 3.0 # Raw magnetic field strength anc.PitchGravityVector = 4.0 # Pitch Gravity Vector anc.RollGravityVector = 5.0 # Roll Gravity Vector anc.VerticalGravityVector = 6.0 # Vertical Gravity Vector amp = Amplitude(num_bins, num_beams) corr = Correlation(num_bins, num_beams) beam_vel = BeamVelocity(num_bins, num_beams) inst_vel = InstrumentVelocity(num_bins, num_beams) earth_vel = EarthVelocity(num_bins, num_beams) gb = GoodBeam(num_bins, num_beams) ge = GoodEarth(num_bins, num_beams) val = 1.0 for beam in range(amp.element_multiplier): for bin_num in range(amp.num_elements): amp.Amplitude[bin_num][beam] = val corr.Correlation[bin_num][beam] = val beam_vel.Velocities[bin_num][beam] = val inst_vel.Velocities[bin_num][beam] = val earth_vel.Velocities[bin_num][beam] = val gb.GoodBeam[bin_num][beam] = 1 * int(beam) ge.GoodEarth[bin_num][beam] = 1 * int(beam) val += 1.1 bt = BottomTrack() bt.FirstPingTime = 12.5 bt.LastPingTime = 12.8 bt.Heading = 152.36 bt.Pitch = 12.6 bt.Roll = 223.1 bt.WaterTemp = 15.23 bt.SystemTemp = 78.58 bt.Salinity = 35.0 bt.Pressure = 23.36 bt.TransducerDepth = 156.2 bt.SpeedOfSound = 1402.36 bt.Status = 9.0 bt.NumBeams = 4.0 bt.ActualPingCount = 23 bt.Range = [1.1, 2.2, 3.3, 4.4] bt.SNR = [1.1, 2.2, 3.3, 4.4] bt.Amplitude = [1.1, 2.2, 3.3, 4.4] bt.Correlation = [1.1, 2.2, 3.3, 4.4] bt.BeamVelocity = [1.1, 2.2, 3.3, 4.4] bt.BeamGood = [1, 2, 3, 4] bt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4] bt.InstrumentGood = [1, 2, 3, 4] bt.EarthVelocity = [1.1, 2.2, 3.3, 4.4] bt.EarthGood = [1, 2, 3, 4] bt.SNR_PulseCoherent = [1, 2, 3, 4] bt.Amp_PulseCoherent = [1, 2, 3, 4] bt.Vel_PulseCoherent = [1, 2, 3, 4] bt.Noise_PulseCoherent = [1, 2, 3, 4] bt.Corr_PulseCoherent = [1, 2, 3, 4] rt = RangeTracking() rt.NumBeams = 4.0 rt.Range = [1.1, 2.2, 3.3, 4.4] rt.Pings = [1, 2, 3, 4] rt.SNR = [1.1, 2.2, 3.3, 4.4] rt.Amplitude = [1.1, 2.2, 3.3, 4.4] rt.Correlation = [1.1, 2.2, 3.3, 4.4] rt.BeamVelocity = [1.1, 2.2, 3.3, 4.4] rt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4] rt.EarthVelocity = [1.1, 2.2, 3.3, 4.4] nmea = NmeaData() nmea.add_nmea("$HEHDT,244.39,T*17\n") nmea.add_nmea( "$GPGGA,195949.00,3254.8103248,N,11655.5779629,W,2,08,1.1,222.174,M,-32.602,M,6.0,0138*75\n" ) nmea.add_nmea("$GPVTG,306.20,T,294.73,M,0.13,N,0.24,K,D*2E\n") nmea.add_nmea("$HEHDT,244.36,T*18\n") ss = SystemSetup() ss.BtSamplesPerSecond = 1.0 ss.BtSystemFreqHz = 3.0 ss.BtCPCE = 1.2 ss.BtNCE = 2.3 ss.BtRepeatN = 23.5 ss.WpSamplesPerSecond = 13.6 ss.WpSystemFreqHz = 11.25 ss.WpCPCE = 25.3 ss.WpNCE = 54.6 ss.WpRepeatN = 35.0 ss.WpLagSamples = 23.78 ss.Voltage = 45.69 ss.XmtVoltage = 1400.23 ss.BtBroadband = 3.0 ss.BtLagLength = 4.0 ss.BtNarrowband = 5.0 ss.BtBeamMux = 6.0 ss.WpBroadband = 6.0 ss.WpLagLength = 6.0 ss.WpTransmitBandwidth = 6.0 ss.WpReceiveBandwidth = 6.0 ens.AddAmplitude(amp) ens.AddCorrelation(corr) ens.AddBeamVelocity(beam_vel) ens.AddInstrumentVelocity(inst_vel) ens.AddEarthVelocity(earth_vel) ens.AddGoodBeam(gb) ens.AddGoodEarth(ge) ens.AddAncillaryData(anc) ens.AddEnsembleData(ens_ds) ens.AddBottomTrack(bt) ens.AddRangeTracking(rt) ens.AddSystemSetup(ss) ens.AddNmeaData(nmea) rti_writer = RtiBinaryWriter("C:\RTI_capture") for ens_count in range(0, 100): bin_data = ens.encode() rti_writer.write(bin_data) ens.EnsembleData.EnsembleNumber += 1 rti_writer.close()