def test_release(self):
cube = marvin.tools.cube.Cube(plateifu=self.plateifu)
spaxel = Spaxel(x=15, y=16, cube=cube)
self.assertEqual(spaxel.release, 'MPL-4')
with self.assertRaises(MarvinError) as ee:
spaxel.release = 'a'
self.assertIn('the release cannot be changed', str(ee.exception))
def test_wrong_force_load(self, galaxy):
x = galaxy.dap['x']
y = galaxy.dap['y']
spaxel = Spaxel(x, y, plateifu=galaxy.plateifu, cube=True,
maps=False, modelcube=False)
with pytest.raises(AssertionError) as ee:
spaxel.load(force='crap')
assert 'force can only be cube, maps, or modelcube' in str(ee)
def _load_data(self, **kwargs):
"""Loads one of the spaxels to get the DAP properties for the binid."""
assert len(self.spaxel_coords) > 0
sample_coords = self.spaxel_coords[0]
if 'plateifu' not in kwargs:
kwargs['plateifu'] = self._maps.plateifu
sample_spaxel = Spaxel(x=sample_coords[0],
y=sample_coords[1],
cube=True,
maps=self._maps,
modelcube=self._modelcube,
load=True,
allow_binned=True,
**kwargs)
self.specres = sample_spaxel.specres
self.specresd = sample_spaxel.specresd
self.spectrum = sample_spaxel.spectrum
self.properties = sample_spaxel.properties
self.model_flux = sample_spaxel.model_flux
self.redcorr = sample_spaxel.redcorr
self.model = sample_spaxel.model
self.emline = sample_spaxel.emline
self.emline_base = sample_spaxel.emline_base
self.stellar_continuum = sample_spaxel.stellar_continuum
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_spaxel_ra_dec(self):
cube = marvin.tools.cube.Cube(plateifu=self.plateifu)
spaxel = Spaxel(x=15, y=16, cube=cube)
self.assertAlmostEqual(spaxel.ra, 232.54512, places=5)
self.assertAlmostEqual(spaxel.dec, 48.690062, places=5)
def _load_spaxels(self, **kwargs):
"""Creates a list of unloaded spaxels for this binid."""
load_spaxels = kwargs.pop('load_spaxels', False)
self.spaxel_coords = self._maps.get_bin_spaxels(self.binid,
only_list=True)
if len(self.spaxel_coords) == 0:
raise MarvinError(
'there are no spaxels associated with binid={0}.'.format(
self.binid))
else:
if 'plateifu' not in kwargs:
kwargs['plateifu'] = self._maps.plateifu
modelcube_for_spaxel = False if not self._modelcube else self._modelcube.get_unbinned(
)
self.spaxels = [
Spaxel(x=cc[0],
y=cc[1],
cube=True,
maps=self._maps.get_unbinned(),
modelcube=modelcube_for_spaxel,
load=load_spaxels,
**kwargs) for cc in self.spaxel_coords
]
def test_no_cube_maps_false_db(self):
spaxel = Spaxel(x=15, y=16, plateifu=self.plateifu, maps=False)
self.assertIsNone(spaxel.maps)
self.assertIsInstance(spaxel.cube, marvin.tools.cube.Cube)
self.assertIsInstance(spaxel.spectrum, Spectrum)
self.assertTrue(len(spaxel.properties) == 0)
def test_bad_binid(self):
spaxel = Spaxel(0, 0, plateifu='8485-1901', cube=True,
maps=True, modelcube=True, bintype='HYB10')
with pytest.raises(MarvinError) as ee:
spaxel.stellar_vel.bin.get_bin_spaxels()
assert 'do not correspond to a valid binid' in str(ee)
def test_cube_false_no_maps_db(self):
spaxel = Spaxel(x=15, y=16, plateifu=self.plateifu, cube=False)
self.assertIsNone(spaxel.cube)
self.assertIsInstance(spaxel.maps, marvin.tools.maps.Maps)
self.assertIsNone(spaxel.spectrum)
self.assertTrue(len(spaxel.properties) > 0)
def test_load_false(self):
spaxel = Spaxel(plateifu=self.plateifu, x=15, y=16, load=False)
self.assertFalse(spaxel.loaded)
self.assertTrue(spaxel.cube)
self.assertTrue(spaxel.maps)
self.assertTrue(spaxel.modelcube)
self.assertEqual(len(spaxel.properties), 0)
self.assertIsNone(spaxel.spectrum)
spaxel.load()
self.assertIsInstance(spaxel.cube, marvin.tools.cube.Cube)
self.assertIsInstance(spaxel.maps, marvin.tools.maps.Maps)
self.assertIsInstance(spaxel.spectrum, Spectrum)
self.assertTrue(len(spaxel.properties) > 0)
self.assertIsInstance(spaxel.properties, DictOfProperties)
def test_db_maps_miles(self):
spaxel = Spaxel(x=15,
y=16,
cube=False,
modelcube=False,
maps=True,
plateifu=self.plateifu,
template_kin='MILES-THIN')
self.assertEqual(spaxel.maps.template_kin, 'MILES-THIN')
def test_cube_object_db(self):
cube = marvin.tools.cube.Cube(plateifu=self.plateifu)
spaxel = Spaxel(x=15, y=16, cube=cube)
self.assertIsInstance(spaxel.cube, marvin.tools.cube.Cube)
self.assertIsInstance(spaxel.maps, marvin.tools.maps.Maps)
self.assertIsInstance(spaxel.spectrum, Spectrum)
self.assertTrue(len(spaxel.properties) > 0)
def test_force_load(self, galaxy, force):
x = galaxy.dap['x']
y = galaxy.dap['y']
spaxel = Spaxel(x, y, plateifu=galaxy.plateifu, cube=True,
maps=False, modelcube=False)
assert spaxel.cube_quantities is not None
assert spaxel.maps_quantities == {}
assert spaxel.modelcube_quantities == {}
spaxel.load(force=force)
if force == 'cube':
assert spaxel.cube_quantities is not None
elif force == 'maps':
assert spaxel.maps_quantities is not None
elif force == 'modelcube':
assert spaxel.modelcube_quantities is not None
def test_getattr(self, galaxy):
x = galaxy.dap['x']
y = galaxy.dap['y']
spaxel = Spaxel(x, y, plateifu='8485-1901', cube=True,
maps=True, modelcube=True)
assert spaxel.flux is not None
assert spaxel.emline_gflux_ha_6564 is not None
assert spaxel.binned_flux is not None
def test_api_maps_invalid_template(self):
with self.assertRaises(AssertionError) as cm:
Spaxel(x=15,
y=16,
cube=False,
modelcube=False,
maps=True,
plateifu=self.plateifu,
template_kin='MILES-TH')
self.assertIn('invalid template_kin', str(cm.exception))
def test_cube_maps_object_filename(self):
cube = marvin.tools.cube.Cube(filename=self.filename_cube)
maps = marvin.tools.maps.Maps(filename=self.filename_maps_default)
spaxel = Spaxel(x=15, y=16, cube=cube, maps=maps)
self.assertIsInstance(spaxel.cube, marvin.tools.cube.Cube)
self.assertIsInstance(spaxel.maps, marvin.tools.maps.Maps)
self.assertIsInstance(spaxel.spectrum, Spectrum)
self.assertTrue(len(spaxel.properties) > 0)
def test_fails_unbinned_maps(self):
maps = marvin.tools.maps.Maps(plateifu=self.plateifu,
bintype='VOR10',
release='MPL-5')
with self.assertRaises(MarvinError) as cm:
Spaxel(x=15, y=16, plateifu=self.plateifu, maps=maps)
self.assertIn('cannot instantiate a Spaxel from a binned Maps.',
str(cm.exception))
def test_load_all(self):
set_the_config('MPL-6')
spaxel = Spaxel(26, 13, plateifu='8485-1901', cube=True,
maps=True, modelcube=True, bintype='HYB10', release='MPL-6')
assert isinstance(spaxel, Spaxel)
bin_spaxels = spaxel.stellar_vel.bin.get_bin_spaxels(lazy=False)
assert len(bin_spaxels) > 0
assert bin_spaxels[0].loaded is True
def test_cube_maps_object_api(self):
cube = marvin.tools.cube.Cube(plateifu=self.plateifu, mode='remote')
maps = marvin.tools.maps.Maps(plateifu=self.plateifu, mode='remote')
spaxel = Spaxel(x=15, y=16, cube=cube, maps=maps)
self.assertIsInstance(spaxel.cube, marvin.tools.cube.Cube)
self.assertIsInstance(spaxel.maps, marvin.tools.maps.Maps)
self.assertIsInstance(spaxel.spectrum, Spectrum)
self.assertTrue(len(spaxel.properties) > 0)
self.assertIsInstance(spaxel.properties, DictOfProperties)
def test_dir(self, galaxy):
x = galaxy.dap['x']
y = galaxy.dap['y']
spaxel = Spaxel(x, y, plateifu='8485-1901', cube=True,
maps=True, modelcube=True)
dir_list = dir(spaxel)
assert 'flux' in dir_list
assert 'emline_gflux_ha_6564' in dir_list
assert 'binned_flux' in dir_list
def test_files_maps(self, galaxy):
x = galaxy.dap['x']
y = galaxy.dap['y']
spaxel = Spaxel(x, y,
cube=False,
maps=galaxy.mapspath,
modelcube=False)
assert isinstance(spaxel, Spaxel)
assert not isinstance(spaxel._cube, Cube)
assert isinstance(spaxel._maps, Maps)
assert not isinstance(spaxel._modelcube, ModelCube)
def test_cube_maps_object_filename_mpl5(self):
marvin.config.setMPL('MPL-5')
cube = marvin.tools.cube.Cube(filename=self.filename_cube)
maps = marvin.tools.maps.Maps(filename=self.filename_maps_default)
spaxel = Spaxel(x=15, y=16, cube=cube, maps=maps)
self.assertEqual(cube._drpver, 'v1_5_1')
self.assertEqual(spaxel._drpver, 'v1_5_1')
self.assertEqual(maps._drpver, 'v1_5_1')
self.assertEqual(maps._dapver, '1.1.1')
self.assertEqual(spaxel._dapver, '1.1.1')
self.assertIsInstance(spaxel.cube, marvin.tools.cube.Cube)
self.assertIsInstance(spaxel.maps, marvin.tools.maps.Maps)
self.assertIsInstance(spaxel.spectrum, Spectrum)
self.assertTrue(len(spaxel.properties) > 0)
def test_pickling_data(self, temp_scratch, galaxy):
drpver, __ = config.lookUpVersions()
maps = Maps(filename=galaxy.mapspath)
modelcube = ModelCube(filename=galaxy.modelpath)
spaxel = maps.getSpaxel(25, 15, xyorig='lower', drp=False, models=modelcube)
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.stellar_vel.value is not None
assert spaxel_restored.stellar_vel.bin.binid is not None
def _getSpaxel(name, x, y, **kwargs):
"""Retrieves a Marvin Spaxel object."""
spaxel = None
results = {}
# Pop the release to remove a duplicate input to Maps
release = kwargs.pop('release', None)
# parse name into either mangaid or plateifu
try:
idtype = parseIdentifier(name)
except Exception as e:
results['error'] = 'Failed to parse input name {0}: {1}'.format(
name, str(e))
return spaxel, results
try:
if idtype == 'plateifu':
plateifu = name
mangaid = None
elif idtype == 'mangaid':
mangaid = name
plateifu = None
else:
raise MarvinError(
'invalid plateifu or mangaid: {0}'.format(idtype))
spaxel = Spaxel(x=x,
y=y,
mangaid=mangaid,
plateifu=plateifu,
release=release,
**kwargs)
results['status'] = 1
except Exception as e:
results['error'] = 'Failed to retrieve Spaxels {0}: {1}'.format(
name, str(e))
return spaxel, results
def get_bin_spaxels(self, lazy=True):
"""Returns a list of the spaxels associated with this bin.
Parameters
----------
lazy : bool
If ``True``, the spaxels returned will be lazy loaded. Spaxels
can be fully loaded by calling their `~.Spaxel.load` method.
Returns
-------
spaxels : list
A list of all the `.Spaxel` instances associated with this
quantity binid.
"""
if self.binid < 0:
raise marvin.core.exceptions.MarvinError(
'coordinates ({}, {}) do not correspond to a valid binid.'.
format(self._spaxel.x, self._spaxel.y))
spaxel_coords = zip(*numpy.where(self.binid_map.value == self.binid))
spaxels = []
for ii, jj in spaxel_coords:
spaxels.append(
Spaxel(x=jj,
y=ii,
plateifu=self._spaxel.plateifu,
release=self._spaxel.release,
cube=self._spaxel._cube,
maps=self._spaxel._maps,
modelcube=self._spaxel._modelcube,
bintype=self._spaxel.bintype,
template=self._spaxel.template,
lazy=lazy))
return spaxels
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_files_modelcube(self, galaxy):
x = galaxy.dap['x']
y = galaxy.dap['y']
if galaxy.release == 'MPL-4':
pytest.skip()
else:
modelcube_filename = galaxy.modelpath
spaxel = Spaxel(x, y,
cube=False,
maps=False,
modelcube=modelcube_filename)
assert isinstance(spaxel, Spaxel)
assert not isinstance(spaxel._cube, Cube)
assert not isinstance(spaxel._maps, Maps)
if galaxy.release != 'MPL-4':
assert isinstance(spaxel._modelcube, ModelCube)
def test_no_inputs(self):
with pytest.raises(MarvinError) as ee:
Spaxel(0, 0, cube=None, maps=None, modelcube=None)
assert 'no inputs defined' in str(ee)
def test_SpaxelBase(self, galaxy, cube_maps_modelcube_modes):
plateifu = galaxy.plateifu
bintype = galaxy.bintype.name
template = galaxy.template.name
release = galaxy.release
x = galaxy.dap['x']
y = galaxy.dap['y']
cube, maps, modelcube = cube_maps_modelcube_modes
if cube == 'object':
cube = Cube(plateifu=plateifu, release=release)
if maps == 'object':
maps = Maps(plateifu=plateifu,
bintype=bintype,
template=template,
release=release)
if release == 'MPL-4':
modelcube = False
elif modelcube == 'object':
modelcube = ModelCube(plateifu=plateifu,
bintype=bintype,
template=template,
release=release)
if cube is False and maps is False and modelcube is False:
pytest.skip()
spaxel = Spaxel(x,
y,
plateifu=plateifu,
cube=cube,
maps=maps,
modelcube=modelcube,
template=template,
bintype=bintype)
assert isinstance(spaxel, Spaxel)
if (spaxel.bintype is not None and spaxel.bintype.binned is True
and (spaxel._maps or spaxel._modelcube)):
assert isinstance(spaxel, Spaxel)
else:
assert isinstance(spaxel, Spaxel)
if spaxel._cube:
assert len(spaxel.cube_quantities) > 0
else:
assert len(spaxel.cube_quantities) == 0
if spaxel._maps:
assert len(spaxel.maps_quantities) > 0
else:
assert len(spaxel.maps_quantities) == 0
if spaxel._modelcube:
assert len(spaxel.modelcube_quantities) > 0
else:
assert len(spaxel.modelcube_quantities) == 0
assert spaxel.plateifu == galaxy.plateifu
assert spaxel.mangaid == galaxy.mangaid
assert isinstance(spaxel.getCube(), Cube)
assert isinstance(spaxel.getMaps(), Maps)
if release != 'MPL-4':
assert isinstance(spaxel.getModelCube(), ModelCube)
def convertToTool(self, tooltype, **kwargs):
''' Converts the list of results into Marvin Tool objects
Creates a list of Marvin Tool objects from a set of query results.
The new list is stored in the Results.objects property.
If the Query.returntype parameter is specified, then the Results object
will automatically convert the results to the desired Tool on initialization.
Parameters:
tooltype (str):
The requested Marvin Tool object that the results are converted into.
Overrides the returntype parameter. If not set, defaults
to the returntype parameter.
limit (int):
Limit the number of results you convert to Marvin tools. Useful
for extremely large result sets. Default is None.
mode (str):
The mode to use when attempting to convert to Tool. Default mode
is to use the mode internal to Results. (most often remote mode)
Example:
>>> # Get the results from some query
>>> r = q.run()
>>> r.results
>>> [NamedTuple(mangaid=u'14-12', name=u'1901', nsa.z=-9999.0),
>>> NamedTuple(mangaid=u'14-13', name=u'1902', nsa.z=-9999.0),
>>> NamedTuple(mangaid=u'27-134', name=u'1901', nsa.z=-9999.0),
>>> NamedTuple(mangaid=u'27-100', name=u'1902', nsa.z=-9999.0),
>>> NamedTuple(mangaid=u'27-762', name=u'1901', nsa.z=-9999.0)]
>>> # convert results to Marvin Cube tools
>>> r.convertToTool('cube')
>>> r.objects
>>> [<Marvin Cube (plateifu='7444-1901', mode='remote', data_origin='api')>,
>>> <Marvin Cube (plateifu='7444-1902', mode='remote', data_origin='api')>,
>>> <Marvin Cube (plateifu='7995-1901', mode='remote', data_origin='api')>,
>>> <Marvin Cube (plateifu='7995-1902', mode='remote', data_origin='api')>,
>>> <Marvin Cube (plateifu='8000-1901', mode='remote', data_origin='api')>]
'''
# set the desired tool type
mode = kwargs.get('mode', self.mode)
limit = kwargs.get('limit', None)
toollist = ['cube', 'spaxel', 'maps', 'rss', 'modelcube']
tooltype = tooltype if tooltype else self.returntype
assert tooltype in toollist, 'Returned tool type must be one of {0}'.format(toollist)
# get the parameter list to check against
paramlist = self.paramtocol.keys()
print('Converting results to Marvin {0} objects'.format(tooltype.title()))
if tooltype == 'cube':
self.objects = [Cube(plateifu=res.__getattribute__(
self._getRefName('cube.plateifu')),
mode=mode) for res in self.results[0:limit]]
elif tooltype == 'maps':
isbin = 'bintype.name' in paramlist
istemp = 'template.name' in paramlist
self.objects = []
for res in self.results[0:limit]:
mapkwargs = {'mode': mode, 'plateifu': res.__getattribute__(self._getRefName('cube.plateifu'))}
if isbin:
binval = res.__getattribute__(self._getRefName('bintype.name'))
mapkwargs['bintype'] = binval
if istemp:
tempval = res.__getattribute__(self._getRefName('template.name'))
mapkwargs['template_kin'] = tempval
self.objects.append(Maps(**mapkwargs))
elif tooltype == 'spaxel':
assert 'spaxelprop.x' in paramlist and 'spaxelprop.y' in paramlist, \
'Parameters must include spaxelprop.x and y in order to convert to Marvin Spaxel.'
self.objects = []
load = kwargs.get('load', True)
maps = kwargs.get('maps', True)
modelcube = kwargs.get('modelcube', True)
for res in self.results[0:limit]:
spaxkwargs = {'plateifu': res.__getattribute__(self._getRefName('cube.plateifu')),
'x': res.__getattribute__(self._getRefName('spaxelprop.x')),
'y': res.__getattribute__(self._getRefName('spaxelprop.y')),
'load': load, 'maps': maps, 'modelcube': modelcube}
self.objects.append(Spaxel(**spaxkwargs))
elif tooltype == 'rss':
self.objects = [RSS(plateifu=res.__getattribute__(
self._getRefName('cube.plateifu')),
mode=mode) for res in self.results[0:limit]]
elif tooltype == 'modelcube':
isbin = 'bintype.name' in paramlist
istemp = 'template.name' in paramlist
self.objects = []
for res in self.results[0:limit]:
mapkwargs = {'mode': mode, 'plateifu': res.__getattribute__(self._getRefName('cube.plateifu'))}
if isbin:
binval = res.__getattribute__(self._getRefName('bintype.name'))
mapkwargs['bintype'] = binval
if istemp:
tempval = res.__getattribute__(self._getRefName('template.name'))
mapkwargs['template_kin'] = tempval
self.objects.append(ModelCube(**mapkwargs))
