def from_fits(cls, filename, chk_version=True):
"""
Args:
filename (str):
chk_version (bool, optional):
If True, demand the on-disk datamodel equals the current
Passed to from_hdu() of DataContainer
Returns:
:class:`AllSpec2DObj`:
"""
# Instantiate
slf = cls()
# Open
hdul = io.fits_open(filename)
# Meta
hkeys = list(hdul[0].header.keys())
for key in hkeys:
if slf.hdr_prefix in key:
slf['meta'][key.split(slf.hdr_prefix)[-1]] = hdul[0].header[key]
# Detectors included
detectors = hdul[0].header[slf.hdr_prefix+'DETS']
for det in [int(item) for item in detectors.split(',')]:
obj = Spec2DObj.from_hdu(hdul, hdu_prefix=spec2d_hdu_prefix(det), chk_version=chk_version)
slf[det] = obj
# Header
slf['meta']['head0'] = hdul[0].header
return slf
def append_NIRCam():
# Load
hdulist = io.fits_open('filtercurves.fits')
curr_filters = [hdu.name for hdu in hdulist]
#
nircam = Table.read(
'nircam_filter/nircam_modABmean_plus_ote_filter_properties.txt',
format='ascii.basic')
filters = nircam['Filter']
for filt in filters:
flt_name = 'NIRCAM-{}'.format(filt)
if flt_name in curr_filters:
print("Filter {} already there, skipping".format(flt_name))
continue
# load in the transmission
filt_table = Table.read(
'nircam_filter/{:}_NRC_and_OTE_ModAB_mean.txt'.format(filt),
format='ascii.basic')
wave = filt_table['microns'] * 1e4
trans = filt_table['throughput']
# Add it
hdu = tohdu(wave, trans, flt_name)
hdulist.append(hdu)
# Write
hdulist.writeto('filtercurves.fits', overwrite=True)
def bpm(self, filename, det, shape=None, msbias=None):
"""
Override parent bpm function with BPM specific to P200 DBSPr.
Parameters
----------
det : int, REQUIRED
msbias : numpy.ndarray, required if the user wishes to generate a BPM based on a master bias
Returns
-------
bpix : ndarray
0 = ok; 1 = Mask
"""
msgs.info("Custom bad pixel mask for DBSPr")
bpm_img = self.empty_bpm(filename, det, shape=shape)
# Fill in bad pixels if a master bias frame is provided
if msbias is not None:
return self.bpm_frombias(msbias, bpm_img)
# Red CCD detector defect is present in data taken 2020-05-22
# and absent in data taken 2020-04-21
DEFECT_DATE = Time('2020-05-21')
# TODO: Model the growth of the detector defect with time.
# TODO: Get more precise date range for detector.
with io.fits_open(filename) as hdul:
if Time(hdul[0].header['UTSHUT']) > DEFECT_DATE:
spec_binning = int(self.get_meta_value([hdul[0].header], 'binning').split(',')[0])
bpm_img[464 // spec_binning : 723 // spec_binning, :] = 1
return bpm_img
def test_coadd1d_1():
"""
Test basic coadd using shane_kast_blue
"""
# NOTE: flux_value is False
parfile = 'coadd1d.par'
if os.path.isfile(parfile):
os.remove(parfile)
coadd_ofile = data_path('J1217p3905_coadd.fits')
if os.path.isfile(coadd_ofile):
os.remove(coadd_ofile)
coadd_ifile = data_path('shane_kast_blue.coadd1d')
coadd_1dspec.main(
coadd_1dspec.parse_args(
[coadd_ifile, '--test_spec_path',
data_path('')]))
hdu = io.fits_open(coadd_ofile)
assert hdu[1].header['EXT_MODE'] == 'OPT'
assert hdu[1].header['FLUXED'] is False
# Clean up
hdu.close()
os.remove(parfile)
os.remove(coadd_ofile)
def load_multiext_fits(filename, ext):
"""
Load data and primary header from a multi-extension FITS file
Args:
filename (:obj:`str`):
Name of the file.
ext (:obj:`str`, :obj:`int`, :obj:`list`):
One or more file extensions with data to return. The
extension can be designated by its 0-indexed integer
number or its name.
Returns:
tuple: Returns the image data from each provided extension.
If return_header is true, the primary header is also
returned.
"""
# Format the input and set the tuple for an empty return
_ext = ext if isinstance(ext, list) else [ext]
n_ext = len(_ext)
# Open the file
hdu = io.fits_open(filename)
head0 = hdu[0].header
# Only one extension
if n_ext == 1:
data = hdu[_ext[0]].data.astype(np.float)
return data, head0
# Multiple extensions
data = tuple([
None if hdu[k].data is None else hdu[k].data.astype(np.float)
for k in _ext
])
# Return
return data + (head0, )
def test_case():
# Remove file if it exists
ofile = 'test.fits.gz'
if os.path.isfile(ofile):
os.remove(ofile)
# Instantiate
data = MixedCaseContainer(np.arange(10), 5, 8.2)
# Attributes and items are case-sensitive
with pytest.raises(AttributeError):
data.uppercase = 3
with pytest.raises(KeyError):
data['LOWERCASE'] = 3
with pytest.raises(AttributeError):
data.cAMELcASE = 3
# HDU items are not
data.to_file(ofile)
with fits_open(ofile) as hdu:
assert hdu['mixedcase'].header['UpPeRcAsE'] == 5, 'Bad header access'
assert hdu['mixedcase'].header['CaMeLcAsE'] == 8.2, 'Bad header access'
# And everything is as it should be when you read it back in
_data = MixedCaseContainer.from_file(ofile)
assert _data.UPPERCASE == 5, 'Bad file read'
# Clean up
os.remove(ofile)
def test_coadd1d_2():
"""
Test combining Echelle
"""
# NOTE: flux_value is False
parfile = 'coadd1d.par'
if os.path.isfile(parfile):
os.remove(parfile)
coadd_ofile = data_path('pisco_coadd.fits')
if os.path.isfile(coadd_ofile):
os.remove(coadd_ofile)
coadd_ifile = data_path('gemini_gnirs_32_sb_sxd.coadd1d')
coadd_1dspec.main(
coadd_1dspec.parse_args(
[coadd_ifile, '--test_spec_path',
data_path('')]))
hdu = io.fits_open(coadd_ofile)
assert hdu[1].header['EXT_MODE'] == 'OPT'
assert hdu[1].header['FLUXED'] is False
# Clean up
hdu.close()
os.remove(parfile)
os.remove(coadd_ofile)
def from_fits(cls, filename, chk_version=True):
"""
Args:
filename (:obj:`str`):
Name of the file to read.
chk_version (:obj:`bool`, optional):
If True, demand the on-disk datamodel equals the current one.
Passed to from_hdu() of DataContainer.
Returns:
:class:`~pypeit.spec2dobj.AllSpec2DObj`: The constructed object.
"""
# Instantiate
self = cls()
# Open
hdul = io.fits_open(filename)
# Meta
for key in hdul[0].header.keys():
if key == self.hdr_prefix + 'DETS':
continue
if self.hdr_prefix in key:
meta_key = key.split(self.hdr_prefix)[-1].lower()
self['meta'][meta_key] = hdul[0].header[key]
# Detectors included
detectors = hdul[0].header[self.hdr_prefix + 'DETS']
for detname in detectors.split(','):
self[detname] = Spec2DObj.from_hdu(hdul,
hdu_prefix=f'{detname}-',
chk_version=chk_version)
return self
def from_file(cls, file, detname, chk_version=True):
"""
Overload :func:`pypeit.datamodel.DataContainer.from_file` to allow det
input and to slurp the header
Args:
file (:obj:`str`):
File name to read.
detname (:obj:`str`):
The string identifier for the detector or mosaic used to select
the data that is read.
chk_version (:obj:`bool`, optional):
If False, allow a mismatch in datamodel to proceed
Returns:
:class:`~pypeit.spec2dobj.Spec2DObj`: 2D spectra object.
"""
hdul = io.fits_open(file)
# Quick check on det
if not np.any([detname in hdu.name for hdu in hdul]):
msgs.error(f'{detname} not available in any extension of {file}')
slf = super().from_hdu(hdul,
hdu_prefix=f'{detname}-',
chk_version=chk_version)
slf.head0 = hdul[0].header
slf.chk_version = chk_version
return slf
def load_telluric_grid(filename):
"""Load a telluric atmospheric grid
NOTE: This is where the path to the data directory is added!
Args:
filename (str):
The filename (NO PATH) of the telluric atmospheric grid to use.
Returns:
(:obj:`astropy.io.fits.HDUList`): Telluric Grid FITS HDU list
"""
# Check for existance of file parameter
if not filename:
msgs.error("No file specified for telluric correction. "
"See https://pypeit.readthedocs.io/en/latest/telluric.html")
# Get the data path for the filename, whether in the package directory or cache
file_with_path = get_telgrid_filepath(filename)
# Check for existance of file
# NOTE: With the use of `get_telgrid_filepath()`, this should never run
if not os.path.isfile(file_with_path):
msgs.error(f"File {file_with_path} is not on your disk. "
"You likely need to download the Telluric files. "
"See https://pypeit.readthedocs.io/en/release/installing.html"
"#atmospheric-model-grids")
return io.fits_open(file_with_path)
def test_coadd1d_2():
"""
Test combining Echelle
"""
# NOTE: flux_value is False
parfile = 'coadd1d.par'
if os.path.isfile(parfile):
os.remove(parfile)
coadd_ofile = data_path('pisco_coadd.fits')
if os.path.isfile(coadd_ofile):
os.remove(coadd_ofile)
coadd_ifile = data_path('gemini_gnirs_32_sb_sxd.coadd1d')
scripts.coadd_1dspec.CoAdd1DSpec.main(
scripts.coadd_1dspec.CoAdd1DSpec.parse_args(
[coadd_ifile, '--test_spec_path',
data_path('')]))
hdu = io.fits_open(coadd_ofile)
assert hdu[1].header['EXT_MODE'] == 'OPT'
assert hdu[1].header['FLUXED'] is False
# Test that the output file is kosher and contains the right quantities
spec = onespec.OneSpec.from_file(coadd_ofile)
assert spec.wave.shape == spec.wave_grid_mid.shape
# Clean up
hdu.close()
os.remove(parfile)
os.remove(coadd_ofile)
def test_coadd1d_1(monkeypatch):
"""
Test basic coadd using shane_kast_blue
"""
dp = data_path('')
# Change to the parent directory of the data path, so we can test that
# coadding without a coadd output file specified places the output next
# to the spec1ds. Using monkeypatch means the current working directory
# will be restored after the test.
monkeypatch.chdir(Path(dp).parent)
# NOTE: flux_value is False
parfile = 'files/coadd1d.par'
if os.path.isfile(parfile):
os.remove(parfile)
coadd_ofile = data_path('coadd1d_J1217p3905_KASTb_20150520_20150520.fits')
if os.path.isfile(coadd_ofile):
os.remove(coadd_ofile)
coadd_ifile = data_path('shane_kast_blue.coadd1d')
scripts.coadd_1dspec.CoAdd1DSpec.main(
scripts.coadd_1dspec.CoAdd1DSpec.parse_args(
[coadd_ifile, "--par_outfile", parfile]))
hdu = io.fits_open(coadd_ofile)
assert hdu[1].header['EXT_MODE'] == 'OPT'
assert hdu[1].header['FLUXED'] is False
# Test that the output file is kosher and contains the right quantities
spec = onespec.OneSpec.from_file(coadd_ofile)
assert spec.wave.shape == spec.wave_grid_mid.shape
# Clean up
hdu.close()
os.remove(parfile)
os.remove(coadd_ofile)
def get_headarr(self, inp, strict=True):
"""
Read the header data from all the extensions in the file.
Args:
inp (:obj:`str`, `astropy.io.fits.HDUList`_):
Name of the file to read or the previously opened HDU list.
strict (:obj:`bool`, optional):
Function will fault if :func:`fits.getheader` fails to read
any of the headers. Set to False to report a warning and
continue.
Returns:
:obj:`list`: A list of `astropy.io.fits.Header`_ objects with the
extension headers.
"""
# Faster to open the whole file and then assign the headers,
# particularly for gzipped files (e.g., DEIMOS)
if isinstance(inp, str):
try:
hdu = io.fits_open(inp)
except:
if strict:
msgs.error('Problem opening {0}.'.format(inp))
else:
msgs.warn(
'Problem opening {0}.'.format(inp) + msgs.newline() +
'Proceeding, but should consider removing this file!')
return ['None'] * 999 # self.numhead
else:
hdu = inp
return [hdu[k].header for k in range(len(hdu))]
def gemini_read_amp(inp, ext):
"""
Read one amplifier of an Gemini GMOS multi-extension FITS image
Parameters
----------
inp: :obj:`tuple`
A two-tuple with either the filename and extension ``(str,int)`` with
the data to read or the already opened `astropy.io.fits.HDUList`_
object and extension ``(hdu,int)``.
Returns
-------
data : `numpy.ndarray`_
2D array with the science region of the raw image.
overscan : `numpy.ndarray`_
2D array with the overscan region of the raw image.
datasec : :obj:`str`
String representation of the section in the raw image with the
science data.
baissec : :obj:`str`
String representation of the section in the raw image with the
overscan.
x1 : :obj:`int`
Starting pixel along the first axis with the science data in the raw
image.
y1 : :obj:`int`
Starting pixel along the second axis with the science data in the raw
image.
"""
# Parse input
hdu = io.fits_open(inp) if isinstance(inp, str) else inp
# get entire extension...
temp = hdu[ext].data.transpose()
tsize = temp.shape
nxt = tsize[0]
# parse the DETSEC keyword to determine the size of the array.
header = hdu[ext].header
detsec = header['DETSEC']
x1, x2, y1, y2 = np.array(parse.load_sections(detsec, fmt_iraf=False)).flatten()
# parse the DATASEC keyword to determine the size of the science region (unbinned)
datasec = header['DATASEC']
xdata1, xdata2, ydata1, ydata2 \
= np.array(parse.load_sections(datasec, fmt_iraf=False)).flatten()
# grab the components...
data = temp[xdata1-1:xdata2,:]
# Overscan
biassec = header['BIASSEC']
xdata1, xdata2, ydata1, ydata2 \
= np.array(parse.load_sections(biassec, fmt_iraf=False)).flatten()
overscan = temp[xdata1-1:xdata2,:]
# Return
return data, overscan, datasec, biassec, x1, x2
def write_filter_list():
# Write the filter list
hdulist = io.fits_open('filtercurves.fits')
all_filters = [hdu.name for hdu in hdulist]
tbl = Table()
tbl['filter'] = all_filters
# Write
tbl.write('filter_list.ascii', format='ascii', overwrite=True)
def append_FORS():
# Load
hdulist = io.fits_open('filtercurves.fits')
curr_filters = [hdu.name for hdu in hdulist]
#
filters = [
'BESS_B', 'BESS_I', 'BESS_R', 'BESS_U', 'BESS_V', 'u_HIGH', 'b_HIGH',
'v_HIGH', 'g_HIGH', 'GUNN_G', 'GUNN_R', 'GUNN_U', 'GUNN_V', 'GUNN_Z',
'SPECIAL_R', 'SPECIAL_U'
]
for filt in filters:
vlt_name = 'VLT-{}'.format(filt)
if vlt_name in curr_filters:
print("Filter {} already there, skipping".format(vlt_name))
continue
if 'HIGH' in filt:
url = 'http://www.eso.org/sci/facilities/paranal/instruments/fors/inst/Filters/{}.txt'.format(
filt)
else:
url = 'http://www.eso.org/sci/facilities/paranal/instruments/fors/inst/Filters/M_{}.txt'.format(
filt)
r = requests.get(url)
# Parse me
ss = r.text.split('\n')
lam, T = [], []
for row in ss:
if 'fors' in row.lower():
continue
elif len(row) == 0:
continue
elif 'Wavelen' in row:
continue
items = row.split(' ')
if len(items[0]) == 0: # Special
items = items[1:]
items[1] = items[-1]
try:
lam.append(float(items[0]) * 10)
except ValueError:
items = row.split('\t') # HIGH
try:
lam.append(float(items[0]) * 10)
except:
embed(header='196')
T.append(float(items[1]) / 10)
else:
try:
T.append(float(items[1]))
except:
embed(header='205')
# Recast
wave = np.array(lam)
trans = np.array(T)
# Add it
hdu = tohdu(wave, trans, vlt_name)
hdulist.append(hdu)
# Write
hdulist.writeto('filtercurves.fits', overwrite=True)
def bpm(self, filename, det, shape=None, msbias=None):
"""
Generate a default bad-pixel mask.
Even though they are both optional, either the precise shape for
the image (``shape``) or an example file that can be read to get
the shape (``filename`` using :func:`get_image_shape`) *must* be
provided.
Args:
filename (:obj:`str` or None):
An example file to use to get the image shape.
det (:obj:`int`):
1-indexed detector number to use when getting the image
shape from the example file.
shape (tuple, optional):
Processed image shape
Required if filename is None
Ignored if filename is not None
msbias (`numpy.ndarray`_, optional):
Master bias frame used to identify bad pixels
Returns:
`numpy.ndarray`_: An integer array with a masked value set
to 1 and an unmasked value set to 0. All values are set to
0.
"""
# Call the base-class method to generate the empty bpm
bpm_img = super().bpm(filename, det, shape=shape, msbias=msbias)
msgs.info("Using hard-coded BPM for MODS2B")
# Get the binning
hdu = io.fits_open(filename)
header = hdu[0].header
xbin, ybin = header['CCDXBIN'], header['CCDYBIN']
hdu.close()
# Apply the mask
bpm_img[5176 // xbin:5179 // xbin, 549 // ybin:1544 // ybin] = 1
bpm_img[5176 // xbin:5179 // xbin, 1544 // ybin:1628 // ybin] = 1
bpm_img[4408 // xbin:4410 // xbin, 1544 // ybin:2661 // ybin] = 1
bpm_img[4408 // xbin:4411 // xbin, 2660 // ybin:2663 // ybin] = 1
bpm_img[2495 // xbin:2499 // xbin, 1326 // ybin:1544 // ybin] = 1
bpm_img[2391 // xbin:2394 // xbin, 1048 // ybin:1051 // ybin] = 1
bpm_img[1974 // xbin:1980 // xbin, 806 // ybin:1544 // ybin] = 1
bpm_img[1975 // xbin:1980 // xbin, 1544 // ybin:1607 // ybin] = 1
bpm_img[1972 // xbin:1974 // xbin, 1587 // ybin:1589 // ybin] = 1
bpm_img[274 // xbin:278 // xbin, 1341 // ybin:1544 // ybin] = 1
bpm_img[275 // xbin:278 // xbin, 1251 // ybin:1341 // ybin] = 1
bpm_img[276 // xbin:278 // xbin, 1242 // ybin:1251 // ybin] = 1
bpm_img[274 // xbin:277 // xbin, 1544 // ybin:3066 // ybin] = 1
bpm_img[2392 // xbin, 1051 // ybin:1544 // ybin] = 1
bpm_img[275 // xbin, 1220 // ybin:1242 // ybin] = 1
return bpm_img
def fix_SDSS():
par = io.fits_open('filter_curves_sdss.fits')
pri_hdu = fits.PrimaryHDU()
hdulist = fits.HDUList(pri_hdu)
for i in ['SDSS-U', 'SDSS-G', 'SDSS-R', 'SDSS-I', 'SDSS-Z']:
wave, trans = par[i[-1]].data['wavelength'], par[i[-1]].data['respt']
hdu = tohdu(wave, trans, i)
hdulist.append(hdu)
# Load
hdulist_orig = io.fits_open('filtercurves.fits')
for i in range(len(hdulist_orig[6:])):
hdulist.append(hdulist_orig[6 + i])
curr_filters = [hdu.name for hdu in hdulist]
# Write
hdulist.writeto('filtercurves.fits', overwrite=True)
def load_filter_file(filter):
"""
Load a system response curve for a given filter
Args:
filter (str): Name of filter
Returns:
ndarray, ndarray: wavelength, instrument throughput
"""
'''
# Optical filters
BASS_MZLS_filters = ['BASS-MZLS-{}'.format(i) for i in ['G', 'R','Z']]
CFHT_filters = ['CFHT-{}'.format(i) for i in ['U', 'G', 'R', 'I', 'Z']]
DECAM_filters = ['DECAM-{}'.format(i) for i in ['U', 'G', 'R', 'I', 'Z', 'Y']]
HSC_filters = ['HSC-{}'.format(i) for i in ['G', 'R', 'I', 'Z', 'Y']]
LSST_filters = ['LSST-{}'.format(i) for i in ['U', 'G', 'R', 'I', 'Z', 'Y']]
PS1_filters = ['PS1-{}'.format(i) for i in ['G', 'R', 'I', 'Z', 'Y']]
SDSS_filters = ['SDSS-{}'.format(i) for i in ['U', 'G', 'R', 'I', 'Z']]
# NIR filters
UKIDSS_filters = ['UKIRT-{}'.format(i) for i in ['Y', 'J', 'H', 'K']]
VISTA_filters = ['VISTA-{}'.format(i) for i in ['Z', 'Y', 'J', 'H', 'K']]
TMASS_filters = ['TMASS-{}'.format(i) for i in ['J', 'H', 'K']]
# Other filters
GAIA_filters = ['GAIA-{}'.format(i) for i in ['G', 'B', 'R']]
GALEX_filters = ['GALEX-{}'.format(i) for i in ['F', 'N']]
WISE_filters = ['WISE-{}'.format(i) for i in ['W1', 'W2', 'W3', 'W4']]
allowed_options = BASS_MZLS_filters + CFHT_filters + DECAM_filters + HSC_filters \
+ LSST_filters + PS1_filters + SDSS_filters + UKIDSS_filters\
+ VISTA_filters + TMASS_filters + GAIA_filters + GALEX_filters + WISE_filters
'''
filter_file = resource_filename('pypeit', os.path.join('data', 'filters', 'filter_list.ascii'))
tbl = table.Table.read(filter_file, format='ascii')
allowed_options = tbl['filter'].data
# Check
if filter not in allowed_options:
msgs.error("PypeIt is not ready for filter = {}".format(filter))
trans_file = resource_filename('pypeit', os.path.join('data', 'filters', 'filtercurves.fits'))
trans = io.fits_open(trans_file)
wave = trans[filter].data['lam'] # Angstroms
instr = trans[filter].data['Rlam'] # Am keeping in atmospheric terms
keep = instr > 0.
# Parse
wave = wave[keep]
instr = instr[keep]
# Return
return wave, instr
def load(cls, sensfile):
# Write to outfile
msgs.info(
'Reading sensitivity function from file: {:}'.format(sensfile))
hdulist = io.fits_open(sensfile)
header = hdulist[0].header
wave = hdulist['WAVE'].data
sensfunc = hdulist['SENSFUNC'].data
meta_table = table.Table(hdulist['METADATA'].data)
out_table = table.Table(hdulist['OUT_TABLE'].data)
return wave, sensfunc, meta_table, out_table, header
def waveids(fname):
infile = io.fits_open(fname)
pixels = []
msgs.info("Loading fitted arc lines")
try:
o = 1
while True:
pixels.append(infile[o].data.astype(np.float))
o += 1
except:
pass
return pixels
def load_thar_spec():
"""Load the archived ThAr spectrum
NOTE: This is where the path to the data directory is added!
Args:
filename (str):
The filename (NO PATH) of the telluric atmospheric grid to use.
Returns:
(:obj:`astropy.io.fits.HDUList`): ThAr Spectrum FITS HDU list
"""
return io.fits_open(os.path.join(Paths.arclines, 'thar_spec_MM201006.fits'))
def test_io(sobj1, sobj2, sobj3, sobj4):
sobjs = specobjs.SpecObjs([sobj1, sobj2, sobj3, sobj4])
sobjs[0]['BOX_WAVE'] = np.arange(1000).astype(float)
sobjs[1]['BOX_WAVE'] = np.arange(1000).astype(float)
sobjs[2]['BOX_WAVE'] = np.arange(1000).astype(float)
#sobjs[0]['BOX_COUNTS'] = np.ones_like(sobjs[0].BOX_WAVE) # This tests single array
sobjs[1]['BOX_COUNTS'] = np.ones_like(sobjs[0].BOX_WAVE)
sobjs[2]['BOX_COUNTS'] = np.ones_like(sobjs[0].BOX_WAVE)
# Detector
sobjs[0]['DETECTOR'] = tstutils.get_kastb_detector()
tmp = tstutils.get_kastb_detector()
tmp['det'] = 2
sobjs[1]['DETECTOR'] = tmp
# Write
header = fits.PrimaryHDU().header
header['TST'] = 'TEST'
ofile = tstutils.data_path('tst_specobjs.fits')
if os.path.isfile(ofile):
os.remove(ofile)
sobjs.write_to_fits(header, ofile, overwrite=False)
# Read
hdul = io.fits_open(ofile)
assert len(hdul) == 7 # Primary + 4 Obj + 2 Detectors
assert hdul[0].header['NSPEC'] == 4
hdul.close()
#
_sobjs = specobjs.SpecObjs.from_fitsfile(ofile)
assert _sobjs.nobj == 4
assert np.array_equal(sobjs[0].BOX_WAVE, _sobjs[0].BOX_WAVE)
assert np.array_equal(sobjs[1].BOX_WAVE, _sobjs[1].BOX_WAVE)
_sobjs.write_to_fits(header, ofile, overwrite=True)
# Detector
assert _sobjs[0].DETECTOR is not None, '1st object started with Detector'
assert _sobjs[
1].DETECTOR is not None, '2nd object has DET=1 so should get decorated'
assert _sobjs[2].DETECTOR is None
# Now try updates!
sobjs1 = specobjs.SpecObjs([sobj1])
sobjs[0]['BOX_WAVE'] = np.arange(2000).astype(float)
sobjs1[0]['DETECTOR'] = tstutils.get_kastb_detector()
header1 = fits.PrimaryHDU().header
sobjs1.write_to_fits(header1, ofile, overwrite=True, update_det='DET01')
# Test
_sobjs1 = specobjs.SpecObjs.from_fitsfile(ofile)
assert _sobjs1.nobj == 3
assert _sobjs1[2].BOX_WAVE.size == 2000
os.remove(ofile)
def bpm(self, filename, det, shape=None, msbias=None):
"""
Generate a default bad-pixel mask.
Even though they are both optional, either the precise shape for
the image (``shape``) or an example file that can be read to get
the shape (``filename`` using :func:`get_image_shape`) *must* be
provided.
Args:
filename (:obj:`str` or None):
An example file to use to get the image shape.
det (:obj:`int`):
1-indexed detector number to use when getting the image
shape from the example file.
shape (tuple, optional):
Processed image shape
Required if filename is None
Ignored if filename is not None
msbias (`numpy.ndarray`_, optional):
Master bias frame used to identify bad pixels
Returns:
`numpy.ndarray`_: An integer array with a masked value set
to 1 and an unmasked value set to 0. All values are set to
0.
"""
# Call the base-class method to generate the empty bpm
bpm_img = super().bpm(filename, det, shape=shape, msbias=msbias)
msgs.info("Using hard-coded BPM for MODS1R")
# TODO: Fix this
# Get the binning
hdu = io.fits_open(filename)
header = hdu[0].header
xbin, ybin = header['CCDXBIN'], header['CCDYBIN']
hdu.close()
# Apply the mask
bpm_img[6278 // xbin:6289 // xbin, 1544 // ybin:1634 // ybin] = 1
bpm_img[4202 // xbin:4204 // xbin, 1474 // ybin:1544 // ybin] = 1
bpm_img[3551 // xbin:3558 // xbin, 2391 // ybin:2903 // ybin] = 1
bpm_img[3553 // xbin:3558 // xbin, 1454 // ybin:1544 // ybin] = 1
bpm_img[5650 // xbin, 1280 // ybin:1544 // ybin] = 1
bpm_img[4780 // xbin, 1406 // ybin:1536 // ybin] = 1
bpm_img[3554 // xbin, 1544 // ybin:2392 // ybin] = 1
bpm_img[163 // xbin, 1544 // ybin:1963 // ybin] = 1
return bpm_img
def from_fitsfile(cls, fits_file, det=None, chk_version=True):
"""
Instantiate from a FITS file
Also tag on the Header
Args:
fits_file (str):
det (int, optional):
Only load SpecObj matching this det value
chk_version (:obj:`bool`):
If False, allow a mismatch in datamodel to proceed
Returns:
specobsj.SpecObjs
"""
# HDUList
hdul = io.fits_open(fits_file)
# Init
slf = cls()
# Add on the header
slf.header = hdul[0].header
# Keep track of HDUList for closing later
detector_hdus = {}
# Loop for Detectors first as we need to add these to the objects
for hdu in hdul[1:]:
if 'DETECTOR' in hdu.name:
detector_hdus[hdu.header[
'DET']] = detector_container.DetectorContainer.from_hdu(
hdu)
# Now the objects
for hdu in hdul[1:]:
if 'DETECTOR' in hdu.name:
continue
sobj = specobj.SpecObj.from_hdu(hdu, chk_version=chk_version)
# Restrict on det?
if det is not None and sobj.DET != det:
continue
# Check for detector
if sobj.DET in detector_hdus.keys():
sobj.DETECTOR = detector_hdus[sobj.DET]
# Append
slf.add_sobj(sobj)
# Return
hdul.close()
return slf
def bpm(self, filename, det, shape=None, msbias=None):
"""
Generate a default bad-pixel mask.
Even though they are both optional, either the precise shape for
the image (``shape``) or an example file that can be read to get
the shape (``filename`` using :func:`get_image_shape`) *must* be
provided.
Args:
filename (:obj:`str` or None):
An example file to use to get the image shape.
det (:obj:`int`):
1-indexed detector number to use when getting the image
shape from the example file.
shape (tuple, optional):
Processed image shape
Required if filename is None
Ignored if filename is not None
msbias (`numpy.ndarray`_, optional):
Master bias frame used to identify bad pixels
Returns:
`numpy.ndarray`_: An integer array with a masked value set
to 1 and an unmasked value set to 0. All values are set to
0.
"""
# Call the base-class method to generate the empty bpm
bpm_img = super().bpm(filename, det, shape=shape, msbias=msbias)
msgs.info("Using hard-coded BPM for det=1 on MMIRS")
# Get the binning
hdu = io.fits_open(filename)
binning = hdu[1].header['CCDSUM']
hdu.close()
# Apply the mask
xbin, ybin = int(binning.split(' ')[0]), int(binning.split(' ')[1])
bpm_img[:, 187 // ybin] = 1
return bpm_img
def append_MIRI():
# Load
hdulist = io.fits_open('filtercurves.fits')
curr_filters = [hdu.name for hdu in hdulist]
#
miri = Table.read('miri_filter/miri_imaging.txt',format='ascii.basic')
filters = ['F560W','F770W','F1000W', 'F1130W', 'F1280W','F1500W','F1800W','F2100W','F2550W']
for filt in filters:
flt_name = 'MIRI-{}'.format(filt)
if flt_name in curr_filters:
print("Filter {} already there, skipping".format(flt_name))
continue
# load in the transmission
wave = miri['Wave']*1e4
trans = miri[filt]
# Add it
hdu = tohdu(wave,trans,flt_name)
hdulist.append(hdu)
# Write
hdulist.writeto('filtercurves.fits', overwrite=True)
def bpm(self, filename, det, shape=None, msbias=None):
"""
Generate a default bad-pixel mask.
Even though they are both optional, either the precise shape for
the image (``shape``) or an example file that can be read to get
the shape (``filename`` using :func:`get_image_shape`) *must* be
provided.
Args:
filename (:obj:`str` or None):
An example file to use to get the image shape.
det (:obj:`int`):
1-indexed detector number to use when getting the image
shape from the example file.
shape (tuple, optional):
Processed image shape
Required if filename is None
Ignored if filename is not None
msbias (`numpy.ndarray`_, optional):
Master bias frame used to identify bad pixels
Returns:
`numpy.ndarray`_: An integer array with a masked value set
to 1 and an unmasked value set to 0. All values are set to
0.
"""
# Call the base-class method to generate the empty bpm
bpm_img = super().bpm(filename, det, shape=shape, msbias=msbias)
# Get the binning
msgs.info("Custom bad pixel mask for MAGE")
hdu = io.fits_open(filename)
binspatial, binspec = parse.parse_binning(hdu[0].header['BINNING'])
hdu.close()
# Do it
bpm_img[:, :10 //
binspatial] = 1. # Setting BPM on the edge of the detector often leads to false edges
bpm_img[:, 1020 // binspatial:] = 1.
# Return
return bpm_img
def from_file(cls, file, det, chk_version=True):
"""
Overload :func:`pypeit.datamodel.DataContainer.from_file` to allow det
input and to slurp the header
Args:
file (:obj:`str`):
det (:obj:`int`):
chk_version (:obj:`bool`):
If False, allow a mismatch in datamodel to proceed
Returns:
`Spec2DObj`:
"""
hdul = io.fits_open(file)
# Quick check on det
if not np.any(['DET{:02d}'.format(det) in hdu.name for hdu in hdul]):
msgs.error("Requested detector {} is not in this file - {}".format(det, file))
#
slf = super(Spec2DObj, cls).from_hdu(hdul, hdu_prefix=spec2d_hdu_prefix(det), chk_version=chk_version)
slf.head0 = hdul[0].header
return slf
def from_file(cls, ifile):
"""
Over-load :func:`pypeit.datamodel.DataContainer.from_file`
to deal with the header
Args:
ifile (str): Filename holding the object
Returns:
:class:`OneSpec`:
"""
hdul = io.fits_open(ifile)
slf = super(OneSpec, cls).from_hdu(hdul)
# Internals
slf.filename = ifile
slf.head0 = hdul[0].header
# Meta
slf.spectrograph = load_spectrograph(slf.PYP_SPEC)
slf.spect_meta = slf.spectrograph.parse_spec_header(slf.head0)
#
return slf
