diff --git a/core/image_operations.py b/core/image_operations.py deleted file mode 100644 index 55e915d..0000000 --- a/core/image_operations.py +++ /dev/null @@ -1,36 +0,0 @@ -### Collection of utility functions for image processing tasks. -import numpy as np - -def median_combine(images: list[np.ndarray]) -> np.ndarray: - """ - Combine a list of images by computing the median across them. - - Parameters - ---------- - images : list of np.ndarray - List of 2D numpy arrays representing images to be combined. - - Returns - ------- - np.ndarray - A 2D numpy array representing the median-combined image. - """ - stacked_images = np.stack(images, axis=0) - return np.median(stacked_images, axis=0) - -def mean_combine(images: list[np.ndarray]) -> np.ndarray: - """ - Combine a list of images by computing the mean across them. - - Parameters - ---------- - images : list of np.ndarray - List of 2D numpy arrays representing images to be combined. - - Returns - ------- - np.ndarray - A 2D numpy array representing the mean-combined image. - """ - stacked_images = np.stack(images, axis=0) - return np.mean(stacked_images, axis=0) \ No newline at end of file diff --git a/datamodels/detector_config.py b/datamodels/detector_config.py deleted file mode 100644 index 628a93f..0000000 --- a/datamodels/detector_config.py +++ /dev/null @@ -1,89 +0,0 @@ -## Functions to automatically generate detector configuration yaml files from the FITS headers -import yaml -import logging -import os - -logger = logging.getLogger(__name__) - -# Create a yaml constructor for slice objects -def slice_constructor(loader, node): - values = loader.construct_sequence(node) - # slice will be created from a list, e.g., [start, stop, step] - start, stop, step = None, None, None - if len(values) == 1: - stop = values[0] - elif len(values) == 2: - start, stop = values - elif len(values) == 3: - start, stop, step = values - else: - raise ValueError("Invalid number of arguments for slice.") - return slice(start, stop, step) - -yaml.add_constructor('!slice', slice_constructor) - -class DetectorConfig: - required_keys = ['detector_type', 'detector_output_class', 'objects'] - required_objects_keys = ['name', 'class', 'properties', 'outputs'] - required_properties_keys = ['x_size', 'y_size', 'pixel_size'] - - def __init__(self, config_input=None, fits_path=None, output_path=None): - """ - Initialize the DetectorConfig either from a YAML config file path, config data in string or json format, - or generate from a FITS file. - :param config_input: str or dict, optional - Path to a YAML config file or config data as a string or dictionary. - :param fits_path: str, optional - Path to a FITS file to generate configuration from. - :param output_path: str, optional - Path to save the generated configuration file if generating from FITS. - """ - self.config = None - - if config_input is not None: - if isinstance(config_input, str) and os.path.isfile(config_input) and config_input.endswith(('.yaml', '.yml')): - with open(config_input, 'r') as stream: - self.load_config(stream) - elif isinstance(config_input, str) and not os.path.isfile(config_input): - try: - self.load_config(config_input) - except Exception as e: - raise ValueError(f"Error parsing config_input string: {e}") - elif isinstance(config_input, dict): - self.config = config_input - else: - raise ValueError("config_input must be either a file path, string or a dictionary.") - elif config_input is None and fits_path is not None: - if not (isinstance(fits_path, str) and '.fits' in fits_path): - raise ValueError(f"Input path should not be None and be a FITS file.") - else: - self.generate_config_from_fits(fits_path, output_path) - else: - logger.warning("No configuration, nor FITS file to generate from. Initializing empty config.") - self.config = {} - - def load_config(self, stream): - try: - self.config = yaml.load(stream, Loader=yaml.FullLoader) - except Exception as e: - raise ValueError(f"Error loading detector configuration file: {e}") - self.validate_config() - - def validate_config(self): - for key in self.required_keys: - if key not in self.config: - raise ValueError(f"Missing required config key: {key}") - - for obj in self.config['objects']: - for key in self.required_objects_keys: - if key not in obj: - raise ValueError(f"Missing required object key: {key} in object {obj.get('name', 'unknown')}") - - for prop_key in self.required_properties_keys: - if prop_key not in obj['properties']: - raise ValueError(f"Missing required property key: {prop_key} in object {obj.get('name', 'unknown')}") - - def generate_config_from_fits(self, fits_path, output_path=None): - raise NotImplementedError() - - diff --git a/tasks/analysis.py b/eregion/__init__.py similarity index 100% rename from tasks/analysis.py rename to eregion/__init__.py diff --git a/eregion/configs/__init__.py b/eregion/configs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/eregion/configs/config.py b/eregion/configs/config.py new file mode 100644 index 0000000..9a12fed --- /dev/null +++ b/eregion/configs/config.py @@ -0,0 +1,126 @@ +from abc import ABC, abstractmethod +import yaml +import logging + +# A yaml constructor for slice objects +def slice_constructor(loader, node): + values = loader.construct_sequence(node) + # slice will be created from a list, e.g., [start, stop, step] + start, stop, step = None, None, None + if len(values) == 1: + stop = values[0] + elif len(values) == 2: + start, stop = values + elif len(values) == 3: + start, stop, step = values + else: + raise ValueError("Invalid number of arguments for slice.") + return slice(start, stop, step) + +yaml.add_constructor('!slice', slice_constructor) + + +### Generic Config Loader Base Class ### +class ConfigLoader(ABC): + required_keys = [] + + def __init__(self, config_input): + """ + Initialize the ConfigLoader either from a YAML config file path, config data in string or dict format. + :param config_input: str or dict + Path to a YAML config file or config data as a string or dictionary. + """ + self.config = None + self.logger = logging.getLogger(__name__) + + if isinstance(config_input, str) and config_input.endswith(('.yaml', '.yml')): + self.set_from_file(config_input) + elif isinstance(config_input, str) and not config_input.endswith(('.yaml', '.yml')): + self.set_from_string(config_input) + elif isinstance(config_input, dict): + self.set_from_dict(config_input) + else: + raise ValueError("config_input must be either a file path, string or a dictionary.") + + def set_from_file(self, input: str): + try: + with open(input, 'r') as stream: + self.load_config(stream) + self.logger.info("Config loaded from file '{}'".format(input)) + except Exception as e: + raise ValueError(f"Error reading config file {input}: {e}") + self.validate_config() + + def set_from_string(self, input: str): + try: + self.load_config(input) + self.logger.info("Config loaded from string input") + except Exception as e: + raise ValueError(f"Error parsing input string into yaml: {e}") + self.validate_config() + + def set_from_dict(self, input: dict): + self.config = input + self.validate_config() + self.logger.info("Config loaded from dict input") + + def load_config(self, stream): + try: + self.config = yaml.load(stream, Loader=yaml.FullLoader) + except Exception as e: + raise ValueError(f"Error loading configuration: {e}") + + @abstractmethod + def validate_config(self): + for key in self.required_keys: + if key not in self.config: + raise ValueError(f"Missing required config key: {key}") + + +### Detector Configuration Class ### +class DetectorConfig(ConfigLoader): + required_keys = ['detector_type', 'detector_output_class', 'objects'] + required_objects_keys = ['name', 'class', 'properties', 'outputs'] + required_properties_keys = ['x_size', 'y_size', 'pixel_size'] + + def __init__(self, config_input): + """ + Initialize the DetectorConfig either from a YAML config file path, config data in string or json format, + or generate from a FITS file. + :param config_input: str or dict + Path to a YAML config file or config data as a string or dictionary. + """ + super().__init__(config_input) + + def validate_config(self): + for key in self.required_keys: + if key not in self.config: + raise ValueError(f"Missing required config key: {key}") + + for obj in self.config['objects']: + for key in self.required_objects_keys: + if key not in obj: + raise ValueError(f"Missing required object key: {key} in object {obj.get('name', 'unknown')}") + + for prop_key in self.required_properties_keys: + if prop_key not in obj['properties']: + raise ValueError(f"Missing required property key: {prop_key} in object {obj.get('name', 'unknown')}") + + + +### Pipeline Configuration Class ### +class PipelineConfig(ConfigLoader): + required_keys = ['pipeline'] + + def __init__(self, config_input): + """ + Initialize the PipelineConfig either from a YAML config file path or config data in string or dict format. + :param config_input: str or dict + Path to a YAML config file or config data as a string or dictionary. + """ + super().__init__(config_input) + + def validate_config(self): + for key in self.required_keys: + if key not in self.config: + raise ValueError(f"Missing required config key: {key}") diff --git a/eregion/configs/detectors/basic_ccd.yaml b/eregion/configs/detectors/basic_ccd.yaml new file mode 100644 index 0000000..ae91744 --- /dev/null +++ b/eregion/configs/detectors/basic_ccd.yaml @@ -0,0 +1,55 @@ +## Config file for creating instances of an image class (here DetImage) for a basic CCD detector +## The DetImage instance contains the outputs from a "single" detector. +## The "image" can be stored in one FITS file with one extension that has all the detectors/outputs, +## OR in multiple FITS extensions, one per detector/output, OR in multiple FITS files, one per detector/output. +## The config structure should describe how to load one FITS file. +--- +description: Basic single CCD detector, one channel +detector_type: CCD # (specify the type of detector, e.g., CCD, CMOS, H2RG, etc.) +detector_output_class: CCDOutput + +# List of class objects, each containing a list of outputs. +# An output is described by the FITS file it is in, the extension in that file, and the slices that define its data. +objects: + - name: 'det_1' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2048 + y_size: 4096 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'chan_1' + ext_id: 1 # FITS extension ID + ext_slice: [!slice [0, 4096], !slice [0, 1024]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4096], !slice [0, 1024]] # Slice of the full DetImage data array where this output's data will go + serial_prescan: !slice [0, 0] + serial_overscan: !slice [1024, 1024] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4096, 4096] + parallel_axis: 'y' # First axis in the data array (rows) represent parallel readout direction + readout_pixel: [0, 0] # Readout starts at (0,0) + gain: 1.0 # electrons/ADU + read_noise: 5.0 # electrons + bias_level: 1000 # ADU + - id: 'chan_2' + ext_id: 1 # FITS extension ID + ext_slice: [!slice [0, 4096], !slice [1024, 2048]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4096], !slice [1024, 2048]] # Slice of the full DetImage data array where this output's data will go + serial_prescan: !slice [0, 0] + serial_overscan: !slice [1024, 1024] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4096, 4096] + parallel_axis: 'y' # First axis in the data array (rows) represent parallel readout direction + readout_pixel: [0, 2047] # Readout starts at (0,2047) + gain: 1.0 # electrons/ADU + read_noise: 5.0 # electrons + bias_level: 1000 # ADU + focal_plane_position: + x_cen: 0.0 # mm + y_cen: 0.0 # mm + angle: 0.0 # degrees + + + diff --git a/playground/deimos.yaml b/eregion/configs/detectors/deimos.yaml similarity index 100% rename from playground/deimos.yaml rename to eregion/configs/detectors/deimos.yaml diff --git a/eregion/configs/detectors/deimos_singledet.yaml b/eregion/configs/detectors/deimos_singledet.yaml new file mode 100644 index 0000000..7ca03c9 --- /dev/null +++ b/eregion/configs/detectors/deimos_singledet.yaml @@ -0,0 +1,54 @@ +## Example detector definition file for the DEIMOS instrument CCD array +## A single FITS file contains 8 extensions, one per detector, so 8 DetImage instances are created from this file. +## Each DetImage instance has two outputs (two channels per detector). +--- +description: DEIMOS CCD detector single +detector_type: CCD # (specify the type of detector, e.g., CCD, CMOS, H2RG, etc.) +detector_output_class: CCDOutput # (use the correct class here for the detector output type) + +objects: + - name: 'det_1' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'chan_1' + ext_id: 1 # FITS extension ID + ext_slice: [!slice [0, 4125], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4125], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go + serial_prescan: !slice [0, 0] + serial_overscan: !slice [1094, 1094] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4125, 4125] + parallel_axis: 'y' # First axis in the data array (rows) represent parallel readout direction + readout_pixel: [0, 0] # top left pixel + gain: 1.0 # electrons/ADU + read_noise: 5.0 # electrons + bias_level: 1000 # ADU + - id: 'chan_2' + ext_id: 2 # FITS extension ID + ext_slice: [!slice [0, 4125], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4125], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go + serial_prescan: !slice [0, 0] + serial_overscan: !slice [1094, 1094] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4125, 4125] + parallel_axis: 'y' # First axis in the data array (rows) represent parallel readout direction + readout_pixel: [0, 1094] # top right pixel + gain: 1.0 # electrons/ADU + read_noise: 5.0 # electrons + bias_level: 1000 # ADU + focal_plane_position: + x_cen: -46.08 # mm + y_cen: 30.72 # mm + angle: 0.0 # degrees + + + + + + diff --git a/eregion/configs/pipeline_flows/masterbias_example.yaml b/eregion/configs/pipeline_flows/masterbias_example.yaml new file mode 100644 index 0000000..a26630e --- /dev/null +++ b/eregion/configs/pipeline_flows/masterbias_example.yaml @@ -0,0 +1,32 @@ +# This is an example pipeline flow configuration for creating a master bias frame +# Example + +debug: false # Optional: set to true to enable debug mode (more verbose logging, etc.) +pipeline: + - name: image_creator + task: tasks.imagegen.ImageCreator + lazy: false + init: # Initialization parameters for the image creator + detector_config: "/Users/yashvi/Desktop/Detector Characterization Tools/eregion/configs/detectors/deimos_singledet.yaml" # For required params, see the task documentation + # Any additional params are passed as kwargs that get set in the task's meta dict + # See task documentation for which kwargs are used + + run: # Run-time inputs and parameters for the image creator + params: # Check which params go here in the task documentation + input_source: "/Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*_bias_*.fits" + identifier_func: tasks.custom.guess_image_type_from_filename_DEIMOS + + + - name: master_bias + task: tasks.calibration.MasterBias + lazy: false + init: + method: "median" # Optional param (kwarg) method to combine bias frames; see task documentation for options + run: + inputs: # use inputs to specify data input coming in from output of other tasks + bias_images: image_creator.data.images # E.g. Input images from the image creator task's output + # Each task's outputs are objects of class TaskResult + # TaskResult.data is a dict containing the actual data produced by the task + # Check which outputs are available in the task documentation + + depends_on: [image_creator] diff --git a/eregion/core/__init__.py b/eregion/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/eregion/core/image_operations.py b/eregion/core/image_operations.py new file mode 100644 index 0000000..2ce07b1 --- /dev/null +++ b/eregion/core/image_operations.py @@ -0,0 +1,90 @@ +### Collection of utility functions for image processing tasks. +import numpy as np +from typing import Callable, Any +from astropy.stats import sigma_clip + +def median_combine(images: list[np.ndarray]) -> np.ndarray: + """ + Combine a list of images by computing the median across them. + + Parameters + ---------- + images : list of np.ndarray + List of 2D numpy arrays representing images to be combined. + + Returns + ------- + np.ndarray + A 2D numpy array representing the median-combined image. + """ + stacked_images = np.stack(images, axis=0) + return np.median(stacked_images, axis=0) + +def mean_combine(images: list[np.ndarray]) -> np.ndarray: + """ + Combine a list of images by computing the mean across them. + + Parameters + ---------- + images : list of np.ndarray + List of 2D numpy arrays representing images to be combined. + + Returns + ------- + np.ndarray + A 2D numpy array representing the mean-combined image. + """ + stacked_images = np.stack(images, axis=0) + return np.mean(stacked_images, axis=0) + +def subtract_from_image(image: np.ndarray, subtract_object: np.ndarray | float, method: Callable, *args): + """ + Subtract a given object (array or scalar) from an image. + + Parameters + ---------- + image : np.ndarray + 2D numpy array representing the image. + subtract_object : np.ndarray or float + The object to subtract from the image. Can be an array of any size from which the value to subtract is derived. + method : Callable + A function that takes the subtract_object and returns a scalar/array to subtract from the image. + Returns + ------- + np.ndarray + The resulting image after subtraction. + """ + value_to_subtract = method(subtract_object, *args) + return image - value_to_subtract, value_to_subtract + +def simple_median(data: np.ndarray, *args) -> Any: + return np.median(data) + +def simple_mean(data: np.ndarray, *args) -> Any: + return np.mean(data) + +def median_by_axis(data: np.ndarray, axis: int, *args) -> np.ndarray: + return np.median(data, axis=axis, keepdims=True) + +def sigma_clip_image(image: np.ndarray | np.ma.MaskedArray, sigma: float, axis: int | None=None, **kwargs) -> np.ma.MaskedArray: + """ + Apply sigma clipping (astropy.stats.sigma_clip) to an image. + + Parameters + ---------- + image : np.ndarray or np.ma.MaskedArray + 2D numpy array representing the image. + sigma : float + The sigma threshold for clipping. + axis : int or None + Axis along which to perform the sigma clipping. If None, the entire array is treated as a single entity. + kwargs : dict + Additional keyword arguments to pass to astropy.stats.sigma_clip. + + Returns + ------- + np.ma.MaskedArray + The sigma-clipped image. + """ + masked = sigma_clip(image, sigma=sigma, axis=axis, **kwargs) + return masked \ No newline at end of file diff --git a/eregion/datamodels/__init__.py b/eregion/datamodels/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/datamodels/image.py b/eregion/datamodels/image.py similarity index 94% rename from datamodels/image.py rename to eregion/datamodels/image.py index a23ba98..c9559aa 100644 --- a/datamodels/image.py +++ b/eregion/datamodels/image.py @@ -1,8 +1,7 @@ from __future__ import annotations -from typing import Optional, Dict, Any, Tuple, List, Literal +from typing import Optional, Any, Literal from pydantic import BaseModel, Field, ConfigDict -from numpy.typing import NDArray import numpy as np import pandas as pd @@ -11,7 +10,7 @@ from astropy.io import fits import logging -from datamodels.image_utils import ensure_dataarray, slice_data +from eregion.datamodels.image_utils import ensure_dataarray, slice_data logger = logging.getLogger(__name__) @@ -46,6 +45,11 @@ class DetImageMeta(BaseModel): model_config = ConfigDict(extra="allow") + def update(self, other: dict[str, Any]): + for key, value in other.items(): + if not hasattr(self, key): + setattr(self, key, value) + class Output(BaseModel): """ One amplifier/output region within a detector image. @@ -74,7 +78,7 @@ def data(self) -> xr.DataArray: raise ValueError("Attach this Output to a DetImage with valid data.") return slice_data(self.parent.data, self.output_slice) - def set_data_in_parent(self, new_data: xr.DataArray | NDArray): + def set_data_in_parent(self, new_data: xr.DataArray | np.ndarray): if self.parent is None or getattr(self.parent, "data", None) is None: raise ValueError("Attach this Output to a DetImage with valid data.") # Ensure new_data is xr.DataArray @@ -107,7 +111,7 @@ class CCDOutput(Output): description="Slice object defining the parallel overscan region for this output.") parallel_axis: Optional[Literal['x', 'y']] = Field(None, description="Name of the parallel readout axis for this output ('x' or 'y').") - readout_pixel: Optional[Tuple[int, int]] = Field(None, + readout_pixel: Optional[tuple[int, int]] = Field(None, description="Tuple defining the (y, x) pixel coordinates of the readout amplifier " "for this output in the full detector array.") @@ -180,10 +184,10 @@ class DetImage: """ def __init__( self, - data: Optional[xr.DataArray | NDArray] = None, - output_objects: Optional[Dict[str, Output]] = None, + data: Optional[xr.DataArray | np.ndarray] = None, + output_objects: Optional[dict[str, Output]] = None, image_type: Optional[str] = None, - meta: Optional[DetImageMeta | Dict[str, Any]] = None, + meta: Optional[DetImageMeta | dict[str, Any]] = None, **kwargs: Any, ): @@ -197,7 +201,7 @@ def __init__( meta = kwargs if isinstance(meta, DetImageMeta): - self.meta: DetImageMeta | Dict[str, Any] = meta + self.meta: DetImageMeta | dict[str, Any] = meta elif isinstance(meta, dict) and meta: # Validate only if sufficient keys are present; otherwise store as-is. if {"name", "properties"}.issubset(meta.keys()): @@ -206,6 +210,9 @@ def __init__( self.meta = dict(meta) else: self.meta = {} + # Merge any additional kwargs into meta + self.meta.update(kwargs) + # Outputs if output_objects is None and self.data is not None: @@ -266,17 +273,17 @@ def __init__( self, num_detectors: int, dim: tuple[int, int], - fp_center: Optional[Tuple[float, float]] = None, - det_images: Optional[List[DetImage]] = None, + fp_center: Optional[tuple[float, float]] = None, + det_images: Optional[list[DetImage]] = None, **kwargs, ): - self.meta: Dict = {} + self.meta: dict = {} if kwargs: self.meta.update(kwargs) self.num_detectors = int(num_detectors) self.dim = tuple(dim) self.fp_cen_pix = fp_center if fp_center is not None else (dim[0] / 2, dim[1] / 2) - self.det_images: List[DetImage] = [] + self.det_images: list[DetImage] = [] if det_images: for di in det_images: self.add_DetImage(di) diff --git a/datamodels/image_utils.py b/eregion/datamodels/image_utils.py similarity index 90% rename from datamodels/image_utils.py rename to eregion/datamodels/image_utils.py index f7f25de..c0a0648 100644 --- a/datamodels/image_utils.py +++ b/eregion/datamodels/image_utils.py @@ -1,15 +1,12 @@ import numpy as np import xarray as xr -from typing import Union, Tuple, List, Any -from numpy.typing import NDArray +from typing import Any from astropy.io import fits -from prefect import task - -def ensure_dataarray(data: Union[xr.DataArray, NDArray]) -> xr.DataArray: +def ensure_dataarray(data: xr.DataArray | np.ndarray) -> xr.DataArray: """ Coerce 2D data to xr.DataArray with dims ('y','x') and integer coords. - :type data: Union[xr.DataArray, NDArray] + :type data: Union[xr.DataArray, np.ndarray] :rtype: xr.DataArray :raises TypeError: if data is not xarray.DataArray or numpy.ndarray :return: xarray.DataArray with dims ('y','x') or ('y','x','t') @@ -72,8 +69,8 @@ def slice_data(data: xr.DataArray, slicer: tuple[slice, ...]) -> xr.DataArray: else: raise ValueError("DataArray must be 2D or 3D.") -@task -def load_image_fits(filename: str) -> Tuple[List[Any], List[fits.Header]]: + +def load_image_fits(filename: str) -> tuple[list[Any], list[fits.Header]]: """ Load FITS file and return the data as a list with hdu extensions as the first axis. :param filename: str @@ -82,7 +79,7 @@ def load_image_fits(filename: str) -> Tuple[List[Any], List[fits.Header]]: A tuple containing a list of data arrays (image/table/...) for each HDU and a list of corresponding FITS headers. """ input_data_array, input_headers = [], [] - with fits.open(filename) as hdulist: + with fits.open(filename, decompress_in_memory=True) as hdulist: for hdu in hdulist: input_data_array.append(hdu.data) input_headers.append(hdu.header) diff --git a/eregion/pipeline/__init__.py b/eregion/pipeline/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/eregion/pipeline/engine.py b/eregion/pipeline/engine.py new file mode 100644 index 0000000..f499ee1 --- /dev/null +++ b/eregion/pipeline/engine.py @@ -0,0 +1,131 @@ +from typing import Iterator +from eregion.tasks.task import TaskResult +from eregion.configs.config import PipelineConfig + +from prefect import task, flow +import importlib +import logging + + +class PipelineEngine: + def __init__(self, pipeline_config: str | dict): + self.pipeline_config = PipelineConfig(pipeline_config) + self.pipeline = self.build_flow() + + def update(self, new_config: str | dict): + self.pipeline_config = PipelineConfig(new_config) + self.pipeline = self.build_flow() + + @staticmethod + def load_task_class(path: str): + module, cls = path.rsplit(".", 1) + return getattr(importlib.import_module(module), cls) + + @staticmethod + def resolve_inputs(input_spec: dict, results: dict) -> dict: + resolved = {} + for arg_name, ref in input_spec.items(): + task_name, _, key = ref.partition(".data.") + if task_name not in results: + raise ValueError(f"Upstream task '{task_name}' not found") + resolved[arg_name] = results[task_name].data[key] + return resolved + + @staticmethod + def execute_task( + task_cls, + name: str, + init_params: dict, + run_inputs: dict, + run_params: dict, + upstream: list[str], + lazy: bool = False, + debug: bool = False, + ) -> TaskResult | Iterator[TaskResult]: + + eregion_task = task_cls(name=name, **init_params) + eregion_task.set_logging_level(logging.DEBUG if debug else logging.INFO) + + merged_params = { + "init": init_params, + "run": run_params, + "lazy": lazy + } + + if lazy: + if not hasattr(eregion_task, "lazy_run"): + raise TypeError(f"Task '{name}' does not support lazy execution") + + def generator(): + for item in eregion_task.lazy_run(**run_inputs, **run_params): + if not isinstance(item, dict): + raise TypeError("lazy_run must yield dicts") + yield TaskResult( + task_name=name, + data=item, + params=merged_params, + upstream=upstream, + ) + return generator() + + # eager execution + result = eregion_task.run(**run_inputs, **run_params) + if not isinstance(result, dict): + raise TypeError("run() must return a dict") + return TaskResult( + task_name=name, + data=result, + params=merged_params, + upstream=upstream, + ) + + def build_flow(self): + cfg = self.pipeline_config.config + + @flow + def pipeline_flow(): + results = {} + + for node in cfg["pipeline"]: + name = node["name"] + task_cls = self.load_task_class(node["task"]) + + lazy = node.get("lazy", False) + init_params = node.get("init", {}) + + run_block = node.get("run", {}) + input_spec = run_block.get("inputs", {}) + run_params = run_block.get("params", {}) + + # upstream_results = { + # dep: results[dep] + # for dep in node.get("depends_on", []) + # } + upstream = node.get("depends_on", []) + + run_inputs = self.resolve_inputs(input_spec, results) + + @task(name=name) + def prefect_task(): + return self.execute_task( + task_cls=task_cls, + name=name, + init_params=init_params, + run_inputs=run_inputs, + run_params=run_params, + upstream=upstream, + lazy=lazy, + debug=cfg.get("debug", False), + ) + + results[name] = prefect_task() + + return results + + return pipeline_flow + + + ## Execute the pipeline + def run(self): + return self.pipeline() + diff --git a/eregion/tasks/__init__.py b/eregion/tasks/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/eregion/tasks/analysis.py b/eregion/tasks/analysis.py new file mode 100644 index 0000000..e69de29 diff --git a/eregion/tasks/calibration.py b/eregion/tasks/calibration.py new file mode 100644 index 0000000..30eb394 --- /dev/null +++ b/eregion/tasks/calibration.py @@ -0,0 +1,82 @@ +import numpy as np + +from eregion.tasks.task import Task +from eregion.datamodels.image import DetImage +from eregion.datamodels.image_utils import ensure_dataarray +from eregion.core.image_operations import median_combine + + +# Task to generate master bias +class MasterBias(Task): + def __init__(self, name=None, **kwargs): + super().__init__(name=name, **kwargs) + + def run(self, bias_images: list[DetImage]) -> dict[str,list[DetImage]]: + """ + Generate master bias frames from a list of bias DetImage objects. + :param bias_images: list of DetImage + List of detector images containing bias frames. + :return: {"master_biases": list[DetImage]} + Dictionary with key 'master_biases' containing a list of master bias DetImage objects. + """ + # Check that bias_images are DetImage instances + if not isinstance(bias_images, list) or not all(isinstance(img, DetImage) for img in bias_images): + raise ValueError("bias_images must be a list of DetImage instances.") + + # Group bias images by detector name + bias_dict = {} + for img in bias_images: + det_name = img.meta.name if 'name' in img.meta else 'default' + if det_name not in bias_dict: + bias_dict[det_name] = [] + bias_dict[det_name].append(img) + + # Create master bias for each detector + master_biases = [] + for det_name, imgs in bias_dict.items(): + # Initialize master bias DetImage + master_bias = DetImage(image_type="master_bias") + # Combine bias data + bias_data = [img.data.values for img in imgs] + master_bias.data = ensure_dataarray(self._create_masterbias(bias_data, + method=self.meta.get('method', 'median'))) + # Copy metadata and outputs from the first bias image + master_bias.meta = imgs[0].meta + master_bias.focal_plane = imgs[0].focal_plane + master_bias.meta.update({'filenames':', '.join([img.meta.filename for img in imgs])}) + master_bias.outputs.update(imgs[0].outputs) + master_biases.append(master_bias) + return {'master_biases': master_biases} + + def _create_masterbias(self, biases: list[np.ndarray], method='median')-> np.ndarray: + """ + Create a master bias frame from a list of bias frames using the specified method. + :param biases: list of numpy arrays + List of detector images containing bias frames. + :param method: str + Method to combine bias frames. Currently only 'median' is implemented. + :return: master_bias: numpy array + The generated master bias frame. + """ + if method == 'median': + return median_combine(biases) + else: + # print available methods + self.print_methods() + raise NotImplementedError + + @property + def methods(self): + """ + Return a dictionary of available methods for creating master bias and their function signatures. + :return: dict + Dictionary with method names as keys and function signatures as values. + """ + return { + 'median': 'core.image_operations.median_combine(images: list[np.ndarray]) -> np.ndarray', + } + + + def __call__(self, biases: list[np.ndarray], method='median') -> np.ndarray: + return self._create_masterbias(biases, method=method) + diff --git a/eregion/tasks/custom.py b/eregion/tasks/custom.py new file mode 100644 index 0000000..725a94d --- /dev/null +++ b/eregion/tasks/custom.py @@ -0,0 +1,22 @@ +### File for custom input functions/tasks defined by the user. ### +import os + +def guess_image_type_from_filename_DEIMOS(filename: str) -> str: + """ + Custom function to guess the image type for DEIMOS based on filename patterns. + :param filename: str + The name of the FITS file. + :return: str + The guessed image type (e.g., 'bias', 'flat', 'science', etc.) + """ + filename_lower = os.path.basename(filename).lower() + if 'bias' in filename_lower: + return 'bias' + elif 'flat' in filename_lower: + return 'flat' + elif 'arc' in filename_lower or 'lamp' in filename_lower: + return 'arc' + elif 'science' in filename_lower or 'obj' in filename_lower: + return 'science' + else: + return 'unknown' diff --git a/tasks/imagegen.py b/eregion/tasks/imagegen.py similarity index 50% rename from tasks/imagegen.py rename to eregion/tasks/imagegen.py index 85db6a1..2702789 100644 --- a/tasks/imagegen.py +++ b/eregion/tasks/imagegen.py @@ -1,34 +1,27 @@ -from datamodels.image import * -from datamodels.image_utils import ensure_dataarray, load_image_fits -from datamodels.detector_config import DetectorConfig -from tasks.task import Task, LazyTask +from eregion.datamodels.image import * +from eregion.datamodels.image_utils import ensure_dataarray, load_image_fits +from eregion.configs.config import DetectorConfig +from eregion.tasks.task import LazyTask -import logging import os, glob2, time -from astropy.io import fits -from typing import Iterator, Generator, Callable, Optional, Iterable, Union +import importlib +from typing import Iterator, Generator, Callable, Optional, Iterable -from prefect import task, flow -from prefect.futures import wait - -logger = logging.getLogger(__name__) +from joblib import Parallel, delayed ## Classes to handle image generation from configuration files class ImageCreator(LazyTask): - def __init__(self, detector_config=None, name='image_creator', watch_mode=False, poll_interval=10, **kwargs): + def __init__(self, detector_config, name='image_creator', watch_mode=False, poll_interval=10, **kwargs): super().__init__(name, watch_mode, poll_interval, **kwargs) - # TODO: if no detector_config is provided, try to generate from a FITS file later - if detector_config is not None: - self.set_detector_config(detector_config) - else: - raise ValueError("Detector configuration must be provided.") + # Load detector configuration + self.det_config = DetectorConfig(config_input=detector_config) - # Store a Prefect task for identification; wrap callables on registration. + # Store a custom function for identification self._identifier_task: Optional[Callable[..., str]] = None - # Store a Prefect task for image loading; wrap callables on registration. + # Store a custom function for image loading self._fitsloader_task: Optional[Callable[..., np.ndarray]] = None # Store processed filenames @@ -40,30 +33,36 @@ def set_detector_config(self, detector_config): :param detector_config: str or dict Path to a YAML config file or config data as a string or dictionary. """ - self.config = DetectorConfig(config_input=detector_config).config + self.det_config = DetectorConfig(config_input=detector_config) - def set_identifier(self, func: Callable[..., str]) -> None: + def set_identifier(self, func: str | Callable[..., str]) -> None: """ Register a custom image-type identification function. - Accepts only a plain callable to be wrapped as a Prefect task. Expected signature: func(filename: str, **kwargs) -> str """ if not callable(func): - raise TypeError("identifier must be callable.") - self._identifier_task = task(func, name="custom_identifier") + try: + module, cls = func.rsplit('.', 1) + func = getattr(importlib.import_module(module), cls) + except Exception as e: + raise ValueError(f"Error loading identifier function '{func}': {e}") + self._identifier_task = func - def set_fitsloader(self, func: Callable[..., str]) -> None: + def set_fitsloader(self, func: str | Callable[..., str]) -> None: """ Register a custom FITS loading function. It should return a tuple of (data_list, header_list). - Accepts only a plain callable to be wrapped as a Prefect task. + Must have filename as a required argument. Expected signature: func(filename: str, **kwargs) -> Tuple(List[Any], List[astropy.io.fits.Header]) """ if not callable(func): - raise TypeError("fitsloader must be callable.") - self._fitsloader_task = task(func, name="custom_fits_loader") + try: + module, cls = func.rsplit('.', 1) + func = getattr(importlib.import_module(module), cls) + except Exception as e: + raise ValueError(f"Error loading FITS loader function '{func}': {e}") + self._fitsloader_task = func - @task def _guess_image_type_from_header(self, header, keywords=None): """ Default image type guessing logic based on FITS header. @@ -98,26 +97,67 @@ def _guess_image_type_from_header(self, header, keywords=None): return 'unknown' # Default assumption # ----------------- Input sources ----------------- - def from_files(self, input_path: str | list[str]) -> Iterator[List[str]]: + def from_files(self, input_path: str | list[str]) -> Iterator[list[str]]: """ Yields batches of file paths. - If watch_mode=False: yields a single batch with all discovered files. - If watch_mode=True: watches a directory/glob and yields newly discovered files. """ - def _discover_once() -> List[str]: + def _discover_once() -> list[str]: if isinstance(input_path, list): - filenames = [f for f in input_path if os.path.isfile(f) and '.fits' in f] - elif os.path.isdir(input_path): - filenames = glob2.glob(os.path.join(input_path, '*.fits*')) - elif '*' in input_path: - filenames = [f for f in glob2.glob(input_path) if os.path.isfile(f) and '.fits' in f] - elif os.path.isfile(input_path) and '.fits' in input_path: - filenames = [input_path] + self.logger.info("Provided input_path is a list of files, checking each...") + filenames = [] + for f in input_path: + if os.path.exists(f) and os.path.isfile(f) and '.fits' in f: + filenames.append(f) + else: + self.logger.warn(f"Path {f} either doesn't exist, is not a file or is not a FITS file") + return sorted(filenames) + + elif isinstance(input_path, str): + if '*' in input_path: + if '.fits' in input_path: + self.logger.info(f"Provided input_path is a glob pattern for FITS files, {input_path}") + filenames = glob2.glob(input_path, recursive=True) + if len(filenames) == 0: + self.logger.warn(f"No FITS files found that match {input_path}") + return [] + + else: + self.logger.info(f"Provided input_path is a glob pattern, {input_path}, searching for all FITS files within.") + filenames = glob2.glob(os.path.join(input_path, '**/*.fits*'), recursive=True) + if len(filenames) == 0: + self.logger.warn(f"No FITS files found in directories and sub-directories of {input_path}") + return [] + return sorted(filenames) + + else: + if os.path.exists(input_path): + if os.path.isdir(input_path): + self.logger.info(f"Provided input_path is a directory, {input_path}") + filenames = glob2.glob(os.path.join(input_path, '**/*.fits*'), recursive=True) + if len(filenames) == 0: + self.logger.warn(f"No FITS files found in {input_path}") + return [] + + else: + if '.fits' in input_path: + self.logger.info(f"Provided input_path is a FITS file, {input_path}") + filenames = [input_path] + else: + self.logger.error(f"Provided input_path is not a FITS file, {input_path}") + raise ValueError("Provided input_path is not a FITS file") + return sorted(filenames) + + else: + self.logger.error(f"Provided input_path does not exist, {input_path}") + raise FileNotFoundError("Provided input_path does not exist") + else: + self.logger.error(f"Invalid input") raise ValueError( "Input path must be a FITS file, a list of FITS files, " "a directory with FITS files, or a glob pattern for FITS files.") - return filenames if not self.watch_mode: batch = _discover_once() @@ -132,7 +172,7 @@ def _discover_once() -> List[str]: yield new_files time.sleep(self.poll_interval) - def from_arrays(self, input_arrays: Iterable[np.ndarray]) -> Iterator[List[np.ndarray]]: + def from_arrays(self, input_arrays: Iterable[np.ndarray]) -> Iterator[list[np.ndarray]]: """ Yields batches of input data arrays. - If watch_mode=False: yields a single batch with all arrays collected @@ -147,32 +187,45 @@ def from_arrays(self, input_arrays: Iterable[np.ndarray]) -> Iterator[List[np.nd yield [array] # ----------------- Image object builders ----------------- - @flow def _build_image_objects(self, input_data_array, input_headers, image_type, filename=None): + cfg = self.det_config.config + ## use joblib to parallelize building image objects images = [] - for obj in self.config['objects']: - image = self._build_single_image_object.submit(obj, input_data_array, input_headers, image_type, filename=filename) - images.append(image) - wait(images) - images = [img.result() for img in images if img.result() is not None] + results = Parallel(n_jobs=self.n_jobs)( + delayed(self._build_single_image_object)( + obj, cfg['detector_output_class'], input_data_array, input_headers, image_type, filename + ) + for obj in cfg['objects'] + ) + for img in results: + if img is not None: + images.append(img) return images - @task - def _build_single_image_object(self, obj, input_data_array, input_headers, image_type, filename=None): + def _build_single_image_object(self, + obj, + output_class, + input_data_array, + input_headers, + image_type, + filename=None): # If a filename is given, check if it matches the filename format if filename is not None: if not glob2.fnmatch.fnmatch(os.path.basename(filename), obj['filename_format']): - logger.info("Skipping file %s as it does not match filename format for this object (%s)", + self.logger.info("Skipping file %s as it does not match filename format for this object (%s)", filename, obj['filename_format']) return None + # pop outputs and class from object outputs = obj.pop('outputs') + self.logger.info("Building object %s with %s %s outputs and type %s from file %s", obj['class'], len(outputs), + output_class, image_type, filename or 'array input') ImageClass = globals()[obj.pop('class')] - OutputClass = globals()[self.config['detector_output_class']] + OutputClass = globals()[output_class] # instantiate image object - image = ImageClass(image_type=image_type, **obj, filename=filename) + image = ImageClass(image_type=image_type, **obj, filename=filename or 'none') image_data_size = [0] * image.ndim for output in outputs: output_obj = OutputClass(**output) @@ -193,27 +246,35 @@ def _build_single_image_object(self, obj, input_data_array, input_headers, image # ----------------- Main lazy run method ----------------- def lazy_run(self, - input_source: Union[str, list[str], Iterable[np.ndarray]], + input_source: str | list[str] | Iterable[np.ndarray], identifier_func: Optional[Callable[..., str]] = None, - identifier_kwargs: Optional[Dict[str, Any]] = None, + identifier_kwargs: Optional[dict[str, Any]] = None, fitsloader_func: Optional[Callable[..., str]] = None, - fitsloader_kwargs: Optional[Dict[str, Any]] = None - ) -> Generator[List, None, None]: + fitsloader_kwargs: Optional[dict[str, Any]] = None, + require_data: bool = True, + ) -> Generator[dict[str, list], None, None]: """ Main lazy run method to generate image objects from input source. :param input_source: str or list of str or Iterable of np.ndarray Input source can be a path to FITS files (file, directory, glob pattern), a list of FITS file paths, or an iterable of numpy arrays. - :param identifier_func: Callable, optional + :param identifier_func: str (from pipeline config) or Callable (if using directly), optional Custom image type identification function. :param identifier_kwargs: dict, optional Additional keyword arguments for the identifier function. - :param fitsloader_func: Callable, optional + :param fitsloader_func: str (from pipeline config) or Callable (if using directly), optional Custom FITS loading function. :param fitsloader_kwargs: dict, optional Additional keyword arguments for the FITS loader function. - :return: Generator yielding lists of DetImage objects. + :param require_data: bool + If True, raises an error if no files are found in the input source. + :return: {"images": list of DetImage} + Generator yielding lists of DetImage objects, stored under the key 'images' in the yielded dict. """ + if self.watch_mode: + self.logger.info("Running in watch mode, will monitor input source for new data, setting require_data=False") + require_data = False + identifier_kwargs = identifier_kwargs or {} if identifier_func is not None: self.set_identifier(identifier_func) @@ -222,28 +283,45 @@ def lazy_run(self, if fitsloader_func is not None: self.set_fitsloader(fitsloader_func) - if isinstance(input_source, (str, list)): + if isinstance(input_source, (str, list[str])): file_batches = self.from_files(input_source) for file_batch in file_batches: + ## if file_batch is empty, print a warning + if len(file_batch) == 0: + self.logger.warn("Empty input source. Skipping.") + if require_data: + raise FileNotFoundError("No FITS files found in the input source.") + continue + images_batch = [] for filename in file_batch: + self.logger.info("Processing file %s", filename) # Load FITS data if self._fitsloader_task is not None: input_data_array, input_headers = self._fitsloader_task(filename=filename, **fitsloader_kwargs) else: input_data_array, input_headers = load_image_fits(filename) + self.logger.debug("Loaded %d HDU from file %s", len(input_data_array), filename) # Determine image type if self._identifier_task is not None: image_type = self._identifier_task(filename=filename, **identifier_kwargs) else: - image_type = self._guess_image_type_from_header(filename=filename, **identifier_kwargs) + image_type = self._guess_image_type_from_header(input_headers[0], **identifier_kwargs) + self.logger.debug("Identified image type as %s for file %s", image_type, filename) # Build image objects images = self._build_image_objects(input_data_array, input_headers, image_type, filename=filename) images_batch.extend(images) - yield images_batch + yield {'images':images_batch} else: array_batches = self.from_arrays(input_source) for array_batch in array_batches: + ## if array_batch is empty, print a warning + if len(array_batch) == 0: + self.logger.warn("Empty input source. Skipping.") + if require_data: + raise ValueError("Empty input source.") + continue + images_batch = [] for input_data_array in array_batch: if self._identifier_task is not None: @@ -252,31 +330,35 @@ def lazy_run(self, image_type = 'unknown' images = self._build_image_objects(input_data_array, image_type, filename=None) images_batch.extend(images) - yield images_batch + yield {'images':images_batch} def run(self, - input_source: Union[str, list[str], Iterable[np.ndarray]], - identifier_func: Optional[Callable[..., str]] = None, - identifier_kwargs: Optional[Dict[str, Any]] = None, - fitsloader_func: Optional[Callable[..., str]] = None, - fitsloader_kwargs: Optional[Dict[str, Any]] = None - ) -> List: + input_source: str | list[str] | Iterable[np.ndarray], + identifier_func: Optional[str | Callable[..., str]] = None, + identifier_kwargs: Optional[dict[str, Any]] = None, + fitsloader_func: Optional[str | Callable[..., str]] = None, + fitsloader_kwargs: Optional[dict[str, Any]] = None, + require_data: bool = True, + ) -> dict[str, list]: """ Eager run method to generate image objects from input source. :param input_source: str or list of str or Iterable of np.ndarray Input source can be a path to FITS files (file, directory, glob pattern), a list of FITS file paths, or an iterable of numpy arrays. - :param identifier_func: Callable, optional + :param identifier_func: str (from pipeline config) or Callable (if using directly), optional Custom image type identification function. :param identifier_kwargs: dict, optional Additional keyword arguments for the identifier function. - :param fitsloader_func: Callable, optional + :param fitsloader_func: str (from pipeline config) or Callable (if using directly), optional Custom FITS loading function. :param fitsloader_kwargs: dict, optional Additional keyword arguments for the FITS loader function. - :return: List of DetImage objects. + :param require_data: bool + If True, raises an error if no files are found in the input source. + :return: {"images": list of DetImage} + List of DetImage objects stored under the key 'images' in the returned dict. """ all_images = [] - for images_batch in self.lazy_run(input_source, identifier_func, identifier_kwargs, fitsloader_func, fitsloader_kwargs): - all_images.extend(images_batch) - return all_images \ No newline at end of file + for batch in self.lazy_run(input_source, identifier_func, identifier_kwargs, fitsloader_func, fitsloader_kwargs, require_data): + all_images.extend(batch['images']) + return {'images':all_images} \ No newline at end of file diff --git a/eregion/tasks/preprocessing.py b/eregion/tasks/preprocessing.py new file mode 100644 index 0000000..064963e --- /dev/null +++ b/eregion/tasks/preprocessing.py @@ -0,0 +1,326 @@ +from copy import deepcopy + +from typing import Optional, Iterable, Iterator, Any +import numpy as np +import xarray as xr + +from eregion.tasks.task import LazyTask +from eregion.datamodels.image import DetImage, Output +from eregion.datamodels.image_utils import ensure_dataarray +from eregion.core.image_operations import subtract_from_image, sigma_clip_image + +from joblib import Parallel, delayed + +########### Bias Subtraction Task ########### +class BiasSubtraction(LazyTask): + required_keys = [] + + def __init__(self, + master_bias: DetImage | np.ndarray | xr.DataArray, + name: Optional[str] = "subtract_bias", + **kwargs + ): + """ + Initialize the BiasSubtraction task. kwargs must include 'master_bias' which can be a DetImage or numpy array. + :param master_bias: DetImage or np.ndarray or xr.DataArray + The master bias frame to subtract from science images. + :param name: Optional[str] + """ + + super().__init__(name=name, **kwargs) + + if isinstance(master_bias, DetImage): + self.master_bias_data = master_bias.data + elif isinstance(master_bias, np.ndarray) or isinstance(master_bias, xr.DataArray): + self.master_bias_data = ensure_dataarray(master_bias) + else: + raise ValueError("master_bias must be either a DetImage, a numpy array, or an xarray DataArray.") + self.meta.update({"master_bias": master_bias}) + + + def _process_single_image(self, img: DetImage) -> DetImage: + """ + Process a single DetImage by subtracting the master bias. + :param img: DetImage + The science image to be bias-subtracted. + :return: DetImage + The bias-subtracted science image. + """ + # check that dimensions match + if img.data.shape != self.master_bias_data.shape: + raise ValueError(f"Image shape {img.data.shape} does not match master bias shape {self.master_bias_data.shape}.") + # initialize a new DetImage for the bias-subtracted result as a copy of the input image + bias_subtracted = deepcopy(img) + bias_subtracted.data = ensure_dataarray(img.data - self.master_bias_data) + bias_subtracted.meta["bias_subtracted"] = True + bias_subtracted.image_type = f'bias_sub_{img.image_type}' + return bias_subtracted + + + def lazy_run( + self, + images: Iterable[DetImage], + batch_size: int = 1, + ) -> Iterator[list[DetImage]]: + """ + Lazy execution: yield processed batches as they complete. + - images: an iterable/stream of DetImage + - batch_size: number of images to process per batch + """ + + batch: list[DetImage] = [] + for img in images: + batch.append(img) + if len(batch) >= batch_size: + yield Parallel(n_jobs=self.n_jobs)(delayed(self._process_single_image)(i) for i in batch) + batch = [] + + if batch: + yield Parallel(n_jobs=self.n_jobs)(delayed(self._process_single_image)(i) for i in batch) + + + def run(self, images: list[DetImage]) -> list[DetImage]: + """ + Subtract the master bias from the given images. + :param images: list of DetImage + List of science images to be bias-subtracted. + :return: list of DetImage + List of bias-subtracted science images. + """ + ## call lazy_run and collect all results + results = [] + for batch in self.lazy_run(images, batch_size=len(images)): + results.extend(batch) + return results + + def __call__(self, image: np.ndarray) -> np.ndarray: + """ + Convenience non-Prefect path for raw arrays. + """ + return image - self.master_bias_data.values + + +########### Scan Subtraction Task ########### +class ScanSubtraction(LazyTask): + required_keys = ["which_scan"] + + def __init__(self, name: Optional[str] = None, **kwargs): + """ + Initialize the ScanSubtraction task. kwargs must include 'which_scan' indicating which scan to subtract. + :param name: Optional[str] + :param kwargs: + which_scan: str, required + One of 'serial_prescan', 'serial_overscan', 'parallel_prescan', 'parallel_overscan'. + method: str, optional + Method to use for subtraction. Default is 'simple_median'. + skip_rows: int, optional + Number of rows to skip from the start of the scan region. Default is 0. + skip_cols: int, optional + Number of columns to skip from the start of the scan region. Default is 0. + """ + super().__init__(name=name, **kwargs) + self.which_scan = kwargs["which_scan"] + if self.which_scan not in ["serial_prescan", "serial_overscan", "parallel_prescan", "parallel_overscan"]: + raise ValueError(f"Invalid which_scan value: {self.which_scan}") + + self.method = kwargs.get("method", "simple_median") + if self.method not in self.methods: + self.print_methods() + raise NotImplementedError(f"Method {self.method} not implemented for ScanSubtraction.") + self.method = globals()[self.method] + + + def _subtract_scan_per_output(self, output: Output, skip_rows: int = 0, skip_cols: int = 0): + axis, scan = self.which_scan.split("_") + getfunc = getattr(output, "get_" + scan) + + scan_data = getfunc(kind=axis) # xr.DataArray + trimmed_scan_data = scan_data.isel({'y': slice(skip_rows, None), 'x': slice(skip_cols, None)}) + + axisint = 1 if axis == "serial" else 0 + + subtracted_scan, subtract_value = subtract_from_image( + image=output.data.values, + subtract_object=trimmed_scan_data.values, + method=self.method, + axis=axisint + ) + return subtracted_scan, subtract_value + + + def _process_single_image(self, image: DetImage) -> DetImage: + """ + Process a single DetImage by subtracting the specified scan from each output. + :param image: DetImage + The image to be processed. + :return: DetImage + The processed image with scans subtracted. + """ + skip_rows = self.meta.get("skip_rows", 0) + skip_cols = self.meta.get("skip_cols", 0) + outputs = image.outputs.values() + results = Parallel(n_jobs=self.n_jobs)( + delayed(self._subtract_scan_per_output)(output, skip_rows, skip_cols) for output in outputs + ) + + new_image = deepcopy(image) + for output, (subtracted_scan, subtract_value) in zip(new_image.outputs.values(), results): + output.set_data_in_parent(subtracted_scan) + setattr(output, f"{self.which_scan}_median", subtract_value) + + new_image.meta[f"{self.which_scan}_subtracted"] = True + new_image.image_type = f'scan_sub_{image.image_type}' + return new_image + + + def lazy_run( + self, + images: Iterable[DetImage], + batch_size: int = 1, + ) -> Iterator[list[DetImage]]: + """ + Lazy execution: yield processed batches as they complete. + - images: an iterable/stream of DetImage + - batch_size: number of images to process per batch + """ + batch: list[DetImage] = [] + for img in images: + batch.append(img) + if len(batch) >= batch_size: + yield Parallel(n_jobs=self.n_jobs)(delayed(self._process_single_image)(i) for i in batch) + batch = [] + + if batch: + yield Parallel(n_jobs=self.n_jobs)(delayed(self._process_single_image)(i) for i in batch) + + + def run(self, images: list[DetImage]) -> list[DetImage]: + """ + Subtract the specified scan from the given images. + :param images: list of DetImage + List of images to be processed. + :return: list of DetImage + List of processed images with scans subtracted. + """ + ## call lazy_run and collect all results + results = [] + for batch in self.lazy_run(images, batch_size=len(images)): + results.extend(batch) + return results + + @property + def methods(self): + """ + Return a dictionary of available methods for creating master bias and their function signatures. + :return: dict + Dictionary with method names as keys and function signatures as values. + """ + return { + 'simple_median': 'core.image_operations.simple_median(data: np.ndarray) -> float[Any]', + 'median_by_axis': 'core.image_operations.median_by_axis(data: np.ndarray, axis: int) -> np.ndarray', + 'simple_mean': 'core.image_operations.simple_mean(data: np.ndarray) -> float[Any]', + } + +########### Cosmic Ray/Bad Pixel Masking ########### +class SigmaClipMasking(LazyTask): + required_keys = [] + + def __init__(self, name: Optional[str] = "sigma_clip_masking", sigma_clip_args: dict[str, Any] = None, **kwargs): + """ + Initialize the SigmaClipMasking task. + :param name: Optional[str] + :param sigma_clip_args: Dict[str, Any] + Arguments to pass to astropy.stats.sigma_clip function. + :param kwargs: + """ + super().__init__(name=name, **kwargs) + self.sigma_clip_args = sigma_clip_args or {"sigma": 5.0, "axis": None, "masked": True, "copy": True, "grow": 10.0} + + + def _sigma_clip_per_output(self, output: Output) -> xr.DataArray: + """ + Apply sigma clipping to a single output to create a mask. + :param output: Output + The output to be processed. + :return: xr.DataArray + The mask created from sigma clipping. + """ + sigma_clip_args_overscan = deepcopy(self.sigma_clip_args) + sigma_clip_args_overscan.pop("grow") + # clip serial overscan + serial_overscan_data = output.get_overscan(kind="serial").values + serial_overscan_clipped = sigma_clip_image(serial_overscan_data, **sigma_clip_args_overscan) + # clip parallel overscan + parallel_overscan_data = output.get_overscan(kind="parallel").values + parallel_overscan_clipped = sigma_clip_image(parallel_overscan_data, **sigma_clip_args_overscan) + # clip image data region + im_yslc = slice(None, output.parallel_overscan.start) + im_xslc = slice(None, output.serial_overscan.start) + image_data = output.data.isel(y=im_yslc, x=im_xslc).values + image_data_clipped = sigma_clip_image(image_data, **self.sigma_clip_args) + # combine masks + combined_clipped = np.ma.MaskedArray(output.data.values, mask=np.zeros_like(output.data.values)) + combined_clipped.mask[im_yslc, im_xslc] = image_data_clipped.mask + combined_clipped.mask[output.serial_overscan, :] |= serial_overscan_clipped.mask + combined_clipped.mask[:, output.parallel_overscan] |= parallel_overscan_clipped.mask + return xr.DataArray(combined_clipped, dims=["y", "x"]) + + + def _process_single_image(self, img: DetImage) -> DetImage: + """ + Process a single DetImage by applying sigma clipping to create a mask. + :param img: DetImage + The image to be processed. + :return: DetImage + The processed image with updated mask. + """ + new_image = deepcopy(img) + results = Parallel(n_jobs=self.n_jobs)( + delayed(self._sigma_clip_per_output)(output) for output in new_image.outputs.values() + ) + for output, clipped_data in zip(new_image.outputs.values(), results): + output.set_data_in_parent(clipped_data) + new_image.meta["bad_pixel_masked"] = True + new_image.image_type = f'bpm_{img.image_type}' + return new_image + + + def lazy_run( + self, + images: Iterable[DetImage], + batch_size: int = 1, + ) -> Iterator[list[DetImage]]: + """ + Lazy execution: yield processed batches as they complete. + - images: an iterable/stream of DetImage + - batch_size: number of images to process per batch + """ + batch: list[DetImage] = [] + for img in images: + batch.append(img) + if len(batch) >= batch_size: + yield Parallel(n_jobs=self.n_jobs)(delayed(self._process_single_image)(i) for i in batch) + batch = [] + + if batch: + yield Parallel(n_jobs=self.n_jobs)(delayed(self._process_single_image)(i) for i in batch) + + + def run(self, images: list[DetImage]) -> list[DetImage]: + """ + Apply sigma clipping to create bad pixel masks for the given images. + :param images: list of DetImage + List of images to be processed. + :return: list of DetImage + List of processed images with updated masks. + """ + ## call lazy_run and collect all results + results = [] + for batch in self.lazy_run(images, batch_size=len(images)): + results.extend(batch) + return results + + + + + diff --git a/eregion/tasks/task.py b/eregion/tasks/task.py new file mode 100644 index 0000000..c12d172 --- /dev/null +++ b/eregion/tasks/task.py @@ -0,0 +1,128 @@ +from collections.abc import Iterator +from abc import ABC, abstractmethod + +from pydantic import BaseModel, Field +from typing import Any + +import os +import logging +import multiprocessing +from astropy.time import Time + +# Base abstract class for tasks, should have a call method for direct execution and a run method for pipeline workflows +class Task(ABC): + required_keys = [] + + def __init__(self, name=None, **kwargs): + self.name = name or self.__class__.__name__ + self.n_jobs = kwargs.get('n_jobs') or self.get_default_n_jobs() + self.logger = self.configure_logger() + + self.meta = {} + self.meta.update(kwargs) + for key in self.required_keys: + if key not in kwargs: + raise ValueError(f"Missing required keyword argument: {key}") + + @abstractmethod + def run(self, *args, **kwargs): + """Run the task in a pipeline workflow.""" + pass + + @property + def methods(self): + """ + Return a dictionary of available methods for this task and their function signatures. + :return: dict + Dictionary with method names as keys and function signatures as values. + """ + return {} + + def print_methods(self): + """ + Print a list available methods for this task and their function signatures. + """ + print(f"Available methods for {self.name}:") + for method, signature in self.methods.items(): + print(f"- {method}: {signature}") + + def __call__(self, *args, **kwargs): + """Directly execute the task.""" + return self.run(*args, **kwargs) + + def configure_logger(self): + """ + Configure the logger for the task. + """ + logger = logging.getLogger(self.name) + handler = logging.StreamHandler() + formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') + handler.setFormatter(formatter) + logger.addHandler(handler) + logger.setLevel(logging.INFO) + return logger + + def set_logging_level(self, level: int): + """ + Set the logging level. + :param level: int + Logging level (e.g., logging.DEBUG, logging.INFO). + """ + self.logger.setLevel(level) + + ####### Some parallelization utility functions ####### + @staticmethod + def get_default_n_jobs(max_fraction: float = 0.75, min_jobs: int = 1) -> int: + """ + Determine a safe default number of parallel jobs. + + - Respects scheduler-provided limits + - Avoids using all cores by default + """ + # Common scheduler environment variables + for var in ("SLURM_CPUS_PER_TASK", "OMP_NUM_THREADS"): + if var in os.environ: + try: + return max(min_jobs, int(os.environ[var])) + except ValueError: + pass + + try: + cpu_count = multiprocessing.cpu_count() + except ModuleNotFoundError: + cpu_count = 1 + return max(min_jobs, int(cpu_count * max_fraction)) + + + +class LazyTask(Task): + """ + Abstract base class for tasks that support lazy (generator-based) execution. + """ + def __init__(self, name=None, watch_mode=False, poll_interval=10, **kwargs): + super().__init__(name=name, **kwargs) + self.watch_mode = watch_mode + self.poll_interval = poll_interval + + @abstractmethod + def lazy_run(self, *args, **kwargs) -> Iterator: + """Run the task lazily, yielding results.""" + pass + + @abstractmethod + def run(self, *args, **kwargs): + """Default run executes the lazy_run and collects all results.""" + return list(self.lazy_run(*args, **kwargs)) + + +class TaskResult(BaseModel): + task_name: str + data: dict[str, Any] + + params: dict[str, Any] = Field(default_factory=dict) + upstream: list[str] = Field(default_factory=list) + timestamp: Time = Field(default_factory=lambda: Time.now()) + + model_config = {"arbitrary_types_allowed": True} + +TaskResult.model_rebuild() diff --git a/playground/basic_ccd.yaml b/playground/basic_ccd.yaml deleted file mode 100644 index 4f26b02..0000000 --- a/playground/basic_ccd.yaml +++ /dev/null @@ -1,46 +0,0 @@ -## Config file for creating instances of an image class (here DetImage) for a basic CCD detector -## The DetImage instance contains the outputs from a "single" detector. -## The "image" can be stored in one FITS file with one extension that has all the detectors/outputs, -## OR in multiple FITS extensions, one per detector/output, OR in multiple FITS files, one per detector/output. -## The config structure should describe how to load one FITS file. ---- -class: DetImage # (this class can handle any general configuration, but you can create and use specialized child classes if needed) -alias: BASIC_CCD -description: Basic single CCD detector, one channel -detector_type: CCD # (specify the type of detector, e.g., CCD, CMOS, H2RG, etc.) - -# List of class objects, each containing a list of outputs. -# An output is described by the FITS file it is in, the extension in that file, and the slices that define its data. -objects: - - name: 'det1' - class: DetImage - filename_format: '*.fits' # Use wildcard to indicate the filename pattern - properties: # General properties of the detector across all outputs - pixel_size: 0.015 # mm - serial_number: '123456789' - saturation_level: 65535 # ADU - x_size: 2048 - y_size: 2048 - ext_id: 1 # FITS extension ID where the detector data is stored, if outputs are not specified individually - outputs: - - id: 'chan_1' - ext_id: 1 # FITS extension ID - ext_slice: Tuple[slice, slice] = (slice(0, 2048), slice(0, 2048)) # Slice of the ext_id that has the data for this output - data_slice: Tuple[slice, slice] = (slice(None), slice(None)) # Slice of the full DetImage data array where this output's data will go - serial_prescan: slice(0, 10) # relative to data_slice - serial_overscan: slice(2020, 2048) # relative to data_slice - parallel_prescan: slice(0, 10) # relative to data_slice - parallel_overscan: slice(2020, 2048) # relative to data_slice - parallel_axis: 0 # First axis in the data array (rows) represent parallel readout direction - readout_pixel: (0, 0) - gain: 1.0 # electrons/ADU - read_noise: 5.0 # electrons - bias_level: 1000 # ADU - - focal_plane_position: - x_cen: 0.0 # mm - y_cen: 0.0 # mm - angle: 0.0 # degrees - - - diff --git a/playground/test.ipynb b/playground/test.ipynb index f7e6f15..166eccc 100644 --- a/playground/test.ipynb +++ b/playground/test.ipynb @@ -1,35 +1,25 @@ { "cells": [ { - "cell_type": "code", - "id": "initial_id", - "metadata": { - "collapsed": true, - "ExecuteTime": { - "end_time": "2025-12-18T18:53:49.317649Z", - "start_time": "2025-12-18T18:53:48.076174Z" - } - }, - "source": [ - "from tasks.imagegen import ImageCreator\n", - "import matplotlib.pyplot as plt" - ], - "outputs": [], - "execution_count": 1 + "metadata": {}, + "cell_type": "markdown", + "source": "## Image Creation Example with DEIMOS detector configuration", + "id": "ba52ca83c18b38fa" }, { "metadata": { "ExecuteTime": { - "end_time": "2025-12-18T18:53:54.135008Z", - "start_time": "2025-12-18T18:53:49.962921Z" + "end_time": "2026-01-23T01:41:51.673791Z", + "start_time": "2026-01-23T01:41:47.625804Z" } }, "cell_type": "code", "source": [ + "from eregion.tasks.imagegen import ImageCreator\n", "# Initialize the ImageCreator with the detector configuration.\n", - "creator = ImageCreator(detector_config='deimos.yaml')\n", + "creator = ImageCreator(detector_config='../eregion/configs/detectors/deimos.yaml')\n", "# Run the image creation process. The input path can be a single FITS file, a list of FITS files, a directory containing FITS files, or a glob pattern.\n", - "images = creator.run(input_source='../data/deimos_raw/d0223_0107_cti.fits')" + "res = creator.run(input_source='../data/deimos_raw/d0223_0107_cti.fits.gz')" ], "id": "5ae90c36955d4557", "outputs": [ @@ -37,231 +27,62 @@ "name": "stderr", "output_type": "stream", "text": [ + "2026-01-22 17:41:48,259 - image_creator - INFO - Provided input_path is a FITS file, ../data/deimos_raw/d0223_0107_cti.fits.gz\n", + "2026-01-22 17:41:48,259 - image_creator - INFO - Processing file ../data/deimos_raw/d0223_0107_cti.fits.gz\n", "WARNING: VerifyWarning: Invalid 'BLANK' keyword in header. The 'BLANK' keyword is only applicable to integer data, and will be ignored in this HDU. [astropy.io.fits.hdu.image]\n" ] - }, - { - "data": { - "text/plain": [ - "10:53:50.004 | \u001B[38;5;184mWARNING\u001B[0m | astropy - VerifyWarning: Invalid 'BLANK' keyword in header. The 'BLANK' keyword is only applicable to integer data, and will be ignored in this HDU.\n" - ], - "text/html": [ - "
10:53:50.004 | WARNING | astropy - VerifyWarning: Invalid 'BLANK' keyword in header.  The 'BLANK' keyword is only applicable to integer data, and will be ignored in this HDU.\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:50.667 | \u001B[36mINFO\u001B[0m | prefect - Starting temporary server on \u001B[94mhttp://127.0.0.1:8899\u001B[0m\n", - "See \u001B[94mhttps://docs.prefect.io/v3/concepts/server#how-to-guides\u001B[0m for more information on running a dedicated Prefect server.\n" - ], - "text/html": [ - "
10:53:50.667 | INFO    | prefect - Starting temporary server on http://127.0.0.1:8899\n",
-       "See https://docs.prefect.io/v3/concepts/server#how-to-guides for more information on running a dedicated Prefect server.\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:52.497 | \u001B[36mINFO\u001B[0m | Task run '_guess_image_type_from_header' - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:52.497 | INFO    | Task run '_guess_image_type_from_header' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:52.552 | \u001B[36mINFO\u001B[0m | Flow run\u001B[35m 'adept-jaguarundi'\u001B[0m - Beginning flow run\u001B[35m 'adept-jaguarundi'\u001B[0m for flow\u001B[1;35m '-build-image-objects'\u001B[0m\n" - ], - "text/html": [ - "
10:53:52.552 | INFO    | Flow run 'adept-jaguarundi' - Beginning flow run 'adept-jaguarundi' for flow '-build-image-objects'\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:53.786 | \u001B[36mINFO\u001B[0m | Task run '_build_single_image_object-a15' - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:53.786 | INFO    | Task run '_build_single_image_object-a15' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:53.809 | \u001B[36mINFO\u001B[0m | Task run '_build_single_image_object-70c' - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:53.809 | INFO    | Task run '_build_single_image_object-70c' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:53.888 | \u001B[36mINFO\u001B[0m | Task run '_build_single_image_object-d0d' - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:53.888 | INFO    | Task run '_build_single_image_object-d0d' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:53.916 | \u001B[36mINFO\u001B[0m | Task run '_build_single_image_object-d5b' - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:53.916 | INFO    | Task run '_build_single_image_object-d5b' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:53.968 | \u001B[36mINFO\u001B[0m | Task run '_build_single_image_object-408' - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:53.968 | INFO    | Task run '_build_single_image_object-408' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:53.998 | \u001B[36mINFO\u001B[0m | Task run '_build_single_image_object-abf' - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:53.998 | INFO    | Task run '_build_single_image_object-abf' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:54.027 | \u001B[36mINFO\u001B[0m | Task run '_build_single_image_object-1b0' - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:54.027 | INFO    | Task run '_build_single_image_object-1b0' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:54.117 | \u001B[36mINFO\u001B[0m | Task run '_build_single_image_object-1b1' - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:54.117 | INFO    | Task run '_build_single_image_object-1b1' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "10:53:54.133 | \u001B[36mINFO\u001B[0m | Flow run\u001B[35m 'adept-jaguarundi'\u001B[0m - Finished in state \u001B[32mCompleted\u001B[0m()\n" - ], - "text/html": [ - "
10:53:54.133 | INFO    | Flow run 'adept-jaguarundi' - Finished in state Completed()\n",
-       "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], - "execution_count": 2 + "execution_count": 1 }, { "metadata": {}, "cell_type": "markdown", - "source": "Output of creator.run() is a list of DetImage objects (or whatever image class is specified in the detector configuration)", + "source": "Output of creator.run() is a dict (all task outputs should be in dict format) with list of DetImage objects (or whatever image class is specified in the detector configuration)", "id": "ceeebc91485589fa" }, { "metadata": { "ExecuteTime": { - "end_time": "2025-12-18T18:53:57.656306Z", - "start_time": "2025-12-18T18:53:57.652387Z" + "end_time": "2026-01-21T00:36:28.045625Z", + "start_time": "2026-01-21T00:36:28.043462Z" } }, "cell_type": "code", - "source": "images", + "source": "res", "id": "b6d0f9ea03d373eb", "outputs": [ { "data": { "text/plain": [ - "[,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ]" + "{'images': [,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]}" ] }, - "execution_count": 3, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 3 + "execution_count": 9 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-12-18T18:53:59.666532Z", - "start_time": "2025-12-18T18:53:58.800423Z" + "end_time": "2026-01-21T00:36:39.934480Z", + "start_time": "2026-01-21T00:36:39.177168Z" } }, "cell_type": "code", "source": [ "# Display the first DetImage from an input file\n", - "det_image = images[0]\n", + "det_image = res['images'][0]\n", "# Show the DetImage using its built-in show method that takes kwargs for plt.imshow\n", "## For example, to set the colormap to 'gray', and scale the values using vmin, vmax from ZScaleInterval:\n", "from astropy.visualization import ZScaleInterval\n", @@ -279,10 +100,13 @@ "image/png": "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" }, "metadata": {}, - "output_type": "display_data" + "output_type": "display_data", + "jetTransient": { + "display_id": null + } } ], - "execution_count": 4 + "execution_count": 10 }, { "metadata": { @@ -302,8 +126,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-12-18T18:56:51.741005Z", - "start_time": "2025-12-18T18:56:51.738705Z" + "end_time": "2026-01-21T00:36:45.378650Z", + "start_time": "2026-01-21T00:36:45.373347Z" } }, "cell_type": "code", @@ -316,18 +140,18 @@ "dict_keys(['chan_1', 'chan_2'])" ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 9 + "execution_count": 11 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-12-18T18:57:47.267108Z", - "start_time": "2025-12-18T18:57:46.853057Z" + "end_time": "2026-01-21T00:36:46.632512Z", + "start_time": "2026-01-21T00:36:46.228895Z" } }, "cell_type": "code", @@ -335,7 +159,7 @@ "# Plotting the first Output\n", "output = det_image.outputs['chan_1']\n", "vmin, vmax = interval.get_limits(output.data)\n", - "## Let's say the serial prescan and overscan regions are first and last 100 columns respectively\n", + "## Let's say the serial prescan and overscan regions are first and last 100 columns respectively (these can be set in the detector config file as well)\n", "output.serial_prescan = slice(0, 100)\n", "output.serial_overscan = slice(1024-100, 1024)\n", "## Same for parallel prescan and overscan regions, first and last 100 rows respectively\n", @@ -353,10 +177,13 @@ "image/png": "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" }, "metadata": {}, - "output_type": "display_data" + "output_type": "display_data", + "jetTransient": { + "display_id": null + } } ], - "execution_count": 11 + "execution_count": 12 }, { "metadata": { @@ -368,31 +195,34 @@ "cell_type": "markdown", "source": [ "The DEIMOS raw FITS used above contains 8 extensions, corresponding to 8 detectors in the focal plane, each detector with two outputs.\n", - "FocalPlaneImage() class can be used to combine multiple DetImage objects into a single focal plane representation." + "\n", + "FocalPlaneImage() class can be used to combine multiple DetImage objects into a single focal plane representation.\n", + "\n", + "The focal plane position information needs to be specified in the detector configuration file." ], "id": "be6ba93773869290" }, { "metadata": { "ExecuteTime": { - "end_time": "2025-12-18T18:58:10.305878Z", - "start_time": "2025-12-18T18:58:10.222747Z" + "end_time": "2026-01-21T00:36:59.413261Z", + "start_time": "2026-01-21T00:36:59.322019Z" } }, "cell_type": "code", "source": [ - "from datamodels.image import FocalPlaneImage\n", - "fpimage = FocalPlaneImage(num_detectors=8, dim=(4096*2, 2048*4), det_images=images)" + "from eregion.datamodels.image import FocalPlaneImage\n", + "fpimage = FocalPlaneImage(num_detectors=8, dim=(4096*2, 2048*4), det_images=res['images'])" ], "id": "2b5cab4588ea587c", "outputs": [], - "execution_count": 12 + "execution_count": 13 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-12-18T18:58:11.556826Z", - "start_time": "2025-12-18T18:58:11.546815Z" + "end_time": "2026-01-21T00:36:59.952996Z", + "start_time": "2026-01-21T00:36:59.941517Z" } }, "cell_type": "code", @@ -403,24 +233,24 @@ "data": { "text/plain": [ " det_id x_min x_max y_min y_max y_min_fp y_max_fp x_min_fp \\\n", - "0 det_1 -4096.0 -2048.0 0.0 4096.0 -0.0 4096.0 0.0 \n", - "1 det_2 -2048.0 0.0 0.0 4096.0 -0.0 4096.0 2048.0 \n", - "2 det_3 0.0 2048.0 0.0 4096.0 -0.0 4096.0 4096.0 \n", - "3 det_4 2048.0 4096.0 0.0 4096.0 -0.0 4096.0 6144.0 \n", - "4 det_5 2048.0 4096.0 -4096.0 0.0 4096.0 8192.0 6144.0 \n", - "5 det_6 0.0 2048.0 -4096.0 0.0 4096.0 8192.0 4096.0 \n", - "6 det_7 -2048.0 0.0 -4096.0 0.0 4096.0 8192.0 2048.0 \n", - "7 det_8 -4096.0 -2048.0 -4096.0 0.0 4096.0 8192.0 0.0 \n", + "0 det_1 -4096.0 -2048.0 0.0 4096.0 0 4096 0 \n", + "1 det_2 -2048.0 0.0 0.0 4096.0 0 4096 2048 \n", + "2 det_3 0.0 2048.0 0.0 4096.0 0 4096 4096 \n", + "3 det_4 2048.0 4096.0 0.0 4096.0 0 4096 6144 \n", + "4 det_5 2048.0 4096.0 -4096.0 0.0 4096 8192 6144 \n", + "5 det_6 0.0 2048.0 -4096.0 0.0 4096 8192 4096 \n", + "6 det_7 -2048.0 0.0 -4096.0 0.0 4096 8192 2048 \n", + "7 det_8 -4096.0 -2048.0 -4096.0 0.0 4096 8192 0 \n", "\n", " x_max_fp \n", - "0 2048.0 \n", - "1 4096.0 \n", - "2 6144.0 \n", - "3 8192.0 \n", - "4 8192.0 \n", - "5 6144.0 \n", - "6 4096.0 \n", - "7 2048.0 " + "0 2048 \n", + "1 4096 \n", + "2 6144 \n", + "3 8192 \n", + "4 8192 \n", + "5 6144 \n", + "6 4096 \n", + "7 2048 " ], "text/html": [ "
\n", @@ -460,10 +290,10 @@ " -2048.0\n", " 0.0\n", " 4096.0\n", - " -0.0\n", - " 4096.0\n", - " 0.0\n", - " 2048.0\n", + " 0\n", + " 4096\n", + " 0\n", + " 2048\n", " \n", " \n", " 1\n", @@ -472,10 +302,10 @@ " 0.0\n", " 0.0\n", " 4096.0\n", - " -0.0\n", - " 4096.0\n", - " 2048.0\n", - " 4096.0\n", + " 0\n", + " 4096\n", + " 2048\n", + " 4096\n", " \n", " \n", " 2\n", @@ -484,10 +314,10 @@ " 2048.0\n", " 0.0\n", " 4096.0\n", - " -0.0\n", - " 4096.0\n", - " 4096.0\n", - " 6144.0\n", + " 0\n", + " 4096\n", + " 4096\n", + " 6144\n", " \n", " \n", " 3\n", @@ -496,10 +326,10 @@ " 4096.0\n", " 0.0\n", " 4096.0\n", - " -0.0\n", - " 4096.0\n", - " 6144.0\n", - " 8192.0\n", + " 0\n", + " 4096\n", + " 6144\n", + " 8192\n", " \n", " \n", " 4\n", @@ -508,10 +338,10 @@ " 4096.0\n", " -4096.0\n", " 0.0\n", - " 4096.0\n", - " 8192.0\n", - " 6144.0\n", - " 8192.0\n", + " 4096\n", + " 8192\n", + " 6144\n", + " 8192\n", " \n", " \n", " 5\n", @@ -520,10 +350,10 @@ " 2048.0\n", " -4096.0\n", " 0.0\n", - " 4096.0\n", - " 8192.0\n", - " 4096.0\n", - " 6144.0\n", + " 4096\n", + " 8192\n", + " 4096\n", + " 6144\n", " \n", " \n", " 6\n", @@ -532,10 +362,10 @@ " 0.0\n", " -4096.0\n", " 0.0\n", - " 4096.0\n", - " 8192.0\n", - " 2048.0\n", - " 4096.0\n", + " 4096\n", + " 8192\n", + " 2048\n", + " 4096\n", " \n", " \n", " 7\n", @@ -544,28 +374,28 @@ " -2048.0\n", " -4096.0\n", " 0.0\n", - " 4096.0\n", - " 8192.0\n", - " 0.0\n", - " 2048.0\n", + " 4096\n", + " 8192\n", + " 0\n", + " 2048\n", " \n", " \n", "\n", "
" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 13 + "execution_count": 14 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-12-18T18:58:22.871077Z", - "start_time": "2025-12-18T18:58:16.520621Z" + "end_time": "2026-01-21T00:37:07.076278Z", + "start_time": "2026-01-21T00:37:00.687461Z" } }, "cell_type": "code", @@ -581,7 +411,7 @@ "" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, @@ -593,23 +423,642 @@ "image/png": "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" }, "metadata": {}, - "output_type": "display_data" + "output_type": "display_data", + "jetTransient": { + "display_id": null + } } ], - "execution_count": 14 + "execution_count": 15 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## Image creation test with single detector DEIMOS configuration", + "id": "f3849f9a6dbb6e9e" }, { "metadata": { "ExecuteTime": { - "end_time": "2025-11-13T02:44:02.027854Z", - "start_time": "2025-11-13T02:44:02.026692Z" + "end_time": "2026-01-21T00:39:17.538259Z", + "start_time": "2026-01-21T00:39:17.086506Z" } }, "cell_type": "code", - "source": "", - "id": "7cfffd7eac7e3055", - "outputs": [], - "execution_count": null + "source": [ + "from eregion.tasks.imagegen import ImageCreator\n", + "creator = ImageCreator(detector_config='../configs/detectors/deimos_singledet.yaml')\n", + "res = creator.run(input_source='/Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*_bias_0*.fits')\n", + "res" + ], + "id": "5edf36e4d279bb64", + "outputs": [ + { + "data": { + "text/plain": [ + "{'images': []}" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 19 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T00:39:18.782351Z", + "start_time": "2026-01-21T00:39:18.032018Z" + } + }, + "cell_type": "code", + "source": "res['images'][0].show(cmap='gray')", + "id": "24eecc7ef33cde00", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 20 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T00:39:34.274539Z", + "start_time": "2026-01-21T00:39:34.168880Z" + } + }, + "cell_type": "code", + "source": "res['images'][0].outputs['chan_1'].data.median(), res['images'][0].outputs['chan_2'].data.median()", + "id": "67320cac943e25f1", + "outputs": [ + { + "data": { + "text/plain": [ + "( Size: 8B\n", + " array(12818916.),\n", + " Size: 8B\n", + " array(15035037.))" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 22 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Master Bias Creation Example using tasks directly", + "id": "83482c51ffcfc722" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T01:13:04.595972Z", + "start_time": "2026-01-21T01:12:56.405297Z" + } + }, + "cell_type": "code", + "source": [ + "from eregion.tasks.imagegen import ImageCreator\n", + "from eregion.tasks.calibration import MasterBias\n", + "\n", + "# Create image creator and run it to get bias images\n", + "creator = ImageCreator(detector_config='../configs/detectors/deimos_singledet.yaml')\n", + "res = creator.run(input_source='/Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*_bias_*.fits')\n", + "bias_images = res['images']\n", + "\n", + "# Create master bias task and run it\n", + "master_bias_task = MasterBias(method='median')\n", + "mb_res = master_bias_task.run(bias_images=bias_images)" + ], + "id": "8273699a2ddbca87", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-01-20 17:12:57,092 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_0_2025-08-12T101355.400.fits\n", + "2026-01-20 17:12:57,997 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_1_2025-08-12T101425.647.fits\n", + "2026-01-20 17:12:58,863 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_2_2025-08-12T101455.893.fits\n", + "2026-01-20 17:12:59,844 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_3_2025-08-12T101526.139.fits\n", + "2026-01-20 17:13:00,301 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_4_2025-08-12T101556.386.fits\n", + "2026-01-20 17:13:00,770 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_5_2025-08-12T101626.632.fits\n", + "2026-01-20 17:13:01,238 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_6_2025-08-12T101656.879.fits\n", + "2026-01-20 17:13:01,699 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_7_2025-08-12T101727.125.fits\n", + "2026-01-20 17:13:02,574 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_8_2025-08-12T101757.371.fits\n", + "2026-01-20 17:13:03,033 - image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_9_2025-08-12T101827.618.fits\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T01:13:06.151786Z", + "start_time": "2026-01-21T01:13:06.145974Z" + } + }, + "cell_type": "code", + "source": "mb_res", + "id": "d260a6523b69b002", + "outputs": [ + { + "data": { + "text/plain": [ + "{'master_biases': []}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T01:13:12.884087Z", + "start_time": "2026-01-21T01:13:12.100193Z" + } + }, + "cell_type": "code", + "source": "mb_res['master_biases'][0].show(cmap='gray')", + "id": "c90a293437af53d9", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-13T02:44:02.027854Z", + "start_time": "2025-11-13T02:44:02.026692Z" + } + }, + "cell_type": "markdown", + "source": "## Example pipeline flow to create master bias", + "id": "fc29275839e791e6" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "This is an example pipeline flow configuration for creating a master bias frame (saved in configs/pipeline_flows/masterbias_example.yaml).\n", + "\n", + "NOTE: Provide absolute paths to the detector configuration and input data files when running the pipeline." + ], + "id": "b908f279322ae471" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T00:12:38.886952Z", + "start_time": "2026-01-21T00:12:38.882447Z" + } + }, + "cell_type": "code", + "source": [ + "_ = \"\"\"\n", + "debug: false # Optional: set to true to enable debug mode (more verbose logging, etc.)\n", + "pipeline:\n", + " - name: image_creator\n", + " task: tasks.imagegen.ImageCreator\n", + " lazy: false\n", + " init: # Initialization parameters for the image creator\n", + " detector_config: \"/Users/yashvi/Desktop/Detector Characterization Tools/eregion/configs/detectors/deimos_singledet.yaml\" # For required params, see the task documentation\n", + " # Any additional params are passed as kwargs that get set in the task's meta dict\n", + " # See task documentation for which kwargs are used\n", + "\n", + " run: # Run-time inputs and parameters for the image creator\n", + " params: # Check which params go here in the task documentation\n", + " input_source: \"/Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*_bias_*.fits\"\n", + " identifier_func: tasks.custom.guess_image_type_from_filename_DEIMOS\n", + "\n", + "\n", + " - name: master_bias\n", + " task: tasks.calibration.MasterBias\n", + " lazy: false\n", + " init:\n", + " method: \"median\" # Optional param (kwarg) method to combine bias frames; see task documentation for options\n", + " run:\n", + " inputs: # use inputs to specify data input coming in from output of other tasks\n", + " bias_images: image_creator.data.images # E.g. Input images from the image creator task's output\n", + " # Each task's outputs are objects of class TaskResult\n", + " # TaskResult.data is a dict containing the actual data produced by the task\n", + " # Check which outputs are available in the task documentation\n", + "\n", + " depends_on: [image_creator]\n", + "\"\"\"" + ], + "id": "866e2f03069e52ae", + "outputs": [], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T00:29:50.671699Z", + "start_time": "2026-01-21T00:29:49.513187Z" + } + }, + "cell_type": "code", + "source": [ + "from eregion.pipeline.engine import PipelineEngine\n", + "mb = PipelineEngine(pipeline_config='../configs/pipeline_flows/masterbias_example.yaml')" + ], + "id": "28ecbb8a52e19198", + "outputs": [], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T00:30:04.504848Z", + "start_time": "2026-01-21T00:29:54.115016Z" + } + }, + "cell_type": "code", + "source": "results = mb.run()", + "id": "a568d9bdf5952aa2", + "outputs": [ + { + "data": { + "text/plain": [ + "16:29:54.775 | \u001B[36mINFO\u001B[0m | prefect - Starting temporary server on \u001B[94mhttp://127.0.0.1:8293\u001B[0m\n", + "See \u001B[94mhttps://docs.prefect.io/v3/concepts/server#how-to-guides\u001B[0m for more information on running a dedicated Prefect server.\n" + ], + "text/html": [ + "
16:29:54.775 | INFO    | prefect - Starting temporary server on http://127.0.0.1:8293\n",
+       "See https://docs.prefect.io/v3/concepts/server#how-to-guides for more information on running a dedicated Prefect server.\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:29:56.620 | \u001B[36mINFO\u001B[0m | Flow run\u001B[35m 'green-rat'\u001B[0m - Beginning flow run\u001B[35m 'green-rat'\u001B[0m for flow\u001B[1;35m 'pipeline-flow'\u001B[0m\n" + ], + "text/html": [ + "
16:29:56.620 | INFO    | Flow run 'green-rat' - Beginning flow run 'green-rat' for flow 'pipeline-flow'\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:29:56.888 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_0_2025-08-12T101355.400.fits\n" + ], + "text/html": [ + "
16:29:56.888 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_0_2025-08-12T101355.400.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:29:57.780 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_1_2025-08-12T101425.647.fits\n" + ], + "text/html": [ + "
16:29:57.780 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_1_2025-08-12T101425.647.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:29:58.614 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_2_2025-08-12T101455.893.fits\n" + ], + "text/html": [ + "
16:29:58.614 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_2_2025-08-12T101455.893.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:29:59.045 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_3_2025-08-12T101526.139.fits\n" + ], + "text/html": [ + "
16:29:59.045 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_3_2025-08-12T101526.139.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:29:59.882 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_4_2025-08-12T101556.386.fits\n" + ], + "text/html": [ + "
16:29:59.882 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_4_2025-08-12T101556.386.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:30:00.721 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_5_2025-08-12T101626.632.fits\n" + ], + "text/html": [ + "
16:30:00.721 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_5_2025-08-12T101626.632.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:30:01.150 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_6_2025-08-12T101656.879.fits\n" + ], + "text/html": [ + "
16:30:01.150 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_6_2025-08-12T101656.879.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:30:01.581 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_7_2025-08-12T101727.125.fits\n" + ], + "text/html": [ + "
16:30:01.581 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_7_2025-08-12T101727.125.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:30:02.006 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_8_2025-08-12T101757.371.fits\n" + ], + "text/html": [ + "
16:30:02.006 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_8_2025-08-12T101757.371.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:30:02.439 | \u001B[36mINFO\u001B[0m | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_9_2025-08-12T101827.618.fits\n" + ], + "text/html": [ + "
16:30:02.439 | INFO    | image_creator - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_9_2025-08-12T101827.618.fits\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:30:03.299 | \u001B[36mINFO\u001B[0m | Task run 'image_creator-82f' - Finished in state \u001B[32mCompleted\u001B[0m()\n" + ], + "text/html": [ + "
16:30:03.299 | INFO    | Task run 'image_creator-82f' - Finished in state Completed()\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:30:04.488 | \u001B[36mINFO\u001B[0m | Task run 'master_bias-9b4' - Finished in state \u001B[32mCompleted\u001B[0m()\n" + ], + "text/html": [ + "
16:30:04.488 | INFO    | Task run 'master_bias-9b4' - Finished in state Completed()\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "16:30:04.501 | \u001B[36mINFO\u001B[0m | Flow run\u001B[35m 'green-rat'\u001B[0m - Finished in state \u001B[32mCompleted\u001B[0m()\n" + ], + "text/html": [ + "
16:30:04.501 | INFO    | Flow run 'green-rat' - Finished in state Completed()\n",
+       "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T00:23:59.162898Z", + "start_time": "2026-01-21T00:23:59.159352Z" + } + }, + "cell_type": "markdown", + "source": "results is a dict with task names as keys and TaskResult objects as values.", + "id": "e83d597e25836c66" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-01-21T00:30:45.673209Z", + "start_time": "2026-01-21T00:30:45.666951Z" + } + }, + "cell_type": "code", + "source": "results['master_bias']", + "id": "f9c4ede898c6a1f1", + "outputs": [ + { + "data": { + "text/plain": [ + "TaskResult(task_name='master_bias', data={'master_biases': []}, params={'init': {'method': 'median'}, 'run': {}, 'lazy': False}, upstream=['image_creator'], timestamp=