dkist-processing-cryonirsp 0.0.78__tar.gz → 0.0.80__tar.gz

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/CHANGELOG.rst

@@ -1,3 +1,31 @@
+v0.0.80 (2024-08-15)
+====================
+
+Bugfixes
+--------
+
+- Use arm-specific Parsing tasks from v0.0.78 in local trial (AKA GROGU) workflows as well. (`#143 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/143>`__)
+- Re-activate `CryonirspL0QualityMetrics` task in "l0_to_l1" local trial workflow. (`#143 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/143>`__)
+- Correctly load a saved SP Dispersion Axis calibration when running local trial workflows. (`#143 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/143>`__)
+- Move to version 4.6.0 of `dkist-fits-specifications` to correct allowed values of the TTBLTRCK header keyword.
+
+
+
+Misc
+----
+
+- Make private methods public where documentation needs to be generated. (`#144 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/144>`__)
+
+
+v0.0.79 (2024-08-12)
+====================
+
+Misc
+----
+
+- Move to version 4.5.0 of `dkist-fits-specifications` which includes `PV1_nA` keys for non linear dispersion.
+
+
 v0.0.78 (2024-08-09)
 ====================
 

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dkist_processing_cryonirsp
-Version: 0.0.78
+Version: 0.0.80
 Summary: Science processing code for the Cryo-NIRSP instrument on DKIST
 Home-page: https://bitbucket.org/dkistdc/dkist_processing_cryonirsp/src/main/
 Author: NSO / AURA

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/dkist_processing_cryonirsp/tasks/assemble_movie.py

@@ -33,7 +33,7 @@ class AssembleCryonirspMovieBase(AssembleMovie):
 
     MPL_COLOR_MAP = "gray"
 
-    def _compute_frame_shape(self) -> tuple[int, int]:
+    def compute_frame_shape(self) -> tuple[int, int]:
         """Dynamically set the dimensions of the movie based on L1 file shape."""
         movie_frame_arrays = self.read(
             tags=[CryonirspTag.movie_frame()], decoder=fits_array_decoder
@@ -56,7 +56,7 @@ class AssembleCryonirspMovieBase(AssembleMovie):
     def pre_run(self) -> None:
         """Set the movie frame shape prior to running."""
         super().pre_run()
-        frame_shape = self._compute_frame_shape()
+        frame_shape = self.compute_frame_shape()
         logger.info(f"Setting movie shape to {frame_shape}")
         self.MOVIE_FRAME_SHAPE = frame_shape
 
@@ -107,7 +107,7 @@ class AssembleCryonirspMovieBase(AssembleMovie):
         if self.constants.correct_for_polarization:
             self.write_line(draw=draw, text="Stokes-I", line=4, column="right", font=self.font_36)
 
-    def _get_middle_line(self, draw: ImageDraw, text: str, font: FreeTypeFont) -> int:
+    def get_middle_line(self, draw: ImageDraw, text: str, font: FreeTypeFont) -> int:
         """
         Get the line number for the middle of the frame.
 

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/dkist_processing_cryonirsp/tasks/bad_pixel_map.py

@@ -45,7 +45,7 @@ class BadPixelMapCalibration(CryonirspTaskBase):
 
         """
         with self.apm_task_step(f"Compute average uncorrected solar gain image"):
-            average_solar_gain_array = self._compute_average_gain_array()
+            average_solar_gain_array = self.compute_average_gain_array()
 
         with self.apm_task_step(f"Compute the bad pixel map"):
             with self.apm_processing_step("Smooth array with median filter"):
@@ -72,7 +72,7 @@ class BadPixelMapCalibration(CryonirspTaskBase):
                 bad_pixel_map, task=CryonirspTaskName.bad_pixel_map.value
             )
 
-    def _compute_average_gain_array(self) -> np.ndarray:
+    def compute_average_gain_array(self) -> np.ndarray:
         """
         Compute an average of uncorrected solar gain arrays.
 

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/dkist_processing_cryonirsp/tasks/beam_boundaries_base.py

@@ -87,7 +87,7 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
         """
         # Step 1:
         with self.apm_processing_step(f"Compute average solar gain image"):
-            average_solar_gain_array = self._compute_average_gain_array()
+            average_solar_gain_array = self.compute_average_gain_array()
 
         # Step 2:
         with self.apm_task_step(f"Retrieve bad pixel map"):
@@ -98,30 +98,30 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
 
         # Step 3
         with self.apm_processing_step(f"Smooth the array to get good segmentation"):
-            smoothed_solar_gain_array = self._smooth_gain_array(corrected_solar_gain_array)
+            smoothed_solar_gain_array = self.smooth_gain_array(corrected_solar_gain_array)
 
         # Step 4
         with self.apm_processing_step(f"Split the beam horizontally"):
-            split_beams = self._split_beams(smoothed_solar_gain_array)
+            split_beams = self.split_beams(smoothed_solar_gain_array)
 
         # Step 5
         with self.apm_processing_step(
             f"Segment the beams into illuminated and non-illuminated pixels"
         ):
-            segmented_beams = self._segment_arrays(split_beams)
+            segmented_beams = self.segment_arrays(split_beams)
 
         # Step 6:
         with self.apm_processing_step(
             f"Compute the inscribed rectangular extents of the illuminated portions of the sensor"
         ):
-            illuminated_boundaries = self._compute_boundaries_of_beam_illumination_regions(
+            illuminated_boundaries = self.compute_boundaries_of_beam_illumination_regions(
                 segmented_beams
             )
 
         # Steps 7 - 9:
         with self.apm_processing_step(f"Compute the boundaries of the illuminated beams"):
             split_beams_float = [split_beam.astype(float) for split_beam in split_beams]
-            boundaries = self._compute_final_beam_boundaries(
+            boundaries = self.compute_final_beam_boundaries(
                 split_beams_float, illuminated_boundaries
             )
 
@@ -134,7 +134,7 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
                     beam=beam,
                 )
 
-    def _compute_average_gain_array(self) -> np.ndarray:
+    def compute_average_gain_array(self) -> np.ndarray:
         """
         Compute an average of uncorrected solar gain arrays.
 
@@ -158,7 +158,7 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
         averaged_gain_data = average_numpy_arrays(lin_corr_gain_arrays)
         return averaged_gain_data
 
-    def _smooth_gain_array(self, array: np.ndarray) -> np.ndarray:
+    def smooth_gain_array(self, array: np.ndarray) -> np.ndarray:
         """
         Smooth the input array with morphological filtering using a disk shape.
 
@@ -181,7 +181,7 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
         return norm_gain
 
     @abstractmethod
-    def _split_beams(self, input_array: np.ndarray) -> list[np.ndarray]:
+    def split_beams(self, input_array: np.ndarray) -> list[np.ndarray]:
         """
         Split the beams along the horizontal axis.
 
@@ -201,7 +201,7 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
         pass
 
     @staticmethod
-    def _segment_arrays(arrays: list[np.ndarray]) -> list[np.ndarray]:
+    def segment_arrays(arrays: list[np.ndarray]) -> list[np.ndarray]:
         """
         Segment the arrays into illuminated (True) and non-illuminated (False) regions.
 
@@ -222,7 +222,7 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
             segmented_arrays.append((beam_array > thresh).astype(bool))
         return segmented_arrays
 
-    def _compute_boundaries_of_beam_illumination_regions(
+    def compute_boundaries_of_beam_illumination_regions(
         self, arrays: list[np.ndarray]
     ) -> list[BeamBoundary]:
         """
@@ -257,7 +257,7 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
         return boundaries
 
     @abstractmethod
-    def _compute_final_beam_boundaries(
+    def compute_final_beam_boundaries(
         self,
         smoothed_solar_gain_arrays: list[np.ndarray],
         illuminated_boundaries: list[BeamBoundary],

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/dkist_processing_cryonirsp/tasks/ci_beam_boundaries.py

@@ -12,7 +12,7 @@ __all__ = ["CIBeamBoundariesCalibration"]
 class CIBeamBoundariesCalibration(BeamBoundariesCalibrationBase):
     """Task class for calculation of the CI beam boundaries for later use during calibration."""
 
-    def _split_beams(self, array: np.ndarray) -> list[np.ndarray]:
+    def split_beams(self, array: np.ndarray) -> list[np.ndarray]:
         """
         Return the input array, as there is no beam split for CI.
 
@@ -31,7 +31,7 @@ class CIBeamBoundariesCalibration(BeamBoundariesCalibrationBase):
         """
         return [array]
 
-    def _compute_final_beam_boundaries(
+    def compute_final_beam_boundaries(
         self, smoothed_solar_gain_array: np.ndarray, illuminated_boundaries: list[BeamBoundary]
     ):
         """

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/dkist_processing_cryonirsp/tasks/ci_science.py

@@ -84,7 +84,7 @@ class CIScienceCalibration(ScienceCalibrationBase):
             calibrations=calibrations,
         )
 
-        intermediate_object = self._wrap_array_and_header_in_fits_access(
+        intermediate_object = self.wrap_array_and_header_in_fits_access(
             intermediate_array, intermediate_header
         )
 
@@ -118,11 +118,11 @@ class CIScienceCalibration(ScienceCalibrationBase):
             exposure_conditions=exposure_conditions,
             calibrations=calibrations,
         )
-        intermediate_header = self._compute_date_keys(intermediate_header)
+        intermediate_header = self.compute_date_keys(intermediate_header)
 
-        intermediate_array = self._add_stokes_dimension_to_intensity_only_array(intermediate_array)
+        intermediate_array = self.add_stokes_dimension_to_intensity_only_array(intermediate_array)
 
-        calibrated_object = self._wrap_array_and_header_in_fits_access(
+        calibrated_object = self.wrap_array_and_header_in_fits_access(
             intermediate_array, intermediate_header
         )
 

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/dkist_processing_cryonirsp/tasks/instrument_polarization.py

@@ -245,7 +245,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
             gain_corrected_array = next(divide_arrays_by_array(dark_corrected_array, gain_array))
 
         with self.apm_processing_step(f"Extract macro pixels from {apm_str}"):
-            self._set_original_beam_size(gain_corrected_array)
+            self.set_original_beam_size(gain_corrected_array)
             output_shape = (
                 self.parameters.polcal_num_spatial_bins,
                 self.parameters.polcal_num_spectral_bins,
@@ -304,14 +304,14 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
 
         target_shape = self.single_beam_shape + demod_shape
         logger.info(f"Target full-frame demodulation shape: {target_shape}")
-        return self._resize_polcal_array(demod_matrices, target_shape)
+        return self.resize_polcal_array(demod_matrices, target_shape)
 
-    def _set_original_beam_size(self, array: np.ndarray) -> None:
+    def set_original_beam_size(self, array: np.ndarray) -> None:
         """Record the shape of a single beam as a class property."""
         self.single_beam_shape = array.shape
 
     @staticmethod
-    def _resize_polcal_array(array: np.ndarray, output_shape: tuple[int, ...]) -> np.ndarray:
+    def resize_polcal_array(array: np.ndarray, output_shape: tuple[int, ...]) -> np.ndarray:
         return next(resize_arrays(array, output_shape))
 
     def generate_polcal_dark_calibration(

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/dkist_processing_cryonirsp/tasks/linearity_correction.py

@@ -44,28 +44,28 @@ class LinearityCorrection(CryonirspTaskBase):
     record_provenance = True
 
     def run(self):
-        """Run method for this task.
+        """
+        Run method for this task.
 
         Steps to be performed:
-            - Iterate through frames by ramp set (identified by date-obs)
-                - Identify the frames in the ramp set and populate the ramp set data structure
-                - Perform linearity correction on the ramp set, minimizing the memory footprint
-                  based on a maximum memory limit for the ramp set
-                - Collate tags for linearity corrected frame(s)
-                - Write linearity corrected frame with updated tags
+        - Iterate through frames by ramp set (identified by date-obs)
+        - Identify the frames in the ramp set and populate the ramp set data structure
+        - Perform linearity correction on the ramp set, minimizing the memory footprint based on a maximum memory limit for the ramp set
+        - Collate tags for linearity corrected frame(s)
+        - Write linearity corrected frame with updated tags
 
         Returns
         -------
         None
         """
         num_ramp_sets = len(self.constants.time_obs_list)
-        for ramp_set in self._identify_ramp_sets():
+        for ramp_set in self.identify_ramp_sets():
             time_obs = ramp_set.time_obs
             ramp_set_num = ramp_set.current_ramp_set_num
             logger.info(
                 f"Processing frames from {time_obs}: ramp set {ramp_set_num} of {num_ramp_sets}"
             )
-            output_array = self._reduce_ramp_set(
+            output_array = self.reduce_ramp_set(
                 ramp_set=ramp_set,
                 mode="LookUpTable",
                 camera_readout_mode=self.constants.camera_readout_mode,
@@ -73,11 +73,11 @@ class LinearityCorrection(CryonirspTaskBase):
                 thresholds=self.parameters.linearization_thresholds,
             )
             # Normalize by the exposure time and correct for the Optical Density filter
-            exposure_corrected_output_array = self._apply_exposure_corrections(
+            exposure_corrected_output_array = self.apply_exposure_corrections(
                 output_array, ramp_set
             )
             # Get the tags for the linearized output frame
-            tags = self._generate_output_tag_set(
+            tags = self.generate_output_tag_set(
                 ramp_set.last_frame_name, ramp_set.frames_to_process[-1]
             )
             # The last frame in the ramp is used for the header
@@ -88,7 +88,7 @@ class LinearityCorrection(CryonirspTaskBase):
                 encoder=fits_array_encoder,
             )
 
-    def _identify_ramp_sets(self) -> Generator[_RampSet, None, None]:
+    def identify_ramp_sets(self) -> Generator[_RampSet, None, None]:
         """
         Identify all the ramp sets present in the input data.
 
@@ -109,14 +109,14 @@ class LinearityCorrection(CryonirspTaskBase):
         Generator which yields _RampSet instances
         """
         for ramp_set_num, time_obs in enumerate(self.constants.time_obs_list):
-            ramp_set = self._populate_ramp_set(time_obs, ramp_set_num)
+            ramp_set = self.populate_ramp_set(time_obs, ramp_set_num)
             if ramp_set.is_valid:
                 yield ramp_set
             else:
                 logger.info(f"Ramp set for {time_obs=} skipped.")
 
     @staticmethod
-    def _tag_list_for_single_ramp_frame(time_obs: str, frame_num: int) -> list[CryonirspTag]:
+    def tag_list_for_single_ramp_frame(time_obs: str, frame_num: int) -> list[CryonirspTag]:
         """Return the tag list required to identify a single ramp frame."""
         tags = [
             CryonirspTag.input(),
@@ -126,7 +126,7 @@ class LinearityCorrection(CryonirspTaskBase):
         ]
         return tags
 
-    def _read_single_ramp_frame(self, time_obs: str, frame_num: int) -> CryonirspRampFitsAccess:
+    def read_single_ramp_frame(self, time_obs: str, frame_num: int) -> CryonirspRampFitsAccess:
         """
         Read a single file from a single ramp set based on the observe time and frame number.
 
@@ -143,7 +143,7 @@ class LinearityCorrection(CryonirspTaskBase):
         A CryonirspRampFitsAccess object containing the desired frame
 
         """
-        tags = self._tag_list_for_single_ramp_frame(time_obs, frame_num)
+        tags = self.tag_list_for_single_ramp_frame(time_obs, frame_num)
         fits_obj_list = list(
             self.read(
                 tags=tags,
@@ -156,7 +156,7 @@ class LinearityCorrection(CryonirspTaskBase):
         fits_obj = fits_obj_list[0]
         return fits_obj
 
-    def _get_ordered_exposure_time_list(self, time_obs: str, num_frames_in_ramp: int) -> np.ndarray:
+    def get_ordered_exposure_time_list(self, time_obs: str, num_frames_in_ramp: int) -> np.ndarray:
         """
         Return a list of exposure times for this ramp, ordered by frame in ramp.
 
@@ -177,11 +177,11 @@ class LinearityCorrection(CryonirspTaskBase):
         """
         exp_time_list = []
         for frame_num in range(1, num_frames_in_ramp + 1):
-            fits_obj = self._read_single_ramp_frame(time_obs, frame_num)
+            fits_obj = self.read_single_ramp_frame(time_obs, frame_num)
             exp_time_list.append(fits_obj.fpa_exposure_time_ms)
         return np.array(exp_time_list, dtype=np.float32)
 
-    def _populate_ramp_set(self, time_obs: str, idx: int) -> _RampSet | None:
+    def populate_ramp_set(self, time_obs: str, idx: int) -> _RampSet | None:
         """
         Populate a _RampSet dataclass for the ramp identified by time_obs.
 
@@ -199,8 +199,8 @@ class LinearityCorrection(CryonirspTaskBase):
         The last frame in the set is read to access the shape of the data frame.
         """
         actual_num_frames_in_ramp = self.count(CryonirspTag.time_obs(time_obs))
-        exp_times = self._get_ordered_exposure_time_list(time_obs, actual_num_frames_in_ramp)
-        last_frame = self._read_single_ramp_frame(time_obs, actual_num_frames_in_ramp)
+        exp_times = self.get_ordered_exposure_time_list(time_obs, actual_num_frames_in_ramp)
+        last_frame = self.read_single_ramp_frame(time_obs, actual_num_frames_in_ramp)
         expected_num_frames_in_ramp = last_frame.num_frames_in_ramp
         ramp_set_num = idx + 1
         # The default list of curr_frame_in_ramp tag numbers to use, which may be altered later on
@@ -220,7 +220,7 @@ class LinearityCorrection(CryonirspTaskBase):
         )
         return ramp_set
 
-    def _generate_output_tag_set(self, frame_name: str, curr_frame_in_ramp: int) -> list[str]:
+    def generate_output_tag_set(self, frame_name: str, curr_frame_in_ramp: int) -> list[str]:
         """
         Use one of the input frames to derive the proper list of output tags.
 
@@ -239,9 +239,7 @@ class LinearityCorrection(CryonirspTaskBase):
         result_tags.append(CryonirspTag.linearized())
         return result_tags
 
-    def _apply_exposure_corrections(
-        self, input_array: np.ndarray, ramp_set: _RampSet
-    ) -> np.ndarray:
+    def apply_exposure_corrections(self, input_array: np.ndarray, ramp_set: _RampSet) -> np.ndarray:
         """
         Normalize the array by converting to counts per second and correcting for Optical Density filter attenuation.
 
@@ -267,7 +265,7 @@ class LinearityCorrection(CryonirspTaskBase):
         od_filter_attenuation = 10**log_od_filter_attenuation
         return exposure_normalized_array / od_filter_attenuation
 
-    def _reduce_ramp_set(
+    def reduce_ramp_set(
         self,
         ramp_set: _RampSet,
         mode: str = None,
@@ -278,7 +276,6 @@ class LinearityCorrection(CryonirspTaskBase):
         """
         Process a single ramp from a set of input frames.
 
-        mode:
         Parameters
         ----------
         ramp_set
@@ -318,7 +315,7 @@ class LinearityCorrection(CryonirspTaskBase):
         ]
 
         if mode == "LookUpTable" and camera_readout_mode == "FastUpTheRamp":
-            return self._reduce_ramp_set_for_lookup_table_and_fast_up_the_ramp(
+            return self.reduce_ramp_set_for_lookup_table_and_fast_up_the_ramp(
                 ramp_set=ramp_set,
                 lin_curve=lin_curve,
                 thresholds=thresh_roi,
@@ -327,7 +324,7 @@ class LinearityCorrection(CryonirspTaskBase):
             f"Linearization mode {mode} and camera readout mode {camera_readout_mode} is currently not supported."
         )
 
-    def _reduce_ramp_set_for_lookup_table_and_fast_up_the_ramp(
+    def reduce_ramp_set_for_lookup_table_and_fast_up_the_ramp(
         self,
         ramp_set: _RampSet,
         lin_curve: np.ndarray,
@@ -339,14 +336,14 @@ class LinearityCorrection(CryonirspTaskBase):
         ramp_set.frames_to_process = ramp_set.frames_to_process[1:]
         ramp_set.exposure_times_ms = ramp_set.exposure_times_ms[1:]
         ramp_set.index_offset_to_first_frame += 1
-        processed_frame = self._linearize_fast_up_the_ramp_with_lookup_table(
+        processed_frame = self.linearize_fast_up_the_ramp_with_lookup_table(
             ramp_set=ramp_set,
             lin_curve=lin_curve,
             thresholds=thresholds,
         )
         return processed_frame
 
-    def _linearize_fast_up_the_ramp_with_lookup_table(
+    def linearize_fast_up_the_ramp_with_lookup_table(
         self,
         ramp_set: _RampSet,
         lin_curve: np.ndarray,
@@ -382,7 +379,7 @@ class LinearityCorrection(CryonirspTaskBase):
         frame_shape = ramp_set.frame_shape
         linearized_frame = np.zeros(np.prod(frame_shape), dtype=np.float32)
         num_frame_size_elements = int(np.prod(frame_shape))
-        chunk_size_nelem = self._compute_linear_chunk_size(
+        chunk_size_nelem = self.compute_linear_chunk_size(
             num_frame_size_elements, ramp_set.num_frames_in_ramp
         )
         # num_chunks = num full chunks + a single partial chunk, if needed
@@ -400,10 +397,10 @@ class LinearityCorrection(CryonirspTaskBase):
             logger.info(f"Processing chunk {chunk} of {num_chunks}")
             current_chunk_size_nelem = min(chunk_size_nelem, elements_remaining)
             current_slice = slice(offset, offset + current_chunk_size_nelem)
-            chunk_stack = self._load_chunk_stack(
+            chunk_stack = self.load_chunk_stack(
                 ramp_set, current_chunk_size_nelem, ramp_set.num_frames_in_ramp, current_slice
             )
-            linearized_frame[current_slice] = self._linearize_chunk(
+            linearized_frame[current_slice] = self.linearize_chunk(
                 chunk_stack,
                 lin_curve,
                 thresholds_flattened[current_slice],
@@ -414,7 +411,7 @@ class LinearityCorrection(CryonirspTaskBase):
 
         return linearized_frame.reshape(frame_shape)
 
-    def _load_chunk_stack(
+    def load_chunk_stack(
         self,
         ramp_set: _RampSet,
         current_chunk_size: int,
@@ -448,12 +445,12 @@ class LinearityCorrection(CryonirspTaskBase):
         """
         chunk_stack = np.zeros((current_chunk_size, trimmed_frames_in_ramp), np.float32)
         for frame_num in ramp_set.frames_to_process:
-            frame = self._read_single_ramp_frame(ramp_set.time_obs, frame_num).data
+            frame = self.read_single_ramp_frame(ramp_set.time_obs, frame_num).data
             frame_pos_in_stack = frame_num - ramp_set.index_offset_to_first_frame
             chunk_stack[:current_chunk_size, frame_pos_in_stack] = frame.flatten()[current_slice]
         return chunk_stack
 
-    def _compute_linear_chunk_size(self, frame_size_nelem: int, num_frames_in_ramp: int) -> int:
+    def compute_linear_chunk_size(self, frame_size_nelem: int, num_frames_in_ramp: int) -> int:
         """
         Compute the number of pixel stacks that constitute a 'chunk'.
 
@@ -487,7 +484,7 @@ class LinearityCorrection(CryonirspTaskBase):
         )
         return chunk_size_nelem
 
-    def _linearize_chunk(
+    def linearize_chunk(
         self, chunk_stack: np.ndarray, linc: np.ndarray, thresh: np.ndarray, exptimes: np.ndarray
     ) -> np.ndarray:
         """
@@ -509,8 +506,8 @@ class LinearityCorrection(CryonirspTaskBase):
         An array containing a linearized slice of the full ramp stack
 
         """
-        raw_data = self._lin_correct(chunk_stack, linc)
-        slopes = self._get_slopes(exptimes, raw_data, thresh)
+        raw_data = self.lin_correct(chunk_stack, linc)
+        slopes = self.get_slopes(exptimes, raw_data, thresh)
         # Scale the slopes by the exposure time to convert to counts
         processed_frame = slopes * np.nanmax(exptimes)
         return processed_frame
@@ -518,7 +515,7 @@ class LinearityCorrection(CryonirspTaskBase):
     # The methods below are derived versions of the same codes in Tom Schad's h2rg.py
     @staticmethod
     @njit(parallel=False)
-    def _lin_correct(raw_data: np.ndarray, linc: np.ndarray) -> np.ndarray:
+    def lin_correct(raw_data: np.ndarray, linc: np.ndarray) -> np.ndarray:
         """
         Correct the measured raw fluence to normalized flux per non-destructive readout (NDR).
 
@@ -531,7 +528,7 @@ class LinearityCorrection(CryonirspTaskBase):
 
     @staticmethod
     @njit(parallel=False)
-    def _get_slopes(exptimes: np.ndarray, data: np.ndarray, thresholds: np.ndarray):
+    def get_slopes(exptimes: np.ndarray, data: np.ndarray, thresholds: np.ndarray):
         """
         Compute the weighted least squares estimate of the normalized flux per exposure time increment for a single ramp.
 

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/dkist_processing_cryonirsp/tasks/mixin/beam_access.py

@@ -22,7 +22,7 @@ class BeamAccessMixin:
         -------
         An ndarray containing the extracted beam
         """
-        boundaries = self._beam_boundaries[beam]
+        boundaries = self.beam_boundaries[beam]
         spatial_min, spatial_max, spectral_min, spectral_max = boundaries
 
         if (
@@ -38,7 +38,7 @@ class BeamAccessMixin:
         return np.copy(array[spatial_min:spatial_max, spectral_min:spectral_max])
 
     @cached_property
-    def _beam_boundaries(self) -> dict[int, np.ndarray]:
+    def beam_boundaries(self) -> dict[int, np.ndarray]:
         """
         Load the beam boundaries from their respective files and return as a boundary dict.
 

{dkist_processing_cryonirsp-0.0.78 → dkist_processing_cryonirsp-0.0.80}/dkist_processing_cryonirsp/tasks/science_base.py

@@ -222,7 +222,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
             intermediate_array = self.polarization_correction(
                 array_stack, calibrations.demod_matrices[CryonirspTag.beam(beam)]
             )
-            intermediate_header = self._compute_date_keys(header_stack)
+            intermediate_header = self.compute_date_keys(header_stack)
 
         return intermediate_array, intermediate_header
 
@@ -298,14 +298,14 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         meas_num
             The current measurement number
         """
-        final_header = self._update_calibrated_header(calibrated_object.header, map_scan=map_scan)
+        final_header = self.update_calibrated_header(calibrated_object.header, map_scan=map_scan)
         if self.constants.correct_for_polarization:
             stokes_I_data = calibrated_object.data[:, :, 0]
             for s, stokes_param in enumerate(self.constants.stokes_params):
                 stokes_data = calibrated_object.data[:, :, s]
-                final_data = self._re_dummy_data(stokes_data)
-                pol_header = self._add_L1_pol_headers(final_header, stokes_data, stokes_I_data)
-                self._write_calibrated_array(
+                final_data = self.re_dummy_data(stokes_data)
+                pol_header = self.add_L1_pol_headers(final_header, stokes_data, stokes_I_data)
+                self.write_calibrated_array(
                     data=final_data,
                     header=pol_header,
                     stokes=stokes_param,
@@ -315,8 +315,8 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
                 )
 
         else:
-            final_data = self._re_dummy_data(calibrated_object.data[:, :, 0])
-            self._write_calibrated_array(
+            final_data = self.re_dummy_data(calibrated_object.data[:, :, 0])
+            self.write_calibrated_array(
                 data=final_data,
                 header=final_header,
                 stokes="I",
@@ -326,7 +326,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
             )
 
     @staticmethod
-    def _wrap_array_and_header_in_fits_access(
+    def wrap_array_and_header_in_fits_access(
         array: np.ndarray, header: fits.Header
     ) -> CryonirspL0FitsAccess:
         """Wrap input array and header in a CryonirspL0FitsAccess object."""
@@ -336,7 +336,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         return obj
 
     @staticmethod
-    def _add_stokes_dimension_to_intensity_only_array(array: np.ndarray) -> np.ndarray:
+    def add_stokes_dimension_to_intensity_only_array(array: np.ndarray) -> np.ndarray:
         """
         Add a length-1 dimension to the end of an array.
 
@@ -345,7 +345,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         return array[..., None]
 
     @staticmethod
-    def _compute_date_keys(headers: Iterable[fits.Header] | fits.Header) -> fits.Header:
+    def compute_date_keys(headers: Iterable[fits.Header] | fits.Header) -> fits.Header:
         """
         Generate correct DATE-??? header keys from a set of input headers.
 
@@ -376,7 +376,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
 
         return header
 
-    def _re_dummy_data(self, data: np.ndarray):
+    def re_dummy_data(self, data: np.ndarray):
         """
         Add the dummy dimension that we have been secretly squeezing out during processing.
 
@@ -390,7 +390,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         logger.info(f"Adding dummy WCS dimension to array with shape {data.shape}")
         return data[None, :, :]
 
-    def _update_calibrated_header(self, header: fits.Header, map_scan: int) -> fits.Header:
+    def update_calibrated_header(self, header: fits.Header, map_scan: int) -> fits.Header:
         """
         Update calibrated headers with any information gleaned during science calibration.
 
@@ -414,7 +414,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
 
         return header
 
-    def _add_L1_pol_headers(
+    def add_L1_pol_headers(
         self, input_header: fits.Header, stokes_data: np.ndarray, stokes_I_data: np.ndarray
     ) -> fits.Header:
         """Compute and add 214 header values specific to polarimetric datasets."""
@@ -460,7 +460,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         """
         return float(1.0 / np.sqrt(np.nanmax(stokes_I_data)))
 
-    def _write_calibrated_array(
+    def write_calibrated_array(
         self,
         data: np.ndarray,
         header: fits.Header,