Source code for hispecdrp.primitives.dark_subtraction.dark_primitive

from ..base_primitive import BasePrimitive
from ...calibrations import DarkSelector
from ... import datamodels
import numpy as np
from numba import njit, prange
from ...utils.parallelization_utils import numba_thread_scope
import logging

logger = logging.getLogger(__name__)

__all__ = ['DarkSubtractionPrimitive', 'dark_subtraction_rate']


[docs] class DarkSubtractionPrimitive(BasePrimitive): """ Subtract the dark current from the input data. This primitive applies the appropriate dark calibration to the input data product. The dark frame is subtracted from the science data, the associated uncertainties are propagated by adding errors in quadrature, and data quality (DQ) flags are combined using a bitwise OR. Parameters ---------- dataset : str or L0Model Input file path or data model to process. Currently, this is expected to be a level 0 (rate map) data product. suffix : str or None, optional Suffix to append to the output filename. Default is ``'darksub'``. max_cores : int, optional Maximum number of CPU cores to use for Numba parallel processing. Default is 1. Calibrations ------------ dark : DarkModel - selector: :class:`~hispecdrp.calibrations.selectors.DarkSelector` Returns ------- output The dark-subtracted data model with updated error and data quality arrays. """ PARAMETERS = { 'suffix' : 'darksub', } CALIBRATIONS = { 'dark': { 'selector': DarkSelector, 'selector_kwargs': {} } } def _perform(self): # Load the input model input_model = datamodels.open(self.dataset) # Get the dark model dark, _ = self.get_calibration(input_model, 'dark') dark_model = datamodels.open(dark) # Output result = self.get_output_model(input_model) # Log logger.info(f"Applying dark correction with {dark_model} to {input_model}") # Perform dark subtraction max_cores = self.max_cores or 1 dark_subtraction_rate( result.rate, result.rate_err, result.dq, dark_model.rate, dark_model.rate_err, dark_model.dq, max_cores=max_cores ) # Output return dict(output=result, dark=dark)
[docs] def dark_subtraction_rate( input_rate: np.ndarray, input_err: np.ndarray, input_dq: np.ndarray, dark_rate: np.ndarray, dark_err: np.ndarray, dark_dq: np.ndarray, max_cores : int = 1 ): """ Subtract the dark current rate from the input rate. Input and dark rates are DN/s. The error arrays are added in quadrature. The data quality arrays are combined with a bitwise OR. The corrections are done in-place. Dark should be corrected before gain correction. Parameters ---------- input_rate : np.ndarray 2D array of rate values (DN/s) input_err : np.ndarray 2D array of error values (DN/s) input_dq : np.ndarray 2D array of data quality flags dark_rate : np.ndarray 2D array of dark rate values (DN/s) dark_err : np.ndarray 2D array of dark error values (DN/s) dark_dq : np.ndarray 2D array of dark data quality flags max_cores : int Maximum number of CPU cores to use for parallel processing. Returns ------- input_rate : np.ndarray Dark-subtracted rate array (modified in place) input_err : np.ndarray Updated error array (modified in place) input_dq : np.ndarray Updated data quality array (modified in place) """ with numba_thread_scope(max_cores): _dark_subtraction_rate_numba( input_rate, input_err, input_dq, dark_rate, dark_err, dark_dq ) return input_rate, input_err, input_dq
@njit(nogil=True, parallel=True, cache=True) def _dark_subtraction_rate_numba( input_rate : np.ndarray, input_err : np.ndarray, input_dq : np.ndarray, dark_rate : np.ndarray, dark_err : np.ndarray, dark_dq : np.ndarray ): ny, nx = input_rate.shape for j in prange(ny): for i in range(nx): # Subtract dark rate input_rate[j, i] = input_rate[j, i] - dark_rate[j, i] # Propagate error input_err[j, i] = np.sqrt(input_err[j, i] * input_err[j, i] + dark_err[j, i] * dark_err[j, i]) # Propagate DQ input_dq[j, i] |= dark_dq[j, i]