def test_add_cube(source2, minicube, tmpdir):
"""Source class: testing add_cube method"""
with pytest.raises(ValueError):
source2.add_cube(minicube, 'TEST')
lbda = (5000, 5500)
source2.add_white_image(minicube, size=minicube.shape[1:], unit_size=None)
source2.add_cube(minicube, 'TEST1', lbda=lbda)
lmin, lmax = minicube.wave.pixel(lbda, unit=u.angstrom, nearest=True)
assert (source2.cubes['TEST1'].shape ==
(lmax - lmin + 1,) + source2.images['MUSE_WHITE'].shape)
filename = str(tmpdir.join('source.fits'))
source2.write(filename)
src = Source.from_file(filename)
assert 'MUSE_WHITE' in src.images
assert 'TEST1' in src.cubes
# Add image again to be sure that the extension is correctly updated
src.add_white_image(minicube, size=(20, 20), unit_size=None)
src.write(filename)
src = Source.from_file(filename)
assert src.images['MUSE_WHITE'].shape == (20, 20)
source3 = Source.from_data(source2.ID, source2.RA, source2.DEC,
(source2.FROM, source2.FROM_V, '', ''),
default_size=source2.default_size)
source3.add_cube(minicube, 'TEST1', lbda=lbda, add_white=True)
assert_array_equal(source3.images['MUSE_WHITE'].data,
source2.images['MUSE_WHITE'].data)
def test_from_data():
s1 = Source.from_data(ID=1, ra=63.35592651367188, dec=10.46536922454834,
origin=('test', 'v0', 'minicube.fits', 'v0'),
proba=1.0, confid=2, extras={'FOO': 'BAR'},
default_size=10)
s2 = pickle.loads(pickle.dumps(s1))
assert 'ID' in dir(s1)
assert 'FOO' in dir(s1)
for src in (s1, s2):
assert src.DPROBA == 1.0
assert src.CONFID == 2
assert src.FOO == 'BAR'
assert src.default_size == 10
src.default_size = 24.12
assert src.default_size == 24.12
src.test = 24.12
assert src.test == 24.12
src.add_attr('test', 'toto')
assert src.test == 'toto'
src.add_attr('test', 1.2345, desc='my keyword', unit=u.deg, fmt='.2f')
assert src.header.comments['TEST'] == 'my keyword u.deg %.2f'
src.remove_attr('test')
with pytest.raises(AttributeError):
src.test
def source1():
col_lines = [
'LBDA_OBS', 'LBDA_OBS_ERR', 'FWHM_OBS', 'FWHM_OBS_ERR', 'LBDA_REST',
'LBDA_REST_ERR', 'FWHM_REST', 'FWHM_REST_ERR', 'FLUX', 'FLUX_ERR',
'LINE'
]
line1 = [5550, 10, 2.3, 0.2, 5600.0, 11.0, 2.5, 0.4, 28.0, 3.1, '[OIII]']
line2 = [
5550, 10, 2.3, 0.2, 5600.0, 11.0, 2.5, 0.4, 28.0879, 3.1, '[OIII]2'
]
lines = Table(names=col_lines, rows=[line1, line2])
s = Source.from_data(ID=1,
ra=-65.1349958,
dec=140.3057987,
origin=('test', 'v0', 'cube.fits', 'v0'),
lines=lines)
s.add_mag('TEST', 2380, 46)
s.add_mag('TEST2', 23.5, 0.1)
s.add_mag('TEST2', 24.5, 0.01)
s.add_z('z_test', 0.07, errz=0.007)
s.add_z('z_test2', 1.0, errz=-9999)
s.add_z('z_test3', 2.0, errz=(1.5, 2.2))
s.add_z('z_test3', 2.0, errz=(1.8, 2.5))
return s
def test_add_narrow_band_image(minicube, tmpdir):
"""Source class: testing methods on narrow bands images"""
src = Source.from_data(ID=1, ra=63.35592651367188, dec=10.46536922454834,
origin=('test', 'v0', 'minicube.fits', 'v0'),
proba=1.0, confid=2, extras={'FOO': 'BAR'})
src.add_z('EMI', 0.086, 0.0001)
src.add_white_image(minicube)
src.add_narrow_band_images(minicube, 'EMI')
assert 'NB_OIII5007' in src.images
assert 'NB_HALPHA' in src.images
assert 'NB_HBETA' in src.images
src.add_narrow_band_image_lbdaobs(minicube, 'OBS7128', 7128)
assert 'OBS7128' in src.images
src.add_seg_images()
assert 'SEG_MUSE_WHITE' in src.images
assert 'SEG_NB_OIII5007' in src.images
assert 'SEG_NB_HALPHA' in src.images
assert 'SEG_NB_HBETA' in src.images
assert 'SEG_OBS7128' in src.images
seg_tags = ['SEG_MUSE_WHITE', 'SEG_NB_OIII5007', 'SEG_OBS7128',
'SEG_NB_HBETA', 'SEG_NB_HALPHA']
src.find_sky_mask(seg_tags=seg_tags)
src.find_union_mask(union_mask='MASK_OBJ', seg_tags=seg_tags)
src.find_intersection_mask(seg_tags=seg_tags)
assert_array_equal(src.images['MASK_OBJ'].data.data.astype(bool),
~(src.images['MASK_SKY'].data.data.astype(bool)))
assert_array_equal(src.images['MASK_INTER'].data.data,
np.zeros(src.images['MASK_INTER'].shape))
src.extract_spectra(minicube, obj_mask='MASK_OBJ', skysub=True, psf=None)
src.extract_spectra(minicube, obj_mask='MASK_OBJ', skysub=False,
psf=0.2 * np.ones(minicube.shape[0]))
filename = str(tmpdir.join('source.fits'))
src.write(filename)
src = Source.from_file(filename)
for name in ('MASK_OBJ', 'MASK_INTER', 'MASK_SKY'):
assert name in src.images
for name in ('MUSE_SKY', 'MUSE_TOT_SKYSUB', 'MUSE_WHITE_SKYSUB',
'NB_HALPHA_SKYSUB', 'MUSE_PSF', 'MUSE_TOT', 'MUSE_WHITE',
'NB_HALPHA'):
assert name in src.spectra
Ny = np.array([ima.shape[0] for ima in src.images.values()])
assert len(np.unique(Ny)) == 1
Nx = np.array([ima.shape[1] for ima in src.images.values()])
assert len(np.unique(Nx)) == 1
def test_SEA(minicube, a478hst):
"""test SEA"""
cat = Table.read(get_data_file('sdetect', 'cat.txt'), format='ascii')
size = 10
width = 8
margin = 10.
fband = 3.
origin = ('sea', '0.0', os.path.basename(minicube.filename), 'v0')
for obj in cat[0:3]:
source = Source.from_data(obj['ID'], obj['RA'], obj['DEC'], origin)
z = float(obj['Z'])
try:
errz = (float(obj['Z_MAX']) - float(obj['Z_MIN'])) / 2.0
except Exception:
errz = np.nan
source.add_z('CAT', z, errz)
# create white image
source.add_white_image(minicube, size, unit_size=u.arcsec)
# create narrow band images
source.add_narrow_band_images(cube=minicube, z_desc='CAT',
size=None, unit_size=u.arcsec,
width=width, margin=margin,
fband=fband, is_sum=False)
# extract images stamps
source.add_image(a478hst, 'HST_')
# segmentation maps
source.add_seg_images(DIR=None)
tags = [tag for tag in source.images.keys() if tag[0:4] == 'SEG_']
source.find_sky_mask(tags)
source.find_union_mask(tags)
source.find_intersection_mask(tags)
# extract spectra
source.extract_spectra(minicube, skysub=True, psf=None)
source.extract_spectra(minicube, skysub=False, psf=None)
Nz = np.array([sp.shape[0] for sp in source.spectra.values()])
assert len(np.unique(Nz)) == 1
tags = [tag for tag in source.images.keys() if tag[0:4] != 'HST_']
Ny = np.array([source.images[tag].shape[0] for tag in tags])
assert len(np.unique(Ny)) == 1
Nx = np.array([source.images[tag].shape[1] for tag in tags])
assert len(np.unique(Nx)) == 1
def test_line():
"""Source class: testing add_line methods"""
src = Source.from_data(ID=1, ra=63.35, dec=10.46,
origin=('test', 'v0', 'minicube.fits', 'v0'))
src.add_line(['LBDA_OBS', 'LBDA_OBS_ERR', 'LINE'], [4810.123, 3.0, 'TEST'],
units=[u.angstrom, u.angstrom, None],
desc=['wavelength', 'error', 'name'],
fmt=['.2f', '.3f', None])
lines = src.lines
assert lines['LBDA_OBS'].unit == u.angstrom
assert lines['LBDA_OBS'][lines['LINE'] == 'TEST'][0] == 4810.123
src.add_line(['LBDA_OBS', 'NEWCOL', 'NEWCOL2', 'NEWCOL3', 'LINE'],
[4807.0, 2, 5.55, 'my new col', 'TEST2'])
src.add_line(['LBDA_OBS'], [4807.0], match=('LINE', 'TEST'))
src.add_line(['LBDA_OBS'], [6000.0], match=('LINE', 'TESTMISS', False))
assert 'NEWCOL' in lines.colnames
assert 'TESTMISS' not in lines['LINE']
assert lines['LBDA_OBS'][lines['LINE'] == 'TEST'][0] == 4807.
def test_SEA2(minicube):
size = 9
shape = (5, size, size)
center = size // 2
np.random.seed(22)
data = np.random.choice([-0.01, 0.02],
np.prod(shape[1:])).reshape(shape[1:])
# Put fake data at the center of the image
sl = slice(2, -2)
for i in range(sl.start, center + 1):
data[i:-i, i:-i] = i - 1
data = np.repeat([data], 5, axis=0)
# Mask some values in the background
data[1:4, 0, 0] = np.nan
# Ideally we should test with NaNs in the data, but the algorithm used
# makes it diffcult to compute expected values without reimplementing the
# same code here
# data[:, 3, 3] = np.nan
cube = Cube(data=data, var=np.ones(shape), wcs=minicube.wcs,
wave=minicube.wave, copy=False)
cube_novar = Cube(data=data, wcs=minicube.wcs, wave=minicube.wave,
copy=False)
dec, ra = cube.wcs.pix2sky([4, 4])[0]
origin = ('sea', '0.0', 'test', 'v0')
s = Source.from_data('1', ra, dec, origin)
s.add_white_image(cube, size, unit_size=None)
white = s.images['MUSE_WHITE'].data
assert_array_equal(white, data[0])
mask = np.zeros(shape[1:], dtype=bool)
mask[sl, sl] = True
s.images['MASK_OBJ'] = Image(data=mask, wcs=cube.wcs)
s.images['MASK_SKY'] = Image(data=~mask, wcs=cube.wcs)
sky_value = np.nanmean(data[:, ~mask], axis=1)
# extract spectra errors
with pytest.raises(ValueError):
s.extract_spectra(cube, skysub=False)
with pytest.raises(ValueError):
s.extract_spectra(cube, skysub=True, obj_mask='MASK_OBJ',
sky_mask='NONE')
dist = np.sum((np.mgrid[:5, :5] - 2) ** 2, axis=0)
psf = np.zeros(shape)
psf[:, sl, sl] = np.max(dist) - dist
# extract spectra without var
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
s.extract_spectra(cube_novar, skysub=False, obj_mask='MASK_OBJ')
assert len(w) == 1
assert issubclass(w[-1].category, MpdafWarning)
# MUSE_TOT
sptot = cube[:, sl, sl].sum(axis=(1, 2))
assert_almost_equal(s.spectra['MUSE_TOT'].data, sptot.data)
assert s.spectra['MUSE_TOT'].var is None
# extract spectra
s.extract_spectra(cube, skysub=False, psf=psf, obj_mask='MASK_OBJ',
apertures=(0.3, 1.0))
s.extract_spectra(cube, skysub=True, psf=psf, obj_mask='MASK_OBJ',
apertures=(0.3, 1.0))
# Check that extraction does not modified the data
assert_almost_equal(cube.data.data, data)
assert_almost_equal(s.images['MUSE_WHITE'].data, data[0])
# MUSE_TOT
npix_sky = np.sum((~cube.mask) & mask, axis=(1, 2))
assert_almost_equal(s.spectra['MUSE_TOT'].data, sptot.data)
assert_almost_equal(s.spectra['MUSE_TOT'].var, sptot.var)
assert_almost_equal(s.spectra['MUSE_TOT_SKYSUB'].data,
sptot.data - sky_value * npix_sky)
# MUSE_APER
sl03 = slice(3, -3)
sp03 = cube[:, sl03, sl03].sum(axis=(1, 2))
assert_almost_equal(s.spectra['MUSE_APER_0.3'].data, sp03.data)
assert_almost_equal(s.spectra['MUSE_APER_0.3'].var, sp03.var)
# 1" aperture is wider than the object mask, so we get the same flux
assert_almost_equal(s.spectra['MUSE_APER_1.0'].data, sptot.data)
assert_almost_equal(s.spectra['MUSE_APER_1.0'].var, sptot.var)
assert_almost_equal(s.spectra['MUSE_APER_1.0_SKYSUB'].data,
sptot.data - sky_value * npix_sky)
# MUSE_PSF
# mask = (psf > 0) & s.images['MASK_OBJ']._data
# sp = np.nansum(cube.data * mask, axis=(1, 2))
# npix_sky = np.sum((~cube.mask) & mask, axis=(1, 2))
assert_almost_equal(31.11, s.spectra['MUSE_PSF'].data, decimal=2)
assert_almost_equal(18.51, s.spectra['MUSE_PSF'].var, decimal=2)
assert_almost_equal(30.98, s.spectra['MUSE_PSF_SKYSUB'].data, decimal=2)
# MUSE_WHITE
# here compute_spectrum subtracts the min value of the weight image, to
# ensure that weights are positive, but this means that on our fake data
# the weights of the boundary are put to 0. So we need to compare on the
# inner part only.
# mask = ((white - white[sl, sl].min()) > 0) & s.images['MASK_OBJ'].data
# mask = broadcast_to(mask, cube.shape)
# sp = np.nansum(cube.data * mask, axis=(1, 2))
# npix_sky = np.sum((~cube.mask) & mask, axis=(1, 2))
assert_almost_equal(18.33, s.spectra['MUSE_WHITE'].data, decimal=2)
assert_almost_equal(8.33, s.spectra['MUSE_WHITE'].var, decimal=2)
assert_almost_equal(18.27, s.spectra['MUSE_WHITE_SKYSUB'].data, decimal=2)
