def main(night_name=None, files=None):
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# ----------------------------------------------------------------------
# Section 1
# ----------------------------------------------------------------------
# ----------------------------------------------------------------------
# Section 2
# ----------------------------------------------------------------------
# ----------------------------------------------------------------------
# ...
# ----------------------------------------------------------------------
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
wmsg = 'Recipe {0} has been successfully completed'
WLOG(p, 'info', wmsg.format(p['PROGRAM']))
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_DARK_spirou.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_DARK_spirou.py [night_directory] [fitsfilename]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p)
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouImage.ReadImageAndCombine(p, framemath='average')
# ----------------------------------------------------------------------
# fix for un-preprocessed files
# ----------------------------------------------------------------------
data = spirouImage.FixNonPreProcess(p, data)
# ----------------------------------------------------------------------
# Find the amplitude to use for the local background
# ----------------------------------------------------------------------
spirouBACK.MakeLocalBackgroundMap(p, data)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p, outputs=None)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_DARK_spirou.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_DARK_spirou.py [night_directory] [fitsfilename]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p)
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouImage.ReadImageAndCombine(p, framemath='average')
# ----------------------------------------------------------------------
# fix for un-preprocessed files
# ----------------------------------------------------------------------
data = spirouImage.FixNonPreProcess(p, data)
# ----------------------------------------------------------------------
# Get basic image properties
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, hdr, name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, hdr, name='exptime')
# get gain
p = spirouImage.GetGain(p, hdr, name='gain')
# ----------------------------------------------------------------------
# Dark exposure time check
# ----------------------------------------------------------------------
# log the Dark exposure time
WLOG(p, 'info', 'Dark Time = {0:.3f} s'.format(p['EXPTIME']))
# Quality control: make sure the exposure time is longer than qc_dark_time
if p['EXPTIME'] < p['QC_DARK_TIME']:
emsg = 'Dark exposure time too short (< {0:.1f} s)'
WLOG(p, 'error', emsg.format(p['QC_DARK_TIME']))
# ----------------------------------------------------------------------
# Resize image
# ----------------------------------------------------------------------
# # rotate the image and conver from ADU/s to e-
# data = data[::-1, ::-1] * p['exptime'] * p['gain']
# convert NaN to zeros
nanmask = ~np.isfinite(data)
data0 = np.where(nanmask, np.zeros_like(data), data)
# resize blue image
bkwargs = dict(xlow=p['IC_CCDX_BLUE_LOW'],
xhigh=p['IC_CCDX_BLUE_HIGH'],
ylow=p['IC_CCDY_BLUE_LOW'],
yhigh=p['IC_CCDY_BLUE_HIGH'])
datablue, nx2, ny2 = spirouImage.ResizeImage(p, data, **bkwargs)
# Make sure we have data in the blue image
if nx2 == 0 or ny2 == 0:
WLOG(p, 'error', ('IC_CCD(X/Y)_BLUE_(LOW/HIGH) remove '
'all pixels from image.'))
# resize red image
rkwargs = dict(xlow=p['IC_CCDX_RED_LOW'],
xhigh=p['IC_CCDX_RED_HIGH'],
ylow=p['IC_CCDY_RED_LOW'],
yhigh=p['IC_CCDY_RED_HIGH'])
datared, nx3, ny3 = spirouImage.ResizeImage(p, data, **rkwargs)
# Make sure we have data in the red image
if nx3 == 0 or ny3 == 0:
WLOG(p, 'error', ('IC_CCD(X/Y)_RED_(LOW/HIGH) remove '
'all pixels from image.'))
# ----------------------------------------------------------------------
# Dark Measurement
# ----------------------------------------------------------------------
# Log that we are doing dark measurement
WLOG(p, '', 'Doing Dark measurement')
# measure dark for whole frame
p = spirouImage.MeasureDark(p, data, 'Whole det', 'full')
# measure dark for blue part
p = spirouImage.MeasureDark(p, datablue, 'Blue part', 'blue')
# measure dark for rede part
p = spirouImage.MeasureDark(p, datared, 'Red part', 'red')
# ----------------------------------------------------------------------
# Identification of bad pixels
# ----------------------------------------------------------------------
# get number of bad dark pixels (as a fraction of total pixels)
with warnings.catch_warnings(record=True) as w:
baddark = 100.0 * np.sum(data0 > p['DARK_CUTLIMIT'])
baddark /= np.product(data0.shape)
# log the fraction of bad dark pixels
wmsg = 'Frac pixels with DARK > {0:.2f} ADU/s = {1:.3f} %'
WLOG(p, 'info', wmsg.format(p['DARK_CUTLIMIT'], baddark))
# define mask for values above cut limit or NaN
with warnings.catch_warnings(record=True) as w:
datacutmask = ~((data0 > p['DARK_CUTLIMIT']) | (~np.isfinite(data)))
spirouCore.spirouLog.warninglogger(p, w)
# get number of pixels above cut limit or NaN
n_bad_pix = np.product(data.shape) - np.nansum(datacutmask)
# work out fraction of dead pixels + dark > cut, as percentage
p['DADEADALL'] = n_bad_pix * 100 / np.product(data.shape)
p.set_source('DADEADALL', __NAME__ + '/main()')
# log fraction of dead pixels + dark > cut
logargs = [p['DARK_CUTLIMIT'], p['DADEADALL']]
WLOG(p, 'info', ('Total Frac dead pixels (N.A.N) + DARK > '
'{0:.2f} ADU/s = {1:.3f} %').format(*logargs))
# ----------------------------------------------------------------------
# Plots
# ----------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
# start interactive plot
sPlt.start_interactive_session(p)
# plot the image with blue and red regions
sPlt.darkplot_image_and_regions(p, data)
# plot histograms
sPlt.darkplot_histograms(p)
# end interactive session
sPlt.end_interactive_session(p)
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
# set passed variable and fail message list
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# ----------------------------------------------------------------------
# check that med < qc_max_darklevel
if p['MED_FULL'] > p['QC_MAX_DARKLEVEL']:
# add failed message to fail message list
fmsg = 'Unexpected Median Dark level ({0:5.2f} > {1:5.2f} ADU/s)'
fail_msg.append(fmsg.format(p['MED_FULL'], p['QC_MAX_DARKLEVEL']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(p['MED_FULL'])
qc_names.append('MED_FULL')
qc_logic.append('MED_FULL > {0:.2f}'.format(p['QC_MAX_DARKLEVEL']))
# ----------------------------------------------------------------------
# check that fraction of dead pixels < qc_max_dead
if p['DADEADALL'] > p['QC_MAX_DEAD']:
# add failed message to fail message list
fmsg = 'Unexpected Fraction of dead pixels ({0:5.2f} > {1:5.2f} %)'
fail_msg.append(fmsg.format(p['DADEADALL'], p['QC_MAX_DEAD']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(p['DADEADALL'])
qc_names.append('DADEADALL')
qc_logic.append('DADEADALL > {0:.2f}'.format(p['QC_MAX_DEAD']))
# ----------------------------------------------------------------------
# checl that the precentage of dark pixels < qc_max_dark
if baddark > p['QC_MAX_DARK']:
fmsg = ('Unexpected Fraction of dark pixels > {0:.2f} ADU/s '
'({1:.2f} > {2:.2f}')
fail_msg.append(
fmsg.format(p['DARK_CUTLIMIT'], baddark, p['QC_MAX_DARK']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(baddark)
qc_names.append('baddark')
qc_logic.append('baddark > {0:.2f}'.format(p['QC_MAX_DARK']))
# ----------------------------------------------------------------------
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ----------------------------------------------------------------------
# Save dark to file
# ----------------------------------------------------------------------
# get raw dark filename
rawdarkfile = os.path.basename(p['FITSFILENAME'])
# construct folder and filename
darkfits, tag = spirouConfig.Constants.DARK_FILE(p)
darkfitsname = os.path.basename(darkfits)
# log saving dark frame
WLOG(p, '', 'Saving Dark frame in ' + darkfitsname)
# add keys from original header file
hdict = spirouImage.CopyOriginalKeys(hdr)
# define new keys to add
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag)
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_INFILE1'],
dim1name='file',
values=p['ARG_FILE_NAMES'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DARK_DEAD'],
value=p['DADEAD_FULL'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DARK_MED'], value=p['MED_FULL'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DARK_B_DEAD'],
value=p['DADEAD_BLUE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DARK_B_MED'],
value=p['MED_BLUE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DARK_R_DEAD'],
value=p['DADEAD_RED'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DARK_R_MED'],
value=p['MED_RED'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DARK_CUT'],
value=p['DARK_CUTLIMIT'])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# Set to zero dark value > dark_cutlimit
cutmask = data0 > p['DARK_CUTLIMIT']
data0c = np.where(cutmask, np.zeros_like(data0), data0)
# write image and add header keys (via hdict)
p = spirouImage.WriteImage(p, darkfits, data0c, hdict)
# ----------------------------------------------------------------------
# Save bad pixel mask
# ----------------------------------------------------------------------
# construct bad pixel file name
badpixelfits, tag = spirouConfig.Constants.DARK_BADPIX_FILE(p)
badpixelfitsname = os.path.split(badpixelfits)[-1]
# log that we are saving bad pixel map in dir
WLOG(p, '', 'Saving Bad Pixel Map in ' + badpixelfitsname)
# add keys from original header file
hdict = spirouImage.CopyOriginalKeys(hdr)
# define new keys to add
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag)
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
hdict['DACUT'] = (p['DARK_CUTLIMIT'],
'Threshold of dark level retain [ADU/s]')
# write to file
datacutmask = np.array(datacutmask, dtype=float)
p = spirouImage.WriteImage(p,
badpixelfits,
datacutmask,
hdict,
dtype='float64')
# ----------------------------------------------------------------------
# Move to calibDB and update calibDB
# ----------------------------------------------------------------------
if p['QC']:
# set dark key
if p['DPRTYPE'] == 'DARK_DARK':
keydb = 'DARK'
elif p['USE_SKYDARK_CORRECTION']:
keydb = 'SKYDARK'
else:
emsg = 'Error: Currently {0} only supports DARK_DARK and OBJ_DARK'
WLOG(p, 'error', emsg.format(__NAME__))
# copy dark fits file to the calibDB folder
spirouDB.PutCalibFile(p, darkfits)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, darkfitsname, hdr)
# # set badpix key
# keydb = 'BADPIX_OLD'
# # copy badpix fits file to calibDB folder
# spirouDB.PutCalibFile(p, badpixelfits)
# # update the master calib DB file with new key
# spirouDB.UpdateCalibMaster(p, keydb, badpixelfitsname, hdr)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_shape_spirou.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_shape_spirou.py [night_directory] [fitsfilename]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p)
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouImage.ReadImageAndCombine(p, framemath='add')
# ----------------------------------------------------------------------
# Once we have checked the e2dsfile we can load calibDB
# ----------------------------------------------------------------------
# as we have custom arguments need to load the calibration database
p = spirouStartup.LoadCalibDB(p)
# ----------------------------------------------------------------------
# Get basic image properties for FP file
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, hdr, name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, hdr, name='exptime')
# get gain
p = spirouImage.GetGain(p, hdr, name='gain')
# ----------------------------------------------------------------------
# Correction of reference FP
# ----------------------------------------------------------------------
# set the number of frames
p['NBFRAMES'] = 1
p.set_source('NBFRAMES', __NAME__ + '.main()')
# Correction of DARK
p, datac = spirouImage.CorrectForDark(p, data, hdr)
# Resize hc data
# rotate the image and convert from ADU/s to e-
data = spirouImage.ConvertToE(spirouImage.FlipImage(p, datac), p=p)
# resize image
bkwargs = dict(xlow=p['IC_CCDX_LOW'], xhigh=p['IC_CCDX_HIGH'],
ylow=p['IC_CCDY_LOW'], yhigh=p['IC_CCDY_HIGH'],
getshape=False)
data1 = spirouImage.ResizeImage(p, data, **bkwargs)
# log change in data size
WLOG(p, '',
('FPref Image format changed to {0}x{1}').format(*data1.shape))
# Correct for the BADPIX mask (set all bad pixels to zero)
bargs = [p, data1, hdr]
p, data1 = spirouImage.CorrectForBadPix(*bargs)
p, badpixmask = spirouImage.CorrectForBadPix(*bargs, return_map=True)
# log progress
WLOG(p, '', 'Cleaning FPref hot pixels')
# correct hot pixels
data1 = spirouEXTOR.CleanHotpix(data1, badpixmask)
# Log the number of dead pixels
# get the number of bad pixels
with warnings.catch_warnings(record=True) as _:
n_bad_pix = np.nansum(data1 <= 0)
n_bad_pix_frac = n_bad_pix * 100 / np.product(data1.shape)
# Log number
wmsg = 'Nb FPref dead pixels = {0} / {1:.2f} %'
WLOG(p, 'info', wmsg.format(int(n_bad_pix), n_bad_pix_frac))
# ----------------------------------------------------------------------
# Get master FP file
# ----------------------------------------------------------------------
# log progress
WLOG(p, '', 'Getting FP Master from calibDB')
# get master fp
p, masterfp = spirouImage.GetFPMaster(p, hdr)
# ----------------------------------------------------------------------
# Get transform parameters
# ----------------------------------------------------------------------
# log progress
wargs = [p['ARG_FILE_NAMES'][0], p['FPMASTERFILE']]
WLOG(p, 'info', 'Calculating transforming for {0} onto {1}'.format(*wargs))
gout = spirouImage.GetLinearTransformParams(p, masterfp, data1)
transform, xres, yres = gout
# ------------------------------------------------------------------
# Need to straighten the fp data for debug
# ------------------------------------------------------------------
p, shapem_x = spirouImage.GetShapeX(p, hdr)
p, shapem_y = spirouImage.GetShapeY(p, hdr)
data2 = spirouImage.EATransform(data1, transform, dxmap=shapem_x,
dymap=shapem_y)
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
# set passed variable and fail message list
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# ----------------------------------------------------------------------
# if transform is None means the fp image quality was too poor
if transform is None:
fail_msg.append('FP Image quality too poor (sigma clip failed)')
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
qc_values.append('None')
qc_names.append('Image Quality')
qc_logic.append('Image too poor')
# ----------------------------------------------------------------------
# get residual qc parameter
qc_res = p['SHAPE_QC_LINEAR_TRANS_RES_THRES']
# assess quality of x residuals
if xres > qc_res:
fail_msg.append('x-resdiuals too high {0} > {1}'.format(xres, qc_res))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
qc_values.append(xres)
qc_names.append('XRES')
qc_logic.append('XRES > {0}'.format(qc_res))
# assess quality of x residuals
if yres > qc_res:
fail_msg.append('y-resdiuals too high {0} > {1}'.format(yres, qc_res))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
qc_values.append(yres)
qc_names.append('YRES')
qc_logic.append('YRES > {0}'.format(qc_res))
# ----------------------------------------------------------------------
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ------------------------------------------------------------------
# Writing shape to file
# ------------------------------------------------------------------
# get the raw tilt file name
raw_shape_file = os.path.basename(p['FITSFILENAME'])
# construct file name and path
shapefits, tag = spirouConfig.Constants.SLIT_SHAPE_LOCAL_FILE(p)
shapefitsname = os.path.basename(shapefits)
# Log that we are saving tilt file
wmsg = 'Saving shape information in file: {0}'
WLOG(p, '', wmsg.format(shapefitsname))
# Copy keys from fits file
hdict = spirouImage.CopyOriginalKeys(hdr)
# add version number
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag)
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBDARK'], value=p['DARKFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBAD'], value=p['BADPFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBSHAPEX'],
value=p['SHAPEXFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBSHAPEY'],
value=p['SHAPEYFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBFPMASTER'],
value=p['FPMASTERFILE'])
hdict = spirouImage.AddKey1DList(p, hdict, p['KW_INFILE1'], dim1name='file',
values=p['ARG_FILE_NAMES'])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# add the transform parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_SHAPE_DX'], value=transform[0])
hdict = spirouImage.AddKey(p, hdict, p['KW_SHAPE_DY'], value=transform[1])
hdict = spirouImage.AddKey(p, hdict, p['KW_SHAPE_A'], value=transform[2])
hdict = spirouImage.AddKey(p, hdict, p['KW_SHAPE_B'], value=transform[3])
hdict = spirouImage.AddKey(p, hdict, p['KW_SHAPE_C'], value=transform[4])
hdict = spirouImage.AddKey(p, hdict, p['KW_SHAPE_D'], value=transform[5])
# write tilt file to file
p = spirouImage.WriteImage(p, shapefits, [transform], hdict)
# ----------------------------------------------------------------------
# Move to calibDB and update calibDB
# ----------------------------------------------------------------------
if p['QC']:
# add shape
keydb = 'SHAPE'
# copy shape file to the calibDB folder
spirouDB.PutCalibFile(p, shapefits)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, shapefitsname, hdr)
# ------------------------------------------------------------------
# Writing sanity check files
# ------------------------------------------------------------------
if p['SHAPE_DEBUG_OUTPUTS']:
# log
WLOG(p, '', 'Saving debug sanity check files')
# construct file names
dargs = [p, p['ARG_FILE_NAMES'][0]]
out1 = spirouConfig.Constants.SLIT_SHAPE_IN_FP_FILE(*dargs)
input_fp_file, tag1= out1
out2 = spirouConfig.Constants.SLIT_SHAPE_OUT_FP_FILE(*dargs)
output_fp_file, tag2 = out2
# write input fp file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
p = spirouImage.WriteImage(p, input_fp_file, data1, hdict)
# write output fp file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag2)
p = spirouImage.WriteImage(p, output_fp_file, data2, hdict)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_SLIT_spirou.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_SLIT_spirou.py [night_directory] [files]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set the fiber type
p['FIBER'] = 'AB'
p.set_source('FIBER', __NAME__ + '/main()')
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouImage.ReadImageAndCombine(p, framemath='add')
# ----------------------------------------------------------------------
# fix for un-preprocessed files
# ----------------------------------------------------------------------
data = spirouImage.FixNonPreProcess(p, data)
# ----------------------------------------------------------------------
# Get basic image properties
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, hdr, name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, hdr, name='exptime')
# get gain
p = spirouImage.GetGain(p, hdr, name='gain')
# ----------------------------------------------------------------------
# Correction of DARK
# ----------------------------------------------------------------------
p, datac = spirouImage.CorrectForDark(p, data, hdr)
datac = data
# ----------------------------------------------------------------------
# Resize image
# ----------------------------------------------------------------------
# rotate the image and convert from ADU/s to e-
data = spirouImage.ConvertToE(spirouImage.FlipImage(p, datac), p=p)
# convert NaN to zeros
data0 = np.where(~np.isfinite(data), np.zeros_like(data), data)
# resize image
bkwargs = dict(xlow=p['IC_CCDX_LOW'], xhigh=p['IC_CCDX_HIGH'],
ylow=p['IC_CCDY_LOW'], yhigh=p['IC_CCDY_HIGH'],
getshape=False)
data2 = spirouImage.ResizeImage(p, data0, **bkwargs)
# log change in data size
WLOG(p, '', ('Image format changed to '
'{0}x{1}').format(*data2.shape))
# ----------------------------------------------------------------------
# Correct for the BADPIX mask (set all bad pixels to zero)
# ----------------------------------------------------------------------
p, data2 = spirouImage.CorrectForBadPix(p, data2, hdr)
p, badpixmap = spirouImage.CorrectForBadPix(p, data2, hdr, return_map=True)
# ----------------------------------------------------------------------
# Background computation
# ----------------------------------------------------------------------
if p['IC_DO_BKGR_SUBTRACTION']:
# log that we are doing background measurement
WLOG(p, '', 'Doing background measurement on raw frame')
# get the bkgr measurement
bargs = [p, data2, hdr, badpixmap]
# background, xc, yc, minlevel = spirouBACK.MeasureBackgroundFF(*bargs)
p, background = spirouBACK.MeasureBackgroundMap(*bargs)
else:
background = np.zeros_like(data2)
p['BKGRDFILE'] = 'None'
p.set_source('BKGRDFILE', __NAME__ + '.main()')
# apply background correction to data
data2 = data2 - background
# save data to loc
loc = ParamDict()
loc['DATA'] = data2
loc.set_source('DATA', __NAME__ + '/main()')
# ----------------------------------------------------------------------
# Log the number of dead pixels
# ----------------------------------------------------------------------
# get the number of bad pixels
n_bad_pix = np.nansum(data2 <= 0)
n_bad_pix_frac = n_bad_pix * 100 / np.product(data2.shape)
# Log number
wmsg = 'Nb dead pixels = {0} / {1:.2f} %'
WLOG(p, 'info', wmsg.format(int(n_bad_pix), n_bad_pix_frac))
# ------------------------------------------------------------------
# Get localisation coefficients
# ------------------------------------------------------------------
# original there is a loop but it is not used --> removed
p = spirouImage.FiberParams(p, p['FIBER'], merge=True)
# get localisation fit coefficients
p, loc = spirouLOCOR.GetCoeffs(p, hdr, loc)
# ------------------------------------------------------------------
# Calculate shape map
# ------------------------------------------------------------------
loc = spirouImage.GetShapeMap(p, loc)
# ------------------------------------------------------------------
# Plotting
# ------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
# plots setup: start interactive plot
sPlt.start_interactive_session(p)
# plot the shape process for each order
sPlt.slit_shape_angle_plot(p, loc)
# end interactive section
sPlt.end_interactive_session(p)
# ------------------------------------------------------------------
# Writing to file
# ------------------------------------------------------------------
# get the raw tilt file name
raw_shape_file = os.path.basename(p['FITSFILENAME'])
# construct file name and path
shapefits, tag = spirouConfig.Constants.SLIT_XSHAPE_FILE(p)
shapefitsname = os.path.basename(shapefits)
# Log that we are saving tilt file
wmsg = 'Saving shape information in file: {0}'
WLOG(p, '', wmsg.format(shapefitsname))
# Copy keys from fits file
# Copy keys from fits file
hdict = spirouImage.CopyOriginalKeys(hdr)
# add version number
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag)
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBDARK'], value=p['DARKFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBAD'], value=p['BADPFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBLOCO'], value=p['LOCOFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBSHAPE'], value=raw_shape_file)
# write tilt file to file
p = spirouImage.WriteImage(p, shapefits, loc['DXMAP'], hdict)
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
# TODO: Decide on some quality control criteria?
# set passed variable and fail message list
passed, fail_msg = True, []
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# ----------------------------------------------------------------------
# Move to calibDB and update calibDB
# ----------------------------------------------------------------------
if p['QC']:
keydb = 'SHAPE'
# copy shape file to the calibDB folder
spirouDB.PutCalibFile(p, shapefits)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, shapefitsname, hdr)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_FF_RAW_spirou.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_FF_RAW_spirou.py [night_directory] [files]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# run specific start up
p['FIB_TYPE'] = p['FIBER_TYPES']
p.set_source('FIB_TYPE', __NAME__ + '__main__()')
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouImage.ReadImageAndCombine(p, framemath='add')
# ----------------------------------------------------------------------
# fix for un-preprocessed files
# ----------------------------------------------------------------------
data = spirouImage.FixNonPreProcess(p, data)
# ----------------------------------------------------------------------
# Get basic image properties
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, hdr, name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, hdr, name='exptime')
# get gain
p = spirouImage.GetGain(p, hdr, name='gain')
# set sigdet and conad keywords (sigdet is changed later)
p['KW_CCD_SIGDET'][1] = p['SIGDET']
p['KW_CCD_CONAD'][1] = p['GAIN']
# ----------------------------------------------------------------------
# Correction of DARK
# ----------------------------------------------------------------------
p, datac = spirouImage.CorrectForDark(p, data, hdr)
# ----------------------------------------------------------------------
# Resize image
# ----------------------------------------------------------------------
# rotate the image and convert from ADU/s to e-
data = spirouImage.ConvertToADU(spirouImage.FlipImage(p, datac), p=p)
# convert NaN to zeros
data0 = np.where(~np.isfinite(data), np.zeros_like(data), data)
# resize image
bkwargs = dict(xlow=p['IC_CCDX_LOW'],
xhigh=p['IC_CCDX_HIGH'],
ylow=p['IC_CCDY_LOW'],
yhigh=p['IC_CCDY_HIGH'],
getshape=False)
data1 = spirouImage.ResizeImage(p, data0, **bkwargs)
# log change in data size
WLOG(p, '', ('Image format changed to '
'{0}x{1}').format(*data1.shape[::-1]))
# ----------------------------------------------------------------------
# Correct for the BADPIX mask (set all bad pixels to zero)
# ----------------------------------------------------------------------
p, data1 = spirouImage.CorrectForBadPix(p, data1, hdr)
# ----------------------------------------------------------------------
# Log the number of dead pixels
# ----------------------------------------------------------------------
# get the number of bad pixels
n_bad_pix = np.sum(~np.isfinite(data1))
n_bad_pix_frac = n_bad_pix * 100 / np.product(data1.shape)
# Log number
wmsg = 'Nb dead pixels = {0} / {1:.4f} %'
WLOG(p, 'info', wmsg.format(int(n_bad_pix), n_bad_pix_frac))
# ----------------------------------------------------------------------
# Get the miny, maxy and max_signal for the central column
# ----------------------------------------------------------------------
# get the central column
y = data1[p['IC_CENT_COL'], :]
# get the min max and max signal using box smoothed approach
miny, maxy, max_signal, diff_maxmin = spirouBACK.MeasureMinMaxSignal(p, y)
# Log max average flux/pixel
wmsg = ('Maximum average flux (95th percentile) /pixel in the spectrum: '
'{0:.1f} [ADU]')
WLOG(p, 'info', wmsg.format(max_signal / p['NBFRAMES']))
# ----------------------------------------------------------------------
# Background computation
# ----------------------------------------------------------------------
# p['ic_bkgr_percent'] = 3.0
if p['IC_DO_BKGR_SUBTRACTION']:
# log that we are doing background measurement
WLOG(p, '', 'Doing background measurement on raw frame')
# get the bkgr measurement
bargs = [p, data1, hdr]
# background, xc, yc, minlevel = spirouBACK.MeasureBackgroundFF(*bargs)
p, background = spirouBACK.MeasureBackgroundMap(*bargs)
else:
background = np.zeros_like(data1)
p['BKGRDFILE'] = 'None'
p.set_source('BKGRDFILE', __NAME__ + '.main()')
# apply background correction to data
data1 = data1 - background
# ----------------------------------------------------------------------
# Read tilt slit angle
# ----------------------------------------------------------------------
# define loc storage parameter dictionary
loc = ParamDict()
# get tilts
if p['IC_FF_EXTRACT_TYPE'] not in EXTRACT_SHAPE_TYPES:
p, loc['TILT'] = spirouImage.ReadTiltFile(p, hdr)
else:
loc['TILT'] = None
loc.set_source('TILT', __NAME__ + '/main()')
# ----------------------------------------------------------------------
# Get all fiber data (for all fibers)
# ----------------------------------------------------------------------
# TODO: This is temp solution for options 5a and 5b
loc_fibers = spirouLOCOR.GetFiberData(p, hdr)
# ------------------------------------------------------------------
# Deal with debananafication
# ------------------------------------------------------------------
# if mode 4a or 4b we need to straighten in x only
if p['IC_FF_EXTRACT_TYPE'] in ['4a', '4b']:
# get the shape parameters
p, shapem_x = spirouImage.GetShapeX(p, hdr)
p, shape_local = spirouImage.GetShapeLocal(p, hdr)
# log progress
WLOG(p, '', 'Debananafying (straightening) image')
# apply shape transforms
targs = dict(lin_transform_vect=shape_local, dxmap=shapem_x)
data2 = spirouImage.EATransform(data1, **targs)
# if mode 5a or 5b we need to straighten in x and y using the
# polynomial fits for location
elif p['IC_FF_EXTRACT_TYPE'] in ['5a', '5b']:
# get the shape parameters
p, shapem_x = spirouImage.GetShapeX(p, hdr)
p, shapem_y = spirouImage.GetShapeY(p, hdr)
p, shape_local = spirouImage.GetShapeLocal(p, hdr)
p, fpmaster = spirouImage.GetFPMaster(p, hdr)
# get the bad pixel map
bkwargs = dict(return_map=True, quiet=True)
p, badpix = spirouImage.CorrectForBadPix(p, data1, hdr, **bkwargs)
# log progress
WLOG(p, '', 'Cleaning image')
# clean the image
data1 = spirouEXTOR.CleanHotpix(data1, badpix)
# log progress
WLOG(p, '', 'Debananafying (straightening) image')
# apply shape transforms
targs = dict(lin_transform_vect=shape_local,
dxmap=shapem_x,
dymap=shapem_y)
data2 = spirouImage.EATransform(data1, **targs)
# in any other mode we do not straighten
else:
data2 = np.array(data1)
# ----------------------------------------------------------------------
# Fiber loop
# ----------------------------------------------------------------------
# loop around fiber types
for fiber in p['FIB_TYPE']:
# set fiber in p
p['FIBER'] = fiber
p.set_source('FIBER', __NAME__ + '/main()')
# get fiber parameters
params2add = spirouImage.FiberParams(p, p['FIBER'])
for param in params2add:
p[param] = params2add[param]
p.set_source(param, __NAME__ + '.main()')
# ------------------------------------------------------------------
# Get fiber specific parameters from loc_fibers
# ------------------------------------------------------------------
# get this fibers parameters
p = spirouImage.FiberParams(p, p['FIBER'], merge=True)
# get localisation parameters
for key in loc_fibers[fiber]:
loc[key] = loc_fibers[fiber][key]
loc.set_source(key, loc_fibers[fiber].sources[key])
# get locofile source
p['LOCOFILE'] = loc['LOCOFILE']
p.set_source('LOCOFILE', loc.sources['LOCOFILE'])
# get the order_profile
order_profile = loc_fibers[fiber]['ORDER_PROFILE']
# ------------------------------------------------------------------
# Set up Extract storage
# ------------------------------------------------------------------
# Create array to store extraction (for each order and each pixel
# along order)
loc['E2DS'] = np.zeros((loc['NUMBER_ORDERS'], data2.shape[1]))
loc['E2DSLL'] = []
# Create array to store the blaze (for each order and at each pixel
# along order)
loc['BLAZE'] = np.zeros((loc['NUMBER_ORDERS'], data2.shape[1]))
# Create array to store the flat (for each order and at each pixel
# along order)
loc['FLAT'] = np.zeros((loc['NUMBER_ORDERS'], data2.shape[1]))
# Create array to store the signal to noise ratios for each order
loc['SNR'] = np.zeros(loc['NUMBER_ORDERS'])
# Create array to store the rms for each order
loc['RMS'] = np.zeros(loc['NUMBER_ORDERS'])
# Manually set the sigdet to be used in extraction weighting
if p['IC_FF_SIGDET'] > 0:
p['SIGDET'] = float(p['IC_FF_SIGDET'])
# ------------------------------------------------------------------
# Extract orders
# old code time: 1 loop, best of 3: 22.3 s per loop
# new code time: 3.16 s ± 237 ms per loop
# ------------------------------------------------------------------
# get limits of order extraction
valid_orders = spirouFLAT.GetValidOrders(p, loc)
# loop around each order
for order_num in valid_orders:
# extract this order
eargs = [p, loc, data2, order_num]
ekwargs = dict(mode=p['IC_FF_EXTRACT_TYPE'],
order_profile=order_profile)
with warnings.catch_warnings(record=True) as w:
eout = spirouEXTOR.Extraction(*eargs, **ekwargs)
# deal with different return
if p['IC_FF_EXTRACT_TYPE'] in EXTRACT_LL_TYPES:
e2ds, e2dsll, cpt = eout
else:
e2ds, cpt = eout
e2dsll = None
# calculate the noise
range1, range2 = p['IC_EXT_RANGE1'], p['IC_EXT_RANGE2']
noise = p['SIGDET'] * np.sqrt(range1 + range2)
# get window size
blaze_win1 = int(data2.shape[1] / 2) - p['IC_EXTFBLAZ']
blaze_win2 = int(data2.shape[1] / 2) + p['IC_EXTFBLAZ']
# get average flux per pixel
flux = np.nansum(
e2ds[blaze_win1:blaze_win2]) / (2 * p['IC_EXTFBLAZ'])
# calculate signal to noise ratio = flux/sqrt(flux + noise^2)
snr = flux / np.sqrt(flux + noise**2)
# remove edge of orders at low S/N
with warnings.catch_warnings(record=True) as _:
blazemask = e2ds < (flux / p['IC_FRACMINBLAZE'])
e2ds = np.where(blazemask, np.nan, e2ds)
# e2ds = np.where(e2ds < p['IC_MINBLAZE'], 0., e2ds)
# calcualte the blaze function
blaze = spirouFLAT.MeasureBlazeForOrder(p, e2ds)
# calculate the flat
flat = e2ds / blaze
# calculate the rms
rms = np.nanstd(flat)
# log the SNR RMS
wmsg = 'On fiber {0} order {1}: S/N= {2:.1f} - FF rms={3:.2f} %'
wargs = [fiber, order_num, snr, rms * 100.0]
WLOG(p, '', wmsg.format(*wargs))
# add calculations to storage
loc['E2DS'][order_num] = e2ds
loc['SNR'][order_num] = snr
loc['RMS'][order_num] = rms
loc['BLAZE'][order_num] = blaze
loc['FLAT'][order_num] = flat
# save the longfile
if p['IC_FF_EXTRACT_TYPE'] in EXTRACT_LL_TYPES:
loc['E2DSLL'].append(e2dsll)
# set sources
source = __NAME__ + '/main()()'
loc.set_sources(['e2ds', 'SNR', 'RMS', 'blaze', 'flat'], source)
# Log if saturation level reached
satvalue = (flux / p['GAIN']) / (range1 + range2)
if satvalue > (p['QC_LOC_FLUMAX'] * p['NBFRAMES']):
wmsg = 'SATURATION LEVEL REACHED on Fiber {0} order={1}'
WLOG(p, 'warning', wmsg.format(fiber, order_num))
# ----------------------------------------------------------------------
# Plots
# ----------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
# start interactive session if needed
sPlt.start_interactive_session(p)
# plot all orders or one order
if p['IC_FF_PLOT_ALL_ORDERS']:
# plot image with all order fits (slower)
sPlt.ff_aorder_fit_edges(p, loc, data1)
else:
# plot image with selected order fit and edge fit (faster)
sPlt.ff_sorder_fit_edges(p, loc, data1)
# plot tilt adjusted e2ds and blaze for selected order
sPlt.ff_sorder_tiltadj_e2ds_blaze(p, loc)
# plot flat for selected order
sPlt.ff_sorder_flat(p, loc)
# plot the RMS for all but skipped orders
# sPlt.ff_rms_plot(p, loc)
if p['IC_FF_EXTRACT_TYPE'] in EXTRACT_SHAPE_TYPES:
sPlt.ff_debanana_plot(p, loc, data2)
# ------------------------------------------------------------------
# Quality control
# ------------------------------------------------------------------
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# saturation check: check that the max_signal is lower than
# qc_max_signal
# if max_signal > (p['QC_MAX_SIGNAL'] * p['nbframes']):
# fmsg = 'Too much flux in the image (max authorized={0})'
# fail_msg.append(fmsg.format(p['QC_MAX_SIGNAL'] * p['nbframes']))
# passed = False
# # For some reason this test is ignored in old code
# passed = True
# WLOG(p, 'info', fail_msg[-1])
# get mask for removing certain orders in the RMS calculation
remove_orders = np.array(p['FF_RMS_PLOT_SKIP_ORDERS'])
mask = np.in1d(np.arange(len(loc['RMS'])), remove_orders)
# apply mask and calculate the maximum RMS
max_rms = np.nanmax(loc['RMS'][~mask])
# apply the quality control based on the new RMS
if max_rms > p['QC_FF_RMS']:
fmsg = 'abnormal RMS of FF ({0:.3f} > {1:.3f})'
fail_msg.append(fmsg.format(max_rms, p['QC_FF_RMS']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(max_rms)
qc_names.append('max_rms')
qc_logic.append('max_rms > {0:.3f}'.format(p['QC_FF_RMS']))
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
wmsg = 'QUALITY CONTROL SUCCESSFUL - Well Done -'
WLOG(p, 'info', wmsg)
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ----------------------------------------------------------------------
# Store Blaze in file
# ----------------------------------------------------------------------
# get raw flat filename
raw_flat_file = os.path.basename(p['FITSFILENAME'])
e2dsllfits, tag4 = spirouConfig.Constants.EXTRACT_E2DSLL_FILE(p)
# get extraction method and function
efout = spirouEXTOR.GetExtMethod(p, p['IC_FF_EXTRACT_TYPE'])
extmethod, extfunc = efout
# construct filename
blazefits, tag1 = spirouConfig.Constants.FF_BLAZE_FILE(p)
blazefitsname = os.path.split(blazefits)[-1]
# log that we are saving blaze file
wmsg = 'Saving blaze spectrum for fiber: {0} in {1}'
WLOG(p, '', wmsg.format(fiber, blazefitsname))
# add keys from original header file
hdict = spirouImage.CopyOriginalKeys(hdr)
# define new keys to add
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_FIBER'], value=p['FIBER'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBDARK'],
value=p['DARKFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBBAD'],
value=p['BADPFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBLOCO'],
value=p['LOCOFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBBACK'],
value=p['BKGRDFILE'])
if p['IC_FF_EXTRACT_TYPE'] not in EXTRACT_SHAPE_TYPES:
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBTILT'],
value=p['TILTFILE'])
if p['IC_FF_EXTRACT_TYPE'] in EXTRACT_SHAPE_TYPES:
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBSHAPEX'],
value=p['SHAPEXFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBSHAPEY'],
value=p['SHAPEYFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBSHAPE'],
value=p['SHAPEFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBFPMASTER'],
value=p['FPMASTERFILE'])
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_INFILE1'],
dim1name='file',
values=p['ARG_FILE_NAMES'])
# add some properties back
hdict = spirouImage.AddKey(p, hdict, p['KW_CCD_SIGDET'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CCD_CONAD'])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# copy extraction method and function to header
# (for reproducibility)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_E2DS_EXTM'],
value=extmethod)
hdict = spirouImage.AddKey(p, hdict, p['KW_E2DS_FUNC'], value=extfunc)
# output keys
hdict = spirouImage.AddKey(p,
hdict,
p['KW_EXT_TYPE'],
value=p['DPRTYPE'])
# write 1D list of the SNR
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_EXTRA_SN'],
values=loc['SNR'])
# write center fits and add header keys (via hdict)
p = spirouImage.WriteImage(p, blazefits, loc['BLAZE'], hdict)
# ----------------------------------------------------------------------
# Store Flat-field in file
# ----------------------------------------------------------------------
# construct filename
flatfits, tag2 = spirouConfig.Constants.FF_FLAT_FILE(p)
flatfitsname = os.path.split(flatfits)[-1]
# log that we are saving blaze file
wmsg = 'Saving FF spectrum for fiber: {0} in {1}'
WLOG(p, '', wmsg.format(fiber, flatfitsname))
# write 1D list of the RMS (add to hdict from blaze)
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag2)
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_FLAT_RMS'],
values=loc['RMS'])
# write center fits and add header keys (via same hdict as blaze)
p = spirouImage.WriteImage(p, flatfits, loc['FLAT'], hdict)
# Save E2DSLL file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag4)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_EXT_TYPE'],
value=p['DPRTYPE'])
if p['IC_FF_EXTRACT_TYPE'] in EXTRACT_LL_TYPES:
llstack = np.vstack(loc['E2DSLL'])
p = spirouImage.WriteImage(p, e2dsllfits, llstack, hdict)
# ------------------------------------------------------------------
# Update the calibration database
# ------------------------------------------------------------------
if p['QC'] == 1:
# copy flatfits to calibdb
keydb = 'FLAT_' + p['FIBER']
# copy localisation file to the calibDB folder
spirouDB.PutCalibFile(p, flatfits)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, flatfitsname, hdr)
# copy blazefits to calibdb
keydb = 'BLAZE_' + p['FIBER']
# copy localisation file to the calibDB folder
spirouDB.PutCalibFile(p, blazefits)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, blazefitsname, hdr)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None, fiber_type=None, **kwargs):
"""
cal_DRIFT_E2DS_spirou.py main function, if night_name and files are
None uses arguments from run time i.e.:
cal_DRIFT_E2DS_spirou.py [night_directory] [files]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:param fiber_type: string, if None does all fiber types (defined in
constants_SPIROU FIBER_TYPES (default is AB, A, B, C
if defined then only does this fiber type (but must
be in FIBER_TYPES)
:param kwargs: any keyword to overwrite constant in param dict "p"
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# deal with fiber type
if fiber_type is None:
fiber_type = p['FIBER_TYPES']
if type(fiber_type) == str:
if fiber_type.upper() == 'ALL':
fiber_type = p['FIBER_TYPES']
elif fiber_type in p['FIBER_TYPES']:
fiber_type = [fiber_type]
else:
emsg = 'fiber_type="{0}" not understood'
WLOG(p, 'error', emsg.format(fiber_type))
# set fiber type
p['FIB_TYPE'] = fiber_type
p.set_source('FIB_TYPE', __NAME__ + '__main__()')
# Overwrite keys from source
for kwarg in kwargs:
p[kwarg] = kwargs[kwarg]
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouImage.ReadImageAndCombine(p, framemath='add')
# ----------------------------------------------------------------------
# fix for un-preprocessed files
# ----------------------------------------------------------------------
data = spirouImage.FixNonPreProcess(p, data)
# ----------------------------------------------------------------------
# Get basic image properties
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, hdr, name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, hdr, name='exptime')
# get gain
p = spirouImage.GetGain(p, hdr, name='gain')
# set sigdet and conad keywords (sigdet is changed later)
p['KW_CCD_SIGDET'][1] = p['SIGDET']
p['KW_CCD_CONAD'][1] = p['GAIN']
# now change the value of sigdet if require
if p['IC_EXT_SIGDET'] > 0:
p['SIGDET'] = float(p['IC_EXT_SIGDET'])
# get DPRTYPE from header (Will have it if valid)
p = spirouImage.ReadParam(p, hdr, 'KW_DPRTYPE', required=False, dtype=str)
# check the DPRTYPE is not None
if (p['DPRTYPE'] == 'None') or (['DPRTYPE'] is None):
emsg1 = 'Error: {0} is not set in header for file {1}'
eargs = [p['KW_DPRTYPE'][0], p['FITSFILENAME']]
emsg2 = '\tPlease run pre-processing on file.'
emsg3 = ('\tIf pre-processing fails or skips file, file is not '
'currrently as valid DRS fits file.')
WLOG(p, 'error', [emsg1.format(*eargs), emsg2, emsg3])
else:
p['DPRTYPE'] = p['DPRTYPE'].strip()
# ----------------------------------------------------------------------
# Correction of DARK
# ----------------------------------------------------------------------
p, datac = spirouImage.CorrectForDark(p, data, hdr)
# ----------------------------------------------------------------------
# Resize image
# ----------------------------------------------------------------------
# rotate the image and convert from ADU/s to ADU
data = spirouImage.ConvertToADU(spirouImage.FlipImage(p, datac), p=p)
# convert NaN to zeros
data0 = np.where(~np.isfinite(data), np.zeros_like(data), data)
# resize image
bkwargs = dict(xlow=p['IC_CCDX_LOW'],
xhigh=p['IC_CCDX_HIGH'],
ylow=p['IC_CCDY_LOW'],
yhigh=p['IC_CCDY_HIGH'],
getshape=False)
data1 = spirouImage.ResizeImage(p, data0, **bkwargs)
# log change in data size
wmsg = 'Image format changed to {1}x{0}'
WLOG(p, '', wmsg.format(*data1.shape))
# ----------------------------------------------------------------------
# Correct for the BADPIX mask (set all bad pixels to zero)
# ----------------------------------------------------------------------
p, data1 = spirouImage.CorrectForBadPix(p, data1, hdr)
# ----------------------------------------------------------------------
# Log the number of dead pixels
# ----------------------------------------------------------------------
# get the number of bad pixels
n_bad_pix = np.sum(~np.isfinite(data1))
n_bad_pix_frac = n_bad_pix * 100 / np.product(data1.shape)
# Log number
wmsg = 'Nb dead pixels = {0} / {1:.4f} %'
WLOG(p, 'info', wmsg.format(int(n_bad_pix), n_bad_pix_frac))
# ----------------------------------------------------------------------
# Get the miny, maxy and max_signal for the central column
# ----------------------------------------------------------------------
# get the central column
y = data1[p['IC_CENT_COL'], :]
# get the min max and max signal using box smoothed approach
miny, maxy, max_signal, diff_maxmin = spirouBACK.MeasureMinMaxSignal(p, y)
# Log max average flux/pixel
wmsg = 'Maximum average flux/pixel in the spectrum: {0:.1f} [ADU]'
WLOG(p, 'info', wmsg.format(max_signal / p['NBFRAMES']))
# ----------------------------------------------------------------------
# Background computation
# ----------------------------------------------------------------------
if p['IC_DO_BKGR_SUBTRACTION']:
# log that we are doing background measurement
WLOG(p, '', 'Doing background measurement on raw frame')
# get the bkgr measurement
bargs = [p, data1, hdr]
# background, xc, yc, minlevel = spirouBACK.MeasureBackgroundFF(*bargs)
p, background = spirouBACK.MeasureBackgroundMap(*bargs)
else:
background = np.zeros_like(data1)
p['BKGRDFILE'] = 'None'
p.set_source('BKGRDFILE', __NAME__ + '.main()')
# apply background correction to data (and set to zero where negative)
data1 = data1 - background
# ----------------------------------------------------------------------
# Read tilt slit angle
# ----------------------------------------------------------------------
# define loc storage parameter dictionary
loc = ParamDict()
# get tilts (if the mode requires it)
if p['IC_EXTRACT_TYPE'] not in EXTRACT_SHAPE_TYPES:
p, loc['TILT'] = spirouImage.ReadTiltFile(p, hdr)
loc.set_source('TILT',
__NAME__ + '/main() + /spirouImage.ReadTiltFile')
else:
loc['TILT'] = None
loc.set_source('TILT', __NAME__ + '/main()')
# ----------------------------------------------------------------------
# Earth Velocity calculation
# ----------------------------------------------------------------------
if p['IC_IMAGE_TYPE'] == 'H4RG':
p, loc = spirouImage.GetEarthVelocityCorrection(p, loc, hdr)
# ----------------------------------------------------------------------
# Get all fiber data (for all fibers)
# ----------------------------------------------------------------------
# TODO: This is temp solution for options 5a and 5b
loc_fibers = spirouLOCOR.GetFiberData(p, hdr)
# ------------------------------------------------------------------
# Deal with debananafication
# ------------------------------------------------------------------
# if mode 4a or 4b we need to straighten in x only
if p['IC_EXTRACT_TYPE'] in ['4a', '4b']:
# get the shape parameters
p, shapem_x = spirouImage.GetShapeX(p, hdr)
p, shape_local = spirouImage.GetShapeLocal(p, hdr)
# log progress
WLOG(p, '', 'Debananafying (straightening) image')
# apply shape transforms
targs = dict(lin_transform_vect=shape_local, dxmap=shapem_x)
data2 = spirouImage.EATransform(data1, **targs)
# if mode 5a or 5b we need to straighten in x and y using the
# polynomial fits for location
elif p['IC_EXTRACT_TYPE'] in ['5a', '5b']:
# get the shape parameters
p, shapem_x = spirouImage.GetShapeX(p, hdr)
p, shapem_y = spirouImage.GetShapeY(p, hdr)
p, shape_local = spirouImage.GetShapeLocal(p, hdr)
p, fpmaster = spirouImage.GetFPMaster(p, hdr)
# get the bad pixel map
bkwargs = dict(return_map=True, quiet=True)
p, badpix = spirouImage.CorrectForBadPix(p, data1, hdr, **bkwargs)
# log progress
WLOG(p, '', 'Cleaning image')
# clean the image
data1 = spirouEXTOR.CleanHotpix(data1, badpix)
# log progress
WLOG(p, '', 'Debananafying (straightening) image')
# apply shape transforms
targs = dict(lin_transform_vect=shape_local,
dxmap=shapem_x,
dymap=shapem_y)
data2 = spirouImage.EATransform(data1, **targs)
# in any other mode we do not straighten
else:
data2 = np.array(data1)
# ----------------------------------------------------------------------
# Fiber loop
# ----------------------------------------------------------------------
# loop around fiber types
for fiber in p['FIB_TYPE']:
# set fiber
p['FIBER'] = fiber
p.set_source('FIBER', __NAME__ + '/main()()')
# ------------------------------------------------------------------
# Read wavelength solution
# ------------------------------------------------------------------
# set source of wave file
wsource = __NAME__ + '/main() + /spirouImage.GetWaveSolution'
# Force A and B to AB solution
if fiber in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = fiber
# get wave image
wkwargs = dict(hdr=hdr,
return_wavemap=True,
return_filename=True,
return_header=True,
fiber=wave_fiber)
wout = spirouImage.GetWaveSolution(p, **wkwargs)
loc['WAVEPARAMS'], loc['WAVE'], loc['WAVEFILE'] = wout[:3]
loc['WAVEHDR'], loc['WSOURCE'] = wout[3:]
source_names = ['WAVE', 'WAVEFILE', 'WAVEPARAMS', 'WAVEHDR']
loc.set_sources(source_names, wsource)
# get dates
loc['WAVE_ACQTIMES'] = spirouDB.GetTimes(p, loc['WAVEHDR'])
loc.set_source('WAVE_ACQTIMES', __NAME__ + '.main()')
# get the recipe that produced the wave solution
if 'WAVECODE' in loc['WAVEHDR']:
loc['WAVE_CODE'] = loc['WAVEHDR']['WAVECODE']
else:
loc['WAVE_CODE'] = 'UNKNOWN'
loc.set_source('WAVE_CODE', __NAME__ + '.main()')
# ----------------------------------------------------------------------
# Get WFP keys
# ----------------------------------------------------------------------
# Read the WFP keys - if they don't exist set to None and deal
# with later
p = spirouImage.ReadParam(p,
loc['WAVEHDR'],
'KW_WFP_DRIFT',
name='WFP_DRIFT',
required=False)
p = spirouImage.ReadParam(p,
loc['WAVEHDR'],
'KW_WFP_FWHM',
name='WFP_FWHM',
required=False)
p = spirouImage.ReadParam(p,
loc['WAVEHDR'],
'KW_WFP_CONTRAST',
name='WFP_CONTRAST',
required=False)
p = spirouImage.ReadParam(p,
loc['WAVEHDR'],
'KW_WFP_MAXCPP',
name='WFP_MAXCPP',
required=False)
p = spirouImage.ReadParam(p,
loc['WAVEHDR'],
'KW_WFP_MASK',
name='WFP_MASK',
required=False)
p = spirouImage.ReadParam(p,
loc['WAVEHDR'],
'KW_WFP_LINES',
name='WFP_LINES',
required=False)
p = spirouImage.ReadParam(p,
loc['WAVEHDR'],
'KW_WFP_TARG_RV',
name='WFP_TARG_RV',
required=False)
p = spirouImage.ReadParam(p,
loc['WAVEHDR'],
'KW_WFP_WIDTH',
name='WFP_WIDTH',
required=False)
p = spirouImage.ReadParam(p,
loc['WAVEHDR'],
'KW_WFP_STEP',
name='WFP_STEP',
required=False)
# ----------------------------------------------------------------------
# Read Flat file
# ----------------------------------------------------------------------
fout = spirouImage.ReadFlatFile(p, hdr, return_header=True)
p, loc['FLAT'], flathdr = fout
loc.set_source('FLAT',
__NAME__ + '/main() + /spirouImage.ReadFlatFile')
# get flat extraction mode
if p['KW_E2DS_EXTM'][0] in flathdr:
flat_ext_mode = flathdr[p['KW_E2DS_EXTM'][0]]
else:
flat_ext_mode = None
# ------------------------------------------------------------------
# Check extraction method is same as flat extraction method
# ------------------------------------------------------------------
# get extraction method and function
extmethod, extfunc = spirouEXTOR.GetExtMethod(p, p['IC_EXTRACT_TYPE'])
if not DEBUG:
# compare flat extraction mode to extraction mode
spirouEXTOR.CompareExtMethod(p, flat_ext_mode, extmethod, 'FLAT',
'EXTRACTION')
# ------------------------------------------------------------------
# Read Blaze file
# ------------------------------------------------------------------
p, loc['BLAZE'] = spirouImage.ReadBlazeFile(p, hdr)
blazesource = __NAME__ + '/main() + /spirouImage.ReadBlazeFile'
loc.set_source('BLAZE', blazesource)
# ------------------------------------------------------------------
# Get fiber specific parameters from loc_fibers
# ------------------------------------------------------------------
# get this fibers parameters
p = spirouImage.FiberParams(p, p['FIBER'], merge=True)
# get localisation parameters
for key in loc_fibers[fiber]:
loc[key] = loc_fibers[fiber][key]
loc.set_source(key, loc_fibers[fiber].sources[key])
# get locofile source
p['LOCOFILE'] = loc['LOCOFILE']
p.set_source('LOCOFILE', loc.sources['LOCOFILE'])
# get the order_profile
order_profile = loc_fibers[fiber]['ORDER_PROFILE']
# ------------------------------------------------------------------
# Set up Extract storage
# ------------------------------------------------------------------
# Create array to store extraction (for each order and each pixel
# along order)
loc['E2DS'] = np.zeros((loc['NUMBER_ORDERS'], data2.shape[1]))
loc['E2DSFF'] = np.zeros((loc['NUMBER_ORDERS'], data2.shape[1]))
loc['E2DSLL'] = []
loc['SPE1'] = np.zeros((loc['NUMBER_ORDERS'], data2.shape[1]))
loc['SPE3'] = np.zeros((loc['NUMBER_ORDERS'], data2.shape[1]))
loc['SPE4'] = np.zeros((loc['NUMBER_ORDERS'], data2.shape[1]))
loc['SPE5'] = np.zeros((loc['NUMBER_ORDERS'], data2.shape[1]))
# Create array to store the signal to noise ratios for each order
loc['SNR'] = np.zeros(loc['NUMBER_ORDERS'])
# ------------------------------------------------------------------
# Extract orders
# ------------------------------------------------------------------
# source for parameter dictionary
source = __NAME__ + '/main()'
# get limits of order extraction
valid_orders = spirouEXTOR.GetValidOrders(p, loc)
# loop around each order
for order_num in valid_orders:
# -------------------------------------------------------------
# IC_EXTRACT_TYPE decides the extraction routine
# -------------------------------------------------------------
eargs = [p, loc, data2, order_num]
ekwargs = dict(mode=p['IC_EXTRACT_TYPE'],
order_profile=order_profile)
with warnings.catch_warnings(record=True) as w:
eout = spirouEXTOR.Extraction(*eargs, **ekwargs)
# deal with different return
if p['IC_EXTRACT_TYPE'] in EXTRACT_LL_TYPES:
e2ds, e2dsll, cpt = eout
else:
e2ds, cpt = eout
e2dsll = None
# -------------------------------------------------------------
# calculate the noise
range1, range2 = p['IC_EXT_RANGE1'], p['IC_EXT_RANGE2']
# set the noise
noise = p['SIGDET'] * np.sqrt(range1 + range2)
# get window size
blaze_win1 = int(data2.shape[0] / 2) - p['IC_EXTFBLAZ']
blaze_win2 = int(data2.shape[0] / 2) + p['IC_EXTFBLAZ']
# get average flux per pixel
flux = np.nansum(
e2ds[blaze_win1:blaze_win2]) / (2 * p['IC_EXTFBLAZ'])
# calculate signal to noise ratio = flux/sqrt(flux + noise^2)
snr = flux / np.sqrt(flux + noise**2)
# log the SNR RMS
wmsg = 'On fiber {0} order {1}: S/N= {2:.1f} Nbcosmic= {3}'
wargs = [p['FIBER'], order_num, snr, cpt]
WLOG(p, '', wmsg.format(*wargs))
# add calculations to storage
loc['E2DS'][order_num] = e2ds
loc['E2DSFF'][order_num] = e2ds / loc['FLAT'][order_num]
loc['SNR'][order_num] = snr
# save the longfile
if p['IC_EXTRACT_TYPE'] in EXTRACT_LL_TYPES:
loc['E2DSLL'].append(e2dsll)
# set sources
loc.set_sources(['e2ds', 'SNR'], source)
# Log if saturation level reached
satvalue = (flux / p['GAIN']) / (range1 + range2)
if satvalue > (p['QC_LOC_FLUMAX'] * p['NBFRAMES']):
wmsg = 'SATURATION LEVEL REACHED on Fiber {0} order={1}'
WLOG(p, 'warning', wmsg.format(fiber, order_num))
# ------------------------------------------------------------------
# Thermal correction
# ------------------------------------------------------------------
# get fiber type
if fiber in ['AB', 'A', 'B']:
fibertype = p['DPRTYPE'].split('_')[0]
else:
fibertype = p['DPRTYPE'].split('_')[1]
# apply thermal correction based on fiber type
if fibertype in p['THERMAL_CORRECTION_TYPE1']:
# log progress
wmsg = 'Correcting thermal background for {0}={1} mode={2}'
wargs = [fiber, fibertype, 1]
WLOG(p, 'info', wmsg.format(*wargs))
# correct E2DS
tkwargs = dict(image=loc['E2DS'], mode=1, fiber=fiber, hdr=hdr)
p, loc['E2DS'] = spirouBACK.ThermalCorrect(p, **tkwargs)
# correct E2DSFF
tkwargs = dict(image=loc['E2DSFF'],
mode=1,
fiber=fiber,
hdr=hdr,
flat=loc['FLAT'])
p, loc['E2DSFF'] = spirouBACK.ThermalCorrect(p, **tkwargs)
elif fibertype in p['THERMAL_CORRECTION_TYPE2']:
# log progress
wmsg = 'Correcting thermal background for {0}={1} mode={2}'
wargs = [fiber, fibertype, 2]
WLOG(p, 'info', wmsg.format(*wargs))
# correct E2DS
tkwargs = dict(image=loc['E2DS'], mode=2, fiber=fiber, hdr=hdr)
p, loc['E2DS'] = spirouBACK.ThermalCorrect(p, **tkwargs)
# correct E2DSFF
tkwargs = dict(image=loc['E2DSFF'],
mode=2,
fiber=fiber,
hdr=hdr,
flat=loc['FLAT'])
p, loc['E2DSFF'] = spirouBACK.ThermalCorrect(p, **tkwargs)
else:
# log progress
wmsg = 'Not correcting thermal background for {0}={1}'
wargs = [fiber, fibertype]
WLOG(p, 'info', wmsg.format(*wargs))
# set filename for output
outfile = 'THERMALFILE_{0}'.format(fiber)
p[outfile] = 'None'
p.set_source(outfile, __NAME__ + '.main()')
# ------------------------------------------------------------------
# Plots
# ------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
# start interactive session if needed
sPlt.start_interactive_session(p)
# plot all orders or one order
if p['IC_FF_PLOT_ALL_ORDERS']:
# plot image with all order fits (slower)
sPlt.ext_aorder_fit(p, loc, data1, max_signal / 10.)
else:
# plot image with selected order fit and edge fit (faster)
sPlt.ext_sorder_fit(p, loc, data1, max_signal / 10.)
# plot e2ds against wavelength
sPlt.ext_spectral_order_plot(p, loc)
if p['IC_EXTRACT_TYPE'] in EXTRACT_SHAPE_TYPES:
sPlt.ext_debanana_plot(p, loc, data2, max_signal / 10.)
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# ----------------------------------------------------------------------
# if array is completely NaNs it shouldn't pass
if np.sum(np.isfinite(loc['E2DS'])) == 0:
fail_msg.append('E2DS image is all NaNs')
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append('NaN')
qc_names.append('image')
qc_logic.append('image is all NaN')
# ----------------------------------------------------------------------
# saturation check: check that the max_signal is lower than
# qc_max_signal
max_qcflux = p['QC_MAX_SIGNAL'] * p['NBFRAMES']
if max_signal > max_qcflux:
fmsg = 'Too much flux in the image ({0:.2f} > {1:.2f})'
fail_msg.append(fmsg.format(max_signal, max_qcflux))
passed = False
# Question: Why is this test ignored?
# For some reason this test is ignored in old code
passed = True
WLOG(p, 'info', fail_msg[-1])
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(max_signal)
qc_names.append('max_signal')
qc_logic.append('QC_MAX_SIGNAL > {0:.3f}'.format(max_qcflux))
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ------------------------------------------------------------------
# Store extraction in file(s)
# ------------------------------------------------------------------
raw_ext_file = os.path.basename(p['FITSFILENAME'])
# construct filename
e2dsfits, tag1 = spirouConfig.Constants.EXTRACT_E2DS_FILE(p)
e2dsfitsname = os.path.split(e2dsfits)[-1]
e2dsfffits, tag2 = spirouConfig.Constants.EXTRACT_E2DSFF_FILE(p)
e2dsfffitsname = os.path.split(e2dsfffits)[-1]
e2dsllfits, tag4 = spirouConfig.Constants.EXTRACT_E2DSLL_FILE(p)
e2dsfllitsname = os.path.split(e2dsllfits)[-1]
# log that we are saving E2DS spectrum
wmsg = 'Saving E2DS spectrum of Fiber {0} in {1}'
WLOG(p, '', wmsg.format(p['FIBER'], e2dsfitsname))
wmsg = 'Saving E2DSFF spectrum of Fiber {0} in {1}'
WLOG(p, '', wmsg.format(p['FIBER'], e2dsfffitsname))
# add keys from original header file
hdict = spirouImage.CopyOriginalKeys(hdr)
# set the version
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_FIBER'], value=p['FIBER'])
# set the input files
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBDARK'],
value=p['DARKFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBBAD'],
value=p['BADPFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBLOCO'],
value=p['LOCOFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBBACK'],
value=p['BKGRDFILE'])
if p['IC_EXTRACT_TYPE'] not in EXTRACT_SHAPE_TYPES:
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBTILT'],
value=p['TILTFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBBLAZE'],
value=p['BLAZFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBFLAT'],
value=p['FLATFILE'])
if p['IC_EXTRACT_TYPE'] in EXTRACT_SHAPE_TYPES:
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBSHAPEX'],
value=p['SHAPEXFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBSHAPEY'],
value=p['SHAPEYFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBSHAPE'],
value=p['SHAPEFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBFPMASTER'],
value=p['FPMASTERFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBTHERMAL'],
value=p['THERMALFILE_{0}'.format(fiber)])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBWAVE'],
value=loc['WAVEFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVESOURCE'],
value=loc['WSOURCE'])
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_INFILE1'],
dim1name='file',
values=p['ARG_FILE_NAMES'])
# construct loco filename
locofile, _ = spirouConfig.Constants.EXTRACT_LOCO_FILE(p)
locofilename = os.path.basename(locofile)
# add barycentric keys to header
hdict = spirouImage.AddKey(p, hdict, p['KW_BERV'], value=loc['BERV'])
hdict = spirouImage.AddKey(p, hdict, p['KW_BJD'], value=loc['BJD'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_BERV_MAX'],
value=loc['BERV_MAX'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_B_OBS_HOUR'],
value=loc['BERVHOUR'])
# add barycentric estimate keys to header
hdict = spirouImage.AddKey(p,
hdict,
p['KW_BERV_EST'],
value=loc['BERV_EST'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_BJD_EST'],
value=loc['BJD_EST'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_BERV_MAX_EST'],
value=loc['BERV_MAX_EST'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_BERV_SOURCE'],
value=loc['BERV_SOURCE'])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# copy extraction method and function to header
# (for reproducibility)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_E2DS_EXTM'],
value=extmethod)
hdict = spirouImage.AddKey(p, hdict, p['KW_E2DS_FUNC'], value=extfunc)
# add localization file name to header
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOCO_FILE'],
value=locofilename)
# add wave solution date
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVE_TIME1'],
value=loc['WAVE_ACQTIMES'][0])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVE_TIME2'],
value=loc['WAVE_ACQTIMES'][1])
# add wave solution number of orders
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVE_ORD_N'],
value=loc['WAVEPARAMS'].shape[0])
# add wave solution degree of fit
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVE_LL_DEG'],
value=loc['WAVEPARAMS'].shape[1] - 1)
# -------------------------------------------------------------------------
# add keys of the wave solution FP CCF
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_FILE'],
value=loc['WAVEFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_DRIFT'],
value=p['WFP_DRIFT'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_FWHM'],
value=p['WFP_FWHM'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_CONTRAST'],
value=p['WFP_CONTRAST'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_MAXCPP'],
value=p['WFP_MAXCPP'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_MASK'],
value=p['WFP_MASK'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_LINES'],
value=p['WFP_LINES'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_TARG_RV'],
value=p['WFP_TARG_RV'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_WIDTH'],
value=p['WFP_WIDTH'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WFP_STEP'],
value=p['WFP_STEP'])
# write 1D list of the SNR
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_E2DS_SNR'],
values=loc['SNR'])
# add localization file keys to header
root = p['KW_ROOT_DRS_LOC'][0]
hdict = spirouImage.CopyRootKeys(p, hdict, locofile, root=root)
# add wave solution coefficients
hdict = spirouImage.AddKey2DList(p,
hdict,
p['KW_WAVE_PARAM'],
values=loc['WAVEPARAMS'])
# Save E2DS file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_EXT_TYPE'],
value=p['DPRTYPE'])
p = spirouImage.WriteImage(p, e2dsfits, loc['E2DS'], hdict)
# Save E2DSFF file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag2)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_EXT_TYPE'],
value=p['DPRTYPE'])
p = spirouImage.WriteImage(p, e2dsfffits, loc['E2DSFF'], hdict)
# Save E2DSLL file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag4)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_EXT_TYPE'],
value=p['DPRTYPE'])
if p['IC_EXTRACT_TYPE'] in EXTRACT_LL_TYPES:
llstack = np.vstack(loc['E2DSLL'])
p = spirouImage.WriteImage(p, e2dsllfits, llstack, hdict)
# ------------------------------------------------------------------
# 1-dimension spectral S1D (uniform in wavelength)
# ------------------------------------------------------------------
# get arguments for E2DS to S1D
e2dsargs = [loc['WAVE'], loc['E2DSFF'], loc['BLAZE']]
# get 1D spectrum
xs1d1, ys1d1 = spirouImage.E2DStoS1D(p, *e2dsargs, wgrid='wave')
# Plot the 1D spectrum
if p['DRS_PLOT'] > 0:
sPlt.ext_1d_spectrum_plot(p, xs1d1, ys1d1)
# construct file name
s1dfile1, tag3 = spirouConfig.Constants.EXTRACT_S1D_FILE1(p)
s1dfilename1 = os.path.basename(s1dfile1)
# add header keys
# set the version
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag3)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_EXT_TYPE'],
value=p['DPRTYPE'])
# log writing to file
wmsg = 'Saving 1D spectrum (uniform in wavelength) for Fiber {0} in {1}'
WLOG(p, '', wmsg.format(p['FIBER'], s1dfilename1))
# Write to file
columns = ['wavelength', 'flux', 'eflux']
values = [xs1d1, ys1d1, np.zeros_like(ys1d1)]
units = ['nm', None, None]
s1d1 = spirouImage.MakeTable(p, columns, values, units=units)
spirouImage.WriteTable(p, s1d1, s1dfile1, header=hdict)
# ------------------------------------------------------------------
# 1-dimension spectral S1D (uniform in velocity)
# ------------------------------------------------------------------
# get arguments for E2DS to S1D
e2dsargs = [loc['WAVE'], loc['E2DSFF'], loc['BLAZE']]
# get 1D spectrum
xs1d2, ys1d2 = spirouImage.E2DStoS1D(p, *e2dsargs, wgrid='velocity')
# Plot the 1D spectrum
if p['DRS_PLOT'] > 0:
sPlt.ext_1d_spectrum_plot(p, xs1d2, ys1d2)
# construct file name
s1dfile2, tag4 = spirouConfig.Constants.EXTRACT_S1D_FILE2(p)
s1dfilename2 = os.path.basename(s1dfile2)
# add header keys
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag4)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_EXT_TYPE'],
value=p['DPRTYPE'])
# log writing to file
wmsg = 'Saving 1D spectrum (uniform in velocity) for Fiber {0} in {1}'
WLOG(p, '', wmsg.format(p['FIBER'], s1dfilename2))
# Write to file
columns = ['wavelength', 'flux', 'eflux']
values = [xs1d2, ys1d2, np.zeros_like(ys1d2)]
units = ['nm', None, None]
s1d2 = spirouImage.MakeTable(p, columns, values, units=units)
spirouImage.WriteTable(p, s1d2, s1dfile2, header=hdict)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_SLIT_spirou.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_SLIT_spirou.py [night_directory] [files]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set the fiber type
p['FIB_TYP'] = 'AB'
p.set_source('FIB_TYP', __NAME__ + '/main()')
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouImage.ReadImageAndCombine(p, framemath='add')
# ----------------------------------------------------------------------
# fix for un-preprocessed files
# ----------------------------------------------------------------------
data = spirouImage.FixNonPreProcess(p, data)
# ----------------------------------------------------------------------
# Get basic image properties
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, hdr, name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, hdr, name='exptime')
# get gain
p = spirouImage.GetGain(p, hdr, name='gain')
# ----------------------------------------------------------------------
# Correction of DARK
# ----------------------------------------------------------------------
p, datac = spirouImage.CorrectForDark(p, data, hdr)
# ----------------------------------------------------------------------
# Resize image
# ----------------------------------------------------------------------
# rotate the image and convert from ADU/s to e-
data = spirouImage.ConvertToE(spirouImage.FlipImage(p, datac), p=p)
# convert NaN to zeros
data0 = np.where(~np.isfinite(data), np.zeros_like(data), data)
# resize image
bkwargs = dict(xlow=p['IC_CCDX_LOW'], xhigh=p['IC_CCDX_HIGH'],
ylow=p['IC_CCDY_LOW'], yhigh=p['IC_CCDY_HIGH'],
getshape=False)
data2 = spirouImage.ResizeImage(p, data0, **bkwargs)
# log change in data size
WLOG(p, '', ('Image format changed to '
'{0}x{1}').format(*data2.shape))
# ----------------------------------------------------------------------
# Correct for the BADPIX mask (set all bad pixels to zero)
# ----------------------------------------------------------------------
p, data2 = spirouImage.CorrectForBadPix(p, data2, hdr)
# ----------------------------------------------------------------------
# Background computation
# ----------------------------------------------------------------------
if p['IC_DO_BKGR_SUBTRACTION']:
# log that we are doing background measurement
WLOG(p, '', 'Doing background measurement on raw frame')
# get the bkgr measurement
bargs = [p, data2, hdr]
# background, xc, yc, minlevel = spirouBACK.MeasureBackgroundFF(*bargs)
p, background = spirouBACK.MeasureBackgroundMap(*bargs)
else:
background = np.zeros_like(data2)
p['BKGRDFILE'] = 'None'
p.set_source('BKGRDFILE', __NAME__ + '.main()')
# correct data2 with background
data2 = data2 - background
# ----------------------------------------------------------------------
# Log the number of dead pixels
# ----------------------------------------------------------------------
# get the number of bad pixels
n_bad_pix = np.nansum(~np.isfinite(data2))
n_bad_pix_frac = n_bad_pix * 100 / np.product(data2.shape)
# Log number
wmsg = 'Nb dead pixels = {0} / {1:.2f} %'
WLOG(p, 'info', wmsg.format(int(n_bad_pix), n_bad_pix_frac))
# ----------------------------------------------------------------------
# Log the number of dead pixels
# ----------------------------------------------------------------------
loc = ParamDict()
# ----------------------------------------------------------------------
# Loop around fiber types
# ----------------------------------------------------------------------
# set fiber
p['FIBER'] = p['FIB_TYP']
# ------------------------------------------------------------------
# Get localisation coefficients
# ------------------------------------------------------------------
# original there is a loop but it is not used --> removed
p = spirouImage.FiberParams(p, p['FIBER'], merge=True)
# get localisation fit coefficients
p, loc = spirouLOCOR.GetCoeffs(p, hdr, loc)
# ------------------------------------------------------------------
# Calculating the tilt
# ------------------------------------------------------------------
# get the tilt by extracting the AB fibers and correlating them
loc = spirouImage.GetTilt(p, loc, data2)
# fit the tilt with a polynomial
loc = spirouImage.FitTilt(p, loc)
# log the tilt dispersion
wmsg = 'Tilt dispersion = {0:.3f} deg'
WLOG(p, 'info', wmsg.format(loc['RMS_TILT']))
# ------------------------------------------------------------------
# Plotting
# ------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
# plots setup: start interactive plot
sPlt.start_interactive_session(p)
# plot image with selected order shown
sPlt.slit_sorder_plot(p, loc, data2)
# plot slit tilt angle and fit
sPlt.slit_tilt_angle_and_fit_plot(p, loc)
# end interactive section
sPlt.end_interactive_session(p)
# ------------------------------------------------------------------
# Replace tilt by the global fit
# ------------------------------------------------------------------
loc['TILT'] = loc['YFIT_TILT']
oldsource = loc.get_source('tilt')
loc.set_source('TILT', oldsource + '+{0}/main()'.format(__NAME__))
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
# set passed variable and fail message list
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# check that tilt rms is below required
if loc['RMS_TILT'] > p['QC_SLIT_RMS']:
# add failed message to fail message list
fmsg = 'abnormal RMS of SLIT angle ({0:.2f} > {1:.2f} deg)'
fail_msg.append(fmsg.format(loc['RMS_TILT'], p['QC_SLIT_RMS']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(loc['RMS_TILT'])
qc_names.append('RMS_TILT')
qc_logic.append('RMS_TILT > {0:.2f}'.format(p['QC_SLIT_RMS']))
# ----------------------------------------------------------------------
# check that tilt is less than max tilt required
max_tilt = np.max(loc['TILT'])
if max_tilt > p['QC_SLIT_MAX']:
# add failed message to fail message list
fmsg = 'abnormal SLIT angle ({0:.2f} > {1:.2f} deg)'
fail_msg.append(fmsg.format(max_tilt, p['QC_SLIT_MAX']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(max_tilt)
qc_names.append('max_tilt')
qc_logic.append('max_tilt > {0:.2f}'.format(p['QC_SLIT_MAX']))
# ----------------------------------------------------------------------
# check that tilt is greater than min tilt required
min_tilt = np.min(loc['TILT'])
if min_tilt < p['QC_SLIT_MIN']:
# add failed message to fail message list
fmsg = 'abnormal SLIT angle ({0:.2f} < {1:.2f} deg)'
fail_msg.append(fmsg.format(max_tilt, p['QC_SLIT_MIN']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(min_tilt)
qc_names.append('min_tilt')
qc_logic.append('min_tilt > {0:.2f}'.format(p['QC_SLIT_MIN']))
# ----------------------------------------------------------------------
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ----------------------------------------------------------------------
# Save and record of tilt table
# ----------------------------------------------------------------------
# copy the tilt along the orders
tiltima = np.ones((int(loc['NUMBER_ORDERS']/2), data2.shape[1]))
tiltima *= loc['TILT'][:, None]
# get the raw tilt file name
raw_tilt_file = os.path.basename(p['FITSFILENAME'])
# construct file name and path
tiltfits, tag = spirouConfig.Constants.SLIT_TILT_FILE(p)
tiltfitsname = os.path.basename(tiltfits)
# Log that we are saving tilt file
wmsg = 'Saving tilt information in file: {0}'
WLOG(p, '', wmsg.format(tiltfitsname))
# Copy keys from fits file
hdict = spirouImage.CopyOriginalKeys(hdr)
# add version number
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag)
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBDARK'],
value=p['DARKFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBAD'],
value=p['BADPFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBLOCO'], value=p['LOCOFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBACK'],
value=p['BKGRDFILE'])
hdict = spirouImage.AddKey1DList(p, hdict, p['KW_INFILE1'], dim1name='file',
values=p['ARG_FILE_NAMES'])
# add qc parameters
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# add tilt parameters as 1d list
hdict = spirouImage.AddKey1DList(p, hdict, p['KW_TILT'], values=loc['TILT'])
# write tilt file to file
p = spirouImage.WriteImage(p, tiltfits, tiltima, hdict)
# ----------------------------------------------------------------------
# Update the calibration data base
# ----------------------------------------------------------------------
if p['QC']:
keydb = 'TILT'
# copy localisation file to the calibDB folder
spirouDB.PutCalibFile(p, tiltfits)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, tiltfitsname, hdr)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_HC_E2DS.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_DARK_spirou.py [night_directory] [fitsfilename]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
# get parameters from configuration files and run time arguments
p = spirouStartup.LoadArguments(p, night_name, files, mainfitsdir='reduced')
# setup files and get fiber
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set the fiber type
p['FIB_TYP'] = [p['FIBER']]
p.set_source('FIB_TYP', __NAME__ + '/main()')
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read and combine all files
p, hcdata, hchdr = spirouImage.ReadImageAndCombine(p, 'add')
# add data and hdr to loc
loc = ParamDict()
loc['HCDATA'], loc['HCHDR'] = hcdata, hchdr
# set the source
sources = ['HCDATA', 'HCHDR']
loc.set_sources(sources, 'spirouImage.ReadImageAndCombine()')
# ----------------------------------------------------------------------
# Get basic parameters
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, loc['HCHDR'], name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, loc['HCHDR'], name='exptime')
# get gain
p = spirouImage.GetGain(p, loc['HCHDR'], name='gain')
# get acquisition time
p = spirouImage.GetAcqTime(p, loc['HCHDR'], name='ACQTIME', kind='julian')
bjdref = p['ACQTIME']
# set sigdet and conad keywords (sigdet is changed later)
p['KW_CCD_SIGDET'][1] = p['SIGDET']
p['KW_CCD_CONAD'][1] = p['GAIN']
# get lamp parameters
p = spirouTHORCA.GetLampParams(p, loc['HCHDR'])
# get number of orders
# we always get fibre A number because AB is doubled in constants file
loc['NBO'] = p['QC_LOC_NBO_FPALL']['A']
loc.set_source('NBO', __NAME__ + '.main()')
# get number of pixels in x from hcdata size
loc['NBPIX'] = loc['HCDATA'].shape[1]
loc.set_source('NBPIX', __NAME__ + '.main()')
# ----------------------------------------------------------------------
# Read blaze
# ----------------------------------------------------------------------
# get tilts
loc['BLAZE'] = spirouImage.ReadBlazeFile(p, hchdr)
loc.set_source('BLAZE', __NAME__ + '/main() + /spirouImage.ReadBlazeFile')
# ----------------------------------------------------------------------
# Read wave solution
# ----------------------------------------------------------------------
# wavelength file; we will use the polynomial terms in its header,
# NOT the pixel values that would need to be interpolated
# getting header info with wavelength polynomials
# set source of wave file
wsource = __NAME__ + '/main() + /spirouImage.GetWaveSolution'
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# get wave image
wout = spirouImage.GetWaveSolution(p, hdr=hchdr, return_wavemap=True,
return_filename=True, fiber=wave_fiber)
loc['WAVEPARAMS'], loc['WAVE_INIT'], loc['WAVEFILE'], loc['WSOURCE'] = wout
loc.set_sources(['WAVE_INIT', 'WAVEFILE', 'WAVEPARAMS', 'WSOURCE'], wsource)
# ----------------------------------------------------------------------
# Check that wave parameters are consistent with "ic_ll_degr_fit"
# ----------------------------------------------------------------------
loc = spirouImage.CheckWaveSolConsistency(p, loc)
# ----------------------------------------------------------------------
# Read UNe solution
# ----------------------------------------------------------------------
wave_u_ne, amp_u_ne = spirouImage.ReadLineList(p)
loc['LL_LINE'], loc['AMPL_LINE'] = wave_u_ne, amp_u_ne
source = __NAME__ + '.main() + spirouImage.ReadLineList()'
loc.set_sources(['ll_line', 'ampl_line'], source)
# ----------------------------------------------------------------------
# Generate wave map from wave solution
# ----------------------------------------------------------------------
loc = spirouWAVE.generate_wave_map(p, loc)
# ----------------------------------------------------------------------
# Find Gaussian Peaks in HC spectrum
# ----------------------------------------------------------------------
loc = spirouWAVE.find_hc_gauss_peaks(p, loc)
# ----------------------------------------------------------------------
# Start plotting session
# ----------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
# start interactive plot
sPlt.start_interactive_session(p)
# ----------------------------------------------------------------------
# Fit Gaussian peaks (in triplets) to
# ----------------------------------------------------------------------
loc = spirouWAVE.fit_gaussian_triplets(p, loc)
# ----------------------------------------------------------------------
# Generate Resolution map and line profiles
# ----------------------------------------------------------------------
# log progress
wmsg = 'Generating resolution map and '
# generate resolution map
loc = spirouWAVE.generate_resolution_map(p, loc)
# map line profile map
if p['DRS_PLOT'] > 0:
sPlt.wave_ea_plot_line_profiles(p, loc)
# ----------------------------------------------------------------------
# End plotting session
# ----------------------------------------------------------------------
# end interactive session
if p['DRS_PLOT'] > 0:
sPlt.end_interactive_session(p)
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# quality control on sigma clip (sig1 > qc_hc_wave_sigma_max
if loc['SIG1'] > p['QC_HC_WAVE_SIGMA_MAX']:
fmsg = 'Sigma too high ({0:.5f} > {1:.5f})'
fail_msg.append(fmsg.format(loc['SIG1'], p['QC_HC_WAVE_SIGMA_MAX']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(loc['SIG1'])
qc_names.append('SIG1')
qc_logic.append('SIG1 > {0:.2f}'.format(p['QC_HC_WAVE_SIGMA_MAX']))
# ----------------------------------------------------------------------
# check the difference between consecutive orders is always positive
# get the differences
wave_diff = loc['WAVE_MAP2'][1:]-loc['WAVE_MAP2'][:-1]
if np.min(wave_diff) < 0:
fmsg = 'Negative wavelength difference between orders'
fail_msg.append(fmsg)
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(np.min(wave_diff))
qc_names.append('MIN WAVE DIFF')
qc_logic.append('MIN WAVE DIFF < 0')
# ----------------------------------------------------------------------
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ----------------------------------------------------------------------
# log the global stats
# ----------------------------------------------------------------------
# calculate catalog-fit residuals in km/s
res_hc =[]
sumres_hc = 0.0
sumres2_hc = 0.0
for order in range(loc['NBO']):
# get HC line wavelengths for the order
order_mask = loc['ORD_T'] == order
hc_x_ord = loc['XGAU_T'][order_mask]
hc_ll_ord = np.polyval(loc['POLY_WAVE_SOL'][order][::-1],hc_x_ord)
hc_ll_cat = loc['WAVE_CATALOG'][order_mask]
hc_ll_diff = hc_ll_ord - hc_ll_cat
res_hc.append(hc_ll_diff*speed_of_light/hc_ll_cat)
sumres_hc += np.nansum(res_hc[order])
sumres2_hc += np.nansum(res_hc[order] ** 2)
total_lines_hc = len(np.concatenate(res_hc))
final_mean_hc = sumres_hc/total_lines_hc
final_var_hc = (sumres2_hc/total_lines_hc) - (final_mean_hc ** 2)
wmsg1 = 'On fiber {0} HC fit line statistic:'.format(p['FIBER'])
wargs2 = [final_mean_hc * 1000.0, np.sqrt(final_var_hc) * 1000.0,
total_lines_hc, 1000.0 * np.sqrt(final_var_hc / total_lines_hc)]
wmsg2 = ('\tmean={0:.3f}[m/s] rms={1:.1f} {2} HC lines (error on mean '
'value:{3:.4f}[m/s])'.format(*wargs2))
WLOG(p, 'info', [wmsg1, wmsg2])
# ----------------------------------------------------------------------
# Save wave map to file
# ----------------------------------------------------------------------
# get base input filenames
bfilenames = []
for raw_file in p['ARG_FILE_NAMES']:
bfilenames.append(os.path.basename(raw_file))
# get wave filename
wavefits, tag1 = spirouConfig.Constants.WAVE_FILE_EA(p)
wavefitsname = os.path.basename(wavefits)
# log progress
WLOG(p, '', 'Saving wave map to {0}'.format(wavefitsname))
# log progress
wargs = [p['FIBER'], wavefitsname]
wmsg = 'Write wavelength solution for Fiber {0} in {1}'
WLOG(p, '', wmsg.format(*wargs))
# write solution to fitsfilename header
# copy original keys
hdict = spirouImage.CopyOriginalKeys(loc['HCHDR'])
# set the version
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
# set the input files
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBLAZE'], value=p['BLAZFILE'])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# add wave solution date
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVE_TIME1'],
value=p['MAX_TIME_HUMAN'])
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVE_TIME2'],
value=p['MAX_TIME_UNIX'])
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVE_CODE'], value=__NAME__)
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBWAVE'], value=loc['WAVEFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVESOURCE'],
value=loc['WSOURCE'])
hdict = spirouImage.AddKey1DList(p, hdict, p['KW_INFILE1'], dim1name='file',
values=p['ARG_FILE_NAMES'])
# add number of orders
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVE_ORD_N'],
value=loc['POLY_WAVE_SOL'].shape[0])
# add degree of fit
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVE_LL_DEG'],
value=loc['POLY_WAVE_SOL'].shape[1]-1)
# add wave solution
hdict = spirouImage.AddKey2DList(p, hdict, p['KW_WAVE_PARAM'],
values=loc['POLY_WAVE_SOL'])
# write the wave "spectrum"
p = spirouImage.WriteImage(p, wavefits, loc['WAVE_MAP2'], hdict)
# get filename for E2DS calibDB copy of FITSFILENAME
e2dscopy_filename, tag2 = spirouConfig.Constants.WAVE_E2DS_COPY(p)
wargs = [p['FIBER'], os.path.split(e2dscopy_filename)[-1]]
wmsg = 'Write reference E2DS spectra for Fiber {0} in {1}'
WLOG(p, '', wmsg.format(*wargs))
# make a copy of the E2DS file for the calibBD
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag2)
p = spirouImage.WriteImage(p, e2dscopy_filename, loc['HCDATA'], hdict)
# ----------------------------------------------------------------------
# Save resolution and line profiles to file
# ----------------------------------------------------------------------
raw_infile = os.path.basename(p['FITSFILENAME'])
# get wave filename
resfits, tag3 = spirouConfig.Constants.WAVE_RES_FILE_EA(p)
resfitsname = os.path.basename(resfits)
WLOG(p, '', 'Saving wave resmap to {0}'.format(resfitsname))
# make a copy of the E2DS file for the calibBD
# set the version
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag3)
# get res data in correct format
resdata, hdicts = spirouTHORCA.GenerateResFiles(p, loc, hdict)
# save to file
p = spirouImage.WriteImageMulti(p, resfits, resdata, hdicts=hdicts)
# ----------------------------------------------------------------------
# Update calibDB
# ----------------------------------------------------------------------
if p['QC']:
# set the wave key
keydb = 'WAVE_{0}'.format(p['FIBER'])
# copy wave file to calibDB folder
spirouDB.PutCalibFile(p, wavefits)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, wavefitsname, loc['HCHDR'])
# set the hcref key
keydb = 'HCREF_{0}'.format(p['FIBER'])
# copy wave file to calibDB folder
spirouDB.PutCalibFile(p, e2dscopy_filename)
# update the master calib DB file with new key
e2dscopyfits = os.path.split(e2dscopy_filename)[-1]
spirouDB.UpdateCalibMaster(p, keydb, e2dscopyfits, loc['HCHDR'])
# ----------------------------------------------------------------------
# Update header of current files
# ----------------------------------------------------------------------
# only copy over if QC passed
if p['QC']:
rdir = os.path.dirname(wavefits)
# loop around hc files and update header with
for rawhcfile in p['ARG_FILE_NAMES']:
hcfile = os.path.join(rdir, rawhcfile)
raw_infilepath1 = os.path.join(p['ARG_FILE_DIR'], hcfile)
p = spirouImage.UpdateWaveSolutionHC(p, loc, raw_infilepath1)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
pol_spirou.py main function, if night_name and files are None uses
arguments from run time i.e.:
pol_spirou.py [night_directory] [fitsfilename]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to process
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
# get parameters from configuration files and run time arguments
p = spirouStartup.LoadArguments(p,
night_name,
files,
mainfitsdir='reduced')
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# ----------------------------------------------------------------------
# Loop through files, identify and sort files and identify fiber types
# ----------------------------------------------------------------------
# set up polar storage
polardict = ParamDict()
# sort files
polardict = spirouPOLAR.SortPolarFiles(p, polardict)
# ----------------------------------------------------------------------
# Load the input polarimetry data and check if provided data are
# sufficient for polarimetry calculation
# ----------------------------------------------------------------------
# set up data storage
loc = ParamDict()
# load files
p, loc = spirouPOLAR.LoadPolarData(p, polardict, loc)
# ------------------------------------------------------------------
# Read wavelength solution
# ------------------------------------------------------------------
# set source of wave file
wsource = __NAME__ + '/main() + /spirouImage.GetWaveSolution'
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# get wave image
wout = spirouImage.GetWaveSolution(p,
hdr=loc['HDR'],
return_wavemap=True,
return_filename=True,
fiber=wave_fiber)
_, loc['WAVE'], loc['WAVEFILE'], loc['WSOURCE'] = wout
loc.set_sources(['WAVE', 'WAVEFILE', 'WSOURCE'], wsource)
# ----------------------------------------------------------------------
# Polarimetry computation
# ----------------------------------------------------------------------
loc = spirouPOLAR.CalculatePolarimetry(p, loc)
# ----------------------------------------------------------------------
# Stokes I computation
# ----------------------------------------------------------------------
loc = spirouPOLAR.CalculateStokesI(p, loc)
# ----------------------------------------------------------------------
# Calculate continuum (for plotting)
# ----------------------------------------------------------------------
loc = spirouPOLAR.CalculateContinuum(p, loc)
# ----------------------------------------------------------------------
# Plots
# ----------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
# start interactive plot
sPlt.start_interactive_session(p)
# plot continuum plots
sPlt.polar_continuum_plot(p, loc)
# plot polarimetry results
sPlt.polar_result_plot(p, loc)
# plot total flux (Stokes I)
sPlt.polar_stokes_i_plot(p, loc)
# end interactive session
sPlt.end_interactive_session(p)
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
# set passed variable and fail message list
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# TODO: Needs doing
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# add to qc header lists
qc_values.append('None')
qc_names.append('None')
qc_logic.append('None')
qc_pass.append(1)
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ------------------------------------------------------------------
# Store polarimetry in file(s)
# ------------------------------------------------------------------
# construct file names
degpolfits, tag1 = spirouConfig.Constants.DEG_POL_FILE(p, loc)
degpolfitsname = os.path.split(degpolfits)[-1]
stokes_ifits, tag2 = spirouConfig.Constants.STOKESI_POL_FILE(p, loc)
stokes_ifitsname = os.path.split(stokes_ifits)[-1]
nullpol1fits, tag3 = spirouConfig.Constants.NULL_POL1_FILE(p, loc)
nullpol1fitsname = os.path.split(nullpol1fits)[-1]
nullpol2fits, tag4 = spirouConfig.Constants.NULL_POL2_FILE(p, loc)
nullpol2fitsname = os.path.split(nullpol2fits)[-1]
# log that we are saving POL spectrum
wmsg = 'Saving POL, STOKESI, NULL1, and NULL2 to {0}, {1}, {2}, {3}'
wargs = [
degpolfitsname, stokes_ifitsname, nullpol1fitsname, nullpol2fitsname
]
WLOG(p, '', wmsg.format(*wargs))
# construct header keywords for output products
hdict, loc = spirouPOLAR.PolarHeader(p, loc, polardict, qc_params)
# save POL data to file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
p = spirouImage.WriteImageMulti(p, degpolfits, [loc['POL'], loc['POLERR']],
hdict)
# save NULL1 data to file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag3)
p = spirouImage.WriteImage(p, nullpol1fits, loc['NULL1'], hdict)
# save NULL2 data to file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag4)
p = spirouImage.WriteImage(p, nullpol2fits, loc['NULL2'], hdict)
# add stokes parameter keyword to header
hdict = spirouImage.AddKey(p, hdict, p['KW_POL_STOKES'], value="I")
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag2)
# save STOKESI data to file
multi_image = [loc['STOKESI'], loc['STOKESIERR']]
p = spirouImage.WriteImageMulti(p, stokes_ifits, multi_image, hdict)
# ------------------------------------------------------------------
if p['IC_POLAR_LSD_ANALYSIS']:
# ------------------------------------------------------------------
# LSD Analysis
# ------------------------------------------------------------------
loc = spirouPOLAR.LSDAnalysis(p, loc)
if p['DRS_PLOT'] > 0:
# plot LSD analysis
sPlt.polar_lsd_plot(p, loc)
# save LSD analysis data to file
p, lsdfits, lsdfitsfitsname = spirouPOLAR.OutputLSDimage(p, loc, hdict)
# log that we are saving LSD analysis data
wmsg = 'Saving LSD analysis data to {0}'.format(lsdfitsfitsname)
WLOG(p, '', wmsg)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# # return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p,
night_name,
files,
mainfitsdir='reduced')
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set up function name
main_name = __NAME__ + '.main()'
# ----------------------------------------------------------------------
# Load first file
# ----------------------------------------------------------------------
loc = ParamDict()
rd = spirouImage.ReadImage(p, p['FITSFILENAME'])
loc['DATA'], loc['DATAHDR'], loc['XDIM'], loc['YDIM'] = rd
loc.set_sources(['DATA', 'DATAHDR', 'XDIM', 'YDIM'], main_name)
# ----------------------------------------------------------------------
# Get object name, airmass and berv
# ----------------------------------------------------------------------
# Get object name
loc['OBJNAME'] = spirouImage.GetObjName(p, loc['DATAHDR'])
# Get the airmass
loc['AIRMASS'] = spirouImage.GetAirmass(p, loc['DATAHDR'])
# Get the Barycentric correction from header
p, loc = spirouImage.GetEarthVelocityCorrection(p, loc, loc['DATAHDR'])
# set sources
source = main_name + '+ spirouImage.ReadParams()'
loc.set_sources(['OBJNAME', 'AIRMASS'], source)
loc.set_sources(['OBJNAME', 'AIRMASS'], source)
# ----------------------------------------------------------------------
# Read wavelength solution
# ----------------------------------------------------------------------
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# used for plotting only
wout = spirouImage.GetWaveSolution(p,
image=loc['DATA'],
hdr=loc['DATAHDR'],
return_wavemap=True,
fiber=wave_fiber)
_, loc['WAVE'], _ = wout
loc.set_source('WAVE', main_name)
# ----------------------------------------------------------------------
# Get and Normalise the blaze
# ----------------------------------------------------------------------
p, loc = spirouTelluric.GetNormalizedBlaze(p, loc, loc['DATAHDR'])
# ----------------------------------------------------------------------
# Load transmission files
# ----------------------------------------------------------------------
transdata = spirouDB.GetDatabaseTellMap(p)
trans_files = transdata[0]
# make sure we have unique filenames for trans_files
trans_files = np.unique(trans_files)
# ----------------------------------------------------------------------
# Start plotting
# ----------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
# start interactive plot
sPlt.start_interactive_session(p)
# ----------------------------------------------------------------------
# Load template (if available)
# ----------------------------------------------------------------------
# read filename from telluDB
template_file = spirouDB.GetDatabaseObjTemp(p,
loc['OBJNAME'],
required=False)
# if we don't have a template flag it
if template_file is None:
loc['FLAG_TEMPLATE'] = False
loc['TEMPLATE'] = None
else:
loc['FLAG_TEMPLATE'] = True
# load template
template, _, _, _ = spirouImage.ReadImage(p, template_file)
# add to loc
loc['TEMPLATE'] = template
# set the source for flag and template
loc.set_sources(['FLAG_TEMPLATE', 'TEMPLATE'], main_name)
# ----------------------------------------------------------------------
# load the expected atmospheric transmission
# ----------------------------------------------------------------------
# read filename from telluDB
tapas_file_names = spirouDB.GetDatabaseTellConv(p)
tapas_file_name = tapas_file_names[-1]
# load atmospheric transmission
loc['TAPAS_ALL_SPECIES'] = np.load(tapas_file_name)
loc.set_source('TAPAS_ALL_SPECIES', main_name)
# ----------------------------------------------------------------------
# Generate the absorption map
# ----------------------------------------------------------------------
# get number of files
nfiles = len(trans_files)
npc = p['TELLU_NUMBER_OF_PRINCIPLE_COMP']
# check that we have enough files (greater than number of principle
# components)
if nfiles <= npc:
emsg1 = 'Not enough "TELL_MAP" files in telluDB to run PCA analysis'
emsg2 = '\tNumber of files = {0}, number of PCA components = {1}'
emsg3 = '\tNumber of files > number of PCA components'
emsg4 = '\tAdd more files or reduce number of PCA components'
WLOG(p, 'error', [emsg1, emsg2.format(nfiles, npc), emsg3, emsg4])
# check whether we can used pre-saved abso
filetime = spirouImage.GetMostRecent(trans_files)
tout = spirouConfig.Constants.TELLU_ABSO_SAVE(p, filetime)
abso_save_file, absoprefix = tout
use_saved = os.path.exists(abso_save_file)
# noinspection PyBroadException
try:
# try loading from file
abso = np.load(abso_save_file)
# log progress
wmsg = 'Loaded abso from file {0}'.format(abso_save_file)
WLOG(p, '', wmsg)
except:
# set up storage for the absorption
abso = np.zeros([nfiles, np.product(loc['DATA'].shape)])
# loop around outputfiles and add them to abso
for it, filename in enumerate(trans_files):
# load data
data_it, _, _, _ = spirouImage.ReadImage(p, filename=filename)
# push data into array
abso[it, :] = data_it.reshape(np.product(loc['DATA'].shape))
# log progres
wmsg = 'Saving abso to file {0}'.format(abso_save_file)
WLOG(p, '', wmsg)
# remove all abso save files (only need most recent one)
afolder = os.path.dirname(abso_save_file)
afilelist = os.listdir(afolder)
for afile in afilelist:
if afile.startswith(absoprefix):
os.remove(os.path.join(afolder, afile))
# save to file for later use
np.save(abso_save_file, abso)
# filter out rows of all NaNs
# TODO: Why are we getting all NaN e2ds files?
abso_filtered = []
for row in range(len(abso)):
if np.sum(np.isnan(abso[row])) != len(abso[row]):
abso_filtered.append(abso[row])
else:
wargs = [trans_files[row]]
WLOG(p, '', 'Removing trans file {0} (all NaN)'.format(*wargs))
abso = np.array(abso_filtered)
# log the absorption cube
with warnings.catch_warnings(record=True) as w:
log_abso = np.log(abso)
# ----------------------------------------------------------------------
# Locate valid pixels for PCA
# ----------------------------------------------------------------------
# determining the pixels relevant for PCA construction
keep = np.isfinite(np.sum(abso, axis=0))
# log fraction of valid (non NaN) pixels
fraction = np.nansum(keep) / len(keep)
wmsg = 'Fraction of valid pixels (not NaNs) for PCA construction = {0:.3f}'
WLOG(p, '', wmsg.format(fraction))
# log fraction of valid pixels > 1 - (1/e)
with warnings.catch_warnings(record=True) as w:
keep &= np.min(log_abso, axis=0) > -1
fraction = np.nansum(keep) / len(keep)
wmsg = 'Fraction of valid pixels with transmission > 1 - (1/e) = {0:.3f}'
WLOG(p, '', wmsg.format(fraction))
# ----------------------------------------------------------------------
# Perform PCA analysis on the log of the telluric absorption map
# ----------------------------------------------------------------------
# Requires p:
# TELLU_NUMBER_OF_PRINCIPLE_COMP
# ADD_DERIV_PC
# FIT_DERIV_PC
# Requires loc:
# DATA
# Returns loc:
# PC
# NPC
# FIT_PC
loc = spirouTelluric.CalculateAbsorptionPCA(p, loc, log_abso, keep)
# Plot PCA components
# debug plot
if p['DRS_PLOT'] and (p['DRS_DEBUG'] > 1):
# plot the transmission map plot
sPlt.tellu_pca_comp_plot(p, loc)
# ----------------------------------------------------------------------
# Get master wavelength grid for shifting
# ----------------------------------------------------------------------
# get master wave map
loc['MASTERWAVEFILE'] = spirouDB.GetDatabaseMasterWave(p)
loc.set_source('MASTERWAVEFILE', main_name)
# log progress
wmsg1 = 'Getting master wavelength grid'
wmsg2 = '\tFile = {0}'.format(os.path.basename(loc['MASTERWAVEFILE']))
WLOG(p, '', [wmsg1, wmsg2])
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# read master wave map
mout = spirouImage.GetWaveSolution(p,
filename=loc['MASTERWAVEFILE'],
return_wavemap=True,
quiet=True,
fiber=wave_fiber)
_, loc['MASTERWAVE'], _ = mout
loc.set_source('MASTERWAVE', main_name)
# ----------------------------------------------------------------------
# Loop around telluric files
# ----------------------------------------------------------------------
for basefilename in p['ARG_FILE_NAMES']:
# ------------------------------------------------------------------
# Construct absolute file path
# ------------------------------------------------------------------
filename = os.path.join(p['ARG_FILE_DIR'], basefilename)
# ------------------------------------------------------------------
# Construct output file names
# ------------------------------------------------------------------
outfile1, tag1 = CONSTANTS.TELLU_FIT_OUT_FILE(p, filename)
outfilename1 = os.path.basename(outfile1)
outfile2, tag2 = CONSTANTS.TELLU_FIT_RECON_FILE(p, filename)
outfilename2 = os.path.basename(outfile2)
# ------------------------------------------------------------------
# Read filename
# ------------------------------------------------------------------
# read image
tdata, thdr, _, _ = spirouImage.ReadImage(p, filename)
# normalise with blaze function
loc['SP'] = tdata / loc['NBLAZE']
loc.set_source('SP', main_name)
# ------------------------------------------------------------------
# check that file has valid DPRTYPE
# ------------------------------------------------------------------
# get FP_FP DPRTYPE
p = spirouImage.ReadParam(p, thdr, 'KW_DPRTYPE', 'DPRTYPE', dtype=str)
# if dprtype is incorrect skip
if p['DPRTYPE'] not in p['ALLOWED_TELLURIC_DPRTYPES']:
wmsg1 = 'Skipping file (DPRTYPE incorrect)'
wmsg2 = '\t DPRTYPE = {0}'.format(p['DPRTYPE'])
WLOG(p, 'warning', [wmsg1, wmsg2])
continue
# ------------------------------------------------------------------
# Set storage
# ------------------------------------------------------------------
loc['RECON_ABSO'] = np.ones(np.product(loc['DATA'].shape))
loc['AMPS_ABSOL_TOTAL'] = np.zeros(loc['NPC'])
loc.set_sources(['RECON_ABSO', 'AMPS_ABSOL_TOTAL'], main_name)
# ------------------------------------------------------------------
# Read wavelength solution
# ------------------------------------------------------------------
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# get wavelength solution
wout = spirouImage.GetWaveSolution(p,
image=tdata,
hdr=thdr,
return_wavemap=True,
return_filename=True,
fiber=wave_fiber)
_, loc['WAVE_IT'], loc['WAVEFILE'], loc['WSOURCE'] = wout
loc.set_sources(['WAVE_IT', 'WAVEFILE', 'WSOURCE'], main_name)
# load wave keys
loc = spirouImage.GetWaveKeys(p, loc, thdr)
# ------------------------------------------------------------------
# Interpolate at shifted wavelengths (if we have a template)
# ------------------------------------------------------------------
if loc['FLAG_TEMPLATE']:
# Requires p:
# TELLU_FIT_KEEP_FRAC
# Requires loc:
# DATA
# TEMPLATE
# WAVE_IT
# Returns:
# TEMPLATE2
loc = spirouTelluric.BervCorrectTemplate(p, loc, thdr)
# debug plot
if p['DRS_PLOT'] and (p['DRS_DEBUG'] > 1):
# plot the transmission map plot
sPlt.tellu_fit_tellu_spline_plot(p, loc)
# store PC and TAPAS_ALL_SPECIES before shift
loc['PC_PRESHIFT'] = np.array(loc['PC'])
loc['TAPAS_ALL_PRESHIFT'] = np.array(loc['TAPAS_ALL_SPECIES'])
loc.set_sources(['PC_PRESHIFT', 'TAPAS_ALL_PRESHIFT'], main_name)
# ------------------------------------------------------------------
# Shift the pca components to correct frame
# ------------------------------------------------------------------
# log process
wmsg1 = 'Shifting PCA components from master wavelength grid'
wmsg2 = '\tFile = {0}'.format(os.path.basename(loc['MASTERWAVEFILE']))
WLOG(p, '', [wmsg1, wmsg2])
# shift pca components (one by one)
for comp in range(loc['NPC']):
wargs = [p, loc['PC'][:, comp], loc['MASTERWAVE'], loc['WAVE_IT']]
shift_pc = spirouTelluric.Wave2Wave(*wargs, reshape=True)
loc['PC'][:, comp] = shift_pc.reshape(wargs[1].shape)
wargs = [
p, loc['FIT_PC'][:, comp], loc['MASTERWAVE'], loc['WAVE_IT']
]
shift_fpc = spirouTelluric.Wave2Wave(*wargs, reshape=True)
loc['FIT_PC'][:, comp] = shift_fpc.reshape(wargs[1].shape)
# ------------------------------------------------------------------
# Shift the tapas spectrum to correct frame
# ------------------------------------------------------------------
# log process
wmsg1 = 'Shifting TAPAS spectrum from master wavelength grid'
wmsg2 = '\tFile = {0}'.format(os.path.basename(loc['MASTERWAVEFILE']))
WLOG(p, '', [wmsg1, wmsg2])
# shift tapas
for comp in range(len(loc['TAPAS_ALL_SPECIES'])):
wargs = [
p, loc['TAPAS_ALL_SPECIES'][comp], loc['MASTERWAVE'],
loc['WAVE_IT']
]
stapas = spirouTelluric.Wave2Wave(*wargs, reshape=True)
loc['TAPAS_ALL_SPECIES'][comp] = stapas.reshape(wargs[1].shape)
# Debug plot to test shifting
if p['DRS_PLOT'] and p['DRS_DEBUG'] > 1:
sPlt.tellu_fit_debug_shift_plot(p, loc)
# ------------------------------------------------------------------
# Calculate reconstructed absorption
# ------------------------------------------------------------------
# Requires p:
# TELLU_FIT_MIN_TRANSMISSION
# TELLU_FIT_NITER
# TELLU_LAMBDA_MIN
# TELLU_LAMBDA_MAX
# TELLU_FIT_VSINI
# TRANSMISSION_CUT
# FIT_DERIV_PC
# LOG_OPT
# Requires loc:
# FLAG_TEMPLATE
# TAPAS_ALL_SPECIES
# AMPS_ABSOL_TOTAL
# WAVE_IT
# TEMPLATE2
# FIT_PC
# NPC
# PC
# Returns loc:
# SP2
# TEMPLATE2
# RECON_ABSO
# AMPS_ABSOL_TOTAL
loc = spirouTelluric.CalcReconAbso(p, loc)
# debug plot
if p['DRS_PLOT'] > 0:
# plot the recon abso plot
sPlt.tellu_fit_recon_abso_plot(p, loc)
# ------------------------------------------------------------------
# Get molecular absorption
# ------------------------------------------------------------------
# Requires p:
# TELLU_FIT_LOG_LIMIT
# Requeres loc:
# RECON_ABSO
# TAPAS_ALL_SPECIES
# Returns loc:
# TAPAS_{molecule}
loc = spirouTelluric.CalcMolecularAbsorption(p, loc)
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
# set passed variable and fail message list
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# ----------------------------------------------------------------------
# get SNR for each order from header
nbo = loc['DATA'].shape[0]
snr_order = p['QC_FIT_TELLU_SNR_ORDER']
snr = spirouImage.Read1Dkey(p, thdr, p['kw_E2DS_SNR'][0], nbo)
# check that SNR is high enough
if snr[snr_order] < p['QC_FIT_TELLU_SNR_MIN']:
fmsg = 'low SNR in order {0}: ({1:.2f} < {2:.2f})'
fargs = [snr_order, snr[snr_order], p['QC_FIT_TELLU_SNR_MIN']]
fail_msg.append(fmsg.format(*fargs))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(snr[snr_order])
qc_name_str = 'SNR[{0}]'.format(snr_order)
qc_names.append(qc_name_str)
qc_logic.append('{0} < {1:.2f}'.format(qc_name_str,
p['QC_FIT_TELLU_SNR_ORDER']))
# ----------------------------------------------------------------------
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
continue
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ------------------------------------------------------------------
# Get components amplitudes for header
# ------------------------------------------------------------------
# get raw file name
raw_in_file = os.path.basename(p['FITSFILENAME'])
# copy original keys
hdict = spirouImage.CopyOriginalKeys(thdr)
# add version number
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
# set the input files
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBBLAZE'],
value=p['BLAZFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBWAVE'],
value=loc['WAVEFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVESOURCE'],
value=loc['WSOURCE'])
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_INFILE1'],
dim1name='file',
values=p['ARG_FILE_NAMES'])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# set tellu keys
npc = loc['NPC']
hdict = spirouImage.AddKey(p, hdict, p['KW_TELLU_NPC'], value=npc)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_TELLU_FIT_DPC'],
value=p['FIT_DERIV_PC'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_TELLU_ADD_DPC'],
value=p['ADD_DERIV_PC'])
if p['ADD_DERIV_PC']:
values = loc['AMPS_ABSOL_TOTAL'][:npc - 2]
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_TELLU_AMP_PC'],
values=values,
dim1name='amp')
hdict = spirouImage.AddKey(p,
hdict,
p['KW_TELLU_DV_TELL1'],
value=loc['AMPS_ABSOL_TOTAL'][npc - 2])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_TELLU_DV_TELL2'],
value=loc['AMPS_ABSOL_TOTAL'][npc - 1])
else:
values = loc['AMPS_ABSOL_TOTAL'][:npc]
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_TELLU_AMP_PC'],
values=values,
dim1name='PC')
# ------------------------------------------------------------------
# Write corrected spectrum to E2DS
# ------------------------------------------------------------------
# reform the E2DS
sp_out = loc['SP2'] / loc['RECON_ABSO']
sp_out = sp_out.reshape(loc['DATA'].shape)
# multiply by blaze
sp_out = sp_out * loc['NBLAZE']
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
# log progress
wmsg = 'Saving {0} to file'.format(outfilename1)
WLOG(p, '', wmsg)
# write sp_out to file
p = spirouImage.WriteImage(p, outfile1, sp_out, hdict)
# ------------------------------------------------------------------
# 1-dimension spectral S1D (uniform in wavelength)
# ------------------------------------------------------------------
# get arguments for E2DS to S1D
e2dsargs = [loc['WAVE'], sp_out, loc['BLAZE']]
# get 1D spectrum
xs1d1, ys1d1 = spirouImage.E2DStoS1D(p, *e2dsargs, wgrid='wave')
# Plot the 1D spectrum
if p['DRS_PLOT'] > 0:
sPlt.ext_1d_spectrum_plot(p, xs1d1, ys1d1)
# construct file name
targs = [p, raw_in_file]
s1dfile1, tag3 = spirouConfig.Constants.TELLU_FIT_S1D_FILE1(*targs)
s1dfilename1 = os.path.basename(s1dfile1)
# add header keys
# set the version
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag3)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_EXT_TYPE'],
value=p['DPRTYPE'])
# log writing to file
wmsg = 'Saving 1D spectrum (uniform in wavelength) in {0}'
WLOG(p, '', wmsg.format(s1dfilename1))
# Write to file
columns = ['wavelength', 'flux', 'eflux']
values = [xs1d1, ys1d1, np.zeros_like(ys1d1)]
units = ['nm', None, None]
s1d1 = spirouImage.MakeTable(p, columns, values, units=units)
spirouImage.WriteTable(p, s1d1, s1dfile1, header=hdict)
# ------------------------------------------------------------------
# 1-dimension spectral S1D (uniform in velocity)
# ------------------------------------------------------------------
# get arguments for E2DS to S1D
e2dsargs = [loc['WAVE'], sp_out, loc['BLAZE']]
# get 1D spectrum
xs1d2, ys1d2 = spirouImage.E2DStoS1D(p, *e2dsargs, wgrid='velocity')
# Plot the 1D spectrum
if p['DRS_PLOT'] > 0:
sPlt.ext_1d_spectrum_plot(p, xs1d2, ys1d2)
# construct file name
targs = [p, raw_in_file]
s1dfile2, tag4 = spirouConfig.Constants.TELLU_FIT_S1D_FILE2(*targs)
s1dfilename2 = os.path.basename(s1dfile2)
# add header keys
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag4)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_EXT_TYPE'],
value=p['DPRTYPE'])
# log writing to file
wmsg = 'Saving 1D spectrum (uniform in velocity) in {0}'
WLOG(p, '', wmsg.format(s1dfilename2))
# Write to file
columns = ['wavelength', 'flux', 'eflux']
values = [xs1d2, ys1d2, np.zeros_like(ys1d2)]
units = ['nm', None, None]
s1d2 = spirouImage.MakeTable(p, columns, values, units=units)
spirouImage.WriteTable(p, s1d2, s1dfile2, header=hdict)
# ------------------------------------------------------------------
# Write reconstructed absorption to E2DS
# ------------------------------------------------------------------
# set up empty storage
recon_abso2 = np.zeros_like(loc['DATA'])
# get dimensions of data
ydim, xdim = loc['DATA'].shape
# loop around orders
for order_num in range(ydim):
# get start and end points
start, end = xdim * order_num, xdim * order_num + xdim
# save to storage
recon_abso2[order_num, :] = loc['RECON_ABSO'][start:end]
# add molecular absorption to file
for it, molecule in enumerate(p['TELLU_ABSORBERS'][1:]):
# get molecule keyword store and key
molkey = '{0}_{1}'.format(p['KW_TELLU_ABSO'][0], molecule.upper())
molkws = [molkey, 0, 'Absorption in {0}'.format(molecule.upper())]
# load into hdict
hdict = spirouImage.AddKey(p, hdict, molkws, value=loc[molkey])
# add water col
if molecule == 'h2o':
loc['WATERCOL'] = loc[molkey]
# set source
loc.set_source('WATERCOL', main_name)
# add the tau keys
hdict = spirouImage.AddKey(p,
hdict,
p['KW_TAU_H2O'],
value=loc['TAU_H2O'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_TAU_REST'],
value=loc['TAU_REST'])
# log progress
wmsg = 'Saving {0} to file'.format(outfilename2)
WLOG(p, '', wmsg)
# write recon_abso to file
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag2)
p = spirouImage.WriteImage(p, outfile2, recon_abso2, hdict)
# ------------------------------------------------------------------
# Update the Telluric database
# ------------------------------------------------------------------
if p['QC']:
# add TELLU_OBJ to telluric database
oparams = dict(objname=loc['OBJNAME'],
berv=loc['BERV'],
airmass=loc['AIRMASS'],
watercol=loc['WATERCOL'])
spirouDB.UpdateDatabaseTellObj(p, outfilename1, **oparams)
# copy file to database
spirouDB.PutTelluFile(p, outfile1)
# add TELLU_RECON to telluric database
# add TELLU_OBJ to telluric database
oparams = dict(objname=loc['OBJNAME'],
berv=loc['BERV'],
airmass=loc['AIRMASS'],
watercol=loc['WATERCOL'])
spirouDB.UpdateDatabaseTellRecon(p, outfilename2, **oparams)
# copy file to database
spirouDB.PutTelluFile(p, outfile2)
# ----------------------------------------------------------------------
# End plotting
# ----------------------------------------------------------------------
# debug plot
if p['DRS_PLOT'] > 0:
# end interactive session
sPlt.end_interactive_session(p)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
EXTRACT_SHAPE_TYPES = ['4a', '4b', '5a', '5b']
# =============================================================================
# Start of code
# =============================================================================
# Main code here
if __name__ == "__main__":
night_name = 'TEST1/20180805'
files = ['2295545o_pp.fits']
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouFITS.readimage_and_combine(p, framemath='add')
# ----------------------------------------------------------------------
# Read star parameters
# ----------------------------------------------------------------------
p = spirouImage.get_sigdet(p, hdr, name='sigdet')
p = spirouImage.get_exptime(p, hdr, name='exptime')
p = spirouImage.get_gain(p, hdr, name='gain')
p = spirouImage.get_param(p, hdr, 'KW_OBSTYPE', dtype=str)
p = spirouImage.get_param(p, hdr, 'KW_OBJRA', dtype=str)
p = spirouImage.get_param(p, hdr, 'KW_OBJDEC', dtype=str)
p = spirouImage.get_param(p, hdr, 'KW_OBJEQUIN')
def main(night_name=None, files=None):
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p,
night_name,
files,
mainfitsdir='reduced')
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set up function name
main_name = __NAME__ + '.main()'
# ----------------------------------------------------------------------
# load up first file
# ----------------------------------------------------------------------
# construct loc parameter dictionary for storing data
loc = ParamDict()
# read first file and assign values
rdata = spirouImage.ReadImage(p, p['FITSFILENAME'])
loc['DATA'], loc['DATAHDR'] = rdata[:2]
# Get output key
loc['OUTPUT'] = loc['DATAHDR'][p['KW_OUTPUT'][0]]
# set source
source = main_name + '+ spirouImage.ReadParams()'
loc.set_source('OUTPUT', source)
# ----------------------------------------------------------------------
# Get database files
# ----------------------------------------------------------------------
# get current telluric maps from telluDB
files, output_codes = [], []
# filter by object name (only keep OBJNAME objects) and only keep
# unique filenames
use_files = []
for it in range(len(files)):
# check that OUTPUT is correct
cond1 = p['KW_OUTPUT'] in output_codes[it]
# check that filename is not already used
cond2 = files[it] not in use_files
# append to file list if criteria correct
if cond1 and cond2:
use_files.append(files[it])
# log if we have no files
if len(use_files) == 0:
wmsg = 'No files found for OUTPUT ="{0}" skipping'
WLOG(p, 'warning', wmsg.format(loc['KW_OUTPUT']))
# End Message
wmsg = 'Recipe {0} has been successfully completed'
WLOG(p, 'info', wmsg.format(p['PROGRAM']))
# return a copy of locally defined variables in the memory
return dict(locals())
else:
# log how many found
wmsg = 'N={0} files found for OUTPUT="{1}"'
WLOG(p, '', wmsg.format(len(use_files), loc['OUTPUT']))
# ----------------------------------------------------------------------
# Set up storage for cubes (NaN arrays)
# ----------------------------------------------------------------------
# set up flat size
dims = [loc['DATA'].shape[0], loc['DATA'].shape[1], len(use_files)]
flatsize = np.product(dims)
# create NaN filled storage
big_cube = np.repeat([np.nan], flatsize).reshape(*dims)
big_cube0 = np.repeat([np.nan], flatsize).reshape(*dims)
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# get master wave map
loc['MASTERWAVEFILE'] = spirouDB.GetDatabaseMasterWave(p)
# read master wave map
mout = spirouImage.GetWaveSolution(p,
filename=loc['MASTERWAVEFILE'],
return_wavemap=True,
quiet=True,
fiber=wave_fiber)
loc['MASTERWAVEPARAMS'], loc['MASTERWAVE'], loc['WSOURCE'] = mout
keys = ['MASTERWAVEPARAMS', 'MASTERWAVE', 'MASTERWAVEFILE', 'WSOURCE']
loc.set_sources(keys, main_name)
# ----------------------------------------------------------------------
# Loop through input files
# ----------------------------------------------------------------------
base_filelist, berv_list = [], []
# loop through files
for it, filename in enumerate(use_files):
# get base filenmae
basefilename = os.path.basename(filename)
# append basename to file list
base_filelist.append(basefilename)
# ------------------------------------------------------------------
# Load the data for this file
tdata, thdr, _, _ = spirouImage.ReadImage(p, filename)
# ------------------------------------------------------------------
# log stats
wmsg = 'Processing file {0} of {1} file={2}'
wargs = [it + 1, len(use_files), basefilename]
WLOG(p, '', wmsg.format(*wargs))
# ------------------------------------------------------------------
# add to cube storage
big_cube0[:, :, it] = tdata
# ----------------------------------------------------------------------
# Save cubes to file
# ----------------------------------------------------------------------
# get raw file name
raw_in_file = os.path.basename(p['FITSFILENAME'])
# construct file names
outfile = raw_in_file.replace('.fits', '_stack.fits')
tag = loc['OUTPUT'] + '_STACK'
# log big cube 1
wmsg1 = 'Saving bigcube to file {0}'.format(os.path.basename(outfile))
# hdict is first file keys
hdict = spirouImage.CopyOriginalKeys(loc['DATAHDR'])
# add version number
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag)
# set the input files
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBLAZE'], value=p['BLAZFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBWAVE'],
value=loc['MASTERWAVEFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVESOURCE'],
value=loc['WSOURCE'])
# add file list to header
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_OBJFILELIST'],
values=base_filelist)
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_OBJBERVLIST'],
values=berv_list)
# add wave solution coefficients
hdict = spirouImage.AddKey2DList(p,
hdict,
p['KW_WAVE_PARAM'],
values=loc['MASTERWAVEPARAMS'])
# log big cube 0
wmsg = 'Saving bigcube0 to file {0}'.format(os.path.basename(outfile))
# save big cube 0
big_cube_s0 = np.swapaxes(big_cube0, 1, 2)
p = spirouImage.WriteImageMulti(p, outfile, big_cube_s0, hdict)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_loc_RAW_spirou.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_loc_RAW_spirou.py [night_name] [files]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouImage.ReadImageAndCombine(p, framemath='add')
# ----------------------------------------------------------------------
# fix for un-preprocessed files
# ----------------------------------------------------------------------
data = spirouImage.FixNonPreProcess(p, data)
# ----------------------------------------------------------------------
# Get basic image properties
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, hdr, name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, hdr, name='exptime')
# get gain
p = spirouImage.GetGain(p, hdr, name='gain')
# ----------------------------------------------------------------------
# Correction of DARK
# ----------------------------------------------------------------------
p, datac = spirouImage.CorrectForDark(p, data, hdr)
# ----------------------------------------------------------------------
# Interpolation over bad regions (to fill in the holes)
# ----------------------------------------------------------------------
# log process
# wmsg = 'Interpolating over bad regions'
# WLOG(p, '', wmsg)
# run interpolation
# datac = spirouImage.InterpolateBadRegions(p, datac)
# ----------------------------------------------------------------------
# Resize image
# ----------------------------------------------------------------------
# rotate the image and convert from ADU/s to e-
data = spirouImage.ConvertToE(spirouImage.FlipImage(p, datac), p=p)
# convert NaN to zeros
data0 = np.where(~np.isfinite(data), np.zeros_like(data), data)
# resize image
bkwargs = dict(xlow=p['IC_CCDX_LOW'],
xhigh=p['IC_CCDX_HIGH'],
ylow=p['IC_CCDY_LOW'],
yhigh=p['IC_CCDY_HIGH'],
getshape=False)
data2 = spirouImage.ResizeImage(p, data0, **bkwargs)
# log change in data size
WLOG(p, '', ('Image format changed to ' '{0}x{1}').format(*data2.shape))
# ----------------------------------------------------------------------
# Correct for the BADPIX mask (set all bad pixels to zero)
# ----------------------------------------------------------------------
p, data2 = spirouImage.CorrectForBadPix(p, data2, hdr)
# ----------------------------------------------------------------------
# Background computation
# ----------------------------------------------------------------------
if p['IC_DO_BKGR_SUBTRACTION']:
# log that we are doing background measurement
WLOG(p, '', 'Doing background measurement on raw frame')
# get the bkgr measurement
bargs = [p, data2, hdr]
# background, xc, yc, minlevel = spirouBACK.MeasureBackgroundFF(*bargs)
p, background = spirouBACK.MeasureBackgroundMap(*bargs)
else:
background = np.zeros_like(data2)
p['BKGRDFILE'] = 'None'
p.set_source('BKGRDFILE', __NAME__ + '.main()')
# apply background correction to data
data2 = data2 - background
# ----------------------------------------------------------------------
# Construct image order_profile
# ----------------------------------------------------------------------
# log that we are doing background measurement
WLOG(p, '', 'Creating Order Profile')
order_profile = spirouLOCOR.BoxSmoothedImage(data2, p['LOC_BOX_SIZE'])
# data 2 is now set to the order profile
data2o = data2.copy()
data2 = order_profile.copy()
# ----------------------------------------------------------------------
# Write image order_profile to file
# ----------------------------------------------------------------------
# Construct folder and filename
rawfits, tag1 = spirouConfig.Constants.LOC_ORDER_PROFILE_FILE(p)
rawfitsname = os.path.split(rawfits)[-1]
# log saving order profile
wmsg = 'Saving processed raw frame in {0}'
WLOG(p, '', wmsg.format(rawfitsname))
# add keys from original header file
hdict = spirouImage.CopyOriginalKeys(hdr)
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBDARK'], value=p['DARKFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBAD'], value=p['BADPFILE'])
# write to file
p = spirouImage.WriteImage(p, rawfits, order_profile, hdict)
# ----------------------------------------------------------------------
# Move order_profile to calibDB and update calibDB
# ----------------------------------------------------------------------
# set key for calibDB
keydb = 'ORDER_PROFILE_{0}'.format(p['FIBER'])
# copy dark fits file to the calibDB folder
spirouDB.PutCalibFile(p, rawfits)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, rawfitsname, hdr)
# ######################################################################
# Localization of orders on central column
# ######################################################################
# storage dictionary for localization parameters
loc = ParamDict()
# Plots setup: start interactive plot
if p['DRS_PLOT'] > 0:
sPlt.start_interactive_session(p)
# ----------------------------------------------------------------------
# Measurement and correction of background on the central column
# ----------------------------------------------------------------------
loc = spirouBACK.MeasureBkgrdGetCentPixs(p, loc, data2)
# ----------------------------------------------------------------------
# Search for order center on the central column - quick estimation
# ----------------------------------------------------------------------
# log progress
WLOG(p, '', 'Searching order center on central column')
# plot the minimum of ycc and ic_locseuil if in debug and plot mode
if p['DRS_DEBUG'] > 0 and p['DRS_PLOT']:
sPlt.debug_locplot_min_ycc_loc_threshold(p, loc['YCC'])
# find the central positions of the orders in the central
posc_all = spirouLOCOR.FindPosCentCol(loc['YCC'], p['IC_LOCSEUIL'])
# depending on the fiber type we may need to skip some pixels and also
# we need to add back on the ic_offset applied
start = p['IC_FIRST_ORDER_JUMP']
posc = posc_all[start:] + p['IC_OFFSET']
# work out the number of orders to use (minimum of ic_locnbmaxo and number
# of orders found in 'LocateCentralOrderPositions')
number_of_orders = np.min([p['IC_LOCNBMAXO'], len(posc)])
# log the number of orders than have been detected
wargs = [p['FIBER'], int(number_of_orders / p['NBFIB']), p['NBFIB']]
WLOG(p, 'info', ('On fiber {0} {1} orders have been detected '
'on {2} fiber(s)').format(*wargs))
# ----------------------------------------------------------------------
# Search for order center and profile on specific columns
# ----------------------------------------------------------------------
# get fit polynomial orders for position and width
fitpos, fitwid = p['IC_LOCDFITC'], p['IC_LOCDFITW']
# Create arrays to store position and width of order for each order
loc['CTRO'] = np.zeros((number_of_orders, data2.shape[1]), dtype=float)
loc['SIGO'] = np.zeros((number_of_orders, data2.shape[1]), dtype=float)
# Create arrays to store coefficients for position and width
loc['ACC'] = np.zeros((number_of_orders, fitpos + 1))
loc['ASS'] = np.zeros((number_of_orders, fitpos + 1))
# Create arrays to store rms values for position and width
loc['RMS_CENTER'] = np.zeros(number_of_orders)
loc['RMS_FWHM'] = np.zeros(number_of_orders)
# Create arrays to store point to point max value for position and width
loc['MAX_PTP_CENTER'] = np.zeros(number_of_orders)
loc['MAX_PTP_FRACCENTER'] = np.zeros(number_of_orders)
loc['MAX_PTP_FWHM'] = np.zeros(number_of_orders)
loc['MAX_PTP_FRACFWHM'] = np.zeros(number_of_orders)
# Create arrays to store rejected points
loc['MAX_RMPTS_POS'] = np.zeros(number_of_orders)
loc['MAX_RMPTS_WID'] = np.zeros(number_of_orders)
# set the central col centers in the cpos_orders array
loc['CTRO'][:, p['IC_CENT_COL']] = posc[0:number_of_orders]
# set source for all locs
loc.set_all_sources(__NAME__ + '/main()')
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# storage for plotting
loc['XPLOT'], loc['YPLOT'] = [], []
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# loop around each order
rorder_num = 0
for order_num in range(number_of_orders):
# find the row centers of the columns
loc = spirouLOCOR.FindOrderCtrs(p, data2, loc, order_num)
# only keep the orders with non-zero width
mask = loc['SIGO'][order_num, :] != 0
loc['X'] = np.arange(data2.shape[1])[mask]
loc.set_source('X', __NAME__ + '/main()')
# check that we have enough data points to fit data
if len(loc['X']) > (fitpos + 1):
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# initial fit params
iofargs = [p, loc, mask, rorder_num]
# initial fit for center positions for this order
loc, cf_data = spirouLOCOR.InitialOrderFit(*iofargs, kind='center')
# initial fit for widths for this order
loc, wf_data = spirouLOCOR.InitialOrderFit(*iofargs, kind='fwhm')
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Log order number and fit at central pixel and width and rms
wargs = [
rorder_num, cf_data['cfitval'], wf_data['cfitval'],
cf_data['rms']
]
WLOG(p, '', ('ORDER: {0} center at pixel {1:.1f} width '
'{2:.1f} rms {3:.3f}').format(*wargs))
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# sigma fit params
sigfargs = [p, loc, cf_data, mask, order_num, rorder_num]
# sigma clip fit for center positions for this order
cf_data = spirouLOCOR.SigClipOrderFit(*sigfargs, kind='center')
# load results into storage arrags for this order
loc['ACC'][rorder_num] = cf_data['a']
loc['RMS_CENTER'][rorder_num] = cf_data['rms']
loc['MAX_PTP_CENTER'][rorder_num] = cf_data['max_ptp']
loc['MAX_PTP_FRACCENTER'][rorder_num] = cf_data['max_ptp_frac']
loc['MAX_RMPTS_POS'][rorder_num] = cf_data['max_rmpts']
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# sigma fit params
sigfargs = [p, loc, wf_data, mask, order_num, rorder_num]
# sigma clip fit for width positions for this order
wf_data = spirouLOCOR.SigClipOrderFit(*sigfargs, kind='fwhm')
# load results into storage arrags for this order
loc['ASS'][rorder_num] = wf_data['a']
loc['RMS_FWHM'][rorder_num] = wf_data['rms']
loc['MAX_PTP_FWHM'][rorder_num] = wf_data['max_ptp']
loc['MAX_PTP_FRACFWHM'][rorder_num] = wf_data['max_ptp_frac']
loc['MAX_RMPTS_WID'][rorder_num] = wf_data['max_rmpts']
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# increase the roder_num iterator
rorder_num += 1
# else log that the order is unusable
else:
WLOG(p, '', 'Order found too much incomplete, discarded')
# ----------------------------------------------------------------------
# Plot the image (ready for fit points to be overplotted later)
if p['DRS_PLOT'] > 0:
# get saturation threshold
satseuil = p['IC_SATSEUIL'] * p['GAIN'] * p['NBFRAMES']
# plot image above saturation threshold
sPlt.locplot_im_sat_threshold(p, loc, data2, satseuil)
# ----------------------------------------------------------------------
# Log that order geometry has been measured
WLOG(p, 'info', ('On fiber {0} {1} orders geometry have been '
'measured').format(p['FIBER'], rorder_num))
# Get mean rms
mean_rms_center = np.nansum(
loc['RMS_CENTER'][:rorder_num]) * 1000 / rorder_num
mean_rms_fwhm = np.nansum(loc['RMS_FWHM'][:rorder_num]) * 1000 / rorder_num
# Log mean rms values
wmsg = 'Average uncertainty on {0}: {1:.2f} [mpix]'
WLOG(p, 'info', wmsg.format('position', mean_rms_center))
WLOG(p, 'info', wmsg.format('width', mean_rms_fwhm))
# ----------------------------------------------------------------------
# Plot of RMS for positions and widths
# ----------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
sPlt.locplot_order_number_against_rms(p, loc, rorder_num)
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# ----------------------------------------------------------------------
# check that max number of points rejected in center fit is below threshold
if np.nansum(loc['MAX_RMPTS_POS']) > p['QC_LOC_MAXLOCFIT_REMOVED_CTR']:
fmsg = 'abnormal points rejection during ctr fit ({0:.2f} > {1:.2f})'
fail_msg.append(
fmsg.format(np.nansum(loc['MAX_RMPTS_POS']),
p['QC_LOC_MAXLOCFIT_REMOVED_CTR']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(np.nansum(loc['MAX_RMPTS_POS']))
qc_names.append('sum(MAX_RMPTS_POS)')
qc_logic.append('sum(MAX_RMPTS_POS) > {0:.2f}'
''.format(p['QC_LOC_MAXLOCFIT_REMOVED_CTR']))
# ----------------------------------------------------------------------
# check that max number of points rejected in width fit is below threshold
if np.nansum(loc['MAX_RMPTS_WID']) > p['QC_LOC_MAXLOCFIT_REMOVED_WID']:
fmsg = 'abnormal points rejection during width fit ({0:.2f} > {1:.2f})'
fail_msg.append(
fmsg.format(np.nansum(loc['MAX_RMPTS_WID']),
p['QC_LOC_MAXLOCFIT_REMOVED_WID']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(np.nansum(loc['MAX_RMPTS_WID']))
qc_names.append('sum(MAX_RMPTS_WID)')
qc_logic.append('sum(MAX_RMPTS_WID) > {0:.2f}'
''.format(p['QC_LOC_MAXLOCFIT_REMOVED_WID']))
# ----------------------------------------------------------------------
# check that the rms in center fit is lower than qc threshold
if mean_rms_center > p['QC_LOC_RMSMAX_CENTER']:
fmsg = 'too high rms on center fitting ({0:.2f} > {1:.2f})'
fail_msg.append(fmsg.format(mean_rms_center,
p['QC_LOC_RMSMAX_CENTER']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(mean_rms_center)
qc_names.append('mean_rms_center')
qc_logic.append('mean_rms_center > {0:.2f}'
''.format(p['QC_LOC_RMSMAX_CENTER']))
# ----------------------------------------------------------------------
# check that the rms in center fit is lower than qc threshold
if mean_rms_fwhm > p['QC_LOC_RMSMAX_FWHM']:
fmsg = 'too high rms on profile fwhm fitting ({0:.2f} > {1:.2f})'
fail_msg.append(fmsg.format(mean_rms_fwhm, p['QC_LOC_RMSMAX_CENTER']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(mean_rms_fwhm)
qc_names.append('mean_rms_fwhm')
qc_logic.append('mean_rms_fwhm > {0:.2f}'
''.format(p['QC_LOC_RMSMAX_CENTER']))
# ----------------------------------------------------------------------
# check for abnormal number of identified orders
if rorder_num != p['QC_LOC_NBO']:
fmsg = ('abnormal number of identified orders (found {0:.2f} '
'expected {1:.2f})')
fail_msg.append(fmsg.format(rorder_num, p['QC_LOC_NBO']))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(rorder_num)
qc_names.append('rorder_num')
qc_logic.append('rorder_num != {0:.2f}'.format(p['QC_LOC_NBO']))
# ----------------------------------------------------------------------
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ----------------------------------------------------------------------
# Save and record of image of localization with order center and keywords
# ----------------------------------------------------------------------
raw_loco_file = os.path.basename(p['FITSFILENAME'])
# construct filename
locofits, tag2 = spirouConfig.Constants.LOC_LOCO_FILE(p)
locofitsname = os.path.split(locofits)[-1]
# log that we are saving localization file
WLOG(p, '', ('Saving localization information '
'in file: {0}').format(locofitsname))
# add keys from original header file
hdict = spirouImage.CopyOriginalKeys(hdr)
# define new keys to add
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag2)
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBDARK'], value=p['DARKFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBAD'], value=p['BADPFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBLOCO'], value=raw_loco_file)
hdict = spirouImage.AddKey(p, hdict, p['KW_CCD_SIGDET'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CCD_CONAD'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOCO_BCKGRD'],
value=loc['MEAN_BACKGRD'])
hdict = spirouImage.AddKey(p, hdict, p['KW_LOCO_NBO'], value=rorder_num)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOCO_DEG_C'],
value=p['IC_LOCDFITC'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOCO_DEG_W'],
value=p['IC_LOCDFITW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_LOCO_DEG_E'])
hdict = spirouImage.AddKey(p, hdict, p['KW_LOCO_DELTA'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_MAXFLX'],
value=float(loc['MAX_SIGNAL']))
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_SMAXPTS_CTR'],
value=np.nansum(loc['MAX_RMPTS_POS']))
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_SMAXPTS_WID'],
value=np.nansum(loc['MAX_RMPTS_WID']))
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_RMS_CTR'],
value=mean_rms_center)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_RMS_WID'],
value=mean_rms_fwhm)
# write 2D list of position fit coefficients
hdict = spirouImage.AddKey2DList(p,
hdict,
p['KW_LOCO_CTR_COEFF'],
values=loc['ACC'][0:rorder_num])
# write 2D list of width fit coefficients
hdict = spirouImage.AddKey2DList(p,
hdict,
p['KW_LOCO_FWHM_COEFF'],
values=loc['ASS'][0:rorder_num])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# write center fits and add header keys (via hdict)
center_fits = spirouLOCOR.CalcLocoFits(loc['ACC'], data2.shape[1])
p = spirouImage.WriteImage(p, locofits, center_fits, hdict)
# ----------------------------------------------------------------------
# Save and record of image of sigma
# ----------------------------------------------------------------------
# construct filename
locofits2, tag3 = spirouConfig.Constants.LOC_LOCO_FILE2(p)
locofits2name = os.path.split(locofits2)[-1]
# log that we are saving localization file
wmsg = 'Saving FWHM information in file: {0}'
WLOG(p, '', wmsg.format(locofits2name))
# add keys from original header file
hdict = spirouImage.CopyOriginalKeys(hdr)
# define new keys to add
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag3)
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBDARK'], value=p['DARKFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBAD'], value=p['BADPFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBACK'], value=p['BKGRDFILE'])
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_INFILE1'],
dim1name='file',
values=p['ARG_FILE_NAMES'])
# add outputs
hdict = spirouImage.AddKey(p, hdict, p['KW_CCD_SIGDET'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CCD_CONAD'])
hdict = spirouImage.AddKey(p, hdict, p['KW_LOCO_NBO'], value=rorder_num)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOCO_DEG_C'],
value=p['IC_LOCDFITC'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOCO_DEG_W'],
value=p['IC_LOCDFITW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_LOCO_DEG_E'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_MAXFLX'],
value=float(loc['MAX_SIGNAL']))
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_SMAXPTS_CTR'],
value=np.nansum(loc['MAX_RMPTS_POS']))
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_SMAXPTS_WID'],
value=np.nansum(loc['MAX_RMPTS_WID']))
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_RMS_CTR'],
value=mean_rms_center)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_LOC_RMS_WID'],
value=mean_rms_fwhm)
# write 2D list of position fit coefficients
hdict = spirouImage.AddKey2DList(p,
hdict,
p['KW_LOCO_CTR_COEFF'],
values=loc['ACC'][0:rorder_num])
# write 2D list of width fit coefficients
hdict = spirouImage.AddKey2DList(p,
hdict,
p['KW_LOCO_FWHM_COEFF'],
values=loc['ASS'][0:rorder_num])
# add quality control
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
# write image and add header keys (via hdict)
width_fits = spirouLOCOR.CalcLocoFits(loc['ASS'], data2.shape[1])
p = spirouImage.WriteImage(p, locofits2, width_fits, hdict)
# ----------------------------------------------------------------------
# Save and Record of image of localization
# ----------------------------------------------------------------------
if p['IC_LOCOPT1']:
# construct filename
locofits3, tag4 = spirouConfig.Constants.LOC_LOCO_FILE3(p)
locofits3name = os.path.split(locofits3)[-1]
# log that we are saving localization file
wmsg1 = 'Saving localization image with superposition of orders in '
wmsg2 = 'file: {0}'.format(locofits3name)
WLOG(p, '', [wmsg1, wmsg2])
# superpose zeros over the fit in the image
data4 = spirouLOCOR.ImageLocSuperimp(data2o, loc['ACC'][0:rorder_num])
# save this image to file
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_FIBER'], value=p['FIBER'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag4)
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBDARK'],
value=p['DARKFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBBAD'],
value=p['BADPFILE'])
p = spirouImage.WriteImage(p, locofits3, data4, hdict)
# ----------------------------------------------------------------------
# Update the calibration database
# ----------------------------------------------------------------------
if p['QC'] == 1:
keydb = 'LOC_' + p['FIBER']
# copy localisation file to the calibDB folder
spirouDB.PutCalibFile(p, locofits)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, locofitsname, hdr)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_FF_RAW_spirou.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_FF_RAW_spirou.py [night_directory] [files]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p)
# get the night name
night_name = p['ARG_NIGHT_NAME']
# ----------------------------------------------------------------------
# get the e2ds filenames (uses ARG_FILE_NAMES by default)
exists = False
e2ds_files, e2dsff_files = dict(), dict()
for fiber in p['FIBER_TYPES']:
# must set file type
p['FIBER'] = fiber
p.set_source('FIBER', __NAME__ + '.main()')
# construct this fibers file names
e2dsfits, tag1 = spirouConfig.Constants.EXTRACT_E2DS_FILE(p)
e2dsfffits, tag2 = spirouConfig.Constants.EXTRACT_E2DSFF_FILE(p)
# check whether e2ds file exists
if os.path.exists(e2dsfits):
exists = exists and True
else:
exists = exists and False
# append to files
e2ds_files[fiber] = e2dsfits
e2dsff_files[fiber] = e2dsfffits
# ----------------------------------------------------------------------
# extract the dark or read dark e2ds header
# ----------------------------------------------------------------------
# check if e2ds file exists - if not extract
if p['ALWAYS_EXTRACT'] or (not exists):
llout = cal_extract_RAW_spirou.main(night_name, files)
# get qc
passed = llout['p']['QC']
# get hdr
hdr = llout['hdr']
# else we need to get
else:
# read file header and push into outputs
hdr = spirouImage.ReadHeader(p, e2ds_files['AB'])
# get quality control parameters
passed = hdr['KW_DRS_QC']
# ------------------------------------------------------------------
# Update the calibration database
# ------------------------------------------------------------------
for fiber in p['FIBER_TYPES']:
if passed:
# copy THERMAL_{FIBER} to calibdb
keydb = 'THERMAL_' + fiber
# get absolute path
abspath = e2ds_files[fiber]
basename = os.path.basename(abspath)
# copy localisation file to the calibDB folder
spirouDB.PutCalibFile(p, abspath)
# update the master calib DB file with new key
spirouDB.UpdateCalibMaster(p, keydb, basename, hdr)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def dark_setup(night_name, files):
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files)
p = spirouStartup.InitialFileSetup(p)
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
p, data, hdr = spirouImage.ReadImageAndCombine(p, framemath='average')
# ----------------------------------------------------------------------
# fix for un-preprocessed files
# ----------------------------------------------------------------------
data = spirouImage.FixNonPreProcess(p, data)
# ----------------------------------------------------------------------
# Get basic image properties
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, hdr, name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, hdr, name='exptime')
# get gain
p = spirouImage.GetGain(p, hdr, name='gain')
# ----------------------------------------------------------------------
# Dark exposure time check
# ----------------------------------------------------------------------
# log the Dark exposure time
WLOG(p, 'info', 'Dark Time = {0:.3f} s'.format(p['EXPTIME']))
# Quality control: make sure the exposure time is longer than qc_dark_time
if p['EXPTIME'] < p['QC_DARK_TIME']:
emsg = 'Dark exposure time too short (< {0:.1f} s)'
WLOG(p, 'error', emsg.format(p['QC_DARK_TIME']))
# ----------------------------------------------------------------------
# Resize image
# ----------------------------------------------------------------------
# # rotate the image and conver from ADU/s to e-
# data = data[::-1, ::-1] * p['exptime'] * p['gain']
# convert NaN to zeros
nanmask = ~np.isfinite(data)
data = np.where(nanmask, np.zeros_like(data), data)
# resize blue image
bkwargs = dict(xlow=p['IC_CCDX_BLUE_LOW'],
xhigh=p['IC_CCDX_BLUE_HIGH'],
ylow=p['IC_CCDY_BLUE_LOW'],
yhigh=p['IC_CCDY_BLUE_HIGH'])
datablue, nx2, ny2 = spirouImage.ResizeImage(p, data, **bkwargs)
# Make sure we have data in the blue image
if nx2 == 0 or ny2 == 0:
WLOG(p, 'error', ('IC_CCD(X/Y)_BLUE_(LOW/HIGH) remove '
'all pixels from image.'))
# resize red image
rkwargs = dict(xlow=p['IC_CCDX_RED_LOW'],
xhigh=p['IC_CCDX_RED_HIGH'],
ylow=p['IC_CCDY_RED_LOW'],
yhigh=p['IC_CCDY_RED_HIGH'])
datared, nx3, ny3 = spirouImage.ResizeImage(p, data, **rkwargs)
# Make sure we have data in the red image
if nx3 == 0 or ny3 == 0:
WLOG(p, 'error', ('IC_CCD(X/Y)_RED_(LOW/HIGH) remove '
'all pixels from image.'))
# ----------------------------------------------------------------------
# Dark Measurement
# ----------------------------------------------------------------------
# Log that we are doing dark measurement
WLOG(p, '', 'Doing Dark measurement')
# measure dark for whole frame
p = spirouImage.MeasureDark(p, data, 'Whole det', 'full')
# measure dark for blue part
p = spirouImage.MeasureDark(p, datablue, 'Blue part', 'blue')
# measure dark for rede part
p = spirouImage.MeasureDark(p, datared, 'Red part', 'red')
# get stats
stats1 = [
data.size,
np.nansum(~np.isfinite(data)),
np.nanmedian(data),
np.nansum(~np.isfinite(data)) * 100 / np.product(data.shape),
p['DADEAD_FULL'], datablue.size,
np.nansum(~np.isfinite(datablue)),
np.nanmedian(datablue),
np.nansum(~np.isfinite(datablue)) * 100 / np.product(datablue.shape),
p['DADEAD_BLUE'], datared.size,
np.nansum(~np.isfinite(datared)),
np.nanmedian(datared),
np.nansum(~np.isfinite(datared)) * 100 / np.product(datared.shape),
p['DADEAD_RED']
]
return stats1
def main(night_name=None, files=None):
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p,
night_name,
files,
mainfitsdir='reduced')
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set up function name
main_name = __NAME__ + '.main()'
# ----------------------------------------------------------------------
# load up first file
# ----------------------------------------------------------------------
# construct loc parameter dictionary for storing data
loc = ParamDict()
# read first file and assign values
rdata = spirouImage.ReadImage(p, p['FITSFILENAME'])
loc['DATA'], loc['DATAHDR'] = rdata[:2]
# Get object name and airmass
loc['OBJNAME'] = spirouImage.GetObjName(p, loc['DATAHDR'])
loc.set_source('OBJNAME', main_name)
loc['AIRMASS'] = spirouImage.GetAirmass(p, loc['DATAHDR'])
# set source
source = main_name + '+ spirouImage.ReadParams()'
loc.set_sources(['OBJNAME', 'AIRMASS'], source)
# ----------------------------------------------------------------------
# Get and Normalise the blaze
# ----------------------------------------------------------------------
p, loc = spirouTelluric.GetNormalizedBlaze(p, loc, loc['DATAHDR'])
# ----------------------------------------------------------------------
# Get database files
# ----------------------------------------------------------------------
# get current telluric maps from telluDB
tellu_db_data = spirouDB.GetDatabaseTellObj(p, required=False)
tellu_db_files, tellu_db_names = tellu_db_data[0], tellu_db_data[1]
# sort files by name
# sortmask = spirouImage.SortByName(tellu_db_files)
# tellu_db_files = np.array(tellu_db_files)[sortmask]
# tellu_db_names = np.array(tellu_db_names)[sortmask]
# filter by object name (only keep OBJNAME objects) and only keep
# unique filenames
tell_files, tell_names = [], []
for it in range(len(tellu_db_files)):
# check that objname is correct
cond1 = loc['OBJNAME'] in tellu_db_names[it]
# check that filename is not already used
cond2 = tellu_db_files[it] not in tell_files
# append to file list if criteria correct
if cond1 and cond2:
tell_files.append(tellu_db_files[it])
tell_names.append(tellu_db_names[it])
# log if we have no files
if len(tell_files) == 0:
wmsg = 'No "TELL_OBJ" files found for object ="{0}" skipping'
WLOG(p, 'warning', wmsg.format(loc['OBJNAME']))
# End Message
wmsg = 'Recipe {0} has been successfully completed'
WLOG(p, 'info', wmsg.format(p['PROGRAM']))
# return a copy of locally defined variables in the memory
return dict(locals())
else:
# log how many found
wmsg = 'N={0} "TELL_OBJ" files found for object ="{1}"'
WLOG(p, 'info', wmsg.format(len(tell_files), loc['OBJNAME']))
# ----------------------------------------------------------------------
# Set up storage for cubes (NaN arrays)
# ----------------------------------------------------------------------
# set up flat size
dims = [loc['DATA'].shape[0], loc['DATA'].shape[1], len(tell_files)]
flatsize = np.product(dims)
# create NaN filled storage
big_cube = np.repeat([np.nan], flatsize).reshape(*dims)
big_cube0 = np.repeat([np.nan], flatsize).reshape(*dims)
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# get master wave map
loc['MASTERWAVEFILE'] = spirouDB.GetDatabaseMasterWave(p)
# read master wave map
mout = spirouImage.GetWaveSolution(p,
filename=loc['MASTERWAVEFILE'],
return_wavemap=True,
quiet=True,
fiber=wave_fiber)
loc['MASTERWAVEPARAMS'], loc['MASTERWAVE'], loc['WSOURCE'] = mout
keys = ['MASTERWAVEPARAMS', 'MASTERWAVE', 'MASTERWAVEFILE', 'WSOURCE']
loc.set_sources(keys, main_name)
# ----------------------------------------------------------------------
# Compile a median SNR for rejection of bad files
# ----------------------------------------------------------------------
snr_all = []
# choose snr to check
snr_order = p['QC_FIT_TELLU_SNR_ORDER']
# loop through files
for it, filename in enumerate(tell_files):
header = spirouImage.ReadHeader(p, filename)
# get the SNR from header
nbo = spirouImage.ReadParam(p,
header,
'KW_WAVE_ORD_N',
dtype=int,
return_value=True)
snr = spirouImage.Read1Dkey(p, header, p['kw_E2DS_SNR'][0], nbo)
# append snr_all
snr_all.append(snr[snr_order])
# work our bad snr (less than half the median SNR)
snr_thres = np.nanmedian(snr_all) / 2.0
bad_snr_objects = np.where(snr_all < snr_thres)[0]
# ----------------------------------------------------------------------
# Loop through input files
# ----------------------------------------------------------------------
# empty lists for storage
loc['BASE_ROWNUM'], loc['BASE_FILELIST'] = [], []
loc['BASE_OBJNAME'], loc['BASE_OBJECT'] = [], []
loc['BASE_BERVLIST'], loc['BASE_WAVELIST'] = [], []
loc['BASE_SNRLIST_{0}'.format(snr_order)] = []
loc['BASE_DATELIST'], loc['BASE_VERSION'] = [], []
loc['BASE_DARKFILE'], loc['BASE_BADFILE'] = [], []
loc['BASE_LOCOFILE'], loc['BASE_BLAZFILE'] = [], []
loc['BASE_FLATFILE'], loc['BASE_SHAPEFILE'] = [], []
# loop through files
for it, filename in enumerate(tell_files):
# get base filenmae
basefilename = os.path.basename(filename)
# ------------------------------------------------------------------
# skip if in bad snr objects
if it in bad_snr_objects:
wargs = [it + 1, len(tell_files), snr_all[it], snr_thres]
wmsg1 = ('Skipping file {0} of {1} due to bad SNR ({2:.3f} < '
'{3:.3f})'.format(*wargs))
wmsg2 = '\tFile = {0}'.format(basefilename)
WLOG(p, 'warning', [wmsg1, wmsg2])
continue
# ------------------------------------------------------------------
# append basename to file list
loc['BASE_FILELIST'].append(basefilename)
# ------------------------------------------------------------------
# create image for storage
image = np.repeat([np.nan], np.product(loc['DATA'].shape))
image = image.reshape(loc['DATA'].shape)
# ------------------------------------------------------------------
# Load the data for this file
tdata0, thdr, _, _ = spirouImage.ReadImage(p, filename)
nbo, npix = tdata0.shape
# Correct for the blaze
tdata = tdata0 / loc['NBLAZE']
# get berv and add to list
if p['KW_BERV'][0] in thdr:
loc['BASE_BERVLIST'].append('{0}'.format(thdr[p['KW_BERV'][0]]))
else:
loc['BASE_BERVLIST'].append('UNKNOWN')
# ------------------------------------------------------------------
# Get parameters from header
snr = snr_all[it]
dateobs = spirouImage.ReadParam(p,
thdr,
'KW_DATE_OBS',
dtype=str,
return_value=True)
utcobs = spirouImage.ReadParam(p,
thdr,
'KW_UTC_OBS',
dtype=str,
return_value=True)
tobjname = spirouImage.ReadParam(p,
thdr,
'KW_OBJNAME',
dtype=str,
return_value=True)
tobject = spirouImage.ReadParam(p,
thdr,
'KW_OBJECT',
dtype=str,
return_value=True)
tversion = spirouImage.ReadParam(p,
thdr,
'KW_version',
dtype=str,
return_value=True)
tdarkfile = spirouImage.ReadParam(p,
thdr,
'KW_CDBDARK',
dtype=str,
return_value=True)
tbadfile = spirouImage.ReadParam(p,
thdr,
'KW_CDBBAD',
dtype=str,
return_value=True)
tlocofile = spirouImage.ReadParam(p,
thdr,
'KW_CDBLOCO',
dtype=str,
return_value=True)
tblazfile = spirouImage.ReadParam(p,
thdr,
'KW_CDBBLAZE',
dtype=str,
return_value=True)
tflatfile = spirouImage.ReadParam(p,
thdr,
'KW_CDBFLAT',
dtype=str,
return_value=True)
tshapfile = spirouImage.ReadParam(p,
thdr,
'KW_CDBSHAPE',
dtype=str,
return_value=True)
# append to lists
loc['BASE_ROWNUM'].append(it)
loc['BASE_SNRLIST_{0}'.format(snr_order)].append(snr_all[it])
loc['BASE_DATELIST'].append('{0}_{1}'.format(dateobs, utcobs))
loc['BASE_OBJNAME'].append(tobjname)
loc['BASE_OBJECT'].append(tobject)
loc['BASE_VERSION'].append(tversion)
loc['BASE_DARKFILE'].append(tdarkfile)
loc['BASE_BADFILE'].append(tbadfile)
loc['BASE_LOCOFILE'].append(tlocofile)
loc['BASE_BLAZFILE'].append(tblazfile)
loc['BASE_FLATFILE'].append(tflatfile)
loc['BASE_SHAPEFILE'].append(tshapfile)
# ------------------------------------------------------------------
# Get the wave solution for this file
# ------------------------------------------------------------------
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# need to reload calibDB
# as we have custom arguments need to load the calibration database
calib_db = dict(p['CALIBDB'])
del p['CALIBDB']
p = spirouStartup.LoadCalibDB(p, header=thdr)
# get wave solution
wout = spirouImage.GetWaveSolution(p,
image=tdata,
hdr=thdr,
return_wavemap=True,
fiber=wave_fiber,
return_filename=True)
_, loc['WAVE'], loc['WAVEFILE'], _ = wout
loc.set_sources(['WAVE', 'WAVEFILE'], main_name)
# add wave to wave list
loc['BASE_WAVELIST'].append(loc['WAVEFILE'])
# readd original calibDB to p
p['CALIBDB'] = dict(calib_db)
# ------------------------------------------------------------------
# Get the Barycentric correction from header
dv, _, _ = spirouImage.GetBERV(p, thdr)
# ------------------------------------------------------------------
# log stats
wmsg = 'Processing file {0} of {1} file={2} dv={3}'
wargs = [it + 1, len(tell_files), basefilename, dv]
WLOG(p, 'info', wmsg.format(*wargs))
# ------------------------------------------------------------------
# shift to correct berv
dvshift = spirouMath.relativistic_waveshift(dv, units='km/s')
image = spirouTelluric.Wave2Wave(p, tdata, loc['WAVE'] * dvshift,
loc['MASTERWAVE'])
# ------------------------------------------------------------------
# loop around orders
for order_num in range(loc['DATA'].shape[0]):
# normalise the tdata
tdata[order_num, :] /= np.nanmedian(tdata[order_num, :])
image[order_num, :] /= np.nanmedian(image[order_num, :])
# ------------------------------------------------------------------
# add to cube storage
big_cube[:, :, it] = image
big_cube0[:, :, it] = tdata
# ----------------------------------------------------------------------
# log if we have no files
if len(loc['BASE_FILELIST']) == 0:
wmsg = 'No good files found for object ="{0}" skipping'
WLOG(p, 'warning', wmsg.format(loc['OBJNAME']))
# End Message
wmsg = 'Recipe {0} has been successfully completed'
WLOG(p, 'info', wmsg.format(p['PROGRAM']))
# return a copy of locally defined variables in the memory
return dict(locals())
# ----------------------------------------------------------------------
# make median image
with warnings.catch_warnings(record=True) as _:
big_cube_med = np.nanmedian(big_cube, axis=2)
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
# set passed variable and fail message list
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# TODO: Needs doing
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# add to qc header lists
qc_values.append('None')
qc_names.append('None')
qc_logic.append('None')
qc_pass.append(1)
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ----------------------------------------------------------------------
# Write Cube median (the template) to file
# ----------------------------------------------------------------------
# get raw file name
raw_in_file = os.path.basename(p['FITSFILENAME'])
# construct filename
outfile, tag = spirouConfig.Constants.OBJTELLU_TEMPLATE_FILE(p, loc)
outfilename = os.path.basename(outfile)
# hdict is first file keys
hdict = spirouImage.CopyOriginalKeys(loc['DATAHDR'])
# add version number
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'], value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'], value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag)
# set the input files
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBLAZE'], value=p['BLAZFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBWAVE'],
value=loc['MASTERWAVEFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVESOURCE'],
value=loc['WSOURCE'])
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_INFILE1'],
dim1name='file',
values=p['ARG_FILE_NAMES'])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# add wave solution coefficients
hdict = spirouImage.AddKey2DList(p,
hdict,
p['KW_WAVE_PARAM'],
values=loc['MASTERWAVEPARAMS'])
# write to file
p = spirouImage.WriteImage(p, outfile, big_cube_med, hdict)
# ----------------------------------------------------------------------
# Update the telluric database with the template
# ----------------------------------------------------------------------
spirouDB.UpdateDatabaseObjTemp(p, outfilename, loc['OBJNAME'],
loc['DATAHDR'])
# put file in telluDB
spirouDB.PutTelluFile(p, outfile)
# ----------------------------------------------------------------------
# Save cubes to file
# ----------------------------------------------------------------------
# make big cube table
big_table = spirouTelluric.ConstructBigTable(p, loc)
# construct file names
outfile1, tag1 = spirouConfig.Constants.OBJTELLU_TEMPLATE_CUBE_FILE1(
p, loc)
outfile2, tag2 = spirouConfig.Constants.OBJTELLU_TEMPLATE_CUBE_FILE2(
p, loc)
# log big cube 1
wmsg1 = 'Saving bigcube to file {0}'.format(os.path.basename(outfile1))
# save big cube 1
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
big_cube_s = np.swapaxes(big_cube, 1, 2)
p = spirouImage.WriteImageTable(p,
outfile1,
image=big_cube_s,
table=big_table,
hdict=hdict)
# log big cube 0
wmsg = 'Saving bigcube0 to file {0}'.format(os.path.basename(outfile2))
# save big cube 0
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag2)
big_cube_s0 = np.swapaxes(big_cube0, 1, 2)
p = spirouImage.WriteImageTable(p,
outfile2,
image=big_cube_s0,
table=big_table,
hdict=hdict)
# # mega plot
# nfiles = big_cube_s0.shape[1]
# ncols = int(np.ceil(np.sqrt(nfiles)))
# nrows = int(np.ceil(nfiles/ncols))
# fig, frames = plt.subplots(ncols=ncols, nrows=nrows)
# for it in range(big_cube_s0.shape[1]):
# jt, kt = it // ncols, it % ncols
# frame = frames[jt][kt]
# frame.imshow(big_cube_s0[:, it, :], origin='lower')
# frame.set(xlim=(2030, 2060))
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p,
night_name,
files,
mainfitsdir='reduced')
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set up function name
main_name = __NAME__ + '.main()'
# ------------------------------------------------------------------
# Load first file
# ------------------------------------------------------------------
loc = ParamDict()
rd = spirouImage.ReadImage(p, p['FITSFILENAME'])
loc['DATA'], loc['DATAHDR'], loc['YDIM'], loc['XDIM'] = rd
loc.set_sources(['DATA', 'DATAHDR', 'XDIM', 'YDIM'], main_name)
# ------------------------------------------------------------------
# Get the wave solution
# ------------------------------------------------------------------
masterwavefile = spirouDB.GetDatabaseMasterWave(p)
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# read master wave map
wout = spirouImage.GetWaveSolution(p,
filename=masterwavefile,
return_wavemap=True,
quiet=True,
return_header=True,
fiber=wave_fiber)
_, loc['WAVE'], loc['WAVEFILE'], _ = wout
loc.set_sources(['WAVE', 'WAVEFILE'], main_name)
# get the wave keys
loc = spirouImage.GetWaveKeys(p, loc, loc['DATAHDR'])
# ------------------------------------------------------------------
# Construct convolution kernels (used in GetMolecularTellLines)
# ------------------------------------------------------------------
loc = spirouTelluric.ConstructConvKernel1(p, loc)
# ------------------------------------------------------------------
# Get molecular telluric lines
# ------------------------------------------------------------------
loc = spirouTelluric.GetMolecularTellLines(p, loc)
# if TAPAS FNAME is not None we generated a new file so should add to tellDB
if loc['TAPAS_FNAME'] is not None:
# add to the telluric database
spirouDB.UpdateDatabaseTellConv(p, loc['TAPAS_FNAME'], loc['DATAHDR'])
# put file in telluDB
spirouDB.PutTelluFile(p, loc['TAPAS_ABSNAME'])
# ----------------------------------------------------------------------
# load the expected atmospheric transmission
# ----------------------------------------------------------------------
# read filename from telluDB
tapas_file_names = spirouDB.GetDatabaseTellConv(p)
tapas_file_name = tapas_file_names[-1]
# load atmospheric transmission
sp_tapas = np.load(tapas_file_name)
loc['TAPAS_ALL_SPECIES'] = sp_tapas
# extract the water and other line-of-sight optical depths
loc['TAPAS_WATER'] = sp_tapas[1, :]
loc['TAPAS_OTHERS'] = np.prod(sp_tapas[2:, :], axis=0)
loc.set_sources(['TAPAS_ALL_SPECIES', 'TAPAS_WATER', 'TAPAS_OTHERS'],
main_name)
# ------------------------------------------------------------------
# Get master wave solution map
# ------------------------------------------------------------------
# get master wave map
masterwavefile = spirouDB.GetDatabaseMasterWave(p)
# log process
wmsg1 = 'Shifting transmission map on to master wavelength grid'
wmsg2 = '\tFile = {0}'.format(os.path.basename(masterwavefile))
WLOG(p, '', [wmsg1, wmsg2])
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# read master wave map
mout = spirouImage.GetWaveSolution(p,
filename=masterwavefile,
return_wavemap=True,
quiet=True,
return_header=True,
fiber=wave_fiber)
masterwavep, masterwave, masterwaveheader, mwsource = mout
# get wave acqtimes
master_acqtimes = spirouDB.GetTimes(p, masterwaveheader)
# ------------------------------------------------------------------
# Loop around the files
# ------------------------------------------------------------------
# construct extension
tellu_ext = '{0}_{1}.fits'
# get current telluric maps from telluDB
# tellu_db_data = spirouDB.GetDatabaseTellMap(p, required=False)
# tellu_db_files = tellu_db_data[0]
# storage for valid output files
loc['OUTPUTFILES'] = []
# loop around the files
for basefilename in p['ARG_FILE_NAMES']:
# ------------------------------------------------------------------
# Get absolute path of filename
# ------------------------------------------------------------------
filename = os.path.join(p['ARG_FILE_DIR'], basefilename)
# ------------------------------------------------------------------
# Read obj telluric file and correct blaze (per order)
# ------------------------------------------------------------------
# get image
sp, shdr, _, _ = spirouImage.ReadImage(p, filename)
# ------------------------------------------------------------------
# check that file has valid DPRTYPE
# ------------------------------------------------------------------
# get FP_FP DPRTYPE
p = spirouImage.ReadParam(p, shdr, 'KW_DPRTYPE', 'DPRTYPE', dtype=str)
# if dprtype is incorrect skip
if p['DPRTYPE'] not in p['ALLOWED_TELLURIC_DPRTYPES']:
wmsg1 = 'Skipping file (DPRTYPE incorrect)'
wmsg2 = '\t DPRTYPE = {0}'.format(p['DPRTYPE'])
WLOG(p, 'warning', [wmsg1, wmsg2])
continue
# get blaze
p, blaze = spirouImage.ReadBlazeFile(p, shdr)
# get the blaze percentile
blaze_p = p['MKTELLU_BLAZE_PERCENTILE']
# loop through blaze orders, normalize blaze by its peak amplitude
for order_num in range(sp.shape[0]):
# normalize the spectrum
spo, bzo = sp[order_num], blaze[order_num]
sp[order_num] = spo / np.nanpercentile(spo, blaze_p)
# normalize the blaze
blaze[order_num] = bzo / np.nanpercentile(bzo, blaze_p)
# find where the blaze is bad
with warnings.catch_warnings(record=True) as _:
badblaze = blaze < p['MKTELLU_CUT_BLAZE_NORM']
# set bad blaze to NaN
blaze[badblaze] = np.nan
# set to NaN values where spectrum is zero
zeromask = sp == 0
sp[zeromask] = np.nan
# divide spectrum by blaze
with warnings.catch_warnings(record=True) as _:
sp = sp / blaze
# add sp to loc
loc['SP'] = sp
loc.set_source('SP', main_name)
# ----------------------------------------------------------------------
# Get object name, airmass and berv
# ----------------------------------------------------------------------
# Get object name
loc['OBJNAME'] = spirouImage.GetObjName(p, shdr)
# Get the airmass
loc['AIRMASS'] = spirouImage.GetAirmass(p, shdr)
# Get the Barycentric correction from header
p, loc = spirouImage.GetEarthVelocityCorrection(p, loc, shdr)
# set sources
source = main_name + '+ spirouImage.ReadParams()'
loc.set_sources(['OBJNAME', 'AIRMASS'], source)
# ------------------------------------------------------------------
# get output transmission filename
outfile, tag1 = spirouConfig.Constants.TELLU_TRANS_MAP_FILE(
p, filename)
outfilename = os.path.basename(outfile)
loc['OUTPUTFILES'].append(outfile)
# ----------------------------------------------------------------------
# Load template (if available)
# ----------------------------------------------------------------------
# read filename from telluDB
template_file = spirouDB.GetDatabaseObjTemp(p,
loc['OBJNAME'],
required=False)
# if we don't have a template flag it
if template_file is None:
loc['FLAG_TEMPLATE'] = False
loc['TEMPLATE'] = None
# construct progres string
pstring = 'No template found.'
else:
loc['FLAG_TEMPLATE'] = True
# load template
template, _, _, _ = spirouImage.ReadImage(p, template_file)
# add to loc
loc['TEMPLATE'] = template
# construct progres string
template_bfile = os.path.basename(template_file)
pstring = 'Using template {0}'.format(template_bfile)
# set the source for flag and template
loc.set_sources(['FLAG_TEMPLATE', 'TEMPLATE'], main_name)
# ------------------------------------------------------------------
# log processing file
wmsg = 'Processing file {0}. {1}'
WLOG(p, '', [wmsg.format(outfilename, pstring)])
# ------------------------------------------------------------------
# Check that basefile is not in blacklist
# ------------------------------------------------------------------
blacklist_check = spirouTelluric.CheckBlackList(loc['OBJNAME'])
if blacklist_check:
# log black list file found
wmsg = 'File {0} is blacklisted (OBJNAME={1}). Skipping'
wargs = [basefilename, loc['OBJNAME']]
WLOG(p, 'warning', wmsg.format(*wargs))
# skip this file
continue
# ------------------------------------------------------------------
# deal with applying template to spectrum
# ------------------------------------------------------------------
# Requires from loc:
# TEMPLATE (None or template loaded from file)
# FLAG_TEMPLATE
# WAVE
# SP
# BERV
#
# Returns:
# SP (modified if template was used)
# TEMPLATE
# WCONV
loc = spirouTelluric.ApplyTemplate(p, loc)
# ------------------------------------------------------------------
# calcullate telluric absorption (with a sigma clip loop)
# ------------------------------------------------------------------
# Requires from loc:
# AIRMASS
# WAVE
# SP
# WCONV
# Returns:
# PASSED [Bool] True or False
# SP_OUT
# SED_OUT
# RECOV_AIRMASS
# RECOV_WATER
loc = spirouTelluric.CalcTelluAbsorption(p, loc)
# calculate tranmission map from sp and sed
transmission_map = loc['SP_OUT'] / loc['SED_OUT']
# ----------------------------------------------------------------------
# Quality control
# ----------------------------------------------------------------------
# set passed variable and fail message list
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# ----------------------------------------------------------------------
# if array is completely NaNs it shouldn't pass
if np.sum(np.isfinite(transmission_map)) == 0:
fail_msg.append('transmission map is all NaNs')
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append('NaN')
qc_names.append('image')
qc_logic.append('image is all NaN')
# ----------------------------------------------------------------------
# get SNR for each order from header
nbo = loc['DATA'].shape[0]
snr_order = p['QC_MK_TELLU_SNR_ORDER']
snr = spirouImage.Read1Dkey(p, shdr, p['kw_E2DS_SNR'][0], nbo)
# check that SNR is high enough
if snr[snr_order] < p['QC_MK_TELLU_SNR_MIN']:
fmsg = 'low SNR in order {0}: ({1:.2f} < {2:.2f})'
fargs = [snr_order, snr[snr_order], p['QC_MK_TELLU_SNR_MIN']]
fail_msg.append(fmsg.format(*fargs))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(snr[snr_order])
qc_name_str = 'SNR[{0}]'.format(snr_order)
qc_names.append(qc_name_str)
qc_logic.append('{0} < {1:.2f}'.format(qc_name_str,
p['QC_MK_TELLU_SNR_ORDER']))
# ----------------------------------------------------------------------
# check that the file passed the CalcTelluAbsorption sigma clip loop
if not loc['PASSED']:
fmsg = 'File {0} did not converge on a solution in function: {1}'
fargs = [basefilename, 'spirouTelluric.CalcTelluAbsorption()']
fail_msg.append(fmsg.format(*fargs))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(basefilename)
qc_names.append('FILE')
qc_logic.append('FILE did not converge')
# ----------------------------------------------------------------------
# check that the airmass is not too different from input airmass
airmass_diff = np.abs(loc['RECOV_AIRMASS'] - loc['AIRMASS'])
fargs = [
loc['RECOV_AIRMASS'], loc['AIRMASS'], p['QC_MKTELLU_AIRMASS_DIFF']
]
if airmass_diff > p['QC_MKTELLU_AIRMASS_DIFF']:
fmsg = ('Recovered airmass to de-similar than input airmass.'
'Recovered: {0:.3f}. Input: {1:.3f}. QC limit = {2}')
fail_msg.append(fmsg.format(*fargs))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(airmass_diff)
qc_names.append('airmass_diff')
qc_logic.append('airmass_diff > {0:.2f}'
''.format(p['QC_MKTELLU_AIRMASS_DIFF']))
# ----------------------------------------------------------------------
# check that the water vapor is within limits
water_cond1 = loc['RECOV_WATER'] < p['MKTELLU_TRANS_MIN_WATERCOL']
water_cond2 = loc['RECOV_WATER'] > p['MKTELLU_TRANS_MAX_WATERCOL']
fargs = [
p['MKTELLU_TRANS_MIN_WATERCOL'], p['MKTELLU_TRANS_MAX_WATERCOL']
]
if water_cond1 or water_cond2:
fmsg = ('Recovered water vapor optical depth not between {0:.3f} '
'and {1:.3f}')
fail_msg.append(fmsg.format(*fargs))
passed = False
qc_pass.append(0)
else:
qc_pass.append(1)
# add to qc header lists
qc_values.append(loc['RECOV_WATER'])
qc_names.append('RECOV_WATER')
qc_logic.append('RECOV_WATER not between {0:.3f} and {1:.3f}'
''.format(*fargs))
# ----------------------------------------------------------------------
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info', 'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
continue
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ------------------------------------------------------------------
# Save transmission map to file
# ------------------------------------------------------------------
# get raw file name
raw_in_file = os.path.basename(p['FITSFILENAME'])
# copy original keys
hdict = spirouImage.CopyOriginalKeys(loc['DATAHDR'])
# add version number
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
# set the input files
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBBLAZE'],
value=p['BLAZFILE'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_CDBWAVE'],
value=os.path.basename(masterwavefile))
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVESOURCE'],
value=mwsource)
hdict = spirouImage.AddKey1DList(p,
hdict,
p['KW_INFILE1'],
dim1name='file',
values=p['ARG_FILE_NAMES'])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# add wave solution date
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVE_TIME1'],
value=master_acqtimes[0])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVE_TIME2'],
value=master_acqtimes[1])
# add wave solution number of orders
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVE_ORD_N'],
value=masterwavep.shape[0])
# add wave solution degree of fit
hdict = spirouImage.AddKey(p,
hdict,
p['KW_WAVE_LL_DEG'],
value=masterwavep.shape[1] - 1)
# add wave solution coefficients
hdict = spirouImage.AddKey2DList(p,
hdict,
p['KW_WAVE_PARAM'],
values=masterwavep)
# add telluric keys
hdict = spirouImage.AddKey(p,
hdict,
p['KW_TELLU_AIRMASS'],
value=loc['RECOV_AIRMASS'])
hdict = spirouImage.AddKey(p,
hdict,
p['KW_TELLU_WATER'],
value=loc['RECOV_WATER'])
# write to file
p = spirouImage.WriteImage(p, outfile, transmission_map, hdict)
# ------------------------------------------------------------------
# Add transmission map to telluDB
# ------------------------------------------------------------------
if p['QC']:
# copy tellu file to the telluDB folder
spirouDB.PutTelluFile(p, outfile)
# update the master tellu DB file with transmission map
targs = [
p, outfilename, loc['OBJNAME'], loc['RECOV_AIRMASS'],
loc['RECOV_WATER']
]
spirouDB.UpdateDatabaseTellMap(*targs)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
p = spirouStartup.LoadArguments(p, night_name, files,
mainfitsdir='reduced')
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set up function name
main_name = __NAME__ + '.main()'
# ------------------------------------------------------------------
# Load first file
# ------------------------------------------------------------------
loc = ParamDict()
rd = spirouImage.ReadImage(p, p['FITSFILENAME'])
loc['DATA'], loc['DATAHDR'], loc['YDIM'], loc['XDIM'] = rd
loc.set_sources(['DATA', 'DATAHDR', 'XDIM', 'YDIM'], main_name)
# ------------------------------------------------------------------
# Get the wave solution
# ------------------------------------------------------------------
wout = spirouImage.GetWaveSolution(p, image=loc['DATA'], hdr=loc['DATAHDR'],
return_wavemap=True,
return_filename=True)
_, loc['WAVE'], loc['WAVEFILE'], _ = wout
loc.set_sources(['WAVE', 'WAVEFILE'], main_name)
# get the wave keys
loc = spirouImage.GetWaveKeys(p, loc, loc['DATAHDR'])
# ------------------------------------------------------------------
# Get and Normalise the blaze
# ------------------------------------------------------------------
p, loc = spirouTelluric.GetNormalizedBlaze(p, loc, loc['DATAHDR'])
# ------------------------------------------------------------------
# Construct convolution kernels
# ------------------------------------------------------------------
loc = spirouTelluric.ConstructConvKernel1(p, loc)
loc = spirouTelluric.ConstructConvKernel2(p, loc, vsini=p['TELLU_VSINI'])
# ------------------------------------------------------------------
# Get molecular telluric lines
# ------------------------------------------------------------------
loc = spirouTelluric.GetMolecularTellLines(p, loc)
# if TAPAS FNAME is not None we generated a new file so should add to tellDB
if loc['TAPAS_FNAME'] is not None:
# add to the telluric database
spirouDB.UpdateDatabaseTellConv(p, loc['TAPAS_FNAME'], loc['DATAHDR'])
# put file in telluDB
spirouDB.PutTelluFile(p, loc['TAPAS_ABSNAME'])
# ------------------------------------------------------------------
# Get master wave solution map
# ------------------------------------------------------------------
# get master wave map
masterwavefile = spirouDB.GetDatabaseMasterWave(p)
# log process
wmsg1 = 'Shifting transmission map on to master wavelength grid'
wmsg2 = '\tFile = {0}'.format(os.path.basename(masterwavefile))
WLOG(p, '', [wmsg1, wmsg2])
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# read master wave map
mout = spirouImage.GetWaveSolution(p, filename=masterwavefile,
return_wavemap=True, quiet=True,
return_header=True, fiber=wave_fiber)
masterwavep, masterwave, masterwaveheader, mwsource = mout
# get wave acqtimes
master_acqtimes = spirouDB.GetTimes(p, masterwaveheader)
# ------------------------------------------------------------------
# Loop around the files
# ------------------------------------------------------------------
# construct extension
tellu_ext = '{0}_{1}.fits'
# get current telluric maps from telluDB
tellu_db_data = spirouDB.GetDatabaseTellMap(p, required=False)
tellu_db_files = tellu_db_data[0]
# storage for valid output files
loc['OUTPUTFILES'] = []
# loop around the files
for basefilename in p['ARG_FILE_NAMES']:
# ------------------------------------------------------------------
# Get absolute path of filename
# ------------------------------------------------------------------
filename = os.path.join(p['ARG_FILE_DIR'], basefilename)
# ------------------------------------------------------------------
# Read obj telluric file and correct for blaze
# ------------------------------------------------------------------
# get image
sp, shdr, _, _ = spirouImage.ReadImage(p, filename)
# divide my blaze
sp = sp / loc['BLAZE']
# ------------------------------------------------------------------
# Get the wave solution
# ------------------------------------------------------------------
wout = spirouImage.GetWaveSolution(p, image=sp, hdr=shdr,
return_wavemap=True,
return_filename=True)
_, loc['WAVE_IT'], loc['WAVEFILE_IT'], _ = wout
loc.set_sources(['WAVE_IT', 'WAVEFILE_IT'], main_name)
# ------------------------------------------------------------------
# Shift data to master wave file
# ------------------------------------------------------------------
# shift map
wargs = [p, sp, loc['WAVE_IT'], masterwave]
sp = spirouTelluric.Wave2Wave(*wargs)
loc['SP'] = np.array(sp)
loc.set_source('SP', main_name)
# ------------------------------------------------------------------
# get output transmission filename
outfile, tag1 = spirouConfig.Constants.TELLU_TRANS_MAP_FILE(p, filename)
outfilename = os.path.basename(outfile)
loc['OUTPUTFILES'].append(outfile)
# if we already have the file skip it
if outfile in tellu_db_files:
wmsg = 'File {0} exists in telluDB, skipping'
WLOG(p, '', wmsg.format(outfilename))
continue
else:
# log processing file
wmsg = 'Processing file {0}'
WLOG(p, '', wmsg.format(outfilename))
# Get object name and airmass
loc['OBJNAME'] = spirouImage.GetObjName(p, shdr)
loc['AIRMASS'] = spirouImage.GetAirmass(p, shdr)
# set source
source = main_name + '+ spirouImage.ReadParams()'
loc.set_sources(['OBJNAME', 'AIRMASS'], source)
# ------------------------------------------------------------------
# Check that basefile is not in blacklist
# ------------------------------------------------------------------
blacklist_check = spirouTelluric.CheckBlackList(loc['OBJNAME'])
if blacklist_check:
# log black list file found
wmsg = 'File {0} is blacklisted (OBJNAME={1}). Skipping'
wargs = [basefilename, loc['OBJNAME']]
WLOG(p, 'warning', wmsg.format(*wargs))
# skip this file
continue
# ------------------------------------------------------------------
# loop around the orders
# ------------------------------------------------------------------
# define storage for the transmission map
transmission_map = np.zeros_like(loc['DATA'])
# define storage for measured rms within expected clean domains
exp_clean_rms = np.zeros(loc['DATA'].shape[0])
# loop around the orders
for order_num in range(loc['DATA'].shape[0]):
# start and end
start = order_num * loc['XDIM']
end = (order_num * loc['XDIM']) + loc['XDIM']
# get this orders combined tapas transmission
trans = loc['TAPAS_ALL_SPECIES'][0, start:end]
# keep track of the pixels that are considered valid for the SED
# determination
mask1 = trans > p['TRANSMISSION_CUT']
mask1 &= np.isfinite(loc['NBLAZE'][order_num, :])
# normalise the spectrum
sp[order_num, :] /= np.nanmedian(sp[order_num, :])
# create a float mask
fmask = np.array(mask1, dtype=float)
# set up an SED to fill
sed = np.ones(loc['XDIM'])
# sigma clip until limit
ww = None
for it in range(p['N_ITER_SED_HOTSTAR']):
# copy the spectrum
sp2 = np.array(sp[order_num, :])
# flag Nans
nanmask = ~np.isfinite(sp2)
# set all NaNs to zero so that it does not propagate when
# we convlve by KER2 - must set sp2[bad] to zero as
# NaN * 0.0 = NaN and we want 0.0!
sp2[nanmask] = 0.0
# trace the invalid points
fmask[nanmask] = 0.0
# multiple by the float mask
sp2 *= fmask
# convolve with the second kernel
sp2b = np.convolve(sp2 / sed, loc['KER2'], mode='same')
# convolve with mask to get weights
ww = np.convolve(fmask, loc['KER2'], mode='same')
# normalise the spectrum by the weights
with warnings.catch_warnings(record=True) as w:
sp2bw = sp2b / ww
# set zero pixels to 1
sp2bw[sp2b == 0] = 1
# recalculate the mask using the deviation from original
with warnings.catch_warnings(record=True) as _:
dev = (sp2bw - sp[order_num, :] / sed)
dev /= np.nanmedian(np.abs(dev))
mask = mask1 * (np.abs(dev) < p['TELLU_SIGMA_DEV'])
# update the SED with the corrected spectrum
sed *= sp2bw
# identify bad pixels
with warnings.catch_warnings(record=True) as _:
bad = (sp[order_num, :] / sed[:] > 1.2)
sed[bad] = np.nan
# debug plot
if p['DRS_PLOT'] and (p['DRS_DEBUG'] > 1) and FORCE_PLOT_ON:
# start non-interactive plot
sPlt.plt.ioff()
# plot the transmission map plot
pargs = [order_num, mask1, sed, trans, sp, ww, outfilename]
sPlt.tellu_trans_map_plot(p, loc, *pargs)
# show and close
sPlt.plt.show()
sPlt.plt.close()
# set all values below a threshold to NaN
sed[ww < p['TELLU_NAN_THRESHOLD']] = np.nan
# save the spectrum (normalised by the SED) to the tranmission map
transmission_map[order_num, :] = sp[order_num, :] / sed
# get expected clean rms
fmaskb = np.array(fmask).astype(bool)
with warnings.catch_warnings(record=True):
zerotrans = np.abs(transmission_map[order_num, fmaskb]-1)
ec_rms = np.nanmedian(zerotrans)
exp_clean_rms[order_num] = ec_rms
# log the rms
wmsg = 'Order {0}: Fractional RMS in telluric free domain = {1:.3f}'
wargs = [order_num, ec_rms]
WLOG(p, '', wmsg.format(*wargs))
# ---------------------------------------------------------------------
# Quality control
# ---------------------------------------------------------------------
# set passed variable and fail message list
passed, fail_msg = True, []
qc_values, qc_names, qc_logic, qc_pass = [], [], [], []
# ----------------------------------------------------------------------
# get SNR for each order from header
nbo = loc['DATA'].shape[0]
snr_order = p['QC_MK_TELLU_SNR_ORDER']
snr = spirouImage.Read1Dkey(p, shdr, p['kw_E2DS_SNR'][0], nbo)
# check that SNR is high enough
if snr[snr_order] < p['QC_MK_TELLU_SNR_MIN']:
fmsg = 'low SNR in order {0}: ({1:.2f} < {2:.2f})'
fargs = [snr_order, snr[snr_order], p['QC_MK_TELLU_SNR_MIN']]
fail_msg.append(fmsg.format(*fargs))
passed = False
# add to qc header lists
qc_values.append(snr[snr_order])
qc_name_str = 'SNR[{0}]'.format(snr_order)
qc_names.append(qc_name_str)
qc_logic.append('{0} < {1:.2f}'.format(qc_name_str,
p['QC_MK_TELLU_SNR_ORDER']))
qc_pass.append(0)
else:
qc_pass.append(1)
# ----------------------------------------------------------------------
# check that the RMS is not too low
if exp_clean_rms[snr_order] > p['QC_TELLU_CLEAN_RMS_MAX']:
fmsg = ('Expected clean RMS is too high in order {0} '
'({1:.3f} > {2:.3f})')
fargs = [snr_order, exp_clean_rms[snr_order],
p['QC_TELLU_CLEAN_RMS_MAX']]
fail_msg.append(fmsg.format(*fargs))
passed = False
# add to qc header lists
qc_values.append(exp_clean_rms[snr_order])
qc_name_str = 'exp_clean_rms[{0}]'.format(snr_order)
qc_names.append(qc_name_str)
qc_logic.append('{0} > {1:.2f}'.format(qc_name_str,
p['QC_TELLU_CLEAN_RMS_MAX']))
qc_pass.append(0)
else:
qc_pass.append(1)
# ----------------------------------------------------------------------
# finally log the failed messages and set QC = 1 if we pass the
# quality control QC = 0 if we fail quality control
if passed:
WLOG(p, 'info',
'QUALITY CONTROL SUCCESSFUL - Well Done -')
p['QC'] = 1
p.set_source('QC', __NAME__ + '/main()')
else:
for farg in fail_msg:
wmsg = 'QUALITY CONTROL FAILED: {0}'
WLOG(p, 'warning', wmsg.format(farg))
p['QC'] = 0
p.set_source('QC', __NAME__ + '/main()')
# store in qc_params
qc_params = [qc_names, qc_values, qc_logic, qc_pass]
# ------------------------------------------------------------------
# Save transmission map to file
# ------------------------------------------------------------------
# get raw file name
raw_in_file = os.path.basename(p['FITSFILENAME'])
# copy original keys
hdict = spirouImage.CopyOriginalKeys(loc['DATAHDR'])
# add version number
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_PID'], value=p['PID'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag1)
# set the input files
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBLAZE'],
value=p['BLAZFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBWAVE'],
value=os.path.basename(masterwavefile))
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVESOURCE'],
value=mwsource)
hdict = spirouImage.AddKey1DList(p, hdict, p['KW_INFILE1'],
dim1name='file',
values=p['ARG_FILE_NAMES'])
# add qc parameters
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_QC'], value=p['QC'])
hdict = spirouImage.AddQCKeys(p, hdict, qc_params)
# add wave solution date
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVE_TIME1'],
value=master_acqtimes[0])
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVE_TIME2'],
value=master_acqtimes[1])
# add wave solution number of orders
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVE_ORD_N'],
value=masterwavep.shape[0])
# add wave solution degree of fit
hdict = spirouImage.AddKey(p, hdict, p['KW_WAVE_LL_DEG'],
value=masterwavep.shape[1] - 1)
# add wave solution coefficients
hdict = spirouImage.AddKey2DList(p, hdict, p['KW_WAVE_PARAM'],
values=masterwavep)
# write to file
p = spirouImage.WriteImage(p, outfile, transmission_map, hdict)
# ------------------------------------------------------------------
# Generate the absorption map
# ------------------------------------------------------------------
# set up storage for the absorption
abso = np.array(transmission_map)
# set values less than low threshold to low threshold
# set values higher than high threshold to 1
low, high = p['TELLU_ABSO_LOW_THRES'], p['TELLU_ABSO_HIGH_THRES']
with warnings.catch_warnings(record=True) as w:
abso[abso < low] = low
abso[abso > high] = 1.0
# write to loc
loc['RECON_ABSO'] = abso.reshape(np.product(loc['DATA'].shape))
loc.set_source('RECON_ABSO', main_name)
# ------------------------------------------------------------------
# Get molecular absorption
# ------------------------------------------------------------------
loc = spirouTelluric.CalcMolecularAbsorption(p, loc)
# add molecular absorption to file
for it, molecule in enumerate(p['TELLU_ABSORBERS'][1:]):
# get molecule keyword store and key
molkey = '{0}_{1}'.format(p['KW_TELLU_ABSO'][0], molecule.upper())
# add water col
if molecule == 'h2o':
loc['WATERCOL'] = loc[molkey]
# set source
loc.set_source('WATERCOL', main_name)
# ------------------------------------------------------------------
# Add transmission map to telluDB
# ------------------------------------------------------------------
if p['QC']:
# copy tellu file to the telluDB folder
spirouDB.PutTelluFile(p, outfile)
# update the master tellu DB file with transmission map
targs = [p, outfilename, loc['OBJNAME'], loc['AIRMASS'],
loc['WATERCOL']]
spirouDB.UpdateDatabaseTellMap(*targs)
# ----------------------------------------------------------------------
# Optional Absorption maps
# ----------------------------------------------------------------------
if p['TELLU_ABSO_MAPS']:
# ------------------------------------------------------------------
# Generate the absorption map
# ------------------------------------------------------------------
# get number of files
nfiles = len(p['OUTPUTFILES'])
# set up storage for the absorption
abso = np.zeros([nfiles, np.product(loc['DATA'].shape)])
# loop around outputfiles and add them to abso
for it, filename in enumerate(p['OUTPUTFILES']):
# push data into array
data_it, _, _, _ = spirouImage.ReadImage(p, filename)
abso[it, :] = data_it.reshape(np.product(loc['DATA'].shape))
# set values less than low threshold to low threshold
# set values higher than high threshold to 1
low, high = p['TELLU_ABSO_LOW_THRES'], p['TELLU_ABSO_HIGH_THRES']
abso[abso < low] = low
abso[abso > high] = 1.0
# set values less than TELLU_CUT_BLAZE_NORM threshold to NaN
abso[loc['NBLAZE'] < p['TELLU_CUT_BLAZE_NORM']] = np.nan
# reshape data (back to E2DS)
abso_e2ds = abso.reshape(nfiles, loc['YDIM'], loc['XDIM'])
# get file name
abso_map_file, tag2 = spirouConfig.Constants.TELLU_ABSO_MAP_FILE(p)
# get raw file name
raw_in_file = os.path.basename(p['FITSFILENAME'])
# write the map to file
hdict = spirouImage.CopyOriginalKeys(loc['DATAHDR'])
# add version number
hdict = spirouImage.AddKey(p, hdict, p['KW_VERSION'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DRS_DATE'],
value=p['DRS_DATE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_DATE_NOW'],
value=p['DATE_NOW'])
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag2)
# set the input files
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBBLAZE'],
value=p['BLAZFILE'])
hdict = spirouImage.AddKey(p, hdict, p['KW_CDBWAVE'],
value=loc['WAVEFILE'])
# write to file
p = spirouImage.WriteImage(p, abso_map_file, abso_e2ds, hdict)
# ------------------------------------------------------------------
# Generate the median and normalized absorption maps
# ------------------------------------------------------------------
# copy the absorption cube
abso2 = np.array(abso)
# log the absorption cube
log_abso = np.log(abso)
# get the threshold from p
threshold = p['TELLU_ABSO_SIG_THRESH']
# calculate the abso_med
abso_med = np.nanmedian(log_abso, axis=0)
# sigma clip around the median
for it in range(p['TELLU_ABSO_SIG_N_ITER']):
# recalculate the abso_med
abso_med = np.nanmedian(log_abso, axis=0)
# loop around each file
for jt in range(nfiles):
# get this iterations row
rowvalue = log_abso[jt, :]
# get the mask of those values above threshold
goodpix = (rowvalue > threshold) & (abso_med > threshold)
# apply the mask of good pixels to work out ratio
part1 = np.nansum(rowvalue[goodpix] * abso_med[goodpix])
part2 = np.nansum(abso_med[goodpix] ** 2)
ratio = part1 / part2
# store normalised absol back on to log_abso
log_abso[jt, :] = log_abso[jt, :] / ratio
# unlog log_abso
abso_out = np.exp(log_abso)
# calculate the median of the log_abso
abso_med_out = np.exp(np.nanmedian(log_abso, axis=0))
# reshape the median
abso_map_n = abso_med_out.reshape(loc['DATA'].shape)
# save the median absorption map to file
abso_med_file, tag3 = spirouConfig.Constants.TELLU_ABSO_MEDIAN_FILE(p)
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag3)
p = spirouImage.WriteImage(p, abso_med_file, abso_med_out, hdict)
# save the normalized absorption map to file
abso_map_file, tag4 = spirouConfig.Constants.TELLU_ABSO_NORM_MAP_FILE(p)
hdict = spirouImage.AddKey(p, hdict, p['KW_OUTPUT'], value=tag4)
p = spirouImage.WriteImage(p, abso_map_file, abso_map_n, hdict)
# ------------------------------------------------------------------
# calculate dv statistic
# ------------------------------------------------------------------
# get the order for dv calculation
dvselect = p['TELLU_ABSO_DV_ORDER']
size = p['TELLU_ABSO_DV_SIZE']
threshold2 = p['TELLU_ABSO_DV_GOOD_THRES']
fitdeg = p['TELLU_ABSO_FIT_DEG']
ydim, xdim = loc['DATA'].shape
# get the start and end points of this order
start, end = xdim * dvselect + size, xdim * dvselect - size + xdim
# get the median for selected order
abso_med2 = np.exp(abso_med[start:end])
# get the dv pixels to extract
dvpixels = np.arange(-np.floor(size / 2), np.ceil(size / 2), 1)
# loop around files
for it, filename in enumerate(p['OUTPUTFILES']):
# storage for the extracted abso ratios for this file
cc = np.zeros(size)
# loop around a box of size="size"
for jt, dv in dvpixels:
# get the start and end position
start = xdim * dvselect + size + dv
end = xdim * dvselect + xdim - size + dv
# get the log abso for this iteration
rowvalue = np.exp(log_abso[it, start:end])
# find the good pixels
goodpix = (rowvalue > threshold2) & (abso_med2 > threshold2)
# get the ratio
part1 = np.nansum(rowvalue[goodpix] * abso_med2[goodpix])
part2 = np.nansum(abso_med2[goodpix] ** 2)
cc[jt] = part1 / part2
# fit the ratio across the points
cfit = nanpolyfit(dvpixels, cc, fitdeg)
# work out the dv pix
dvpix = -0.5 * (cfit[1] / cfit[0])
# log stats
wmsg = 'File: "{0}", dv={1}'
WLOG(p, '', wmsg.format(filename, dvpix))
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
# get parameters from configuration files and run time arguments
customargs = spirouStartup.GetCustomFromRuntime(p, [0], [str], ['reffile'])
p = spirouStartup.LoadArguments(p,
night_name,
customargs=customargs,
mainfitsfile='reffile',
mainfitsdir='reduced')
# setup files and get fiber
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set the fiber type
p['FIB_TYP'] = [p['FIBER']]
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read the image data
gfkwargs = dict(path=p['REDUCED_DIR'], filename=p['REFFILE'])
p['REFFILENAME'] = spirouStartup.GetFile(p, **gfkwargs)
p.set_source('REFFILENAME', __NAME__ + '/main()')
# get the fiber type
p['FIBER'] = 'AB'
e2ds, hdr, nx, ny = spirouImage.ReadImage(p)
# Force A and B to AB solution
if p['FIBER'] in ['A', 'B']:
wave_fiber = 'AB'
else:
wave_fiber = p['FIBER']
# get wave image
_, wave, _ = spirouImage.GetWaveSolution(p,
hdr=hdr,
return_wavemap=True,
fiber=wave_fiber)
blaze = spirouImage.ReadBlazeFile(p)
# ----------------------------------------------------------------------
# Get lamp params
# ----------------------------------------------------------------------
# get lamp parameters
p = spirouTHORCA.GetLampParams(p, hdr)
# ----------------------------------------------------------------------
# Get catalogue and fitted line list
# ----------------------------------------------------------------------
# load line file (from p['IC_LL_LINE_FILE'])
ll_line_cat, ampl_line_cat = spirouImage.ReadLineList(p)
# construct fitted lines table filename
wavelltbl = spirouConfig.Constants.WAVE_LINE_FILE(p)
WLOG(p, '', wavelltbl)
# read fitted lines
ll_ord, ll_line_fit, ampl_line_fit = np.genfromtxt(wavelltbl,
skip_header=4,
skip_footer=2,
unpack=True,
usecols=(0, 1, 3))
# ----------------------------------------------------------------------
# Plots
# ----------------------------------------------------------------------
# define line colours
col = ['magenta', 'purple']
# get order parity
ll_ord_par = np.mod(ll_ord, 2)
print(ll_ord_par)
col2 = [col[int(x)] for x in ll_ord_par]
# start interactive plot
sPlt.start_interactive_session(p)
plt.figure()
for order_num in np.arange(nx):
plt.plot(wave[order_num], e2ds[order_num])
# get heights
heights = []
for line in range(len(ll_line_cat)):
heights.append(200000 + np.max([np.min(e2ds), ampl_line_cat[line]]))
# plot ll_line_cat
plt.vlines(ll_line_cat,
0,
heights,
colors='darkgreen',
linestyles='dashed')
# get heights
heights = []
for line in range(len(ll_line_fit)):
heights.append(200000 + np.max([np.min(e2ds), ampl_line_fit[line]]))
# plot ll_line_fit
plt.vlines(ll_line_fit, 0, heights, colors=col2, linestyles='dashdot')
plt.xlabel('Wavelength [nm]')
plt.ylabel('Flux e-')
plt.title(p['REFFILENAME'])
# end interactive session
# sPlt.end_interactive_session()
# old code:
# plt.ion()
# plt.figure()
#
# for order_num in np.arange(nx):
# plt.plot(wave[order_num], e2ds[order_num])
#
# for line in range(len(ll_line_cat)):
# plt.vlines(ll_line_cat[line], 0, 200000 +
# max(np.min(e2ds), ampl_line_cat[line]),
# colors='darkgreen', linestyles='dashed')
#
# for line in range(len(ll_line_fit)):
# plt.vlines(ll_line_fit[line], 0, 200000 +
# max(np.min(e2ds), ampl_line_fit[line]),
# colors='magenta', linestyles='dashdot')
#
# plt.xlabel('Wavelength [nm]')
# plt.ylabel('Flux e-')
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p, outputs=None)
# return a copy of locally defined variables in the memory
return dict(locals())
def main(night_name=None, files=None):
"""
cal_HC_E2DS.py main function, if night_name and files are None uses
arguments from run time i.e.:
cal_DARK_spirou.py [night_directory] [fitsfilename]
:param night_name: string or None, the folder within data raw directory
containing files (also reduced directory) i.e.
/data/raw/20170710 would be "20170710" but
/data/raw/AT5/20180409 would be "AT5/20180409"
:param files: string, list or None, the list of files to use for
arg_file_names and fitsfilename
(if None assumes arg_file_names was set from run time)
:return ll: dictionary, containing all the local variables defined in
main
"""
# ----------------------------------------------------------------------
# Set up
# ----------------------------------------------------------------------
# get parameters from config files/run time args/load paths + calibdb
p = spirouStartup.Begin(recipe=__NAME__)
# get parameters from configuration files and run time arguments
p = spirouStartup.LoadArguments(p,
night_name,
files,
mainfitsdir='reduced')
# setup files and get fiber
p = spirouStartup.InitialFileSetup(p, calibdb=True)
# set the fiber type
p['FIB_TYP'] = [p['FIBER']]
p.set_source('FIB_TYP', __NAME__ + '/main()')
# set find line mode
find_lines_mode = p['HC_FIND_LINES_MODE']
# ----------------------------------------------------------------------
# Read image file
# ----------------------------------------------------------------------
# read and combine all files
p, hcdata, hchdr = spirouImage.ReadImageAndCombine(p, 'add')
# add data and hdr to loc
loc = ParamDict()
loc['HCDATA'], loc['HCHDR'] = hcdata, hchdr
# set the source
sources = ['HCDATA', 'HCHDR']
loc.set_sources(sources, 'spirouImage.ReadImageAndCombine()')
# ----------------------------------------------------------------------
# Get basic parameters
# ----------------------------------------------------------------------
# get sig det value
p = spirouImage.GetSigdet(p, loc['HCHDR'], name='sigdet')
# get exposure time
p = spirouImage.GetExpTime(p, loc['HCHDR'], name='exptime')
# get gain
p = spirouImage.GetGain(p, loc['HCHDR'], name='gain')
# get acquisition time
p = spirouImage.GetAcqTime(p, loc['HCHDR'], name='acqtime', kind='julian')
bjdref = p['ACQTIME']
# set sigdet and conad keywords (sigdet is changed later)
p['KW_CCD_SIGDET'][1] = p['SIGDET']
p['KW_CCD_CONAD'][1] = p['GAIN']
# get lamp parameters
p = spirouTHORCA.GetLampParams(p, loc['HCHDR'])
# ----------------------------------------------------------------------
# Obtain the flat
# ----------------------------------------------------------------------
# get the flat
# p, loc = spirouFLAT.GetFlat(p, loc, hchdr)
# correct the data with the flat
# TODO: Should this be used?
# log
# WLOG(p, '', 'Applying flat correction')
# loc['HCDATA'] = loc['HCDATA']/loc['FLAT']
# ----------------------------------------------------------------------
# Read blaze
# ----------------------------------------------------------------------
# get tilts
loc['BLAZE'] = spirouImage.ReadBlazeFile(p, hchdr)
loc.set_source('BLAZE', __NAME__ + '/main() + /spirouImage.ReadBlazeFile')
# ----------------------------------------------------------------------
# Start plotting session
# ----------------------------------------------------------------------
if p['DRS_PLOT'] > 0:
# start interactive plot
sPlt.start_interactive_session(p)
# ----------------------------------------------------------------------
# loop around fiber type
# ----------------------------------------------------------------------
for fiber in p['FIB_TYP']:
# set fiber type for inside loop
p['FIBER'] = fiber
# ------------------------------------------------------------------
# Wave solution
# ------------------------------------------------------------------
# log message for loop
wmsg = 'Processing Wavelength Calibration for Fiber {0}'
WLOG(p, 'info', wmsg.format(p['FIBER']))
# ------------------------------------------------------------------
# Part 1
# ------------------------------------------------------------------
p, loc = part1(p, loc, mode=find_lines_mode)
# ------------------------------------------------------------------
# Part 2
# ------------------------------------------------------------------
# set params for part2
p['QC_RMS_LITTROW_MAX'] = p['QC_HC_RMS_LITTROW_MAX']
p['QC_DEV_LITTROW_MAX'] = p['QC_HC_DEV_LITTROW_MAX']
# ------------------------------------------------------------------
# run part 2
p, loc = part2(p, loc)
# ----------------------------------------------------------------------
# End plotting session
# ----------------------------------------------------------------------
# end interactive session
if p['DRS_PLOT'] > 0:
sPlt.end_interactive_session(p)
# ----------------------------------------------------------------------
# End Message
# ----------------------------------------------------------------------
p = spirouStartup.End(p)
# return a copy of locally defined variables in the memory
return dict(locals())