def test_getSpaxel_inputs(self, galaxy, x, y, ra, dec, excType, message):
"""Tests exceptions when getSpaxel gets inappropriate inputs."""
kwargs = self._dropNones(x=x, y=y, ra=ra, dec=dec)
with pytest.raises(excType) as ee:
cube = Cube(plateifu=galaxy.plateifu, release=galaxy.release)
cube.getSpaxel(**kwargs)
assert message in str(ee.value)
def test_getspaxel_matches_file_db_remote(self, galaxy):
cube_file = Cube(filename=galaxy.cubepath)
cube_db = Cube(plateifu=galaxy.plateifu)
cube_api = Cube(plateifu=galaxy.plateifu, mode='remote')
assert cube_file.data_origin == 'file'
assert cube_db.data_origin == 'db'
assert cube_api.data_origin == 'api'
xx = galaxy.spaxel['x']
yy = galaxy.spaxel['y']
spec_idx = galaxy.spaxel['specidx']
flux = galaxy.spaxel['flux']
ivar = galaxy.spaxel['ivar']
mask = galaxy.spaxel['mask']
spaxel_slice_file = cube_file[yy, xx]
spaxel_slice_db = cube_db[yy, xx]
spaxel_slice_api = cube_api[yy, xx]
abs = 1.e-7
assert spaxel_slice_file.flux.value[spec_idx] == pytest.approx(flux, abs=abs)
assert spaxel_slice_db.flux.value[spec_idx] == pytest.approx(flux, abs=abs)
assert spaxel_slice_api.flux.value[spec_idx] == pytest.approx(flux, abs=abs)
assert spaxel_slice_file.flux.ivar[spec_idx] == pytest.approx(ivar)
assert spaxel_slice_db.flux.ivar[spec_idx] == pytest.approx(ivar)
assert spaxel_slice_api.flux.ivar[spec_idx] == pytest.approx(ivar)
assert spaxel_slice_file.flux.mask[spec_idx] == pytest.approx(mask)
assert spaxel_slice_db.flux.mask[spec_idx] == pytest.approx(mask)
assert spaxel_slice_api.flux.mask[spec_idx] == pytest.approx(mask)
xx_cen = galaxy.spaxel['x_cen']
yy_cen = galaxy.spaxel['y_cen']
try:
spaxel_getspaxel_file = cube_file.getSpaxel(x=xx_cen, y=yy_cen)
spaxel_getspaxel_db = cube_db.getSpaxel(x=xx_cen, y=yy_cen)
spaxel_getspaxel_api = cube_api.getSpaxel(x=xx_cen, y=yy_cen)
except MarvinError as ee:
assert 'do not correspond to a valid binid' in str(ee)
pytest.skip()
assert spaxel_getspaxel_file.flux.value[spec_idx] == pytest.approx(flux, abs=1e-6)
assert spaxel_getspaxel_db.flux.value[spec_idx] == pytest.approx(flux, abs=1e-6)
assert spaxel_getspaxel_api.flux.value[spec_idx] == pytest.approx(flux, abs=1e-6)
assert spaxel_getspaxel_file.flux.ivar[spec_idx] == pytest.approx(ivar)
assert spaxel_getspaxel_db.flux.ivar[spec_idx] == pytest.approx(ivar)
assert spaxel_getspaxel_api.flux.ivar[spec_idx] == pytest.approx(ivar)
assert spaxel_getspaxel_file.flux.mask[spec_idx] == pytest.approx(mask)
assert spaxel_getspaxel_db.flux.mask[spec_idx] == pytest.approx(mask)
assert spaxel_getspaxel_api.flux.mask[spec_idx] == pytest.approx(mask)
def _getSpaxel_remote_fail(self,
ra,
dec,
errMsg1,
errMsg2=None,
excType=MarvinError):
cube = Cube(mangaid=self.mangaid, mode='remote')
with self.assertRaises(excType) as cm:
cube.getSpaxel(ra=ra, dec=dec)
self.assertIn(errMsg1, str(cm.exception))
if errMsg2:
self.assertIn(errMsg2, str(cm.exception))
def test_pickling_only_cube_file(self, temp_scratch, galaxy):
if galaxy.bintype.name != 'SPX':
pytest.skip("Can't instantiate a Spaxel from a binned Maps.")
cube = Cube(filename=galaxy.cubepath)
maps = Maps(filename=galaxy.mapspath)
spaxel = cube.getSpaxel(1, 3, maps=maps, modelcube=False)
file = temp_scratch.join('test_spaxel.mpf')
path_saved = spaxel.save(str(file), overwrite=True)
assert file.check() is True
assert os.path.exists(path_saved)
del spaxel
spaxel_restored = Spaxel.restore(str(file))
assert spaxel_restored is not None
assert isinstance(spaxel_restored, Spaxel)
assert spaxel_restored._cube is not None
assert spaxel_restored._cube.data_origin == 'file'
assert isinstance(spaxel_restored._cube.data, astropy.io.fits.HDUList)
assert spaxel_restored._maps is not None
assert spaxel_restored._maps.data_origin == 'file'
assert isinstance(spaxel_restored._maps.data, astropy.io.fits.HDUList)
def test_pickling_db_fails(self, temp_scratch, galaxy):
cube = Cube(plateifu=galaxy.plateifu)
spaxel = cube.getSpaxel(1, 3)
file = temp_scratch.join('test_spaxel.mpf')
with pytest.raises(MarvinError) as cm:
spaxel.save(str(file), overwrite=True)
assert 'objects with data_origin=\'db\' cannot be saved.' in str(cm.value)
def test_getSpaxel_remote_drpver_differ_from_global(self, galaxy, monkeyconfig):
if galaxy.release == 'MPL-5':
pytest.skip('Skipping release for forced global MPL-5')
assert config.release == 'MPL-5'
cube = Cube(plateifu=galaxy.plateifu, mode='remote', release=galaxy.release)
expected = galaxy.spaxel['flux']
spectrum = cube.getSpaxel(ra=galaxy.spaxel['ra'], dec=galaxy.spaxel['dec']).flux
assert spectrum.value[galaxy.spaxel['specidx']] == pytest.approx(expected)
def test_pickling_all_api(self, temp_scratch, galaxy):
drpver, __ = config.lookUpVersions()
cube = Cube(plateifu=galaxy.plateifu, mode='remote')
maps = Maps(plateifu=galaxy.plateifu, mode='remote')
modelcube = ModelCube(plateifu=galaxy.plateifu, mode='remote')
spaxel = cube.getSpaxel(1, 3, maps=maps, modelcube=modelcube)
assert spaxel._cube.data_origin == 'api'
assert spaxel._maps.data_origin == 'api'
assert spaxel._modelcube.data_origin == 'api'
file = temp_scratch.join('test_spaxel_api.mpf')
path_saved = spaxel.save(str(file), overwrite=True)
assert file.check() is True
assert os.path.exists(path_saved)
del spaxel
spaxel_restored = Spaxel.restore(str(file))
assert spaxel_restored is not None
assert isinstance(spaxel_restored, Spaxel)
assert spaxel_restored._cube is not None
assert isinstance(spaxel_restored._cube, Cube)
assert spaxel_restored._cube.data_origin == 'api'
assert spaxel_restored._cube.data is None
assert spaxel_restored._cube.header['VERSDRP3'] == drpver
assert spaxel_restored._maps is not None
assert isinstance(spaxel_restored._maps, Maps)
assert spaxel_restored._maps.data_origin == 'api'
assert spaxel_restored._maps.data is None
assert spaxel_restored._modelcube is not None
assert isinstance(spaxel_restored._modelcube, ModelCube)
assert spaxel_restored._modelcube.data_origin == 'api'
assert spaxel_restored._modelcube.data is None
def test_getspaxel_matches_file_db_remote(self):
self._update_release('MPL-4')
self.assertEqual(config.release, 'MPL-4')
cube_file = Cube(filename=self.filename)
cube_db = Cube(plateifu=self.plateifu)
cube_api = Cube(plateifu=self.plateifu, mode='remote')
self.assertEqual(cube_file.data_origin, 'file')
self.assertEqual(cube_db.data_origin, 'db')
self.assertEqual(cube_api.data_origin, 'api')
xx = 12
yy = 5
spec_idx = 200
spaxel_slice_file = cube_file[yy, xx]
spaxel_slice_db = cube_db[yy, xx]
spaxel_slice_api = cube_api[yy, xx]
flux_result = 0.017639931
ivar_result = 352.12421
mask_result = 1026
self.assertAlmostEqual(spaxel_slice_file.spectrum.flux[spec_idx],
flux_result)
self.assertAlmostEqual(spaxel_slice_db.spectrum.flux[spec_idx],
flux_result)
self.assertAlmostEqual(spaxel_slice_api.spectrum.flux[spec_idx],
flux_result)
self.assertAlmostEqual(spaxel_slice_file.spectrum.ivar[spec_idx],
ivar_result,
places=5)
self.assertAlmostEqual(spaxel_slice_db.spectrum.ivar[spec_idx],
ivar_result,
places=3)
self.assertAlmostEqual(spaxel_slice_api.spectrum.ivar[spec_idx],
ivar_result,
places=3)
self.assertAlmostEqual(spaxel_slice_file.spectrum.mask[spec_idx],
mask_result)
self.assertAlmostEqual(spaxel_slice_db.spectrum.mask[spec_idx],
mask_result)
self.assertAlmostEqual(spaxel_slice_api.spectrum.mask[spec_idx],
mask_result)
xx_cen = -5
yy_cen = -12
spaxel_getspaxel_file = cube_file.getSpaxel(x=xx_cen, y=yy_cen)
spaxel_getspaxel_db = cube_db.getSpaxel(x=xx_cen, y=yy_cen)
spaxel_getspaxel_api = cube_api.getSpaxel(x=xx_cen, y=yy_cen)
self.assertAlmostEqual(spaxel_getspaxel_file.spectrum.flux[spec_idx],
flux_result)
self.assertAlmostEqual(spaxel_getspaxel_db.spectrum.flux[spec_idx],
flux_result)
self.assertAlmostEqual(spaxel_getspaxel_api.spectrum.flux[spec_idx],
flux_result)
self.assertAlmostEqual(spaxel_getspaxel_file.spectrum.ivar[spec_idx],
ivar_result,
places=5)
self.assertAlmostEqual(spaxel_getspaxel_db.spectrum.ivar[spec_idx],
ivar_result,
places=3)
self.assertAlmostEqual(spaxel_getspaxel_api.spectrum.ivar[spec_idx],
ivar_result,
places=3)
self.assertAlmostEqual(spaxel_getspaxel_file.spectrum.mask[spec_idx],
mask_result)
self.assertAlmostEqual(spaxel_getspaxel_db.spectrum.mask[spec_idx],
mask_result)
self.assertAlmostEqual(spaxel_getspaxel_api.spectrum.mask[spec_idx],
mask_result)
