Source code for hispecdrp.primitives.spectral_extraction.extract_box

from numba import njit
import numpy as np
from ..utils.array_utils import any_sc
from ...datamodels.dqflags import DQ_FLAGS
import matplotlib.pyplot as plt
from .extraction_utils import get_extraction_window
DO_NOT_USE = DQ_FLAGS['DO_NOT_USE']

[docs] def extract_spectrum_box( input_data : np.ndarray, input_err : np.ndarray, input_dq : np.ndarray, input_var_rnoise : np.ndarray, input_var_poisson : np.ndarray, input_mid_time : np.ndarray, trace_positions : np.ndarray, extraction_aperture : float, pix_range : tuple | None = None, spec_output : np.ndarray = None, err_output : np.ndarray = None, var_rnoise_output : np.ndarray = None, var_poisson_output : np.ndarray = None, dq_output : np.ndarray = None, mid_time_output : np.ndarray = None, orders_are_vertical : bool = True, ) -> dict: """ Box spectral extraction. Parameters ---------- input_data : np.ndarray 2D array of input data. input_err : np.ndarray 2D array of input errors. input_dq : np.ndarray 2D array of input data quality flags. input_var_rnoise : np.ndarray 2D array of input read noise variance. input_var_poisson : np.ndarray 2D array of input Poisson noise variance. input_mid_time : np.ndarray 2D array of input mid times for each pixel. trace_positions : np.ndarray 2D array of y-coordinates for the extraction (order, ypos). extraction_aperture : float Width of the aperture to use for extraction. pix_range : tuple, optional. Range of pixel-coordinates to extract (min, max) in the spectral direction. spec_output : np.ndarray 1D array to store extracted spectrum. err_output : np.ndarray 1D array to store extracted errors. var_rnoise_output : np.ndarray 1D array to store extracted read noise variance. var_poisson_output : np.ndarray 1D array to store extracted Poisson noise variance. dq_output : np.ndarray 1D array to store extracted data quality flags. mid_time_output : np.ndarray 1D array to store extracted mid times. orders_are_vertical : bool Whether the orders are oriented vertically. Returns ------- dict Dictionary containing extracted flux, error, read noise variance for the box extracted spectrum. """ ny, nx = input_data.shape if pix_range is None: if orders_are_vertical: pix_range = (0, ny - 1) npix = ny else: pix_range = (0, nx - 1) npix = nx # Mock / sim L0s may omit optional companion arrays — fill zeros so dtype # access and the numba kernel never see None. data_dtype = np.asarray(input_data).dtype if input_err is None: input_err = np.zeros((ny, nx), dtype=data_dtype) if input_var_rnoise is None: input_var_rnoise = np.zeros((ny, nx), dtype=data_dtype) if input_var_poisson is None: input_var_poisson = np.zeros((ny, nx), dtype=data_dtype) if input_dq is None: input_dq = np.zeros((ny, nx), dtype=np.uint32) if input_mid_time is None: input_mid_time = np.zeros((ny, nx), dtype=np.float64) if spec_output is None: spec_output = np.full(npix, np.nan, dtype=data_dtype) if err_output is None: err_output = np.full(npix, np.nan, dtype=input_err.dtype) if var_rnoise_output is None: var_rnoise_output = np.full(npix, np.nan, dtype=input_var_rnoise.dtype) if var_poisson_output is None: var_poisson_output = np.full(npix, np.nan, dtype=input_var_poisson.dtype) if dq_output is None: dq_output = np.full(npix, 0, dtype=input_dq.dtype) if mid_time_output is None: mid_time_output = np.full(npix, np.nan, dtype=input_mid_time.dtype) _extract_box_numba( input_data=input_data, input_err=input_err, input_dq=input_dq, input_var_rnoise=input_var_rnoise, input_var_poisson=input_var_poisson, input_mid_time=input_mid_time, trace_positions=trace_positions, extraction_aperture=extraction_aperture, pix_range=pix_range, spec_output=spec_output, err_output=err_output, var_rnoise_output=var_rnoise_output, var_poisson_output=var_poisson_output, dq_output=dq_output, mid_time_output=mid_time_output, orders_are_vertical=orders_are_vertical, ) return dict( spec=spec_output, err=err_output, var_rnoise=var_rnoise_output, var_poisson=var_poisson_output, dq=dq_output, mid_time=mid_time_output, )
[docs] @njit(nogil=True, parallel=False, cache=True) def _extract_box_numba( input_data : np.ndarray, input_err : np.ndarray, input_dq : np.ndarray, input_var_rnoise : np.ndarray, input_var_poisson : np.ndarray, input_mid_time : np.ndarray, trace_positions : np.ndarray, extraction_aperture : float, pix_range : tuple, spec_output : np.ndarray, err_output : np.ndarray, var_rnoise_output : np.ndarray, var_poisson_output : np.ndarray, dq_output : np.ndarray, mid_time_output : np.ndarray, orders_are_vertical : bool = True, ): n_cross = input_data.shape[1] if orders_are_vertical else input_data.shape[0] # Loop over spectral bins for x in range(pix_range[0], pix_range[1] + 1): # Get extraction window (clip to detector; non-finite trace → empty window) window_inds, W = get_extraction_window( trace_positions[x], extraction_aperture, n_cross ) if len(window_inds) == 0 or np.sum(W) <= 0.0: spec_output[x] = np.nan err_output[x] = np.nan var_rnoise_output[x] = np.nan var_poisson_output[x] = np.nan dq_output[x] = DO_NOT_USE continue # Slices for this spectral bin if orders_are_vertical: D = input_data[x, window_inds].copy() D_var = input_err[x, window_inds]**2 D_var_poisson = input_var_poisson[x, window_inds].copy() D_var_rnoise = input_var_rnoise[x, window_inds].copy() D_dq = input_dq[x, window_inds] else: D = input_data[window_inds, x].copy() D_var = input_err[window_inds, x]**2 D_var_poisson = input_var_poisson[window_inds, x].copy() D_var_rnoise = input_var_rnoise[window_inds, x].copy() D_dq = input_dq[window_inds, x] # Finite rate with non-finite err: treat variance as 0 and keep the pixel. # Dropping empty aperture-edge pixels (NaN rate_err) and renormalizing # caused large spectral spikes for undersampled PSFs. for i in range(D.size): if np.isfinite(D[i]) and not np.isfinite(D_var[i]): D_var[i] = 0.0 if np.isfinite(D[i]) and not np.isfinite(D_var_poisson[i]): D_var_poisson[i] = 0.0 if np.isfinite(D[i]) and not np.isfinite(D_var_rnoise[i]): D_var_rnoise[i] = 0.0 # Mask bad pixels: DQ DO_NOT_USE and non-finite rate only M = ((D_dq & DO_NOT_USE) == 0) & np.isfinite(D) bad = np.where(~M)[0] n_good = len(M) - len(bad) if n_good == 0: spec_output[x] = np.nan err_output[x] = np.nan var_rnoise_output[x] = np.nan var_poisson_output[x] = np.nan dq_output[x] = DO_NOT_USE continue # Flux that would have been contributed by masked pixels (before zeroing). # If that flux is negligible, skip aperture renormalization so empty / # DQ-only edge pixels do not inflate the spectrum. flux_keep = 0.0 flux_lost = 0.0 w_good = 0.0 w_tot = 0.0 for i in range(D.size): wi = W[i] w_tot += wi di = D[i] if np.isfinite(D[i]) else 0.0 if M[i]: w_good += wi flux_keep += di * wi else: flux_lost += di * wi # Zero bad pixels (M already excludes them). Use 0 not inf for variances: # ``M * inf`` is NaN and would poison the error sum. D[bad] = 0 D_var[bad] = 0 D_var_poisson[bad] = 0 D_var_rnoise[bad] = 0 if w_good <= 0.0: spec_output[x] = np.nan err_output[x] = np.nan var_rnoise_output[x] = np.nan var_poisson_output[x] = np.nan dq_output[x] = DO_NOT_USE continue # Renormalize only when masked pixels carried real flux. scale = max(abs(flux_keep), 1e-30) if abs(flux_lost) > 1e-6 * scale and w_tot > 0.0: N = w_good / w_tot else: N = 1.0 if N == 0: spec_output[x] = np.nan err_output[x] = np.nan var_rnoise_output[x] = np.nan var_poisson_output[x] = np.nan dq_output[x] = DO_NOT_USE continue # Compute raw box extraction sums using full pixels spec_output[x] = np.sum(M * D * W) / N err_output[x] = np.sqrt(np.sum(M * W**2 * D_var)) / N var_rnoise_output[x] = np.sum(M * W**2 * D_var_rnoise) / N**2 var_poisson_output[x] = np.sum(M * W**2 * D_var_poisson) / N**2 dq_output[x] = 0 # Mid times mid_time_output[x] = np.sum(M * W * input_mid_time[x, window_inds]) / np.sum(M * W)