def _tag_arm(self):
if re.findall(r"_\w_\d{4}", self.filename)[0][1] == 'b':
return TagSet(['BLUE'])
elif re.findall(r"_\w_\d{4}", self.filename)[0][1] == 'r':
return TagSet(['RED'])
else:
return TagSet(['UNDEFINED'])
def _tag_res(self):
"""
Define the tagset for GHOST data of different resolutions.
"""
if self.phu.get('SMPNAME') == 'HI_ONLY':
return TagSet(['HIGH'])
else:
return TagSet(['STD'])
def _tag_binning_mode(self):
"""
Define the tagset for GHOST data of different binning modes.
"""
binnings = self.hdr.get('CCDSUM')
if isinstance(binnings, list):
if all([x == binnings[0] for x in binnings]):
return TagSet([binnings[0].replace(' ', 'x', 1)])
else:
return TagSet(['NxN'])
else:
return TagSet([binnings.replace(' ', 'x', 1)])
def _tag_dichroic(self):
dich = self.phu.get('DICHROIC', '')
if 'Mirror' in dich:
return TagSet(set(['ADI_B']), ())
elif 'Open' in dich:
return TagSet(set(['ADI_R']), ())
elif '50/50' in dich:
crmode = self.phu.get('CRMODE')
if crmode == 'FOLLOW':
return TagSet(set(['SDI']), ())
elif crmode == 'FIXED':
return TagSet(set(['ASDI']), ())
def _tag_slitflat(self):
"""
Define the 'slitflat data' tag set for GHOST data.
"""
if self.phu.get('OBSTYPE') == 'FLAT' and self.phu.get(
'CAMERA', '').lower().startswith('slit'):
return TagSet(['CAL', 'SLITFLAT'])
def _tag_slitv(self):
"""
Define the 'slit data' tag set for GHOST data.
"""
if self.phu.get('CAMERA', '').lower().startswith('slit'):
return TagSet(['SLITV', 'SLIT', 'IMAGE'],
blocks=['SPECT', 'BUNDLE'])
def _tag_ifu(self):
if not self._tag_is_spect():
return
mapping = {
'IFU-B': 'ONESLIT_BLUE',
'IFU-B-NS': 'ONESLIT_BLUE',
'b': 'ONESLIT_BLUE',
'IFU-R': 'ONESLIT_RED',
'IFU-R-NS': 'ONESLIT_RED',
'r': 'ONESLIT_RED',
'IFU-2': 'TWOSLIT',
'IFU-NS-2': 'TWOSLIT',
's': 'TWOSLIT'
}
names = set(key for key in mapping.keys() if key.startswith('IFU'))
mskt, mskn = self.phu.get('MASKTYP'), self.phu.get('MASKNAME')
if mskt == -1 and (mskn in names
or re.match('g[ns]ifu_slit[rbs]_mdf', mskn)):
if mskn not in names:
mskn = re.match('g.ifu_slit(.)_mdf', mskn).groups()[0]
return TagSet(['SPECT', 'IFU', mapping[mskn]])
def _tag_image(self):
if 'grism' not in self.phu.get('FILTER3', ''):
tags = ['IMAGE']
if self.phu.get('OBJECT', '').upper() == 'TWILIGHT':
tags.extend(['CAL', 'FLAT', 'TWILIGHT'])
return TagSet(tags)
def _tag_ls(self):
if not self._tag_is_spect():
return
if self.phu.get('MASKTYP') == 1 and self.phu.get(
'MASKNAME', '').endswith('arcsec'):
return TagSet(['SPECT', 'LS'])
def _tag_spect(self):
"""
Define the 'spectrograph data' tag set for GHOST data.
"""
# Also returns BLUE or RED if the CAMERA keyword is set thus
if 'CAMERA' in self.phu:
return TagSet(({self.phu['CAMERA']} & {'BLUE', 'RED'}) | {'SPECT'},
blocks=['BUNDLE'])
def _tag_twilight(self):
if self.phu.get('OBJECT', '').upper() == 'TWILIGHT':
# Twilight flats are of OBSTYPE == OBJECT, meaning that the generic
# FLAT tag won't be triggered. Add it explicitly
return TagSet([
'TWILIGHT', 'CAL',
'SLITILLUM' if self._tag_is_spect() else 'FLAT'
])
def _tag_flat(self):
if self.phu.get('OBSTYPE') == 'FLAT':
if self.phu.get('GRATING') == 'MIRROR':
f1, f2 = self.phu.get('FILTER1'), self.phu.get('FILTER2')
# This kind of filter prevents imaging to be classified as FLAT
if any(('Hartmann' in f) for f in (f1, f2)):
return
return TagSet(['GCALFLAT', 'FLAT', 'CAL'])
def _tag_is_mos(self):
if not self._tag_is_spect():
return
decker = self.phu.get('DECKER') == 'mos' or self.phu.get('DCKERPOS') == 'mos'
if decker or re.match("mos.?", self.phu.get('MOSPOS', '')):
return TagSet(['MOS', 'SPECT'])
def _tag_is_ls(self):
if not self._tag_is_spect():
return
decker = self.phu.get('DECKER') == 'Long_slit' or self.phu.get('DCKERPOS') == 'Long_slit'
if decker or re.match(".?pix-slit", self.phu.get('MOSPOS', '')):
return TagSet(['LS', 'SPECT'])
def _tag_image(self):
tags = ['IMAGE']
if self.phu.get('OBSTYPE') == 'FLAT':
tags.extend(['FLAT', 'CAL'])
if 'DOMEFLAT' in self.phu.get('OBJECT', '').upper():
tags.extend(['DOMEFLAT', 'FLAT', 'CAL'])
elif 'TWILIGHT' in self.phu.get('OBJECT', '').upper():
tags.extend(['TWILIGHT', 'FLAT', 'CAL'])
return TagSet(tags)
def _tag_mos(self):
if not self._tag_is_spect():
return
mskt = self.phu.get('MASKTYP')
mskn = self.phu.get('MASKNAME', '')
if mskt == 1 and not (mskn.startswith('IFU')
or mskn.startswith('focus')
or mskn.endswith('arcsec')):
return TagSet(['SPECT', 'MOS'])
def _status_processed_ghost_cals(self):
"""
Define the 'processed data' tag set for GHOST data.
"""
kwords = set([
'PRSLITIM', 'PRSLITBI', 'PRSLITDA', 'PRSLITFL', 'PRWAVLFT',
'PRPOLYFT'
])
if set(self.phu) & kwords:
return TagSet(['PROCESSED'])
def _tag_dark(self):
ot = self.phu.get('OBSTYPE')
dkflt = False
for f in (self.phu.get('FILTER1', ''), self.phu.get('FILTER2', '')):
if re.match('DK.?', f):
dkflt = True
break
if dkflt or ot == 'DARK':
return TagSet(['DARK', 'CAL'], blocks=['IMAGE', 'SPECT'])
def _type_spect(self):
if self.phu.get('ACQMIR') == 'Out':
tags = set(['SPECT'])
slit = self.phu.get('SLIT', '').lower()
grat = self.phu.get('GRATING', '')
prism = self.phu.get('PRISM', '')
if slit == 'IFU':
tags.add('IFU')
elif ('arcsec' in slit or 'pin' in slit) and 'mm' in grat:
if 'MIR' in prism:
tags.add('LS')
elif 'XD' in prism:
tags.add('XD')
return TagSet(tags)
def _tag_bias(self):
if 'bias' in self.phu.get('OBSTYPE', '').lower():
return TagSet(['BIAS', 'CAL'], blocks=['IMAGE'])
def _tag_flat(self):
if 'flat' in self.phu.get('OBSTYPE', '').lower():
return TagSet(['FLAT', 'CAL'])
def _tag_dark(self):
if 'dark' in self.phu.get('OBSTYPE', '').lower():
return TagSet(['DARK', 'CAL'], blocks=['IMAGE'])
def _tag_image(self):
return TagSet(['IMAGE'])
def _tag_instrument(self):
return TagSet(['HRWFS'])
def _tag_bias(self):
if self.phu.get('OBSTYPE') == 'BIAS':
return TagSet(['BIAS', 'CAL'], blocks=['IMAGE', 'SPECT'])
def _tag_arc(self):
if self.phu.get('OBSTYPE') == 'ARC':
return TagSet(['ARC', 'CAL'])
def _tag_dark(self):
if self.phu.get('OBSTYPE') == 'DARK':
return TagSet(['DARK'], blocks=['IMAGE', 'SPECT'])
def _tag_instrument(self):
# tags = ['GMOS', self.instrument().upper().replace('-', '_')]
return TagSet(['GMOS'])
def _tag_nodandshuffle(self):
if 'NODPIX' in self.phu:
return TagSet(['NODANDSHUFFLE'])
def _tag_image(self):
if self.phu.get('GRATING') == 'MIRROR':
return TagSet(['IMAGE'])
