def test_svcorrect_module(self):
dset = load_dataset(RealFqpr())
multibeam = dset.raw_ping[0].isel(time=0).expand_dims('time')
cast = json.loads(multibeam.profile_1495599960)
beam_azimuth = xr.DataArray(data=expected_beam_azimuth,
dims=['time', 'beam'],
coords={
'time': multibeam.time.values,
'beam': multibeam.beam.values
})
beam_angle = xr.DataArray(data=expected_corrected_beam_angles,
dims=['time', 'beam'],
coords={
'time': multibeam.time.values,
'beam': multibeam.beam.values
})
traveltime = multibeam.traveltime
surface_ss = multibeam.soundspeed
installation_params_time = list(dset.xyzrph['tx_r'].keys())[0]
waterline = float(dset.xyzrph['waterline'][installation_params_time])
additional_offsets = np.array([[0], [0], [0]])
alongtrack, acrosstrack, depth = run_ray_trace_v2(
cast, beam_azimuth, beam_angle, traveltime, surface_ss, waterline,
additional_offsets)
assert np.array_equal(alongtrack, expected_alongtrack)
assert np.array_equal(acrosstrack, expected_acrosstrack)
assert np.array_equal(depth, expected_depth)
def test_orientation_module(self):
dset = load_dataset(RealFqpr())
raw_attitude = dset.raw_att
# expand_dims required to maintain the time dimension metadata when you select only one value
multibeam = dset.raw_ping[0].isel(time=0).expand_dims('time')
traveltime = multibeam.traveltime
delay = multibeam.delay
timestamps = multibeam.time
installation_params_time = list(dset.xyzrph['tx_r'].keys())[0]
tx_orientation = [
np.array(
[1, 0,
0]), # starting vector for the tx transducer (points forward)
dset.xyzrph['tx_r']
[installation_params_time], # roll mounting angle for tx
dset.xyzrph['tx_p']
[installation_params_time], # pitch mounting angle for tx
dset.xyzrph['tx_h']
[installation_params_time], # yaw mounting angle for tx
installation_params_time
] # time stamp for the installation parameters record
rx_orientation = [
np.array([0, 1, 0]), # same but for the receiver
dset.xyzrph['rx_r'][installation_params_time],
dset.xyzrph['rx_p'][installation_params_time],
dset.xyzrph['rx_h'][installation_params_time],
installation_params_time
]
latency = 0 # no latency applied for this test
calc_tx_vector, calc_rx_vector = build_orientation_vectors(
raw_attitude, traveltime, delay, timestamps, tx_orientation,
rx_orientation, latency)
try:
assert np.array_equal(calc_tx_vector.values, expected_tx_vector)
except AssertionError:
print(
'Falling back to approx, should only be seen in TravisCI environment in my experience'
)
# use approx here, I get ever so slightly different answers in the Travis CI environment
assert calc_tx_vector.values == pytest.approx(
expected_tx_vector, 0.000001)
try:
assert np.array_equal(calc_rx_vector.values, expected_rx_vector)
except AssertionError:
print(
'Falling back to approx, should only be seen in TravisCI environment in my experience'
)
# use approx here, I get ever so slightly different answers in the Travis CI environment
assert calc_rx_vector.values == pytest.approx(
expected_rx_vector, 0.000001)
def test_beampointingvector_module(self):
dset = load_dataset(RealFqpr())
raw_attitude = dset.raw_att
heading = raw_attitude.heading
multibeam = dset.raw_ping[0].isel(time=0).expand_dims('time')
beampointingangle = multibeam.beampointingangle
tiltangle = multibeam.tiltangle
ping_time_heading = heading.interp_like(beampointingangle)
tx_vecs = xr.DataArray(data=expected_tx_vector,
dims=['time', 'beam', 'xyz'],
coords={
'time': multibeam.time.values,
'beam': multibeam.beam.values,
'xyz': ['x', 'y', 'z']
})
rx_vecs = xr.DataArray(data=expected_rx_vector,
dims=['time', 'beam', 'xyz'],
coords={
'time': multibeam.time.values,
'beam': multibeam.beam.values,
'xyz': ['x', 'y', 'z']
})
tx_reversed = False
rx_reversed = False
beam_azimuth, corrected_beam_angle = build_beam_pointing_vectors(
ping_time_heading, beampointingangle, tiltangle, tx_vecs, rx_vecs,
tx_reversed, rx_reversed)
try:
assert np.array_equal(beam_azimuth.values, expected_beam_azimuth)
except AssertionError:
print(
'Falling back to approx, should only be seen in TravisCI environment in my experience'
)
# use approx here, I get ever so slightly different answers in the Travis CI environment
assert beam_azimuth.values == pytest.approx(
expected_beam_azimuth, 0.000001)
try:
assert np.array_equal(corrected_beam_angle.values,
expected_corrected_beam_angles)
except AssertionError:
print(
'Falling back to approx, should only be seen in TravisCI environment in my experience'
)
# use approx here, I get ever so slightly different answers in the Travis CI environment
assert corrected_beam_angle.values == pytest.approx(
expected_corrected_beam_angles, 0.000001)
def test_tpu(self):
dset = load_dataset(RealFqpr())
multibeam = dset.raw_ping[0].isel(time=0).expand_dims('time')
qf = multibeam.qualityfactor
tpu = dset.return_tpu_parameters(
list(dset.xyzrph['waterline'].keys())[0])
surface_ss = multibeam.soundspeed
beampointingangle = multibeam.beampointingangle
corr_beam_angle = xr.DataArray(data=expected_corrected_beam_angles,
dims=['time', 'beam'],
coords={
'time': multibeam.time.values,
'beam': multibeam.beam.values
})
x = xr.DataArray(data=expected_alongtrack,
dims=['time', 'beam'],
coords={
'time': multibeam.time.values,
'beam': multibeam.beam.values
})
z = xr.DataArray(data=expected_depth,
dims=['time', 'beam'],
coords={
'time': multibeam.time.values,
'beam': multibeam.beam.values
})
raw_attitude = dset.raw_att
roll = raw_attitude['roll'].interp_like(beampointingangle)
tvu, thu = calculate_tpu(roll,
beampointingangle,
corr_beam_angle,
x,
z,
surface_ss,
tpu_dict=tpu,
quality_factor=qf,
vert_ref='waterline')
assert np.array_equal(thu, expected_thu)
assert np.array_equal(tvu, expected_tvu)
def test_interp_across_chunks(self):
synth = load_dataset(RealFqpr(), skip_dask=False)
# 11 attitude values, chunking by 4 gives us three chunks
# att.chunks
# Out[10]: Frozen(SortedKeysDict({'time': (4, 4, 3)}))
att = synth.raw_att.chunk(4)
times_interp_to = xr.DataArray(
np.array([1495563084.455, 1495563084.490, 1495563084.975]),
dims={'time'},
coords={
'time':
np.array([1495563084.455, 1495563084.490, 1495563084.975])
})
dask_interp_att = interp_across_chunks(att,
times_interp_to,
dimname='time',
daskclient=synth.client)
interp_att = interp_across_chunks(att, times_interp_to, dimname='time')
expected_att = xr.Dataset(
{
'heading':
(['time'],
np.array([
307.8539977551496, 307.90348427192055, 308.6139892100822
])),
'heave': (['time'],
np.array([
0.009999999776482582, 0.009608692733222632,
-0.009999999776482582
])),
'roll': (['time'],
np.array([
0.4400004684929343, 0.07410809820512047,
-4.433999538421631
])),
'pitch':
(['time'],
np.array([-0.5, -0.5178477924436871, -0.3760000467300415]))
},
coords={
'time':
np.array([1495563084.455, 1495563084.49, 1495563084.975])
})
# make sure the dask/non-dask methods line up
assert dask_interp_att.time.values == approx(interp_att.time.values,
0.001)
assert dask_interp_att.heading.values == approx(
interp_att.heading.values, 0.001)
assert dask_interp_att.heave.values == approx(interp_att.heave.values,
0.001)
assert dask_interp_att.pitch.values == approx(interp_att.pitch.values,
0.001)
assert dask_interp_att['roll'].values == approx(
interp_att['roll'].values, 0.001)
# make sure the values line up with what we would expect
assert dask_interp_att.time.values == approx(expected_att.time.values,
0.001)
assert dask_interp_att.heading.values == approx(
expected_att.heading.values, 0.001)
assert dask_interp_att.heave.values == approx(
expected_att.heave.values, 0.001)
assert dask_interp_att.pitch.values == approx(
expected_att.pitch.values, 0.001)
assert dask_interp_att['roll'].values == approx(
expected_att['roll'].values, 0.001)
print('Passed: interp_across_chunks')
def setUpClass(cls) -> None:
cls.dset = load_dataset(RealFqpr())