def test_delete_extension(tmpdir, source2):
filename = str(tmpdir.join('source.fits'))
table = Table(rows=[[1, 2.34, 'Hello']], names=('ID', 'value', 'name'))
source2.tables['TEST'] = table
table = Table(rows=[[2, 0.34, 'Foo']], names=('ID2', 'value2', 'name2'))
source2.tables['TEST2'] = table
source2.images['NB7317'].var = np.ones(source2.images['NB7317'].shape)
source2.images['MUSE_WHITE'] = source2.images['NB7317'].copy()
source2.add_image(source2.images['NB7317'], 'TESTIM')
del source2.images['NB7317']
# Write file from scratch
source2._filename = None
source2.write(filename)
source2 = None
src = Source.from_file(filename)
assert 'NB7317' not in src.images
assert len(src.tables['TEST2']) == 1
del src.tables['TEST']
del src.images['TESTIM']
src.write(filename)
src = Source.from_file(filename)
assert list(src.tables.keys()) == ['TEST2']
assert list(src.images.keys()) == ['MUSE_WHITE']
assert [h.name for h in fits.open(filename)] == [
'PRIMARY', 'LINES', 'IMA_MUSE_WHITE_DATA', 'IMA_MUSE_WHITE_STAT',
'TAB_TEST2']
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_file():
filename = get_data_file('sdetect', 'sing-0032.fits')
src = Source.from_file(filename, ext='NB*')
assert 'NB7317' in src.images
src = Source.from_file(filename, ext=['NB*'])
assert 'NB7317' in src.images
src = Source.from_file(filename, ext='FOO')
assert 'NB7317' not in src.images
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 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_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 test_create_psf_cube():
src = Source.from_file(get_data_file('sdetect', 'origin-00026.fits'))
cube = Cube(get_data_file('sdetect', 'subcub_mosaic.fits'))
src.add_FSF(cube)
wcs = src.images['MUSE_WHITE'].wcs
shape = src.images['MUSE_WHITE'].shape
# a, b, beta, field = src.get_FSF()
a = 0.862
b = -3.46e-05
beta = 2.8
psf = b * cube.wave.coord() + a
# Gaussian
gauss = create_psf_cube(psf.shape + shape, psf, wcs=wcs)
im = Image(data=gauss[0], wcs=wcs)
res = im.gauss_fit()
assert_almost_equal(wcs.sky2pix(res.center)[0], [12., 12.])
assert np.allclose(res.fwhm, psf[0])
assert np.allclose(res.flux, 1.0)
# Moffat
moff = create_psf_cube(psf.shape + shape, psf, wcs=wcs, beta=beta)
im = Image(data=moff[0], wcs=wcs)
res = im.moffat_fit()
assert_almost_equal(wcs.sky2pix(res.center)[0], [12., 12.])
assert np.allclose(res.fwhm, psf[0])
assert np.allclose(res.flux, 1.0, atol=1e-2)
def test_add_FSF(minicube):
"""Source class: testing add_FSF method"""
src = Source.from_file(get_data_file('sdetect', 'origin-00026.fits'))
assert src.get_FSF() is None
with pytest.raises(ValueError):
src.add_FSF(minicube)
cube = Cube(get_data_file('sdetect', 'subcub_mosaic.fits'))
src.add_FSF(cube)
assert src.FSF99BET == 2.8
assert src.FSF99FWA == 0.843
assert src.FSF99FWB == -3.301e-05
assert src.get_FSF() == (0.843, -3.301e-05, 2.8, 99)
def test_add_FSF(minicube):
"""Source class: testing add_FSF method"""
src = Source.from_file(get_data_file('sdetect', 'origin-00026.fits'))
assert src.get_FSF() is None
with pytest.raises(ValueError):
src.add_FSF(minicube)
cube = Cube(get_data_file('sdetect', 'subcub_mosaic.fits'))
src.add_FSF(cube)
assert src.FSFMODE == 2
assert src.FSF99FNC == 2
assert src.FSF99BNC == 1
assert np.isclose(src.FSF99B00, 2.8, 1e-2)
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_write(tmpdir, source1):
filename = str(tmpdir.join('source.fits'))
with pytest.raises(ValueError):
source1.add_z('z_error', 2.0, errz=[0.001])
sel = np.where(source1.z['Z_DESC'] == 'z_test2')[0][0]
assert source1.z['Z'][sel] == 1.0
assert source1.z['Z_MIN'][sel] is np.ma.masked
assert source1.z['Z_MAX'][sel] is np.ma.masked
source1.add_z('z_test2', -9999)
assert 'z_test2' not in source1.z['Z_DESC']
table = Table(rows=[[1, 2.34, 'Hello']], names=('ID', 'value', 'name'))
source1.tables['TEST'] = table
source1.write(filename)
with pytest.raises(OSError):
source1.write(filename, overwrite=False)
source1.info()
source1 = None
src = Source.from_file(filename)
sel = np.where(src.mag['BAND'] == 'TEST2')[0][0]
assert src.mag['MAG'][sel] == 24.5
assert src.mag['MAG_ERR'][sel] == 0.01
assert 'z_test2' not in src.z['Z_DESC']
sel = np.where(src.z['Z_DESC'] == 'z_test')[0][0]
assert src.z['Z'][sel] == 0.07
assert src.z['Z_MIN'][sel] == 0.07 - 0.007 / 2
assert src.z['Z_MAX'][sel] == 0.07 + 0.007 / 2
sel = np.where(src.z['Z_DESC'] == 'z_test3')[0][0]
assert src.z['Z'][sel] == 2.0
assert src.z['Z_MIN'][sel] == 1.8
assert src.z['Z_MAX'][sel] == 2.5
assert src.tables['TEST'].colnames == table.colnames
assert src.tables['TEST'][0].as_void() == table[0].as_void()
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_pickle(filename):
filename = get_data_file('sdetect', filename)
src = Source.from_file(filename)
s1 = pickle.loads(pickle.dumps(src))
# Force loading all extensions
for objtype in ('images', 'cubes', 'spectra', 'tables'):
for name, obj in getattr(src, objtype).items():
print(name, obj)
s2 = pickle.loads(pickle.dumps(src))
for s in (s1, s2):
assert src.header.tostring() == s.header.tostring()
for objtype in ('images', 'cubes', 'spectra', 'tables'):
attr_ref = getattr(src, objtype)
attr_new = getattr(s, objtype)
if attr_ref is None:
assert attr_new is None
else:
assert list(attr_ref.keys()) == list(attr_new.keys())
def test_init():
with pytest.raises(ValueError):
Source({})
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)
def test_add_image(tmpdir, source2, a478hst, a370II):
"""Source class: testing add_image method"""
minicube = Cube(get_data_file('sdetect', 'minicube.fits'), dtype=float)
source2.add_white_image(minicube)
ima = minicube.mean(axis=0)
# The position source2.dec, source2.ra corresponds
# to pixel index 18.817,32.432 in the cube. The default 5
# arcsecond requested size of the white-light image corresponds
# to 25 pixels. There will thus be 12 pixels on either side of
# a central pixel. The nearest pixel to the center is 19,32, so
# we expect add_white_image() to have selected the following
# range of pixels cube[19-12:19+12+1, 32-12:32+12+1], which
# is cube[7:32, 20:45]. However the cube only has 40 pixels
# along the X-axis, so the white-light image should correspond
# to:
#
# white[:,:] = cube[7:32, 20:40]
# white.shape=(25,20)
#
# So: cube[15,25] = white[15-7, 25-20] = white[8, 5]
assert ima[15, 25] == source2.images['MUSE_WHITE'][8, 5]
# Add a square patch of an HST image equal in width and height
# to the height of the white-light image, which has a height
# of 25 white-light pixels.
source2.add_image(a478hst, 'HST1')
# Add the same HST image, but this time set the width and height
# equal to the height of the above HST patch (ie. 50 pixels). This
# should have the same result as giving it the same size as the
# white-light image.
size = source2.images['HST1'].shape[0]
source2.add_image(a478hst, 'HST2', size=size, minsize=size, unit_size=None)
assert source2.images['HST1'][10, 10] == source2.images['HST2'][10, 10]
# Add the HST image again, but this time rotate it to the same
# orientation as the white-light image, then check that they end
# up with the same rotation angles.
source2.add_image(a478hst, 'HST3', rotate=True)
assert_almost_equal(source2.images['HST3'].get_rot(),
source2.images['MUSE_WHITE'].get_rot(), 3)
# Trying to add image not overlapping with Source
assert source2.add_image(a370II, 'ERROR') is None
white = source2.images['MUSE_WHITE']
mean, std = white.background()
mask = white.data > (mean + 2 * std)
mask = Image.new_from_obj(white, data=mask.astype(int))
mask.data = mask.data.astype(int)
source2.add_image(mask, 'MYMASK')
filename = str(tmpdir.join('source.fits'))
source2.write(filename)
src = Source.from_file(filename)
assert src.images['MYMASK'].data.dtype == '>i8'
assert_masked_allclose(mask.data, src.images['MYMASK'].data)
with fits.open(filename) as hdul:
'IMA_MYMASK_DQ' in hdul
assert (np.count_nonzero(hdul['IMA_MYMASK_DQ'].data) ==
np.count_nonzero(white.mask))
def source2():
return Source.from_file(get_data_file('sdetect', 'sing-0032.fits'))
def test_origin(caplog, tmpdir):
"""Test the full ORIGIN process."""
orig = ORIGIN.init(MINICUBE, name='tmp', loglevel='INFO', path=str(tmpdir))
orig.write()
origfolder = str(tmpdir.join('tmp'))
# test that log level is correctly reloaded, then change it
orig = ORIGIN.load(origfolder)
assert orig.logger.handlers[0].level == 20
orig.set_loglevel('DEBUG')
assert orig.logger.handlers[0].level == 10
orig.step01_preprocessing()
assert orig.ima_dct is not None
assert orig.ima_std is not None
orig.write()
orig = ORIGIN.load(origfolder)
orig.step02_areas(minsize=30, maxsize=60)
assert orig.param['nbareas'] == 4
assert list(np.unique(orig.areamap._data)) == [1, 2, 3, 4]
orig.write()
orig = ORIGIN.load(origfolder)
assert orig.param['nbareas'] == 4
orig.step03_compute_PCA_threshold()
orig.step04_compute_greedy_PCA()
# TGLR computing (normalized correlations)
orig.step05_compute_TGLR(ncpu=1)
# orig.step05_compute_TGLR(ncpu=1, NbSubcube=2)
# threshold applied on pvalues
orig.step06_compute_purity_threshold(purity=0.8)
# FIXME: threshold is hardcoded for now
orig.step07_detection(threshold=9.28, segmap=SEGMAP)
# estimation
orig.step08_compute_spectra()
orig.write()
cat = Catalog.read(str(tmpdir.join('tmp', 'Cat1.fits')))
subcat = cat[cat['comp'] == 0]
assert np.all(np.isnan(np.array(subcat['STD'])))
# Test that the columns mask is correct. To be tested when we switch
# back to a masked table
# assert np.all(subcat['T_GLR'].mask == False)
# assert np.all(subcat['STD'].mask == True)
# cleaned results
orig = ORIGIN.load(origfolder, newname='tmp2')
orig.step09_clean_results()
orig.write()
# check that the catalog version was saves
assert "CAT3_TS" in Catalog.read(
str(tmpdir.join('tmp2', 'Cat3_lines.fits'))).meta
assert "CAT3_TS" in Catalog.read(
str(tmpdir.join('tmp2', 'Cat3_sources.fits'))).meta
# create masks
origfolder2 = str(tmpdir.join('tmp2'))
orig = ORIGIN.load(origfolder2)
orig.step10_create_masks()
orig.write()
# list of source objects
orig = ORIGIN.load(origfolder2)
orig.step11_save_sources("0.1")
orig.step11_save_sources("0.1", n_jobs=2, overwrite=True)
orig.info()
with open(orig.logfile) as f:
log = f.read().splitlines()
assert '11 Done' in log[-1]
tbl = orig.timestat(table=True)
assert len(tbl) == 12
assert tbl.colnames == ['Step', 'Exec Date', 'Exec Time']
caplog.clear()
orig.timestat()
rec = caplog.records
assert rec[0].message.startswith('step01_preprocessing executed:')
assert rec[10].message.startswith('step11_save_sources executed:')
assert rec[11].message.startswith('*** Total run time:')
caplog.clear()
orig.stat()
assert [rec.message for rec in caplog.records] == [
'ORIGIN PCA pfa 0.01 Back Purity: 0.80 Threshold: 9.28 '
'Bright Purity 0.80 Threshold 5.46',
'Nb of detected lines: 16',
'Nb of sources Total: 6 Background: 3 Cont: 3',
'Nb of sources detected in faint (after PCA): 4 in std (before PCA): 2',
]
cat = Catalog.read(str(tmpdir.join('tmp2', 'Cat3_lines.fits')))
assert len(cat) == 16
assert max(cat['ID']) == 6
# test returned sources are valid
src1 = Source.from_file(
str(tmpdir.join('tmp2', 'sources', 'source-00001.fits')))
src2 = Source.from_file(
str(tmpdir.join('tmp2', 'sources', 'source-00002.fits')))
# FIXME: check if this test is really useful
# assert set(sp.shape[0] for sp in src.spectra.values()) == {22, 1100}
assert {ima.shape for ima in src1.images.values()} == {(25, 25)}
assert src1.cubes['MUSE_CUBE'].shape == (1100, 25, 25)
assert "SRC_TS" in src1.header
assert src1.header["CAT3_TS"] == src2.header["CAT3_TS"]
assert src1.header["SRC_TS"] == src2.header["SRC_TS"]
# Cleanup (try to close opened files to avoid warnings)
for h in orig.logger.handlers:
h.close()
