def _get_a_file(self, filename, local=None):
''' Retrieve a file served locally or remotely over the internet
Will retrieve a local filename or grab the file
contents remotely from the SAS
Parameters:
filename (str):
Full filepath to load
local (bool):
If True, does a local system check
Returns:
A file object to be read in by Yanny
'''
if local:
if not os.path.exists(filename):
raise MarvinError(
'No {0} file found locally.'.format(filename))
else:
fileobj = filename
else:
r = requests.get(filename)
if not r.ok:
raise MarvinError(
'Could not retrieve {0} file remotely'.format(filename))
else:
fileobj = stringio(r.content.decode())
return fileobj
def _getIdleProcesses(self):
''' Get a list of all idle processes on server
This grabs a list of all processes in a state of
idle, or idle in transaction using pg_stat_activity
and returns the process id, the state, and the query
'''
if self.mode == 'local':
sql = ("select p.pid,p.state,p.query from pg_stat_activity as p \
where p.state ilike '%idle%';")
res = self.session.execute(sql)
procs = res.fetchall()
elif self.mode == 'remote':
# Fail if no route map initialized
if not config.urlmap:
raise MarvinError('No URL Map found. Cannot make remote call')
# Get the query route
url = config.urlmap['api']['cleanupqueries']['url']
params = {'task': 'getprocs', 'release': self._release}
try:
ii = Interaction(route=url, params=params)
except Exception as e:
raise MarvinError('API Query call failed: {0}'.format(e))
else:
procs = ii.getData()
return procs
def _check_file(header, data, objtype):
''' Check the file input to ensure correct tool '''
# get/check various header keywords
bininhdr = ('binkey' in header) or ('bintype' in header)
dapinhdr = 'dapfrmt' in header
dapfrmt = header['DAPFRMT'] if dapinhdr else None
# check the file
if objtype == 'Maps' or objtype == 'ModelCube':
# get indices in daptype
daptype = ['MAPS', 'LOGCUBE']
dapindex = daptype.index(
"MAPS") if objtype == 'Maps' else daptype.index("LOGCUBE")
altdap = 1 - dapindex
# check for emline_gflux extension
gfluxindata = 'EMLINE_GFLUX' in data
wronggflux = (gfluxindata and objtype == 'ModelCube') or \
(not gfluxindata and objtype == 'Maps')
if not bininhdr:
raise MarvinError(
'Trying to open a non DAP file with Marvin {0}'.format(
objtype))
else:
if (dapfrmt and dapfrmt != daptype[dapindex]) or (wronggflux):
raise MarvinError(
'Trying to open a DAP {0} with Marvin {1}'.format(
daptype[altdap], objtype))
elif objtype == 'Cube':
if bininhdr or dapinhdr:
raise MarvinError('Trying to open a DAP file with Marvin Cube')
def _doLocal(self):
"""Tests if it's possible to load the data locally."""
if self.filename:
if os.path.exists(self.filename):
self.mode = 'local'
self.data_origin = 'file'
else:
raise MarvinError('input file {0} not found'.format(
self.filename))
elif self.plateifu:
testDbConnection(marvindb.session)
if marvindb.db and not self._ignore_db:
self.mode = 'local'
self.data_origin = 'db'
else:
fullpath = self._getFullPath()
if fullpath and os.path.exists(fullpath):
self.mode = 'local'
self.filename = fullpath
self.data_origin = 'file'
else:
if self._forcedownload:
self.download()
self.data_origin = 'file'
else:
raise MarvinError('this is the end of the road. '
'Try using some reasonable inputs.')
def _get_dapall_from_db(self):
"""Uses the DB to retrieve the DAPAll data."""
dapall_data = {}
daptype = self.bintype.name + '-' + self.template.name
mdb = marvin.marvindb
if not mdb.isdbconnected:
raise MarvinError('No DB connected')
datadb = mdb.datadb
dapdb = mdb.dapdb
dapall_row = mdb.session.query(dapdb.DapAll).join(
dapdb.File, datadb.PipelineInfo, datadb.PipelineVersion).filter(
mdb.datadb.PipelineVersion.version == self._dapver,
dapdb.DapAll.plateifu == self.plateifu,
dapdb.DapAll.daptype == daptype).first()
if dapall_row is None:
raise MarvinError('cannot find a DAPall match for this target in the DB.')
for col in dapall_row.__table__.columns.keys():
if col != 'pk' and '_pk' not in col:
dapall_data[col] = getattr(dapall_row, col)
return dapall_data
def _get_column(results, colname, format_type=None):
''' Gets a column from a Query
Parameters:
results (obj):
A set of Marvin Results
colname (str):
The name of the column to extract
format_type (str):
The format of the dictionary
Returns:
A list of data for that column
'''
column = None
if format_type == 'list':
try:
column = results.getListOf(colname)
except MarvinError as e:
raise MarvinError('Cannot get list for column {0}: {1}'.format(
colname, e))
elif format_type in ['listdict', 'dictlist']:
try:
if colname == 'None':
column = results.getDictOf(format_type=format_type)
else:
column = results.getDictOf(colname, format_type=format_type)
except MarvinError as e:
raise MarvinError(
'Cannot get dictionary for column {0}: {1}'.format(colname, e))
return column
def _load_modelcube_from_db(self):
"""Initialises a model cube from the DB."""
mdb = marvin.marvindb
plate, ifu = self.plateifu.split('-')
if not mdb.isdbconnected:
raise MarvinError('No db connected')
else:
datadb = mdb.datadb
dapdb = mdb.dapdb
if self.data:
assert isinstance(self.data, dapdb.ModelCube), \
'data is not an instance of marvindb.dapdb.ModelCube.'
else:
# Initial query for version
version_query = mdb.session.query(dapdb.ModelCube).join(
dapdb.File, datadb.PipelineInfo,
datadb.PipelineVersion).filter(
datadb.PipelineVersion.version ==
self._dapver).from_self()
# Query for model cube parameters
db_modelcube = version_query.join(
dapdb.File, datadb.Cube, datadb.IFUDesign).filter(
datadb.Cube.plate == plate,
datadb.IFUDesign.name == str(ifu)).from_self().join(
dapdb.File, dapdb.FileType
).filter(dapdb.FileType.value == 'LOGCUBE').join(
dapdb.Structure, dapdb.BinType).join(
dapdb.Template, dapdb.Structure.template_kin_pk
== dapdb.Template.pk).filter(
dapdb.BinType.name == self.bintype.name,
dapdb.Template.name ==
self.template.name).all()
if len(db_modelcube) > 1:
raise MarvinError('more than one ModelCube found for '
'this combination of parameters.')
elif len(db_modelcube) == 0:
raise MarvinError(
'no ModelCube found for this combination of parameters.'
)
self.data = db_modelcube[0]
self.header = self.data.file.primary_header
self.wcs = WCS(self.data.file.cube.wcs.makeHeader())
self._wavelength = np.array(
self.data.file.cube.wavelength.wavelength, dtype=np.float)
self._redcorr = np.array(self.data.redcorr[0].value,
dtype=np.float)
self._shape = self.data.file.cube.shape.shape
self.plateifu = str(self.header['PLATEIFU'].strip())
self.mangaid = str(self.header['MANGAID'].strip())
def getSubset(self, start, limit=10):
''' Extracts a subset of results
Parameters:
start (int):
The starting index of your subset extraction
limit (int):
The limiting number of results to return.
Returns:
results (list):
A list of query results
Example:
>>> r = q.run()
>>> r.getSubset(0, 10)
>>> [(u'14-12', u'1901', -9999.0),
>>> (u'14-13', u'1902', -9999.0),
>>> (u'27-134', u'1901', -9999.0),
>>> (u'27-100', u'1902', -9999.0),
>>> (u'27-762', u'1901', -9999.0),
>>> (u'27-759', u'1902', -9999.0),
>>> (u'27-827', u'1901', -9999.0),
>>> (u'27-828', u'1902', -9999.0),
>>> (u'27-1170', u'1901', -9999.0),
>>> (u'27-1167', u'1902', -9999.0)]
'''
start = 0 if int(start) < 0 else int(start)
end = start + int(limit)
# if end > self.count:
# end = self.count
# start = end - int(limit)
self.start = start
self.end = end
self.chunk = limit
if self.mode == 'local':
self.results = self.query.slice(start, end).all()
elif self.mode == 'remote':
# Fail if no route map initialized
if not config.urlmap:
raise MarvinError('No URL Map found. Cannot make remote call')
# Get the query route
url = config.urlmap['api']['getsubset']['url']
params = {'searchfilter': self.searchfilter, 'params': self.returnparams,
'start': start, 'end': end, 'limit': self.limit,
'sort': self.sortcol, 'order': self.order}
try:
ii = Interaction(route=url, params=params)
except MarvinError as e:
raise MarvinError('API Query GetNext call failed: {0}'.format(e))
else:
self.results = ii.getData()
self._makeNamedTuple()
if self.returntype:
self.convertToTool()
return self.results
def _load_rss_from_api(self):
"""Initialises the RSS object using the remote API."""
# Checks that the RSS exists.
routeparams = {'name': self.plateifu}
url = marvin.config.urlmap['api']['getRSS']['url'].format(**routeparams)
try:
response = self._toolInteraction(url.format(name=self.plateifu))
except Exception as ee:
raise MarvinError('found a problem when checking if remote RSS '
'exists: {0}'.format(str(ee)))
data = response.getData()
self.header = fits.Header.fromstring(data['header'])
self.wcs = astropy.wcs.WCS(fits.Header.fromstring(data['wcs_header']))
self._wavelength = data['wavelength']
self._nfibers = data['nfibers']
self.obsinfo = astropy.io.ascii.read(data['obsinfo'])
if self.plateifu != data['plateifu']:
raise MarvinError('remote RSS has a different plateifu!')
return
def _load_rss_from_db(self):
"""Initialises the RSS object from the DB."""
import sqlalchemy
mdb = marvin.marvindb
if not mdb.isdbconnected:
raise MarvinError('No db connected')
plate, ifudesign = [item.strip() for item in self.plateifu.split('-')]
try:
self.data = mdb.session.query(mdb.datadb.RssFiber).join(
mdb.datadb.Cube, mdb.datadb.PipelineInfo,
mdb.datadb.PipelineVersion, mdb.datadb.IFUDesign).filter(
mdb.datadb.PipelineVersion.version == self._drpver,
mdb.datadb.Cube.plate == plate,
mdb.datadb.IFUDesign.name == ifudesign).all()
except sqlalchemy.orm.exc.NoResultFound as ee:
raise MarvinError('Could not retrieve RSS for plate-ifu {0}: '
'No Results Found: {1}'.format(
self.plateifu, ee))
except Exception as ee:
raise MarvinError('Could not retrieve RSS for plate-ifu {0}: '
'Unknown exception: {1}'.format(
self.plateifu, ee))
if not self.data:
raise MarvinError('Could not retrieve RSS for plate-ifu {0}: '
'Unknown error.'.format(self.plateifu))
def restore(path, delete=False):
"""Restores a MarvinToolsClass object from a pickled file.
If ``delete=True``, the pickled file will be removed after it has been
unplickled. Note that, for objects with ``data_origin='file'``, the
original file must exists and be in the same path as when the object
was first created.
"""
assert isinstance(path, string_types), 'path must be a string.'
path = os.path.realpath(os.path.expanduser(path))
if os.path.isdir(path):
raise MarvinError('path must be a full route, including the filename.')
if not os.path.exists(path):
raise MarvinError('the path does not exists.')
try:
with open(path, 'rb') as fin:
obj = pickle.load(fin)
except Exception as ee:
raise MarvinError(
'something went wrong unplicking the object: {0}'.format(str(ee)))
if delete is True:
os.remove(path)
return obj
def get_binid(self, model=None):
"""Returns the 2D array for the binid map associated with ``model``."""
assert model is None or isinstance(model, Model), 'invalid model type.'
if model is not None:
binid_prop = model.binid
else:
binid_prop = self.datamodel.parent.default_binid
# Before MPL-6, the modelcube does not include the binid extension,
# so we need to get the binid map from the associated MAPS.
if (distutils.version.StrictVersion(self._dapver) <
distutils.version.StrictVersion('2.1')):
return self.getMaps().get_binid()
if self.data_origin == 'file':
if binid_prop.channel is None:
return self.data[binid_prop.name].data[:, :]
else:
return self.data[binid_prop.name].data[binid_prop.channel.idx, :, :]
elif self.data_origin == 'db':
mdb = marvin.marvindb
table = mdb.dapdb.ModelSpaxel
column = getattr(table, binid_prop.db_column())
binid_list = mdb.session.query(column).filter(
table.modelcube_pk == self.data.pk).order_by(table.x, table.y).all()
nx = ny = int(np.sqrt(len(binid_list)))
binid_array = np.array(binid_list)
return binid_array.transpose().reshape((ny, nx)).transpose(1, 0)
elif self.data_origin == 'api':
params = {'release': self._release}
url = marvin.config.urlmap['api']['getModelCubeBinid']['url']
extension = model.fits_extension().lower() if model is not None else 'flux'
try:
response = self._toolInteraction(
url.format(name=self.plateifu,
modelcube_extension=extension,
bintype=self.bintype.name,
template=self.template.name), params=params)
except Exception as ee:
raise MarvinError('found a problem when checking if remote '
'modelcube exists: {0}'.format(str(ee)))
if response.results['error'] is not None:
raise MarvinError('found a problem while getting the binid from API: {}'
.format(str(response.results['error'])))
return np.array(response.getData()['binid'])
def _doLocal(self):
"""Tests if it's possible to load the data locally."""
if self.filename:
if os.path.exists(self.filename):
self.mode = 'local'
self.data_origin = 'file'
else:
raise MarvinError('input file {0} not found'.format(
self.filename))
elif self.plateifu:
from marvin import marvindb
if marvindb:
testDbConnection(marvindb.session)
if marvindb and marvindb.db and not self._ignore_db:
self.mode = 'local'
self.data_origin = 'db'
else:
fullpath = self._getFullPath()
if fullpath and os.path.exists(fullpath):
self.mode = 'local'
self.filename = fullpath
self.data_origin = 'file'
else:
if self._forcedownload:
self.download()
self.data_origin = 'file'
else:
raise MarvinError('failed to retrieve data using '
'input parameters.')
def save(self, path=None, overwrite=False):
''' Save the results as a pickle object
Parameters:
path (str):
Filepath and name of the pickled object
overwrite (bool):
Set this to overwrite an existing pickled file
Returns:
path (str):
The filepath and name of the pickled object
'''
# set Marvin query object to None, in theory this could be pickled as well
self._queryobj = None
try:
isnotstr = type(self.query) != unicode
except NameError as e:
isnotstr = type(self.query) != str
if isnotstr:
self.query = None
sf = self.searchfilter.replace(' ', '') if self.searchfilter else 'anon'
# set the path
if not path:
path = os.path.expanduser('~/marvin_results_{0}.mpf'.format(sf))
# check for file extension
if not os.path.splitext(path)[1]:
path = os.path.join(path+'.mpf')
path = os.path.realpath(path)
if os.path.isdir(path):
raise MarvinError('path must be a full route, including the filename.')
if os.path.exists(path) and not overwrite:
warnings.warn('file already exists. Not overwriting.', MarvinUserWarning)
return
dirname = os.path.dirname(path)
if not os.path.exists(dirname):
os.makedirs(dirname)
try:
pickle.dump(self, open(path, 'wb'), protocol=-1)
except Exception as ee:
if os.path.exists(path):
os.remove(path)
raise MarvinError('Error found while pickling: {0}'.format(str(ee)))
return path
def __init__(self, *args, **kwargs):
valid_kwargs = [
'data', 'cube', 'maps', 'filename', 'mangaid', 'plateifu', 'mode',
'release', 'bintype', 'template_kin', 'template_pop', 'nsa_source'
]
assert len(args) == 0, 'Maps does not accept arguments, only keywords.'
for kw in kwargs:
assert kw in valid_kwargs, 'keyword {0} is not valid'.format(kw)
if kwargs.pop('template_pop', None):
warnings.warn('template_pop is not yet in use. Ignoring value.',
MarvinUserWarning)
self.bintype = kwargs.pop('bintype',
marvin.tools.maps.__BINTYPES_UNBINNED__)
self.template_kin = kwargs.pop(
'template_kin', marvin.tools.maps.__TEMPLATES_KIN_DEFAULT__)
self.template_pop = None
super(ModelCube, self).__init__(*args, **kwargs)
# Checks that DAP is at least MPL-5
MPL5 = distutils.version.StrictVersion('2.0.2')
if self.filename is None and distutils.version.StrictVersion(
self._dapver) < MPL5:
raise MarvinError('ModelCube requires at least dapver=\'2.0.2\'')
self._cube = kwargs.pop('cube', None)
self._maps = kwargs.pop('maps', None)
assert self.bintype in marvin.tools.maps.__BINTYPES__, \
'bintype must be on of {0}'.format(marvin.tools.maps.__BINTYPES__)
assert self.template_kin in marvin.tools.maps.__TEMPLATES_KIN__, \
'template_kin must be on of {0}'.format(marvin.tools.maps.__TEMPLATES_KIN__)
self.header = None
self.wcs = None
self.shape = None
self.wavelength = None
if self.data_origin == 'file':
self._load_modelcube_from_file()
elif self.data_origin == 'db':
self._load_modelcube_from_db()
elif self.data_origin == 'api':
self._load_modelcube_from_api()
else:
raise MarvinError('data_origin={0} is not valid'.format(
self.data_origin))
# Confirm that drpver and dapver match the ones from the header.
marvin.tools.maps.Maps._check_versions(self)
def save(obj, path=None, overwrite=False):
"""Pickles the object.
If ``path=None``, uses the default location of the file in the tree
but changes the extension of the file to ``.mpf`` (MaNGA Pickle File).
Returns the path of the saved pickle file.
"""
from marvin.core.core import MarvinToolsClass
if path is None:
assert isinstance(
obj,
MarvinToolsClass), 'path=None is only allowed for core objects.'
path = obj._getFullPath()
assert isinstance(path, string_types), 'path must be a string.'
if path is None:
raise MarvinError('cannot determine the default path in the '
'tree for this file. You can overcome this '
'by calling save with a path keyword with '
'the path to which the file should be saved.')
# Replaces the extension (normally fits) with mpf
if '.fits.gz' in path:
path = path.strip('.fits.gz')
else:
path = os.path.splitext(path)[0]
path += '.mpf'
path = os.path.realpath(os.path.expanduser(path))
if os.path.isdir(path):
raise MarvinError('path must be a full route, including the filename.')
if os.path.exists(path) and not overwrite:
warnings.warn('file already exists. Not overwriting.',
MarvinUserWarning)
return
dirname = os.path.dirname(path)
if not os.path.exists(dirname):
os.makedirs(dirname)
try:
with open(path, 'wb') as fout:
pickle.dump(obj, fout, protocol=-1)
except Exception as ee:
if os.path.exists(path):
os.remove(path)
raise MarvinError('error found while pickling: {0}'.format(str(ee)))
return path
def _getCube(name, use_file=False, release=None, **kwargs):
''' Retrieve a cube using marvin tools '''
drpver, __ = config.lookUpVersions(release)
cube = None
results = {}
# parse name into either mangaid or plateifu
try:
idtype = parseIdentifier(name)
except Exception as ee:
results['error'] = 'Failed to parse input name {0}: {1}'.format(name, str(ee))
return cube, results
filename = None
plateifu = None
mangaid = None
try:
if use_file:
if idtype == 'mangaid':
plate, ifu = mangaid2plateifu(name, drpver=drpver)
elif idtype == 'plateifu':
plate, ifu = name.split('-')
if Path is not None:
filename = Path(release=release).full('mangacube', ifu=ifu, plate=plate, drpver=drpver, wave='LOG')
assert os.path.exists(filename), 'file not found.'
else:
raise MarvinError('cannot create path for MaNGA cube.')
else:
if idtype == 'plateifu':
plateifu = name
elif idtype == 'mangaid':
mangaid = name
else:
raise MarvinError('invalid plateifu or mangaid: {0}'.format(idtype))
cube = Cube(filename=filename, mangaid=mangaid, plateifu=plateifu,
mode='local', release=release)
results['status'] = 1
except Exception as ee:
results['error'] = 'Failed to retrieve cube {0}: {1}'.format(name, str(ee))
return cube, results
def _getRSS(name, use_file=True, release=None, **kwargs):
"""Retrieves a RSS Marvin object."""
drpver, __ = marvin.config.lookUpVersions(release)
rss = None
results = {}
# parse name into either mangaid or plateifu
try:
idtype = parseIdentifier(name)
except Exception as ee:
results['error'] = 'Failed to parse input name {0}: {1}'.format(name, str(ee))
return rss, results
filename = None
plateifu = None
mangaid = None
try:
if use_file:
if idtype == 'mangaid':
plate, ifu = mangaid2plateifu(name, drpver=drpver)
elif idtype == 'plateifu':
plate, ifu = name.split('-')
if Path is not None:
filename = Path().full('mangarss', ifu=ifu, plate=plate, drpver=drpver)
assert os.path.exists(filename), 'file not found.'
else:
raise MarvinError('cannot create path for MaNGA rss.')
else:
if idtype == 'plateifu':
plateifu = name
elif idtype == 'mangaid':
mangaid = name
else:
raise MarvinError('invalid plateifu or mangaid: {0}'.format(idtype))
rss = marvin.tools.RSS(filename=filename, mangaid=mangaid, plateifu=plateifu,
mode='local', release=release)
results['status'] = 1
except Exception as ee:
results['error'] = 'Failed to retrieve RSS {0}: {1}'.format(name, str(ee))
return rss, results
def _determine_inputs(self, input):
"""Determines what inputs to use in the decision tree."""
if input:
assert self.filename is None and self.plateifu is None and self.mangaid is None, \
'if input is set, filename, plateifu, and mangaid cannot be set.'
assert isinstance(input,
six.string_types), 'input must be a string.'
input_dict = self._parse_input(input)
if input_dict['plate'] is not None and input_dict[
'ifu'] is not None:
self.plateifu = input
elif input_dict['plate'] is not None and input_dict['ifu'] is None:
self._plate = input
elif input_dict['mangaid'] is not None:
self.mangaid = input
else:
# Assumes the input must be a filename
self.filename = input
if self.filename is None and self.mangaid is None and self.plateifu is None:
raise MarvinError('no inputs defined.')
if self.filename:
self.mangaid = None
self.plateifu = None
if self.mode == 'remote':
raise MarvinError('filename not allowed in remote mode.')
assert os.path.exists(self.filename), \
'filename {} does not exist.'.format(str(self.filename))
elif self.plateifu:
assert not self.filename, 'invalid set of inputs.'
elif self.mangaid:
assert not self.filename, 'invalid set of inputs.'
self.plateifu = mangaid2plateifu(self.mangaid,
drpall=self._drpall,
drpver=self._drpver)
elif self._plate:
assert not self.filename, 'invalid set of inputs.'
def lookUpVersions(self, release=None):
"""Retrieve the DRP and DAP versions that make up a release version.
Parameters:
release (str or None):
The release version. If ``None``, uses the currently set
``release`` value.
Returns:
drpver, dapver (tuple):
A tuple of strings of the DRP and DAP versions according
to the input MPL version
"""
release = release or self.release
try:
drpver, dapver = self._mpldict[release]
except KeyError:
raise MarvinError(
'MPL/DR version {0} not found in lookup table. '
'No associated DRP/DAP versions. '
'Should they be added? Check for typos.'.format(release))
return drpver, dapver
def _load_modelcube_from_api(self):
"""Initialises a model cube from the API."""
url = marvin.config.urlmap['api']['getModelCube']['url']
url_full = url.format(name=self.plateifu,
bintype=self.bintype.name,
template=self.template.name)
try:
response = self._toolInteraction(url_full)
except Exception as ee:
raise MarvinError(
'found a problem when checking if remote model cube '
'exists: {0}'.format(str(ee)))
data = response.getData()
self.header = fits.Header.fromstring(data['header'])
self.wcs = WCS(fits.Header.fromstring(data['wcs_header']))
self._wavelength = np.array(data['wavelength'])
self._redcorr = np.array(data['redcorr'])
self._shape = tuple(data['shape'])
self.plateifu = str(self.header['PLATEIFU'].strip())
self.mangaid = str(self.header['MANGAID'].strip())
def getDir3d(inputid, mode=None, release=None):
''' Get the 3d redux Image directory from an input plate or plate-IFU '''
idtype = parseIdentifier(inputid)
if idtype == 'plate':
plateid = inputid
elif idtype == 'plateifu':
plateid, __ = inputid.split('-')
release = marvin.config.release if not release else release
drpver, __ = marvin.config.lookUpVersions(release=release)
if check_versions(drpver, 'v1_5_4'):
from marvin.tools.plate import Plate
try:
plate = Plate(plate=plateid, nocubes=True, mode=mode, release=release)
except Exception as e:
raise MarvinError('Could not retrieve a remote plate. If it is a mastar '
'plate you are after, Marvin currently does not handle those: {0}'.format(e))
else:
dir3d = plate.dir3d
else:
dir3d = 'stack'
return dir3d
def get_available_params(self):
''' Retrieve the available parameters to query on
Retrieves a list of all the available query parameters.
Used primarily for the web autocompletion.
Parameters:
Returns:
mykeys (list):
a list of all of the available queryable parameters
'''
if self.mode == 'local':
keys = list(self.marvinform._param_form_lookup.keys())
keys.sort()
rev = {v: k for k, v in self.marvinform._param_form_lookup._tableShortcuts.items()}
# simplify the spaxelprop list down to one set
mykeys = [k.split('.', 1)[-1] for k in keys if 'cleanspaxel' not in k]
mykeys = [k.replace(k.split('.')[0], 'spaxelprop') if 'spaxelprop'
in k else k for k in mykeys]
# replace table names with shortcut names
newkeys = [k.replace(k.split('.')[0], rev[k.split('.')[0]]) if k.split('.')[0] in rev.keys() else k for k in mykeys]
return newkeys
elif self.mode == 'remote':
# Get the query route
url = config.urlmap['api']['getparams']['url']
params = {'paramdisplay': 'all'}
try:
ii = Interaction(route=url, params=params)
except MarvinError as e:
raise MarvinError('API Query call to get params failed: {0}'.format(e))
else:
mykeys = ii.getData()
return mykeys
def dapall(self):
"""Returns the contents of the DAPall data for this target."""
if (not self._dapver or
distutils.version.StrictVersion(self._dapver) < self.__min_dapall_version__):
raise MarvinError('DAPall is not available for versions before MPL-6.')
if hasattr(self, '_dapall') and self._dapall is not None:
return self._dapall
if self.data_origin == 'file':
try:
dapall_data = self._get_dapall_from_file()
except IOError:
warnings.warn('cannot find DAPall file. Trying remote request.',
MarvinUserWarning)
dapall_data = self._get_from_api()
elif self.data_origin == 'db':
dapall_data = self._get_dapall_from_db()
else:
dapall_data = self._get_dapall_from_api()
self._dapall = dapall_data
return self._dapall
def _checkFilename(self):
''' Checks the filename for a proper FITS file '''
# if filename is not FITS, then try to load one
if 'fits' not in self.filename.lower():
if not Path:
raise MarvinError('sdss_access is not installed')
else:
# is_public = 'DR' in self._release
# path_release = self._release.lower() if is_public else None
sdss_path = Path(release=self._release)
# try a cube
full = sdss_path.full('mangacube', drpver=self._drpver, plate=self.plateid, ifu='*', wave='LOG')
cubeexists = sdss_path.any('', full=full)
if cubeexists:
file = sdss_path.one('', full=full)
else:
# try an rss
full = sdss_path.full('mangarss', drpver=self._drpver, plate=self.plateid, ifu='*', wave='LOG')
rssexists = sdss_path.any('', full=full)
if rssexists:
file = sdss_path.one('', full=full)
else:
file = None
# load the file
if file:
self.filename = file
else:
self.filename = None
def login(self, refresh=None):
''' Login with netrc credentials to receive an API token
Copy this token into the "use_token" parameter in your
custom marvin.yml file to ensure preserve authentication
across iPython user sessions.
Parameters:
refresh (bool):
Set to True to refresh a login to receive a new token
'''
assert config.access == 'collab', 'You must have collaboration access to login.'
# do nothing if token already generated
if self.token and not refresh:
return
valid_netrc = bconfig._check_netrc()
if valid_netrc:
# get login info for api.sdss.org
user, password = bconfig._read_netrc('api.sdss.org')
data = {'username': user, 'password': password}
# send token request
url = self.urlmap['api']['login']['url']
try:
resp = Interaction(url, params=data, auth='netrc')
except Exception as e:
raise MarvinError('Error getting login token. {0}'.format(e))
else:
self.token = resp.results['access_token']
def overlay_hexagon(self, ax, return_figure=True, **kwargs):
""" Overlay the IFU hexagon on a plot
Parameters:
ax (Axis):
The matplotlib axis object
return_figure (bool):
If True, returns the figure axis object. Default is True
kwargs:
Any keyword arguments accepted by Matplotlib plot
"""
if self.wcs is None:
raise MarvinError('No WCS found. Cannot overlay hexagon.')
# get IFU hexagon pixel coordinates
hexagon_pix = self.wcs.wcs_world2pix(self.bundle.hexagon, 1)
# reconnect the last point to the first point.
hexagon_pix = np.concatenate((hexagon_pix, [hexagon_pix[0]]), axis=0)
# some matplotlib kwargs
kwargs['color'] = kwargs.get('color', 'magenta')
kwargs['linestyle'] = kwargs.get('linestyle', 'solid')
kwargs['linewidth'] = kwargs.get('linewidth', 0.8)
ax.plot(hexagon_pix[:, 0], hexagon_pix[:, 1], **kwargs)
if return_figure:
return ax
def _getExtensionData(self, extName):
"""Returns the data from an extension."""
if self.data_origin == 'file':
return self.data[extName.upper()].data
elif self.data_origin == 'db':
return self.data.get3DCube(extName.lower())
elif self.data_origin == 'api':
url = marvin.config.urlmap['api']['getCubeExtension']['url']
try:
response = self._toolInteraction(
url.format(name=self.plateifu,
cube_extension=extName.lower()))
except Exception as ee:
raise MarvinError(
'found a problem when checking if remote cube '
'exists: {0}'.format(str(ee)))
data = response.getData()
return np.array(data['cube_extension'])
def getDapRedux(release=None):
''' Retrieve SAS url link to the DAP redux directory
Parameters:
release (str):
The release version of the data to download.
Defaults to Marvin config.release.
Returns:
dapredux (str):
The full redux path to the DAP MAPS
'''
if not Path:
raise MarvinError('sdss_access is not installed')
else:
sdss_path = Path()
release = release or marvin.config.release
drpver, dapver = marvin.config.lookUpVersions(release=release)
# hack a url version of MANGA_SPECTRO_ANALYSIS
dapdefault = sdss_path.dir('mangadefault',
drpver=drpver,
dapver=dapver,
plate=None,
ifu=None)
dappath = dapdefault.rsplit('/', 2)[0]
dapredux = sdss_path.url('', full=dappath)
return dapredux
def __init__(self, ra, dec, width, height, scale=None, **kwargs):
self.rawurl = (
"http://skyserver.sdss.org/public/SkyServerWS/ImgCutout/getjpeg?"
"ra={ra}&dec={dec}&scale={scale}&width={width_pix}&height={height_pix}&opt={opts}&query="
)
self.ra = ra
self.dec = dec
self.scale = scale or 0.198 # default arcsec/pixel
self.image = None
self.center = np.array([ra, dec])
self.size = np.array([width, height], dtype=int)
self.coords = {
'ra': ra,
'dec': dec,
'width': width,
'height': height,
'scale': self.scale
}
self._get_pix_size()
if max(self.size_pix) >= 2048:
raise MarvinError(
'Requested image size is too large. '
'The Skyserver image cutout can only return a size up to 2048 pixels'
)
self._define_wcs()
self._get_cutout(**kwargs)
