def test_proc_diff(nires_sci_files, nires_bg_files):
"""
Run on near-IR frames
"""
# Setup
det = 1
bpm = np.zeros((2048, 1024))
pixelflat = np.ones_like(bpm)
# Sci image
flatImages = flatfield.FlatImages(pixelflat_norm=pixelflat)
sciImg = buildimage.buildimage_fromlist(keck_nires,
det,
nires_par['scienceframe'],
nires_sci_files,
bias=None,
bpm=bpm,
flatimages=flatImages)
# Bg image
bgImg = buildimage.buildimage_fromlist(keck_nires,
det,
nires_par['scienceframe'],
nires_bg_files,
bias=None,
bpm=bpm,
flatimages=flatImages)
# Difference
sciImg = sciImg.sub(bgImg, nires_par['scienceframe']['process'])
# Test
assert isinstance(sciImg, pypeitimage.PypeItImage)
def test_flatimages():
tmp = np.ones((1000, 100)) * 10.
x = np.random.rand(500)
# Create bspline
spat_bspline1 = bspline.bspline(x, bkspace=0.01 * (np.max(x) - np.min(x)))
spat_bspline2 = bspline.bspline(x, bkspace=0.01 * (np.max(x) - np.min(x)))
instant_dict = dict(procflat=tmp,
pixelflat=np.ones_like(tmp),
flat_model=None,
spat_bsplines=np.asarray(
[spat_bspline1, spat_bspline2]),
spat_id=np.asarray([100, 200]))
flatImages = flatfield.FlatImages(**instant_dict)
assert flatImages.flat_model is None
# I/O
outfile = data_path('tst_flatimages.fits')
flatImages.to_file(outfile, overwrite=True)
_flatImages = flatfield.FlatImages.from_file(outfile)
# Test
for key in instant_dict.keys():
if key == 'spat_bsplines':
np.array_equal(flatImages[key][0].breakpoints,
_flatImages[key][0].breakpoints)
continue
if isinstance(instant_dict[key], np.ndarray):
assert np.array_equal(flatImages[key], _flatImages[key])
else:
assert flatImages[key] == _flatImages[key]
os.remove(outfile)
def test_proc_diff(nires_sci_files, nires_bg_files):
"""
Run on near-IR frames
"""
# Setup
det = 1
bpm = np.zeros((2048, 1024), dtype=int)
pixelflat = np.ones(bpm.shape, dtype=float)
nires_par = keck_nires.default_pypeit_par()
# Sci image
flatImages = flatfield.FlatImages(pixelflat_norm=pixelflat)
nires_par['scienceframe']['process']['use_illumflat'] = False
nires_par['scienceframe']['process']['use_specillum'] = False
sciImg = buildimage.buildimage_fromlist(keck_nires,
det,
nires_par['scienceframe'],
nires_sci_files,
bias=None,
bpm=bpm,
flatimages=flatImages)
# Bg image
bgImg = buildimage.buildimage_fromlist(keck_nires,
det,
nires_par['scienceframe'],
nires_bg_files,
bias=None,
bpm=bpm,
flatimages=flatImages)
# Difference
sciImg = sciImg.sub(bgImg, nires_par['scienceframe']['process'])
# Test
assert isinstance(sciImg, pypeitimage.PypeItImage)
def test_instantiate_from_one(shane_kast_blue_sci_files):
"""
Run on a single science frame
"""
#
det = 1
# Load calibrations
pixelflat = load_kast_blue_masters(pixflat=True)[0]
bpm = kast_blue.empty_bpm(shane_kast_blue_sci_files[0], det)
# Process steps -- Set in PypeItPar
frame_par = kast_par['scienceframe']
frame_par['process']['use_illumflat'] = False
frame_par['process']['use_biasimage'] = False
# Load
rawImage = rawimage.RawImage(shane_kast_blue_sci_files[0], kast_blue, det)
flatImages = flatfield.FlatImages(pixelflat_norm=pixelflat)
pypeItImage = rawImage.process(frame_par['process'], flatimages=flatImages)
def test_flatimages():
tmp = np.ones((1000, 100)) * 10.
x = np.random.rand(500)
# Create bspline
spat_bspline1 = bspline.bspline(x, bkspace=0.01 * (np.max(x) - np.min(x)))
spat_bspline2 = bspline.bspline(x, bkspace=0.01 * (np.max(x) - np.min(x)))
instant_dict = dict(
pixelflat_raw=tmp,
pixelflat_norm=np.ones_like(tmp),
pixelflat_model=None,
pixelflat_spat_bsplines=np.asarray([spat_bspline1, spat_bspline2]),
pixelflat_spec_illum=None,
illumflat_raw=tmp,
illumflat_spat_bsplines=np.asarray([spat_bspline1, spat_bspline2]),
spat_id=np.asarray([100, 200]),
PYP_SPEC="specname")
flatImages = flatfield.FlatImages(**instant_dict)
assert flatImages.pixelflat_model is None
assert flatImages.pixelflat_spec_illum is None
assert flatImages.pixelflat_spat_bsplines is not None
# I/O
outfile = data_path('tst_flatimages.fits')
flatImages.to_master_file(outfile)
_flatImages = flatfield.FlatImages.from_file(outfile)
# Test
for key in instant_dict.keys():
if key == 'pixelflat_spat_bsplines':
np.array_equal(flatImages[key][0].breakpoints,
_flatImages[key][0].breakpoints)
continue
if key == 'illumflat_spat_bsplines':
np.array_equal(flatImages[key][0].breakpoints,
_flatImages[key][0].breakpoints)
continue
if isinstance(instant_dict[key], np.ndarray):
assert np.array_equal(flatImages[key], _flatImages[key])
else:
assert flatImages[key] == _flatImages[key]
os.remove(outfile)
def test_from_list(shane_kast_blue_sci_files):
"""
Run on two frames
"""
det = 1
# Load calibrations
pixelflat = load_kast_blue_masters(pixflat=True)[0]
bpm = kast_blue.empty_bpm(shane_kast_blue_sci_files[0], det)
# Do it
flatImages = flatfield.FlatImages(pixelflat_norm=pixelflat)
kast_par['scienceframe']['process']['use_illumflat'] = False
kast_par['scienceframe']['process']['use_biasimage'] = False
sciImg = buildimage.buildimage_fromlist(kast_blue,
det,
kast_par['scienceframe'],
shane_kast_blue_sci_files,
bpm=bpm,
bias=None,
flatimages=flatImages)
# Test
assert isinstance(sciImg, pypeitimage.PypeItImage)
def get_flats(self):
"""
Load or generate a normalized pixel flat and slit illumination
flat.
Requires :attr:`slits`, :attr:`wavetilts`, :attr:`det`,
:attr:`par`.
Constructs :attr:`flatimages`.
"""
# Check for existing data
if not self._chk_objs(['msarc', 'msbpm', 'slits', 'wv_calib']):
msgs.warn(
'Must have the arc, bpm, slits, and wv_calib defined to make flats! Skipping and may crash down the line'
)
self.flatimages = flatfield.FlatImages()
return
# Slit and tilt traces are required to flat-field the data
if not self._chk_objs(['slits', 'wavetilts']):
# TODO: Why doesn't this fault?
msgs.warn(
'Flats were requested, but there are quantities missing necessary to '
'create flats. Proceeding without flat fielding....')
self.flatimages = flatfield.FlatImages()
return
# Check internals
self._chk_set(['det', 'calib_ID', 'par'])
# Prep
illum_image_files, self.master_key_dict[
'flat'] = self._prep_calibrations('illumflat')
pixflat_image_files, self.master_key_dict[
'flat'] = self._prep_calibrations('pixelflat')
masterframe_filename = masterframe.construct_file_name(
flatfield.FlatImages,
self.master_key_dict['flat'],
master_dir=self.master_dir)
# The following if-elif-else does:
# 1. Try to load a MasterFrame (if reuse_masters is True). If successful, pass it back
# 2. Build from scratch
# 3. Load any user-supplied images to over-ride any built
# Load MasterFrame?
if os.path.isfile(masterframe_filename) and self.reuse_masters:
flatimages = flatfield.FlatImages.from_file(masterframe_filename)
flatimages.is_synced(self.slits)
# Load user defined files
if self.par['flatfield']['pixelflat_file'] is not None:
# Load
msgs.info(
'Using user-defined file: {0}'.format('pixelflat_file'))
with fits.open(self.par['flatfield']['pixelflat_file']) as hdu:
nrm_image = flatfield.FlatImages(
pixelflat_norm=hdu[self.det].data)
flatimages = flatfield.merge(flatimages, nrm_image)
self.flatimages = flatimages
# update slits
self.slits.mask_flats(self.flatimages)
return self.flatimages
# Generate the image
pixelflatImages, illumflatImages = None, None
# Check if the image files are the same
pix_is_illum = Counter(illum_image_files) == Counter(
pixflat_image_files)
if len(pixflat_image_files) > 0:
pixel_flat = buildimage.buildimage_fromlist(
self.spectrograph,
self.det,
self.par['pixelflatframe'],
pixflat_image_files,
dark=self.msdark,
bias=self.msbias,
bpm=self.msbpm)
# Initialise the pixel flat
pixelFlatField = flatfield.FlatField(pixel_flat, self.spectrograph,
self.par['flatfield'],
self.slits, self.wavetilts,
self.wv_calib)
# Generate
pixelflatImages = pixelFlatField.run(show=self.show)
# Only build illum_flat if the input files are different from the pixel flat
if (not pix_is_illum) and len(illum_image_files) > 0:
illum_flat = buildimage.buildimage_fromlist(
self.spectrograph,
self.det,
self.par['illumflatframe'],
illum_image_files,
dark=self.msdark,
bias=self.msbias,
bpm=self.msbpm)
# Initialise the pixel flat
illumFlatField = flatfield.FlatField(illum_flat,
self.spectrograph,
self.par['flatfield'],
self.slits,
self.wavetilts,
self.wv_calib,
spat_illum_only=True)
# Generate
illumflatImages = illumFlatField.run(show=self.show)
# Merge the illum flat with the pixel flat
if pixelflatImages is not None:
# Combine the pixelflat and illumflat parameters into flatimages.
# This will merge the attributes of pixelflatImages that are not None
# with the attributes of illflatImages that are not None. Default is
# to take pixelflatImages.
flatimages = flatfield.merge(pixelflatImages, illumflatImages)
else:
# No pixel flat, but there might be an illumflat. This will mean that
# the attributes prefixed with 'pixelflat_' will all be None.
flatimages = illumflatImages
# Save flat images
if flatimages is not None:
flatimages.to_master_file(masterframe_filename)
# Save slits too, in case they were tweaked
self.slits.to_master_file()
# 3) Load user-supplied images
# NOTE: This is the *final* images, not just a stack
# And it will over-ride what is generated below (if generated)
if self.par['flatfield']['pixelflat_file'] is not None:
# Load
msgs.info('Using user-defined file: {0}'.format('pixelflat_file'))
with fits.open(self.par['flatfield']['pixelflat_file']) as hdu:
flatimages = flatfield.merge(
flatimages,
flatfield.FlatImages(pixelflat_norm=hdu[self.det].data))
self.flatimages = flatimages
# Return
return self.flatimages
def get_flats(self):
"""
Load or generate a normalized pixel flat and slit illumination
flat.
Requires :attr:`slits`, :attr:`wavetilts`, :attr:`det`,
:attr:`par`.
Returns:
:class:`pypeit.flatfield.FlatImages`:
"""
# Check for existing data
if not self._chk_objs(['msarc', 'msbpm', 'slits', 'wv_calib']):
msgs.warn(
'Must have the arc, bpm, slits, and wv_calib defined to make flats! Skipping and may crash down the line'
)
self.flatimages = flatfield.FlatImages(None, None, None, None)
return
# Slit and tilt traces are required to flat-field the data
if not self._chk_objs(['slits', 'wavetilts']):
# TODO: Why doesn't this fault?
msgs.warn(
'Flats were requested, but there are quantities missing necessary to '
'create flats. Proceeding without flat fielding....')
self.flatimages = flatfield.FlatImages(None, None, None, None)
return
# Check internals
self._chk_set(['det', 'calib_ID', 'par'])
# Prep
illum_image_files, self.master_key_dict[
'flat'] = self._prep_calibrations('illumflat')
pixflat_image_files, self.master_key_dict[
'flat'] = self._prep_calibrations('pixelflat')
masterframe_filename = masterframe.construct_file_name(
flatfield.FlatImages,
self.master_key_dict['flat'],
master_dir=self.master_dir)
# The following if-elif-else does:
# 1. Try to load a MasterFrame (if reuse_masters is True). If successful, pass it back
# 2. Build from scratch
# 3. Load any user-supplied images to over-ride any built
# Load MasterFrame?
if os.path.isfile(masterframe_filename) and self.reuse_masters:
self.flatimages = flatfield.FlatImages.from_file(
masterframe_filename)
self.flatimages.is_synced(self.slits)
self.slits.mask_flats(self.flatimages)
return self.flatimages
# TODO -- Allow for separate pixelflat and illumflat images
# Generate the image
stacked_flat = None
if len(illum_image_files) > 0:
stacked_flat = buildimage.buildimage_fromlist(
self.spectrograph,
self.det,
self.par['illumflatframe'],
illum_image_files,
dark=self.msdark,
bias=self.msbias,
bpm=self.msbpm)
if stacked_flat is None and len(pixflat_image_files) > 0:
stacked_flat = buildimage.buildimage_fromlist(
self.spectrograph,
self.det,
self.par['pixelflatframe'],
pixflat_image_files,
dark=self.msdark,
bias=self.msbias,
bpm=self.msbpm)
if stacked_flat is not None:
# Create pixelflat and illumination flat from illumination flat stack
flatField = flatfield.FlatField(stacked_flat, self.spectrograph,
self.par['flatfield'], self.slits,
self.wavetilts)
# Run
self.flatimages = flatField.run(show=self.show)
# Save to Masters
self.flatimages.to_master_file(masterframe_filename)
# Save slits too, in case they were tweaked
self.slits.to_master_file()
else:
self.flatimages = flatfield.FlatImages(None, None, None, None)
# 3) Load user-supplied images
# NOTE: This is the *final* images, not just a stack
# And it will over-ride what is generated below (if generated)
if self.par['flatfield']['pixelflat_file'] is not None:
# - Name is explicitly correct?
# THIS IS DONE IN PYPEITPAR
#if os.path.isfile(self.par['flatfield']['pixelflat_file']):
# flat_file = self.par['flatfield']['pixelflat_file']
#else:
# msgs.error('Could not find user-defined flatfield file: {0}'.format(
# self.par['flatfield']['pixelflat_file']))
# Load
msgs.info('Using user-defined file: {0}'.format('pixelflat_file'))
with fits.open(self.par['flatfield']['pixelflat_file']) as hdu:
self.flatimages.pixelflat = hdu[self.det].data
# Return
return self.flatimages