def test_run_and_master(kast_blue_bias_files):
# Instantiate
bias_frame = biasframe.BiasFrame(shane_kast_blue,
files=kast_blue_bias_files,
master_key='A_1_01',
master_dir=data_root())
assert bias_frame.frametype == 'bias'
# In case of previous test failure
if os.path.isfile(bias_frame.master_file_path):
os.remove(bias_frame.master_file_path)
# Run
msbias = bias_frame.build_image()
#assert bias_frame.steps[-1] == 'combine'
# Save it
bias_frame.save()
# Run with reuse (should simply load the file)
bias_frame2 = biasframe.BiasFrame(shane_kast_blue,
master_key='A_1_01',
master_dir=data_root(),
reuse_masters=True)
bias2 = bias_frame2.load()
assert isinstance(bias2.image, np.ndarray)
assert len(bias_frame2.process_steps) == 3
assert np.array_equal(bias2.image, bias_frame.pypeitImage.image)
# Clean up
os.remove(bias_frame.master_file_path)
def test_instantiate(kast_blue_bias_files):
# Empty
bias_frame0 = biasframe.BiasFrame(shane_kast_blue)
assert bias_frame0.nfiles == 0
#
bias_frame1 = biasframe.BiasFrame(shane_kast_blue, files=kast_blue_bias_files)
assert bias_frame1.nfiles == 10
def test_run_and_master(kast_blue_bias_files):
root_path = data_path('MF')
master_key = 'A_1_01'
# Instantiate
master_dir = root_path + '_shane_kast_blue'
bias_frame = biasframe.BiasFrame('shane_kast_blue',
files=kast_blue_bias_files,
master_key=master_key,
master_dir=master_dir)
assert bias_frame.frametype == 'bias'
# Run
msbias = bias_frame.build_image()
bias_frame.save_master(msbias)
assert bias_frame.steps[-1] == 'combine'
# Run with reuse (should simply load the file)
bias_frame2 = biasframe.BiasFrame('shane_kast_blue',
master_key=master_key,
master_dir=master_dir,
reuse_masters=True)
bias2, head2 = bias_frame2.master()
assert isinstance(bias_frame2.msframe, np.ndarray)
assert len(bias_frame2.steps) == 0
# Load (not kept in the Object!)
bias_frame3 = biasframe.BiasFrame('shane_kast_blue',
master_key=master_key,
master_dir=master_dir,
reuse_masters=True)
bias3, head = bias_frame3.load_master(bias_frame3.ms_name)
assert bias_frame3.msframe is None
assert np.array_equal(bias2, bias3)
def test_io(kast_blue_bias_files):
# Instantiate
bias_frame = biasframe.BiasFrame(shane_kast_blue,
files=kast_blue_bias_files,
master_dir=data_root(),
master_key='A_01_1',
reuse_masters=True)
# In case of previous test failure
if os.path.isfile(bias_frame.master_file_path):
os.remove(bias_frame.master_file_path)
# Run
bias_frame.build_image()
# Save as a master frame
bias_frame.save()
assert os.path.isfile(
bias_frame.master_file_path), 'Error writing MasterBias'
# Load master frame
pypeitImage = bias_frame.load()
assert np.array_equal(pypeitImage.image, bias_frame.pypeitImage.image)
# Instantiate from master frame
bias_frame2 = biasframe.BiasFrame.from_master_file(
bias_frame.master_file_path)
assert np.array_equal(pypeitImage.image, bias_frame2.pypeitImage.image)
# Clean up
os.remove(bias_frame.master_file_path)
def test_process(kast_blue_bias_files):
# Instantiate
bias_frame = biasframe.BiasFrame(shane_kast_blue, files=kast_blue_bias_files)
# Run
bias_img = bias_frame.build_image()
assert isinstance(bias_img.image, np.ndarray)
assert isinstance(bias_frame.pypeitImage.image, np.ndarray)
def test_read_write(kast_blue_bias_files):
# Instantiate
bias_frame = biasframe.BiasFrame('shane_kast_blue',
files=kast_blue_bias_files)
# Run
bias_img = bias_frame.build_image()
# Write
bias_frame.write_stack_to_fits(data_path('tmp.fits'))
def test_process(kast_blue_bias_files):
# Instantiate
bias_frame = biasframe.BiasFrame('shane_kast_blue',
files=kast_blue_bias_files)
# Run
bias_img = bias_frame.build_image()
assert isinstance(bias_img, np.ndarray)
assert isinstance(bias_frame.stack, np.ndarray)
assert bias_frame.steps[-1] == 'combine'
def get_bias(self):
"""
Load or generate the bias frame/command
Requirements:
master_key, det, par
Returns:
ndarray or str: :attr:`bias`
"""
# Check internals
self._chk_set(['det', 'calib_ID', 'par'])
# Prep
bias_rows = self.fitstbl.find_frames('bias',
calib_ID=self.calib_ID,
index=True)
self.bias_files = self.fitstbl.frame_paths(bias_rows)
self.master_key_dict['bias'] \
= self.fitstbl.master_key(bias_rows[0] if len(bias_rows) > 0 else self.frame,
det=self.det)
# Grab from internal dict (or hard-drive)?
if self._cached('bias', self.master_key_dict['bias']):
self.msbias = self.calib_dict[self.master_key_dict['bias']]['bias']
msgs.info("Reloading the bias from the internal dict")
return self.msbias
# Instantiate
self.biasFrame = biasframe.BiasFrame(
self.spectrograph,
files=self.bias_files,
det=self.det,
par=self.par['biasframe'],
master_key=self.master_key_dict['bias'],
master_dir=self.master_dir,
reuse_masters=self.reuse_masters)
# Try to load the master bias
self.msbias = self.biasFrame.load()
if self.msbias is None:
# Build it and save it
self.msbias = self.biasFrame.build_image()
if self.save_masters:
self.biasFrame.save()
# Save & return
self._update_cache('bias', 'bias', self.msbias)
return self.msbias
def main(args):
import time
import os
import numpy as np
from pypeit.spectrographs.util import load_spectrograph
from pypeit import traceimage, edgetrace, biasframe
from pypeit.pypeit import PypeIt
from pypeit.core import parse
from IPython import embed
if args.pypeit_file is not None:
pypeit_file = args.pypeit_file
if not os.path.isfile(pypeit_file):
raise FileNotFoundError(
'File does not exist: {0}'.format(pypeit_file))
pypeit_file = os.path.abspath(pypeit_file)
redux_path = os.path.abspath(
os.path.split(pypeit_file)[0] if args.redux_path is None else args.
redux_path)
rdx = PypeIt(pypeit_file, redux_path=redux_path)
# Save the spectrograph
spec = rdx.spectrograph
# Get the calibration group to use
group = np.unique(
rdx.fitstbl['calib'])[0] if args.group is None else args.group
if group not in np.unique(rdx.fitstbl['calib']):
raise ValueError(
'Not a valid calibration group: {0}'.format(group))
# Find the rows in the metadata table with trace frames in the
# specified calibration group
tbl_rows = rdx.fitstbl.find_frames('trace',
calib_ID=int(group),
index=True)
# Master keyword
master_key_base = '_'.join(
rdx.fitstbl.master_key(tbl_rows[0]).split('_')[:2])
# Save the binning
binning = rdx.fitstbl['binning'][tbl_rows[0]]
# Save the full file paths
files = rdx.fitstbl.frame_paths(tbl_rows)
# Trace image processing parameters
proc_par = rdx.caliBrate.par['traceframe']
# Slit tracing parameters
trace_par = rdx.caliBrate.par['slitedges']
# Get the bias files, if requested
bias_rows = rdx.fitstbl.find_frames('bias',
calib_ID=int(group),
index=True)
bias_files = rdx.fitstbl.frame_paths(bias_rows)
bias_par = rdx.caliBrate.par['biasframe']
# Set the QA path
qa_path = rdx.qa_path
else:
spec = load_spectrograph(args.spectrograph)
master_key_base = 'A_1'
binning = '1,1' if args.binning is None else args.binning
if not os.path.isfile(args.trace_file):
raise FileNotFoundError('File does not exist: {0}'.format(
args.trace_file))
files = [os.path.abspath(args.trace_file)]
redux_path = os.path.abspath(
os.path.split(files[0])[0] if args.redux_path is None else args.
redux_path)
par = spec.default_pypeit_par()
proc_par = par['calibrations']['traceframe']
trace_par = par['calibrations']['slitedges']
bias_files = None
bias_par = None
# Set the QA path
qa_path = os.path.join(os.path.abspath(os.path.split(files[0])[0]),
'QA')
detectors = np.arange(spec.ndet) + 1 if args.detector is None else [
args.detector
]
master_dir = os.path.join(redux_path, args.master_dir)
for det in detectors:
# Master keyword for output file name
master_key = '{0}_{1}'.format(master_key_base, str(det).zfill(2))
# Get the bias frame if requested
if bias_files is None:
proc_par['process']['bias'] = 'skip'
msbias = None
else:
biasFrame = biasframe.BiasFrame(spec,
files=bias_files,
det=det,
par=bias_par,
master_key=master_key,
master_dir=master_dir)
msbias = biasFrame.build_image()
msbpm = spec.bpm(files[0], det)
# Build the trace image
traceImage = traceimage.TraceImage(spec,
files=files,
det=det,
par=proc_par,
bias=msbias)
traceImage.build_image(bias=msbias, bpm=msbpm)
# Trace the slit edges
t = time.perf_counter()
edges = edgetrace.EdgeTraceSet(spec,
trace_par,
master_key=master_key,
master_dir=master_dir,
img=traceImage,
det=det,
bpm=msbpm,
auto=True,
debug=args.debug,
show_stages=args.show,
qa_path=qa_path)
print('Tracing for detector {0} finished in {1} s.'.format(
det,
time.perf_counter() - t))
edges.save()
return 0
