def test_xmca_input(self):
xMCA()
xMCA(self.A)
xMCA(self.A, self.B)
with self.assertRaises(ValueError):
xMCA(self.A, self.B, self.A)
with self.assertRaises(TypeError):
xMCA(np.array([1,2,3]))
def test_rotated_mca(self):
svalues = xr.open_dataarray(
join(self.path, 'mca_c0_r10_p01_singular_values.nc'))
eofs_A = xr.open_dataarray(
join(self.path, 'mca_c0_r10_p01_sst_eofs.nc'))
eofs_B = xr.open_dataarray(
join(self.path, 'mca_c0_r10_p01_prcp_eofs.nc'))
pcs_A = xr.open_dataarray(join(self.path, 'mca_c0_r10_p01_sst_pcs.nc'))
pcs_B = xr.open_dataarray(join(self.path,
'mca_c0_r10_p01_prcp_pcs.nc'))
mca = xMCA(self.A, self.B)
mca.set_field_names('sst', 'prcp')
mca.solve()
mca.rotate(10)
np.testing.assert_allclose(svalues,
mca.singular_values(),
err_msg='singular values do not match')
np.testing.assert_allclose(eofs_A,
mca.eofs()['left'],
err_msg='left eofs do not match')
np.testing.assert_allclose(eofs_B,
mca.eofs()['right'],
err_msg='right eofs do not match')
np.testing.assert_allclose(pcs_B,
mca.pcs()['right'],
err_msg='left pcs do not match')
np.testing.assert_allclose(pcs_B,
mca.pcs()['right'],
err_msg='right pcs do not match')
mca.plot(1)
mca.save_analysis('./tests/integration')
mca2 = xMCA()
mca2.load_analysis(
'./tests/integration/xmca/sst_prcp/mca_c0_r10_p01.info')
np.testing.assert_allclose(svalues,
mca2.singular_values(),
err_msg='singular values do not match')
np.testing.assert_allclose(eofs_A,
mca2.eofs()['left'],
err_msg='left eofs do not match')
np.testing.assert_allclose(eofs_B,
mca2.eofs()['right'],
err_msg='right eofs do not match')
np.testing.assert_allclose(pcs_B,
mca2.pcs()['right'],
err_msg='left pcs do not match')
np.testing.assert_allclose(pcs_B,
mca2.pcs()['right'],
err_msg='right pcs do not match')
rmtree(join(getcwd(), 'tests/integration/xmca/'))
def test_complex_mca(self):
svalues = xr.open_dataarray(join(self.path,
'mca_c1_r10_p01_singular_values.nc'),
engine='h5netcdf')
eofs_A = xr.open_dataarray(join(self.path,
'mca_c1_r10_p01_sst_eofs.nc'),
engine='h5netcdf')
eofs_B = xr.open_dataarray(join(self.path,
'mca_c1_r10_p01_prcp_eofs.nc'),
engine='h5netcdf')
pcs_B = xr.open_dataarray(join(self.path,
'mca_c1_r10_p01_prcp_pcs.nc'),
engine='h5netcdf')
pcs_A = xr.open_dataarray(join(self.path, 'mca_c1_r10_p01_sst_pcs.nc'),
engine='h5netcdf')
mca = xMCA(self.A, self.B)
mca.set_field_names('sst', 'prcp')
mca.solve(complexify=True, theta=True, period=12)
mca.rotate(10)
np.testing.assert_allclose(svalues,
mca.singular_values(),
err_msg='singular values do not match')
np.testing.assert_allclose(eofs_A,
mca.eofs()['left'],
err_msg='left eofs do not match')
np.testing.assert_allclose(eofs_B,
mca.eofs()['right'],
err_msg='right eofs do not match')
np.testing.assert_allclose(pcs_B,
mca.pcs()['right'],
err_msg='left pcs do not match')
np.testing.assert_allclose(pcs_B,
mca.pcs()['right'],
err_msg='right pcs do not match')
mca.plot(1)
mca.save_analysis('./tests/integration')
mca2 = xMCA()
mca2.load_analysis(
'./tests/integration/xmca/sst_prcp/mca_c1_r10_p01.info')
np.testing.assert_allclose(svalues,
mca2.singular_values(),
err_msg='singular values do not match')
np.testing.assert_allclose(eofs_A,
mca2.eofs()['left'],
err_msg='left eofs do not match')
np.testing.assert_allclose(eofs_B,
mca2.eofs()['right'],
err_msg='right eofs do not match')
np.testing.assert_allclose(pcs_B,
mca2.pcs()['right'],
err_msg='left pcs do not match')
np.testing.assert_allclose(pcs_B,
mca2.pcs()['right'],
err_msg='right pcs do not match')
rmtree(join(getcwd(), 'tests/integration/xmca/'))
@classmethod
def tearDownClass(self):
pass
def test_standard_mca(self):
files = {
'svalues': 'mca_c0_r00_p00_singular_values.nc',
'eofs_A': 'mca_c0_r00_p00_sst_eofs.nc',
'eofs_B': 'mca_c0_r00_p00_prcp_eofs.nc',
'pcs_A': 'mca_c0_r00_p00_sst_pcs.nc',
'pcs_B': 'mca_c0_r00_p00_prcp_pcs.nc',
}
svalues = xr.open_dataarray(join(self.path,
files['svalues']))[:self.modes]
eofs_A = xr.open_dataarray(join(self.path,
files['eofs_A']))[..., :self.modes]
eofs_B = xr.open_dataarray(join(self.path,
files['eofs_B']))[..., :self.modes]
pcs_A = xr.open_dataarray(join(self.path,
files['pcs_A']))[:, :self.modes]
pcs_B = xr.open_dataarray(join(self.path,
files['pcs_B']))[:, :self.modes]
mca = xMCA(self.A, self.B)
mca.set_field_names('sst', 'prcp')
mca.solve()
vals = mca.singular_values(self.modes)
eofs = mca.eofs(self.modes)
pcs = mca.pcs(self.modes)
# fields = mca.reconstructed_fields()
assert_allclose(svalues,
vals,
err_msg='svalues do not match',
**self.tols)
assert_allclose(eofs_A,
eofs['left'],
err_msg='eofs A do not match',
**self.tols)
assert_allclose(eofs_B,
eofs['right'],
err_msg='eofs B do not match',
**self.tols)
assert_allclose(pcs_A,
pcs['left'],
err_msg='pcs A do not match',
**self.tols)
assert_allclose(pcs_B,
pcs['right'],
err_msg='pcs B do not match',
**self.tols)
# assert_allclose(self.A, fields['left'], rtol=1e-3)
# assert_allclose(self.B, fields['right'], rtol=1e-3, atol=9e-2)
mca.plot(1)
mca.save_analysis('./tests/integration')
path = './tests/integration/xmca/sst_prcp/mca_c0_r00_p00.info'
mca2 = xMCA()
mca2.load_analysis(path)
vals = mca2.singular_values(self.modes)
eofs = mca2.eofs(self.modes)
pcs = mca2.pcs(self.modes)
# fields = mca2.reconstructed_fields()
assert_allclose(svalues,
vals,
err_msg='singular values do not match',
**self.tols)
assert_allclose(eofs_A,
eofs['left'],
err_msg='left eofs do not match',
**self.tols)
assert_allclose(eofs_B,
eofs['right'],
err_msg='right eofs do not match',
**self.tols)
assert_allclose(pcs_B,
pcs['right'],
err_msg='left eofs do not match',
**self.tols)
assert_allclose(pcs_B,
pcs['right'],
err_msg='right eofs do not match',
**self.tols)
# assert_allclose(
# self.A, fields['left'],
# err_msg='left reconstructed field does not match'
# )
# assert_allclose(
# self.B, fields['right'],
# err_msg='right reconstructed field does not match'
# )
rmtree(join(getcwd(), 'tests/integration/xmca/'))
def test_complex_mca(self):
files = {
'svalues': 'mca_c1_r10_p01_singular_values.nc',
'eofs_A': 'mca_c1_r10_p01_sst_eofs.nc',
'eofs_B': 'mca_c1_r10_p01_prcp_eofs.nc',
'pcs_A': 'mca_c1_r10_p01_sst_pcs.nc',
'pcs_B': 'mca_c1_r10_p01_prcp_pcs.nc',
}
svalues = xr.open_dataarray(join(self.path, files['svalues']),
engine='h5netcdf')[:self.modes]
eofs_A = xr.open_dataarray(join(self.path, files['eofs_A']),
engine='h5netcdf')[..., :self.modes]
eofs_B = xr.open_dataarray(join(self.path, files['eofs_B']),
engine='h5netcdf')[..., :self.modes]
pcs_A = xr.open_dataarray(join(self.path, files['pcs_A']),
engine='h5netcdf')[:, :self.modes]
pcs_B = xr.open_dataarray(join(self.path, files['pcs_B']),
engine='h5netcdf')[:, :self.modes]
mca = xMCA(self.A, self.B)
mca.set_field_names('sst', 'prcp')
mca.solve(complexify=True, extend='theta', period=12)
mca.rotate(10)
vals = mca.singular_values(self.modes)
eofs = mca.eofs(self.modes)
pcs = mca.pcs(self.modes)
assert_allclose(svalues,
vals,
err_msg='singular values do not match',
**self.tols)
assert_allclose(eofs_A,
eofs['left'],
err_msg='left eofs do not match',
**self.tols)
assert_allclose(eofs_B,
eofs['right'],
err_msg='right eofs do not match',
**self.tols)
assert_allclose(pcs_A,
pcs['left'],
err_msg='left pcs do not match',
**self.tols)
assert_allclose(pcs_B,
pcs['right'],
err_msg='right pcs do not match',
**self.tols)
mca.plot(1)
mca.save_analysis('./tests/integration')
path = './tests/integration/xmca/sst_prcp/mca_c1_r10_p01.info'
mca2 = xMCA()
mca2.load_analysis(path)
vals = mca2.singular_values(self.modes)
eofs = mca2.eofs(self.modes)
pcs = mca2.pcs(self.modes)
assert_allclose(svalues,
vals,
err_msg='singular values do not match',
**self.tols)
assert_allclose(eofs_A,
eofs['left'],
err_msg='left eofs do not match',
**self.tols)
assert_allclose(eofs_B,
eofs['right'],
err_msg='right eofs do not match',
**self.tols)
assert_allclose(pcs_A,
pcs['left'],
err_msg='left pcs do not match',
**self.tols)
assert_allclose(pcs_B,
pcs['right'],
err_msg='right pcs do not match',
**self.tols)
rmtree(join(getcwd(), 'tests/integration/xmca/'))
@classmethod
def tearDownClass(self):
pass
def test_rotated_mca(self):
files = {
'svalues': 'mca_c0_r10_p01_singular_values.nc',
'eofs_A': 'mca_c0_r10_p01_sst_eofs.nc',
'eofs_B': 'mca_c0_r10_p01_prcp_eofs.nc',
'pcs_A': 'mca_c0_r10_p01_sst_pcs.nc',
'pcs_B': 'mca_c0_r10_p01_prcp_pcs.nc',
}
svalues = xr.open_dataarray(join(self.path,
files['svalues']))[:self.modes]
eofs_A = xr.open_dataarray(join(self.path,
files['eofs_A']))[..., :self.modes]
eofs_B = xr.open_dataarray(join(self.path,
files['eofs_B']))[..., :self.modes]
pcs_A = xr.open_dataarray(join(self.path,
files['pcs_A']))[:, :self.modes]
pcs_B = xr.open_dataarray(join(self.path,
files['pcs_B']))[:, :self.modes]
mca = xMCA(self.A, self.B)
mca.set_field_names('sst', 'prcp')
mca.solve()
mca.rotate(10)
vals = mca.singular_values(self.modes)
eofs = mca.eofs(self.modes)
pcs = mca.pcs(self.modes)
assert_allclose(svalues,
vals,
err_msg='singular values do not match',
**self.tols)
assert_allclose(eofs_A,
eofs['left'],
err_msg='left eofs do not match',
**self.tols)
assert_allclose(eofs_B,
eofs['right'],
err_msg='right eofs do not match',
**self.tols)
assert_allclose(pcs_A,
pcs['left'],
err_msg='left pcs do not match',
**self.tols)
assert_allclose(pcs_B,
pcs['right'],
err_msg='right pcs do not match',
**self.tols)
mca.plot(1)
mca.save_analysis('./tests/integration')
path = './tests/integration/xmca/sst_prcp/mca_c0_r10_p01.info'
mca2 = xMCA()
mca2.load_analysis(path)
vals = mca2.singular_values(self.modes)
eofs = mca2.eofs(self.modes)
pcs = mca2.pcs(self.modes)
assert_allclose(svalues[:20],
vals[:20],
err_msg='singular values do not match',
**self.tols)
assert_allclose(eofs_A,
eofs['left'],
err_msg='left eofs do not match',
**self.tols)
assert_allclose(eofs_B,
eofs['right'],
err_msg='right eofs do not match',
**self.tols)
assert_allclose(pcs_A,
pcs['left'],
err_msg='left pcs do not match',
**self.tols)
assert_allclose(pcs_B,
pcs['right'],
err_msg='right pcs do not match',
**self.tols)
rmtree(join(getcwd(), 'tests/integration/xmca/'))