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_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_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_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_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_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_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_shortcuts(make_data=False):
test_dat = adv_setup(tv)
if make_data:
save(test_dat.short, 'vector_data01_u.nc')
return
assert_allclose(test_dat.short, load('vector_data01_u.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_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_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_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_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_q_hpr():
dat = load('Sig1000_IMU.nc')
dcm = quaternion2orient(dat.quaternions)
assert_allclose(
dat.orientmat,
dcm,
atol=5e-4,
err_msg="Disagreement b/t quaternion-calc'd & HPR-calc'd orientmat")
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_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_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_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_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_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_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_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)
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_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_pr_declination():
# Test to confirm that pitch and roll don't change when you set
# declination
declin = 15.37
dat = load('vector_data_imu01.nc')
h0, p0, r0 = orient2euler(dat['orientmat'].values)
set_declination(dat, declin, inplace=True)
h1, p1, r1 = orient2euler(dat['orientmat'].values)
assert_allclose(p0,
p1,
atol=1e-5,
err_msg="Pitch changes when setting declination")
assert_allclose(r0,
r1,
atol=1e-5,
err_msg="Roll changes when setting declination")
assert_allclose(h0 + declin,
h1,
atol=1e-5,
err_msg="incorrect heading change when "
"setting declination")
from dolfyn.tests.base import load_netcdf as load, rfnm
vec = load('vector_data01.nc')
sig = load('BenchFile01.nc')
rdi = load('RDI_test01.nc')
def test_repr(make_data=False):
_str = []
for dat, fnm in [(vec, rfnm('vector_data01.repr.txt')),
(sig, rfnm('BenchFile01.repr.txt')),
(rdi, rfnm('RDI_test01.repr.txt')), ]:
_str = dat.velds.__repr__()
if make_data:
with open(fnm, 'w') as fl:
fl.write(_str)
else:
with open(fnm, 'r') as fl:
test_str = fl.read()
assert test_str == _str
