Source code for hispecdrp.primitives.wavesol.drift_correction_primitive

from ..base_primitive import BasePrimitive
from ... import datamodels
from ..utils.spectral_utils import delta_pix_to_delta_wave, delta_wave_to_delta_vel
from ..utils.stats import robust_stats, weighted_quantile
from ...calibrations import ReferenceEtalonSelector
import logging

from koa_middleware import CalibrationStore

import numpy as np
import scipy.constants

logger = logging.getLogger(__name__)

__all__ = ['CalculateEtalonDriftCorrectionPrimitive', 'ApplyDriftCorrectionPrimitive']

[docs] class CalculateEtalonDriftCorrectionPrimitive(BasePrimitive): """ Determines the per-etalon-peak drift by matching each etalon peak based on a proximity threshold in wavelength space. **For now, a per-order drift is calculated** as the weighted average of the drifts measured in detector pixels. The drift is then converted to effective drifts in wavelength and velocity units according to the local dispersion. Corrects the wavelength drifts. Currently only the Fabry-Pérot etalons are used to measure and correct for any drifts. Drifts are also currently calculated on a per-order basis which is subject to change as the instrument is characterized. *Calculation and applying the WLS are separate primitives while other WLS sources are under development.* Parameters ---------- input Level 1 or 2 data product. suffix : str, optional Suffix for the output data product. Default is 'driftcalc'. do_fibers : Sequence[str], optional List of fibers to perform drift correction for. If None, all fibers will be used. do_orders : Sequence[int], optional List of orders to perform drift correction for. If None, all orders will be used. Calibrations ------------ ref_etalon : ReferenceEtalonModel - selector: :class:`~hispecdrp.calibrations.selectors.ReferenceEtalonSelector` """ # PARAMETERS = { 'suffix' : 'driftcalc', 'do_fibers' : None, 'do_orders' : None, } CALIBRATIONS = { 'ref_etalon' : { 'selector' : ReferenceEtalonSelector, 'selector_kwargs' : {} }, } def _perform(self): input_model = datamodels.open(self.dataset) ref_model, _ = self.get_calibration(input_model, 'ref_etalon') ref_model = datamodels.open(ref_model) output_model = self.get_output_model(input_model) # Get fibers and orders do_fibers, do_orders = self.get_do_traces(input_model, self.do_fibers, self.do_orders) drift_results = {fiber : [] for fiber in do_fibers} for fiber in do_fibers: wave = getattr(input_model, f'wave_fib{fiber}') xarr = np.arange(wave.shape[1]) params_table = getattr(input_model, f'etalon_fitparams_fib{fiber}') params_table_ref = getattr(ref_model, f'etalon_fitparams_fib{fiber}') line_centers = params_table['MU_PIX'] line_centers_ref = params_table_ref['MU_PIX'] line_center_errs = params_table['MU_ERR_PIX'] line_center_errs_ref = params_table_ref['MU_ERR_PIX'] drift_table = getattr(output_model, f'drift_fib{fiber}') for order in do_orders: order_mask = params_table['ORDER'] == order order_mask_ref = params_table_ref['ORDER'] == order lcs = line_centers[order_mask] lcs_ref = line_centers_ref[order_mask_ref] lcs_err = line_center_errs[order_mask] lcs_ref_err = line_center_errs_ref[order_mask_ref] if len(lcs) == 0 or len(lcs_ref) == 0: logger.info(f'No etalon lines found for {order=}, {fiber=}. Skipping.') continue drifts = calculate_etalon_drifts_pix(lcs, lcs_err, lcs_ref, lcs_ref_err) n_lines = len(drifts) for i in range(n_lines): r = { 'PIXEL' : drifts[i]['PIXEL'], 'ORDER' : order, 'DRIFT_PIX' : drifts[i]['DRIFT'], 'DRIFT_ERR_PIX' : drifts[i]['DRIFT_ERR'] } # Relative order index oi = np.abs(order - input_model.meta.order_start) r['WAVE'] = np.interp(r['PIXEL'], xarr, wave[oi, :], left=wave[oi, 0], right=wave[oi, -1]) r['DRIFT_WAVE'] = delta_pix_to_delta_wave(r['DRIFT_PIX'], r['PIXEL'], wave[oi, :]) r['DRIFT_ERR_WAVE'] = delta_pix_to_delta_wave(r['DRIFT_ERR_PIX'], r['PIXEL'], wave[oi, :]) r['DRIFT_VEL'] = delta_wave_to_delta_vel(r['DRIFT_WAVE'], r['WAVE']) r['DRIFT_ERR_VEL'] = delta_wave_to_delta_vel(r['DRIFT_ERR_WAVE'], r['WAVE']) drift_results[fiber].append(r) # Calculate per order drifts from distribution drifts_pix = np.array([d['DRIFT_PIX'] for d in drift_results[fiber] if d['ORDER'] == order]) drift_err_pix = np.array([d['DRIFT_ERR_PIX'] for d in drift_results[fiber] if d['ORDER'] == order]) w = 1 / drift_err_pix**2 good = np.isfinite(w) & (w > 0) if np.count_nonzero(good) > 0: drifts_pix = drifts_pix[good] w = w[good] drift_pix_order, drift_order_err, drift_mask = robust_stats(drifts_pix, w=w) drift_order_err /= np.sqrt(np.count_nonzero(good) - 1) pixels = np.array([d['PIXEL'] for d in drift_results[fiber] if d['ORDER'] == order]) pix_eff = weighted_quantile(pixels[drift_mask], w=w[drift_mask]) wave_eff = np.interp(pix_eff, xarr, wave[oi, :], left=wave[oi, 0], right=wave[oi, -1]) else: drift_pix_order, drift_order_err = np.nan, np.nan pix_eff = np.nan wave_eff = np.nan # Update drift table with per order drift drift_wave_order = delta_pix_to_delta_wave(drift_pix_order, pix_eff, wave[oi, :]) drift_err_wave_order = delta_pix_to_delta_wave(drift_order_err, pix_eff, wave[oi, :]) drift_vel_order = delta_wave_to_delta_vel(drift_wave_order, wave_eff) drift_err_vel_order = delta_wave_to_delta_vel(drift_err_wave_order, wave_eff) drift_table.add_row({ 'PIXEL' : pix_eff, 'ORDER' : order, 'WAVE' : wave_eff, 'DRIFT_PIX' : drift_pix_order, 'DRIFT_ERR_PIX' : drift_order_err, 'DRIFT_WAVE' : drift_wave_order, 'DRIFT_ERR_WAVE' : drift_err_wave_order, 'DRIFT_VEL' : drift_vel_order, 'DRIFT_ERR_VEL' : drift_err_vel_order, }) drift_table.sort(['ORDER', 'PIXEL']) return dict(output=output_model, drift_results=drift_results)
[docs] class ApplyDriftCorrectionPrimitive(BasePrimitive): """ Applies the calculated drift corrections to the input data's wavelength grid as a classical Doppler shift. Parameters ---------- input Level 1 or 2 data product. suffix : str, optional Suffix for the output data product. Default is 'driftcorr'. fiber_reference_map : dict[str, str] A mapping of fiber numbers to their reference fibers. *Example to apply drift from fiber 1 to fibers 1-3.:* >>> fiber_reference_map = { '1' : '1', '2' : '1', '3' : '1' } do_orders : Sequence[int], optional List of orders to perform drift correction for. If None, all orders will be used. """ PARAMETERS = { 'suffix' : 'driftcorr', 'fiber_reference_map' : None, 'do_orders' : None, } def _perform(self): input_model = datamodels.open(self.dataset) # Get fibers and orders _, do_orders = self.get_do_traces(input_model, None, self.do_orders) for fiber, ref_fiber in self.fiber_reference_map.items(): wave = getattr(input_model, f'wave_fib{fiber}') for order in do_orders: drift_table = getattr(input_model, f'drift_fib{ref_fiber}') k = np.where(drift_table['ORDER'] == order)[0] if len(k) == 0: logger.warning(f'No drift correction found for {fiber=} {order=}. Skipping.') continue k = k[0] drift_vel = drift_table['DRIFT_VEL'][k] oi = np.abs(order - input_model.meta.order_start) wave[oi, :] *= (1 - drift_vel / scipy.constants.c) # NOTE: For line_pos_new - line_pos_ref return dict(output=input_model)
def calculate_drifts_from_line_centers( line_centers : np.ndarray, line_centers_err : np.ndarray, line_centers_ref : np.ndarray, line_centers_ref_err : np.ndarray, max_sep : float = 1 ) -> list[dict[str, float]]: drifts = [] for i_ref in range(len(line_centers_ref)): lc_ref = line_centers_ref[i_ref] lc_ref_err = line_centers_ref_err[i_ref] diffs = line_centers - lc_ref k = np.argmin(np.abs(diffs)) if abs(diffs[k]) < max_sep: lc = line_centers[k] lc_err = line_centers_err[k] drift = lc - lc_ref drift_err = np.sqrt(lc_err**2 + lc_ref_err**2) drifts.append({ 'MU_REF': lc_ref, 'MU': lc, 'DRIFT': drift, 'DRIFT_ERR': drift_err }) else: drifts.append({ 'MU_REF': lc_ref, 'MU': np.nan, 'DRIFT': np.nan, 'DRIFT_ERR': np.nan }) return drifts