def test_rotate_inst2beam(make_data=False):
td = load('RDI_test01_rotate_beam2inst.nc')
rotate2(td, 'beam', inplace=True)
td_awac = load('AWAC_test01_earth2inst.nc')
rotate2(td_awac, 'beam', inplace=True)
td_sig = load('BenchFile01_rotate_beam2inst.nc')
rotate2(td_sig, 'beam', inplace=True)
td_sig_i = load('Sig1000_IMU_rotate_beam2inst.nc')
rotate2(td_sig_i, 'beam', inplace=True)
td_sig_ie = load('Sig500_Echo_earth2inst.nc')
rotate2(td_sig_ie, 'beam', inplace=True)
if make_data:
save(td_awac, 'AWAC_test01_inst2beam.nc')
save(td_sig_ie, 'Sig500_Echo_inst2beam.nc')
return
cd_td = tr.dat_rdi.copy(deep=True)
cd_awac = load('AWAC_test01_inst2beam.nc')
cd_sig = tr.dat_sig.copy(deep=True)
cd_sig_i = tr.dat_sig_i.copy(deep=True)
cd_sig_ie = load('Sig500_Echo_inst2beam.nc')
# # The reverse RDI rotation doesn't work b/c of NaN's in one beam
# # that propagate to others, so we impose that here.
cd_td['vel'].values[:, np.isnan(cd_td['vel'].values).any(0)] = np.NaN
assert_allclose(td, cd_td, atol=1e-5)
assert_allclose(td_awac, cd_awac, atol=1e-5)
assert_allclose(td_sig, cd_sig, atol=1e-5)
assert_allclose(td_sig_i, cd_sig_i, atol=1e-5)
assert_allclose(td_sig_ie, cd_sig_ie, atol=1e-5)
def test_sep_probes(make_data=False):
tdm = tv.dat_imu.copy(deep=True)
tdm = avm.correct_motion(tdm, separate_probes=True)
if make_data:
save(tdm, 'vector_data_imu01_mcsp.nc')
return
assert_allclose(tdm, load('vector_data_imu01_mcsp.nc'), atol=1e-7)
def test_rotate_beam2inst():
td = load('vector_data01_rotate_inst2beam.nc')
rotate2(td, 'inst', inplace=True)
tdm = load('vector_data_imu01_rotate_inst2beam.nc')
rotate2(tdm, 'inst', inplace=True)
cd = tr.dat.copy(deep=True)
cdm = tr.dat_imu.copy(deep=True)
assert_allclose(td, cd, atol=1e-6)
assert_allclose(tdm, cdm, atol=1e-6)
def test_spike_thresh(make_data=False):
td = tv.dat_imu.copy(deep=True)
mask = avm.clean.spike_thresh(td.vel, thresh=10)
td['vel'] = avm.clean.clean_fill(td.vel, mask, method='cubic')
if make_data:
save(td, 'vector_data01_sclean.nc')
return
assert_allclose(td, load('vector_data01_sclean.nc'), atol=1e-6)
def test_range_limit(make_data=False):
td = tv.dat_imu.copy(deep=True)
mask = avm.clean.range_limit(td.vel)
td['vel'] = avm.clean.clean_fill(td.vel, mask, method='cubic')
if make_data:
save(td, 'vector_data01_rclean.nc')
return
assert_allclose(td, load('vector_data01_rclean.nc'), atol=1e-6)
def test_rotate_earth2inst():
td_rdi = load('RDI_test01_rotate_inst2earth.nc')
rotate2(td_rdi, 'inst', inplace=True)
tdwr2 = load('winriver02_rotate_ship2earth.nc')
rotate2(tdwr2, 'inst', inplace=True)
td_awac = tr.dat_awac.copy(deep=True)
rotate2(td_awac, 'inst', inplace=True) # AWAC is in earth coords
td_sig = load('BenchFile01_rotate_inst2earth.nc')
rotate2(td_sig, 'inst', inplace=True)
td_sig_i = load('Sig1000_IMU_rotate_inst2earth.nc')
rotate2(td_sig_i, 'inst', inplace=True)
cd_rdi = load('RDI_test01_rotate_beam2inst.nc')
cd_wr2 = tr.dat_wr2
# ship and inst are considered equivalent in dolfy
cd_wr2.attrs['coord_sys'] = 'inst'
cd_awac = load('AWAC_test01_earth2inst.nc')
cd_sig = load('BenchFile01_rotate_beam2inst.nc')
cd_sig_i = load('Sig1000_IMU_rotate_beam2inst.nc')
assert_allclose(td_rdi, cd_rdi, atol=1e-5)
assert_allclose(tdwr2, cd_wr2, atol=1e-5)
assert_allclose(td_awac, cd_awac, atol=1e-5)
assert_allclose(td_sig, cd_sig, atol=1e-5)
# known failure due to orientmat, see test_vs_nortek
#assert_allclose(td_sig_i, cd_sig_i, atol=1e-3)
npt.assert_allclose(td_sig_i.accel.values,
cd_sig_i.accel.values,
atol=1e-3)
def test_heading(make_data=False):
td = tr.dat_imu.copy(deep=True)
head, pitch, roll = orient2euler(td)
td['pitch'].values = pitch
td['roll'].values = roll
td['heading'].values = head
if make_data:
save(td, 'vector_data_imu01_head_pitch_roll.nc')
return
cd = load('vector_data_imu01_head_pitch_roll.nc')
assert_allclose(td, cd, atol=1e-6)
def test_rotate_earth2inst():
td = load('vector_data01_rotate_inst2earth.nc')
rotate2(td, 'inst', inplace=True)
tdm = load('vector_data_imu01_rotate_inst2earth.nc')
rotate2(tdm, 'inst', inplace=True)
cd = tr.dat.copy(deep=True)
cdm = tr.dat_imu.copy(deep=True)
# The heading/pitch/roll data gets modified during rotation, so it
# doesn't go back to what it was.
cdm = cdm.drop_vars(['heading', 'pitch', 'roll'])
tdm = tdm.drop_vars(['heading', 'pitch', 'roll'])
assert_allclose(td, cd, atol=1e-6)
assert_allclose(tdm, cdm, atol=1e-6)
def test_rotate_earth2principal_set_declination():
declin = 3.875
td = load('vector_data01_rotate_inst2earth.nc')
td0 = td.copy(deep=True)
td.attrs['principal_heading'] = calc_principal_heading(td['vel'])
rotate2(td, 'principal', inplace=True)
set_declination(td, declin, inplace=True)
rotate2(td, 'earth', inplace=True)
set_declination(td0, -1, inplace=True)
set_declination(td0, declin, inplace=True)
td0.attrs['principal_heading'] = calc_principal_heading(td0['vel'])
rotate2(td0, 'earth', inplace=True)
assert_allclose(td0, td, atol=1e-6)
def test_rotate_inst2beam(make_data=False):
td = tr.dat.copy(deep=True)
rotate2(td, 'beam', inplace=True)
tdm = tr.dat_imu.copy(deep=True)
rotate2(tdm, 'beam', inplace=True)
if make_data:
save(td, 'vector_data01_rotate_inst2beam.nc')
save(tdm, 'vector_data_imu01_rotate_inst2beam.nc')
return
cd = load('vector_data01_rotate_inst2beam.nc')
cdm = load('vector_data_imu01_rotate_inst2beam.nc')
assert_allclose(td, cd, atol=1e-6)
assert_allclose(tdm, cdm, atol=1e-6)
def test_orient_filter(make_data=False):
td_sig = tp.dat_sig_i.copy(deep=True)
td_sig = apm.clean.medfilt_orient(td_sig)
apm.rotate2(td_sig, 'earth', inplace=True)
td_rdi = tp.dat_rdi.copy(deep=True)
td_rdi = apm.clean.medfilt_orient(td_rdi)
apm.rotate2(td_rdi, 'earth', inplace=True)
if make_data:
save(td_sig, 'Sig1000_IMU_ofilt.nc')
save(td_rdi, 'RDI_test01_ofilt.nc')
return
assert_allclose(td_sig, load('Sig1000_IMU_ofilt.nc'), atol=1e-6)
assert_allclose(td_rdi, load('RDI_test01_ofilt.nc'), atol=1e-6)
def test_do_func(make_data=False):
dat_vec = adv_setup(tv)
adat_vec = dat_vec.avg_tool.do_avg(dat_vec.dat1)
adat_vec = dat_vec.avg_tool.do_var(dat_vec.dat1, adat_vec)
adat_vec = dat_vec.avg_tool.do_tke(dat_vec.dat1, adat_vec)
dat_sig = adp_setup(tr)
adat_sig = dat_sig.avg_tool.do_avg(dat_sig.dat)
adat_sig = dat_sig.avg_tool.do_var(dat_sig.dat, adat_sig)
if make_data:
save(adat_vec, 'vector_data01_avg.nc')
save(adat_sig, 'BenchFile01_avg.nc')
return
assert_allclose(adat_vec, load('vector_data01_avg.nc'), atol=1e-6)
assert_allclose(adat_sig, load('BenchFile01_avg.nc'), atol=1e-6)
def test_nortek2_crop(make_data=False):
# Test file cropping function
crop_ensembles(infile=tb.exdt('Sig500_Echo.ad2cp'),
outfile=tb.exdt('Sig500_Echo_crop.ad2cp'),
range=[50, 100])
td_sig_ie_crop = tb.drop_config(read('Sig500_Echo_crop.ad2cp'))
if make_data:
save(td_sig_ie_crop, 'Sig500_Echo_crop.nc')
return
os.remove(tb.exdt('Sig500_Echo.ad2cp.index'))
os.remove(tb.exdt('Sig500_Echo_crop.ad2cp'))
os.remove(tb.exdt('Sig500_Echo_crop.ad2cp.index'))
cd_sig_ie_crop = load('Sig500_Echo_crop.nc')
assert_allclose(td_sig_ie_crop, cd_sig_ie_crop, atol=1e-6)
def test_rotate_earth2principal(make_data=False):
td = load('vector_data01_rotate_inst2earth.nc')
td.attrs['principal_heading'] = calc_principal_heading(td['vel'])
rotate2(td, 'principal', inplace=True)
tdm = load('vector_data_imu01_rotate_inst2earth.nc')
tdm.attrs['principal_heading'] = calc_principal_heading(tdm['vel'])
rotate2(tdm, 'principal', inplace=True)
if make_data:
save(td, 'vector_data01_rotate_earth2principal.nc')
save(tdm, 'vector_data_imu01_rotate_earth2principal.nc')
return
cd = load('vector_data01_rotate_earth2principal.nc')
cdm = load('vector_data_imu01_rotate_earth2principal.nc')
assert_allclose(td, cd, atol=1e-6)
assert_allclose(tdm, cdm, atol=1e-6)
def test_adv_turbulence(make_data=False):
dat = tv.dat.copy(deep=True)
bnr = avm.ADVBinner(n_bin=20.0, fs=dat.fs)
tdat = bnr(dat)
acov = bnr.calc_acov(dat.vel)
assert_identical(tdat, avm.calc_turbulence(dat, n_bin=20.0, fs=dat.fs))
tdat['LT83'] = bnr.calc_epsilon_LT83(tdat.psd, tdat.velds.U_mag)
tdat['SF'] = bnr.calc_epsilon_SF(dat.vel[0], tdat.velds.U_mag)
tdat['TE01'] = bnr.calc_epsilon_TE01(dat, tdat)
tdat['L'] = bnr.calc_L_int(acov, tdat.vel)
if make_data:
save(tdat, 'vector_data01_bin.nc')
return
assert_allclose(tdat, load('vector_data01_bin.nc'), atol=1e-6)
def test_GN2002(make_data=False):
td = tv.dat.copy(deep=True)
td_imu = tv.dat_imu.copy(deep=True)
td.vel[0, 50:65] = np.nan # fudge up some data
mask = avm.clean.GN2002(td.vel, npt=20)
td['vel'] = avm.clean.clean_fill(td.vel, mask, method='cubic')
mask = avm.clean.GN2002(td_imu.vel, npt=20)
td_imu['vel'] = avm.clean.clean_fill(td_imu.vel, mask, method='cubic')
if make_data:
save(td, 'vector_data01_GN.nc')
save(td_imu, 'vector_data_imu01_GN.nc')
return
assert_allclose(td, load('vector_data01_GN.nc'), atol=1e-6)
assert_allclose(td_imu, load('vector_data_imu01_GN.nc'), atol=1e-6)
def test_clean_upADCP(make_data=False):
td_awac = tp.dat_awac.copy(deep=True)
td_sig = tp.dat_sig_tide.copy(deep=True)
apm.clean.find_surface_from_P(td_awac, salinity=30)
td_awac = apm.clean.nan_beyond_surface(td_awac)
apm.clean.set_range_offset(td_sig, 0.6)
apm.clean.find_surface_from_P(td_sig, salinity=31)
td_sig = apm.clean.nan_beyond_surface(td_sig)
td_sig = apm.clean.correlation_filter(td_sig, thresh=50)
if make_data:
save(td_awac, 'AWAC_test01_clean.nc')
save(td_sig, 'Sig1000_tidal_clean.nc')
return
assert_allclose(td_awac, load('AWAC_test01_clean.nc'), atol=1e-6)
assert_allclose(td_sig, load('Sig1000_tidal_clean.nc'), atol=1e-6)
def test_clean_downADCP(make_data=False):
td = tp.dat_sig_ie.copy(deep=True)
# First remove bad data
td['vel'] = apm.clean.val_exceeds_thresh(td.vel, thresh=3)
td['vel'] = apm.clean.fillgaps_time(td.vel)
td['vel_b5'] = apm.clean.fillgaps_time(td.vel_b5)
td['vel'] = apm.clean.fillgaps_depth(td.vel)
td['vel_b5'] = apm.clean.fillgaps_depth(td.vel_b5)
# Then clean below seabed
apm.clean.set_range_offset(td, 0.5)
apm.clean.find_surface(td, thresh=10, nfilt=3)
td = apm.clean.nan_beyond_surface(td)
if make_data:
save(td, 'Sig500_Echo_clean.nc')
return
assert_allclose(td, load('Sig500_Echo_clean.nc'), atol=1e-6)
def test_rotate_earth2principal(make_data=False):
td_rdi = load('RDI_test01_rotate_inst2earth.nc')
td_sig = load('BenchFile01_rotate_inst2earth.nc')
td_awac = tr.dat_awac.copy(deep=True)
td_rdi.attrs['principal_heading'] = calc_principal_heading(
td_rdi.vel.mean('range'))
td_sig.attrs['principal_heading'] = calc_principal_heading(
td_sig.vel.mean('range'))
td_awac.attrs['principal_heading'] = calc_principal_heading(
td_awac.vel.mean('range'), tidal_mode=False)
rotate2(td_rdi, 'principal', inplace=True)
rotate2(td_sig, 'principal', inplace=True)
rotate2(td_awac, 'principal', inplace=True)
if make_data:
save(td_rdi, 'RDI_test01_rotate_earth2principal.nc')
save(td_sig, 'BenchFile01_rotate_earth2principal.nc')
save(td_awac, 'AWAC_test01_earth2principal.nc')
return
cd_rdi = load('RDI_test01_rotate_earth2principal.nc')
cd_sig = load('BenchFile01_rotate_earth2principal.nc')
cd_awac = load('AWAC_test01_earth2principal.nc')
assert_allclose(td_rdi, cd_rdi, atol=1e-5)
assert_allclose(td_awac, cd_awac, atol=1e-5)
assert_allclose(td_sig, cd_sig, atol=1e-5)
def test_matlab_io(make_data=False):
nens = 100
td_vec = drop_config(read('vector_data_imu01.VEC', nens=nens))
td_rdi_bt = drop_config(read('RDI_withBT.000', nens=nens))
# This read should trigger a warning about the declination being
# defined in two places (in the binary .ENX files), and in the
# .userdata.json file. NOTE: DOLfYN defaults to using what is in
# the .userdata.json file.
with pytest.warns(UserWarning, match='magnetic_var_deg'):
td_vm = drop_config(read('vmdas01.ENX', nens=nens))
if make_data:
save_matlab(td_vec, 'dat_vec')
save_matlab(td_rdi_bt, 'dat_rdi_bt')
save_matlab(td_vm, 'dat_vm')
return
mat_vec = load_matlab('dat_vec.mat')
mat_rdi_bt = load_matlab('dat_rdi_bt.mat')
mat_vm = load_matlab('dat_vm.mat')
assert_allclose(td_vec, mat_vec, atol=1e-6)
assert_allclose(td_rdi_bt, mat_rdi_bt, atol=1e-6)
assert_allclose(td_vm, mat_vm, atol=1e-6)
def test_calc_func(make_data=False):
dat_vec = adv_setup(tv)
test_ds = type(dat_vec.dat1)()
test_ds_demean = type(dat_vec.dat1)()
test_ds_dif = type(dat_vec.dat1)()
c = dat_vec.avg_tool
dat_adp = adp_setup(tr)
c2 = dat_adp.avg_tool
test_ds_adp = type(dat_adp.dat)()
test_ds['coh'] = c.calc_coh(
dat_vec.dat1.vel[0], dat_vec.dat1.vel[1], n_fft_coh=dat_vec.dat1.fs)
test_ds['pang'] = c.calc_phase_angle(
dat_vec.dat1.vel[0], dat_vec.dat1.vel[1], n_fft_coh=dat_vec.dat1.fs)
test_ds['xcov'] = c.calc_xcov(dat_vec.dat1.vel[0], dat_vec.dat1.vel[1])
test_ds['acov'] = c.calc_acov(dat_vec.dat1.vel)
test_ds['tke_vec'] = c.calc_tke(dat_vec.dat1.vel)
test_ds['stress'] = c.calc_stress(dat_vec.dat1.vel)
test_ds['psd'] = c.calc_psd(dat_vec.dat1.vel)
test_ds['csd'] = c.calc_csd(dat_vec.dat1.vel)
test_ds_demean['tke_vec'] = c.calc_tke(dat_vec.dat1.vel, detrend=False)
test_ds_demean['stress'] = c.calc_stress(dat_vec.dat1.vel, detrend=False)
# Different lengths
test_ds_dif['coh_dif'] = c.calc_coh(dat_vec.dat1.vel, dat_vec.dat2.vel)
test_ds_dif['pang_dif'] = c.calc_phase_angle(
dat_vec.dat1.vel, dat_vec.dat2.vel)
# Test ADCP single vector spectra, cross-spectra to test radians code
test_ds_adp['psd_b5'] = c2.calc_psd(
dat_adp.dat.vel_b5.isel(range_b5=5), window='hamm')
test_ds_adp['tke_b5'] = c2.calc_tke(dat_adp.dat.vel_b5)
test_ds_adp['csd'] = c2.calc_csd(dat_adp.dat.vel.isel(dir=slice(0, 3), range=0),
freq_units='rad', window='hamm')
if make_data:
save(test_ds, 'vector_data01_func.nc')
save(test_ds_dif, 'vector_data01_funcdif.nc')
save(test_ds_demean, 'vector_data01_func_demean.nc')
save(test_ds_adp, 'BenchFile01_func.nc')
return
assert_allclose(test_ds, load('vector_data01_func.nc'), atol=1e-6)
assert_allclose(test_ds_dif, load('vector_data01_funcdif.nc'), atol=1e-6)
assert_allclose(test_ds_demean, load(
'vector_data01_func_demean.nc'), atol=1e-6)
assert_allclose(test_ds_adp, load('BenchFile01_func.nc'), atol=1e-6)
def test_rotate_beam2inst(make_data=False):
td_rdi = rotate2(tr.dat_rdi, 'inst', inplace=False)
td_sig = rotate2(tr.dat_sig, 'inst', inplace=False)
td_sig_i = rotate2(tr.dat_sig_i, 'inst', inplace=False)
td_sig_ieb = rotate2(tr.dat_sig_ieb, 'inst', inplace=False)
if make_data:
save(td_rdi, 'RDI_test01_rotate_beam2inst.nc')
save(td_sig, 'BenchFile01_rotate_beam2inst.nc')
save(td_sig_i, 'Sig1000_IMU_rotate_beam2inst.nc')
save(td_sig_ieb, 'VelEchoBT01_rotate_beam2inst.nc')
return
cd_rdi = load('RDI_test01_rotate_beam2inst.nc')
cd_sig = load('BenchFile01_rotate_beam2inst.nc')
cd_sig_i = load('Sig1000_IMU_rotate_beam2inst.nc')
cd_sig_ieb = load('VelEchoBT01_rotate_beam2inst.nc')
assert_allclose(td_rdi, cd_rdi, atol=1e-5)
assert_allclose(td_sig, cd_sig, atol=1e-5)
assert_allclose(td_sig_i, cd_sig_i, atol=1e-5)
assert_allclose(td_sig_ieb, cd_sig_ieb, atol=1e-5)
def test_io_nortek(make_data=False):
nens = 100
with pytest.warns(UserWarning):
td_awac = tb.drop_config(
read('AWAC_test01.wpr', userdata=False, nens=[0, nens]))
td_awac_ud = tb.drop_config(read('AWAC_test01.wpr', nens=nens))
td_hwac = tb.drop_config(read('H-AWAC_test01.wpr'))
if make_data:
save(td_awac, 'AWAC_test01.nc')
save(td_awac_ud, 'AWAC_test01_ud.nc')
save(td_hwac, 'H-AWAC_test01.nc')
return
assert_allclose(td_awac, dat_awac, atol=1e-6)
assert_allclose(td_awac_ud, dat_awac_ud, atol=1e-6)
assert_allclose(td_hwac, dat_hwac, atol=1e-6)
def test_rotate_inst2earth(make_data=False):
td = tr.dat.copy(deep=True)
rotate2(td, 'earth', inplace=True)
tdm = tr.dat_imu.copy(deep=True)
rotate2(tdm, 'earth', inplace=True)
tdo = tr.dat.copy(deep=True)
omat = tdo['orientmat']
tdo = rotate2(tdo.drop_vars('orientmat'), 'earth', inplace=False)
tdo['orientmat'] = omat
if make_data:
save(td, 'vector_data01_rotate_inst2earth.nc')
save(tdm, 'vector_data_imu01_rotate_inst2earth.nc')
return
cd = load('vector_data01_rotate_inst2earth.nc')
cdm = load('vector_data_imu01_rotate_inst2earth.nc')
assert_allclose(td, cd, atol=1e-6)
assert_allclose(tdm, cdm, atol=1e-6)
assert_allclose(tdo, cd, atol=1e-6)
def test_io_nortek2(make_data=False):
nens = 100
td_sig = tb.drop_config(read('BenchFile01.ad2cp', nens=nens))
td_sig_i = tb.drop_config(
read('Sig1000_IMU.ad2cp', userdata=False, nens=nens))
td_sig_i_ud = tb.drop_config(read('Sig1000_IMU.ad2cp', nens=nens))
td_sig_ieb = tb.drop_config(read('VelEchoBT01.ad2cp', nens=nens))
td_sig_ie = tb.drop_config(read('Sig500_Echo.ad2cp', nens=nens))
td_sig_tide = tb.drop_config(read('Sig1000_tidal.ad2cp', nens=nens))
with pytest.warns(UserWarning):
# This issues a warning...
td_sig_skip = tb.drop_config(read('Sig_SkippedPings01.ad2cp'))
with pytest.warns(UserWarning):
# Note: this datafile has a missing time value only - data is whole
td_sig_badt = tb.drop_config(
sig.read_signature(tb.rfnm('Sig1000_BadTime01.ad2cp')))
# Make sure we read all the way to the end of the file.
# This file ends exactly at the end of an ensemble.
td_sig5_leiw = tb.drop_config(read('Sig500_last_ensemble_is_whole.ad2cp'))
os.remove(tb.exdt('BenchFile01.ad2cp.index'))
os.remove(tb.exdt('Sig1000_IMU.ad2cp.index'))
os.remove(tb.exdt('VelEchoBT01.ad2cp.index'))
os.remove(tb.exdt('Sig500_Echo.ad2cp.index'))
os.remove(tb.exdt('Sig1000_tidal.ad2cp.index'))
os.remove(tb.exdt('Sig_SkippedPings01.ad2cp.index'))
os.remove(tb.exdt('Sig500_last_ensemble_is_whole.ad2cp.index'))
os.remove(tb.rfnm('Sig1000_BadTime01.ad2cp.index'))
if make_data:
save(td_sig, 'BenchFile01.nc')
save(td_sig_i, 'Sig1000_IMU.nc')
save(td_sig_i_ud, 'Sig1000_IMU_ud.nc')
save(td_sig_ieb, 'VelEchoBT01.nc')
save(td_sig_ie, 'Sig500_Echo.nc')
save(td_sig_tide, 'Sig1000_tidal.nc')
save(td_sig_skip, 'Sig_SkippedPings01.nc')
save(td_sig_badt, 'Sig1000_BadTime01.nc')
save(td_sig5_leiw, 'Sig500_last_ensemble_is_whole.nc')
return
assert_allclose(td_sig, dat_sig, atol=1e-6)
assert_allclose(td_sig_i, dat_sig_i, atol=1e-6)
assert_allclose(td_sig_i_ud, dat_sig_i_ud, atol=1e-6)
assert_allclose(td_sig_ieb, dat_sig_ieb, atol=1e-6)
assert_allclose(td_sig_ie, dat_sig_ie, atol=1e-6)
assert_allclose(td_sig_tide, dat_sig_tide, atol=1e-6)
assert_allclose(td_sig5_leiw, dat_sig5_leiw, atol=1e-6)
assert_allclose(td_sig_skip, dat_sig_skip, atol=1e-6)
assert_allclose(td_sig_badt, dat_sig_badt, atol=1e-6)
def test_motion_adv(make_data=False):
tdm = tv.dat_imu.copy(deep=True)
tdm = avm.correct_motion(tdm)
# user added metadata
tdmj = tv.dat_imu_json.copy(deep=True)
tdmj = avm.correct_motion(tdmj)
# set declination and then correct
tdm10 = tv.dat_imu.copy(deep=True)
tdm10.velds.set_declination(10.0, inplace=True)
tdm10 = avm.correct_motion(tdm10)
# test setting declination to 0 doesn't affect correction
tdm0 = tv.dat_imu.copy(deep=True)
tdm0.velds.set_declination(0.0, inplace=True)
tdm0 = avm.correct_motion(tdm0)
tdm0.attrs.pop('declination')
tdm0.attrs.pop('declination_in_orientmat')
# test motion-corrected data rotation
tdmE = tv.dat_imu.copy(deep=True)
tdmE.velds.set_declination(10.0, inplace=True)
tdmE.velds.rotate2('earth', inplace=True)
tdmE = avm.correct_motion(tdmE)
if make_data:
save(tdm, 'vector_data_imu01_mc.nc')
save(tdm10, 'vector_data_imu01_mcDeclin10.nc')
save(tdmj, 'vector_data_imu01-json_mc.nc')
return
cdm10 = load('vector_data_imu01_mcDeclin10.nc')
assert_allclose(tdm, load('vector_data_imu01_mc.nc'), atol=1e-7)
assert_allclose(tdm10, tdmj, atol=1e-7)
assert_allclose(tdm0, tdm, atol=1e-7)
assert_allclose(tdm10, cdm10, atol=1e-7)
assert_allclose(tdmE, cdm10, atol=1e-7)
assert_allclose(tdmj, load('vector_data_imu01-json_mc.nc'), atol=1e-7)
def test_io_rdi(make_data=False):
warnings.simplefilter('ignore', UserWarning)
nens = 100
td_rdi = tb.drop_config(read('RDI_test01.000'))
td_7f79 = tb.drop_config(read('RDI_7f79.000'))
td_rdi_bt = tb.drop_config(read('RDI_withBT.000', nens=nens))
td_vm = tb.drop_config(read('vmdas01.ENX', nens=nens))
td_wr1 = tb.drop_config(read('winriver01.PD0'))
td_wr2 = tb.drop_config(read('winriver02.PD0'))
if make_data:
save(td_rdi, 'RDI_test01.nc')
save(td_7f79, 'RDI_7f79.nc')
save(td_rdi_bt, 'RDI_withBT.nc')
save(td_vm, 'vmdas01.nc')
save(td_wr1, 'winriver01.nc')
save(td_wr2, 'winriver02.nc')
return
assert_allclose(td_rdi, dat_rdi, atol=1e-6)
assert_allclose(td_7f79, dat_rdi_7f79, atol=1e-6)
assert_allclose(td_rdi_bt, dat_rdi_bt, atol=1e-6)
assert_allclose(td_vm, dat_rdi_vm, atol=1e-6)
assert_allclose(td_wr1, dat_wr1, atol=1e-6)
assert_allclose(td_wr2, dat_wr2, atol=1e-6)
def test_rotate_inst2earth(make_data=False):
# AWAC & Sig500 are loaded in earth
td_awac = tr.dat_awac.copy(deep=True)
rotate2(td_awac, 'inst', inplace=True)
td_sig_ie = tr.dat_sig_ie.copy(deep=True)
rotate2(td_sig_ie, 'inst', inplace=True)
td_sig_o = td_sig_ie.copy(deep=True)
td = rotate2(tr.dat_rdi, 'earth', inplace=False)
tdwr2 = rotate2(tr.dat_wr2, 'earth', inplace=False)
td_sig = load('BenchFile01_rotate_beam2inst.nc')
rotate2(td_sig, 'earth', inplace=True)
td_sig_i = load('Sig1000_IMU_rotate_beam2inst.nc')
rotate2(td_sig_i, 'earth', inplace=True)
if make_data:
save(td_awac, 'AWAC_test01_earth2inst.nc')
save(td, 'RDI_test01_rotate_inst2earth.nc')
save(tdwr2, 'winriver02_rotate_ship2earth.nc')
save(td_sig, 'BenchFile01_rotate_inst2earth.nc')
save(td_sig_i, 'Sig1000_IMU_rotate_inst2earth.nc')
save(td_sig_ie, 'Sig500_Echo_earth2inst.nc')
return
td_awac = rotate2(load('AWAC_test01_earth2inst.nc'),
'earth',
inplace=False)
td_sig_ie = rotate2(load('Sig500_Echo_earth2inst.nc'),
'earth',
inplace=False)
td_sig_o = rotate2(td_sig_o.drop_vars('orientmat'), 'earth', inplace=False)
cd = load('RDI_test01_rotate_inst2earth.nc')
cdwr2 = load('winriver02_rotate_ship2earth.nc')
cd_sig = load('BenchFile01_rotate_inst2earth.nc')
cd_sig_i = load('Sig1000_IMU_rotate_inst2earth.nc')
assert_allclose(td, cd, atol=1e-5)
assert_allclose(tdwr2, cdwr2, atol=1e-5)
assert_allclose(td_awac, tr.dat_awac, atol=1e-5)
assert_allclose(td_sig, cd_sig, atol=1e-5)
assert_allclose(td_sig_i, cd_sig_i, atol=1e-5)
assert_allclose(td_sig_ie, tr.dat_sig_ie, atol=1e-5)
npt.assert_allclose(td_sig_o.vel, tr.dat_sig_ie.vel, atol=1e-5)
