pyreduce-astro 0.7a5__cp314-cp314-win_amd64.whl → 0.7a6__cp314-cp314-win_amd64.whl

pyreduce/__main__.py

@@ -4,8 +4,8 @@ PyReduce command-line interface.
 Usage:
     uv run reduce --help
     uv run reduce run UVES HD132205 --night 2010-04-01
-    uv run reduce run UVES HD132205 --steps bias,flat,orders
-    uv run reduce bias UVES HD132205
+    uv run reduce run UVES HD132205 --steps bias,flat,trace
+    uv run reduce trace UVES HD132205
     uv run reduce combine --output combined.fits *.final.fits
 """
 
@@ -14,7 +14,7 @@ import click
 ALL_STEPS = (
     "bias",
     "flat",
-    "orders",
+    "trace",
     "curvature",
     "scatter",
     "norm_flat",
@@ -279,30 +279,94 @@ def make_step_command(step_name):
 
     @click.command(name=step_name)
     @click.argument("instrument")
-    @click.argument("target")
+    @click.argument("target", required=False, default="")
     @click.option("--night", "-n", default=None, help="Observation night")
     @click.option("--channel", "-c", default=None, help="Instrument channel")
     @click.option("--base-dir", "-b", default=None, help="Base directory")
     @click.option("--input-dir", "-i", default="raw", help="Input directory")
     @click.option("--output-dir", "-o", default="reduced", help="Output directory")
     @click.option("--plot", "-p", default=0, help="Plot level")
-    def cmd(instrument, target, night, channel, base_dir, input_dir, output_dir, plot):
+    @click.option(
+        "--file",
+        "-f",
+        default=None,
+        help="Specific input file (bypasses file discovery)",
+    )
+    def cmd(
+        instrument, target, night, channel, base_dir, input_dir, output_dir, plot, file
+    ):
         from .configuration import get_configuration_for_instrument
         from .reduce import main as reduce_main
 
-        config = get_configuration_for_instrument(instrument)
-        reduce_main(
-            instrument=instrument,
-            target=target,
-            night=night,
-            channels=channel,
-            steps=(step_name,),
-            base_dir=base_dir or "",
-            input_dir=input_dir,
-            output_dir=output_dir,
-            configuration=config,
-            plot=plot,
-        )
+        if file:
+            # Direct file mode: run step on specific file
+            import os
+
+            import numpy as np
+
+            from . import reduce as reduce_module
+            from .configuration import get_configuration_for_instrument
+            from .instruments.instrument_info import load_instrument
+
+            inst = load_instrument(instrument)
+            channel = channel or (inst.channels[0] if inst.channels else "")
+            output_dir_full = output_dir
+            if base_dir:
+                output_dir_full = os.path.join(base_dir, output_dir)
+            os.makedirs(output_dir_full, exist_ok=True)
+
+            # Load configuration for this step
+            config = get_configuration_for_instrument(instrument)
+            step_config = config.get(step_name, {})
+            step_config["plot"] = plot
+
+            # Get the step class
+            step_classes = {
+                "bias": reduce_module.Bias,
+                "flat": reduce_module.Flat,
+                "trace": reduce_module.OrderTracing,
+                "curvature": reduce_module.SlitCurvatureDetermination,
+                "scatter": reduce_module.BackgroundScatter,
+                "norm_flat": reduce_module.NormalizeFlatField,
+                "wavecal_master": reduce_module.WavelengthCalibrationMaster,
+                "wavecal_init": reduce_module.WavelengthCalibrationInitialize,
+                "wavecal": reduce_module.WavelengthCalibrationFinalize,
+                "freq_comb_master": reduce_module.LaserFrequencyCombMaster,
+                "freq_comb": reduce_module.LaserFrequencyCombFinalize,
+                "science": reduce_module.ScienceExtraction,
+                "continuum": reduce_module.ContinuumNormalization,
+            }
+
+            if step_name not in step_classes:
+                raise click.ClickException(
+                    f"Step '{step_name}' does not support --file option"
+                )
+
+            step_class = step_classes[step_name]
+            step = step_class(
+                inst,
+                channel,
+                target=target or "",
+                night=night,
+                output_dir=output_dir_full,
+                order_range=None,
+                **step_config,
+            )
+            step.run(files=np.array([file]), mask=None, bias=None)
+        else:
+            config = get_configuration_for_instrument(instrument)
+            reduce_main(
+                instrument=instrument,
+                target=target,
+                night=night,
+                channels=channel,
+                steps=(step_name,),
+                base_dir=base_dir or "",
+                input_dir=input_dir,
+                output_dir=output_dir,
+                configuration=config,
+                plot=plot,
+            )
 
     cmd.__doc__ = f"Run the '{step_name}' step."
     return cmd

pyreduce/cli.py

@@ -287,7 +287,7 @@ def run(config_file: str, steps: str, skip_existing: bool, plot: int):
         pipe = pipe.flat(_expand_globs(files["flat"]))
 
     if "trace" in config_steps:
-        trace_files = files.get("orders") or files.get("flat")
+        trace_files = files.get("trace") or files.get("flat")
         pipe = pipe.trace_orders(_expand_globs(trace_files) if trace_files else None)
 
     if "scatter" in config_steps:

pyreduce/combine_frames.py

@@ -305,6 +305,14 @@ def combine_frames(
     if instrument is None or isinstance(instrument, str):
         instrument = load_instrument(instrument)
 
+    # For multi-amplifier instruments, use simple combination since the
+    # row-by-row approach doesn't work with multi-extension assembly
+    if instrument.config.amplifiers is not None:
+        logger.debug("Multi-amplifier instrument detected, using simple combination")
+        return combine_frames_simple(
+            files, instrument, channel, extension=extension, dtype=dtype, **kwargs
+        )
+
     # summarize file info
     logger.debug("Files:")
     for i, fname in zip(range(len(files)), files, strict=False):

pyreduce/instruments/common.py

@@ -24,6 +24,29 @@ from .models import InstrumentConfig
 logger = logging.getLogger(__name__)
 
 
+def parse_iraf_section(section_str):
+    """Parse IRAF-style section string into pixel coordinates.
+
+    IRAF format: [x1:x2,y1:y2] where coordinates are 1-based inclusive.
+
+    Parameters
+    ----------
+    section_str : str
+        Section string like "[28:1179,1:4616]"
+
+    Returns
+    -------
+    x1, x2, y1, y2 : int
+        1-based inclusive pixel coordinates
+    """
+    # Remove brackets and split
+    s = section_str.strip("[]")
+    x_part, y_part = s.split(",")
+    x1, x2 = map(int, x_part.split(":"))
+    y1, y2 = map(int, y_part.split(":"))
+    return x1, x2, y1, y2
+
+
 def find_first_index(arr, value):
     """find the first element equal to value in the array arr"""
     try:
@@ -121,7 +144,7 @@ class Instrument:
             "target": ObjectFilter(self.config.target, regex=True),
             "bias": Filter(self.config.kw_bias),
             "flat": Filter(self.config.kw_flat),
-            "orders": Filter(self.config.kw_orders),
+            "trace": Filter(self.config.kw_orders),
             "curvature": Filter(self.config.kw_curvature),
             "scatter": Filter(self.config.kw_scatter),
             "wave": Filter(self.config.kw_wave),
@@ -142,7 +165,7 @@ class Instrument:
             "flat",
             "wavecal_master",
             "freq_comb_master",
-            "orders",
+            "trace",
             "scatter",
             "curvature",
         ]
@@ -224,6 +247,147 @@ class Instrument:
 
         return config, info
 
+    def get_amplifier_extensions(self, header):
+        """Get list of amplifier extensions if multi-amp mode is configured.
+
+        Parameters
+        ----------
+        header : fits.Header
+            Primary FITS header
+
+        Returns
+        -------
+        list or None
+            List of extension names/indices if multi-amp, None otherwise
+        """
+        if self.config.amplifiers is None:
+            return None
+
+        amp_config = self.config.amplifiers
+        # Get number of amplifiers
+        if isinstance(amp_config.count, int):
+            n_amps = amp_config.count
+        else:
+            n_amps = header.get(amp_config.count)
+            if n_amps is None:
+                logger.warning(
+                    "Amplifier count keyword '%s' not found in header",
+                    amp_config.count,
+                )
+                return None
+
+        # Generate extension names from template
+        extensions = []
+        for n in range(1, n_amps + 1):
+            ext_name = amp_config.extension_template.format(n=n)
+            extensions.append(ext_name)
+
+        return extensions
+
+    def assemble_amplifiers(self, hdu, amp_extensions, channel):
+        """Assemble multi-amplifier readout into single frame.
+
+        Reads data from multiple FITS extensions, each representing one
+        amplifier's readout region, and assembles them into a single frame
+        using DATASEC/DETSEC mappings.
+
+        Parameters
+        ----------
+        hdu : HDUList
+            Open FITS file
+        amp_extensions : list
+            List of extension names to read
+        channel : str
+            Instrument channel
+
+        Returns
+        -------
+        data : ndarray
+            Assembled frame (float32)
+        header : fits.Header
+            Combined header with per-amplifier e_gain{n}, e_readn{n}
+        """
+        amp_config = self.config.amplifiers
+        h_prime = hdu[0].header
+
+        # First pass: determine output size and collect amp info
+        xmax, ymax = 0, 0
+        amp_info = []
+
+        for ext in amp_extensions:
+            h = hdu[ext].header
+            datasec = parse_iraf_section(h[amp_config.datasec])
+            detsec = parse_iraf_section(h[amp_config.detsec])
+
+            # DETSEC gives the destination in the assembled image
+            xmax = max(xmax, detsec[1])
+            ymax = max(ymax, detsec[3])
+
+            amp_info.append(
+                {
+                    "ext": ext,
+                    "datasec": datasec,
+                    "detsec": detsec,
+                    "gain": h.get(amp_config.gain, 1.0),
+                    "readnoise": h.get(amp_config.readnoise, 0.0),
+                }
+            )
+
+        # Allocate output array
+        assembled = np.zeros((ymax, xmax), dtype=np.float32)
+
+        # Second pass: place each amplifier's data
+        for info in amp_info:
+            # Extract valid data region (DATASEC is 1-based inclusive)
+            dx1, dx2, dy1, dy2 = info["datasec"]
+            raw = hdu[info["ext"]].data[dy1 - 1 : dy2, dx1 - 1 : dx2]
+
+            # Place into output at DETSEC location (1-based inclusive)
+            ox1, ox2, oy1, oy2 = info["detsec"]
+            assembled[oy1 - 1 : oy2, ox1 - 1 : ox2] = raw
+
+        # Build combined header
+        header = hdu[amp_extensions[0]].header.copy()
+        header.extend(h_prime, strip=False)
+
+        # Add standard header info first (sets e_orient, e_transpose, etc.)
+        header = self.add_header_info(header, channel)
+        header["e_input"] = (
+            os.path.basename(hdu.filename()),
+            "Original input filename",
+        )
+
+        # Store per-amplifier calibration values
+        # Use e_namps (not e_ampl) to avoid triggering clipnflip's multi-amp path
+        # since we've already assembled the frame
+        header["e_namps"] = (len(amp_info), "Number of amplifiers in raw data")
+        for i, info in enumerate(amp_info, 1):
+            header[f"HIERARCH e_gain{i}"] = (
+                info["gain"],
+                f"Gain for amplifier {i}",
+            )
+            header[f"HIERARCH e_readn{i}"] = (
+                info["readnoise"],
+                f"Readnoise for amplifier {i}",
+            )
+
+        # Override e_gain/e_readn with median across amplifiers
+        gains = [info["gain"] for info in amp_info]
+        readnoises = [info["readnoise"] for info in amp_info]
+        header["e_gain"] = (float(np.median(gains)), "Median gain across amplifiers")
+        header["e_readn"] = (
+            float(np.median(readnoises)),
+            "Median readnoise across amplifiers",
+        )
+
+        # Override bounds for assembled frame (full frame, no prescan/overscan)
+        header["e_xlo"] = 0
+        header["e_xhi"] = xmax
+        header["e_ylo"] = 0
+        header["e_yhi"] = ymax
+
+        return assembled, header
+
     def load_fits(
         self, fname, channel, extension=None, mask=None, header_only=False, dtype=None
     ):
@@ -235,6 +399,9 @@ class Instrument:
         data is clipnflipped
         mask is applied
 
+        For multi-amplifier instruments, data from multiple extensions
+        is assembled into a single frame before clipnflip.
+
         Parameters
         ----------
         fname : str
@@ -266,20 +433,39 @@ class Instrument:
 
         hdu = fits.open(fname)
         h_prime = hdu[0].header
-        if extension is None:
-            extension = self.get_extension(h_prime, channel)
 
-        header = hdu[extension].header
-        if extension != 0:
-            header.extend(h_prime, strip=False)
-        header = self.add_header_info(header, channel)
-        header["e_input"] = (os.path.basename(fname), "Original input filename")
+        # Check for multi-amplifier mode
+        amp_extensions = self.get_amplifier_extensions(h_prime)
+
+        if amp_extensions is not None:
+            # Multi-amplifier path: assemble from multiple extensions
+            if header_only:
+                # For header_only, just return first extension header + primary
+                header = hdu[amp_extensions[0]].header.copy()
+                header.extend(h_prime, strip=False)
+                header = self.add_header_info(header, channel)
+                header["e_input"] = (os.path.basename(fname), "Original input filename")
+                hdu.close()
+                return header
+
+            data, header = self.assemble_amplifiers(hdu, amp_extensions, channel)
+            data = clipnflip(data, header)
+        else:
+            # Single extension path (original behavior)
+            if extension is None:
+                extension = self.get_extension(h_prime, channel)
+
+            header = hdu[extension].header
+            if extension != 0:
+                header.extend(h_prime, strip=False)
+            header = self.add_header_info(header, channel)
+            header["e_input"] = (os.path.basename(fname), "Original input filename")
 
-        if header_only:
-            hdu.close()
-            return header
+            if header_only:
+                hdu.close()
+                return header
 
-        data = clipnflip(hdu[extension].data, header)
+            data = clipnflip(hdu[extension].data, header)
 
         if dtype is not None:
             data = data.astype(dtype)
@@ -398,10 +584,10 @@ class Instrument:
                 "night": night,
                 "flat": self.config.id_flat,
             },
-            "orders": {
+            "trace": {
                 "instrument": self.config.id_instrument,
                 "night": night,
-                "orders": self.config.id_orders,
+                "trace": self.config.id_orders,
             },
             "scatter": {
                 "instrument": self.config.id_instrument,

pyreduce/instruments/harpn.py

@@ -70,7 +70,7 @@ class HARPN(Instrument):
             "flat",
             "wavecal_master",
             "freq_comb_master",
-            "orders",
+            "trace",
             "scatter",
         ]
 
@@ -109,7 +109,7 @@ class HARPN(Instrument):
         expectations = {
             "bias": {"instrument": "HARPN", "night": night, "type": r"BIAS,BIAS"},
             "flat": {"instrument": "HARPN", "night": night, "type": r"LAMP,LAMP,TUN"},
-            "orders": {
+            "trace": {
                 "instrument": "HARPN",
                 "night": night,
                 "type": id_orddef,

pyreduce/instruments/harps.py

@@ -111,7 +111,7 @@ class HARPS(Instrument):
             "flat",
             "wavecal_master",
             "freq_comb_master",
-            "orders",
+            "trace",
             "scatter",
             "curvature",
         ]
@@ -202,7 +202,7 @@ class HARPS(Instrument):
         expectations = {
             "bias": {"instrument": "HARPS", "night": night, "type": r"BIAS,BIAS"},
             "flat": {"instrument": "HARPS", "night": night, "type": r"(LAMP,LAMP),.*"},
-            "orders": {
+            "trace": {
                 "instrument": "HARPS",
                 "night": night,
                 "fiber": fiber,

pyreduce/instruments/models.py

@@ -48,6 +48,27 @@ class FileClassification(BaseModel):
     model_config = ConfigDict(extra="allow")
 
 
+class AmplifiersConfig(BaseModel):
+    """Configuration for multi-amplifier readout assembly.
+
+    Used when detector data is split across multiple FITS extensions,
+    each with its own gain/readnoise and region mapping.
+    """
+
+    # Extension naming: template with {n} placeholder, e.g. "AMPLIFIER {n:02d}"
+    extension_template: str
+    # Number of amplifiers: header keyword or literal int
+    count: str | int
+    # Header keywords in each extension for calibration values
+    gain: str = "GAIN"
+    readnoise: str = "RDNOISE"
+    # Header keywords for region mapping (IRAF section format)
+    datasec: str = "DATASEC"
+    detsec: str = "DETSEC"
+
+    model_config = ConfigDict(extra="forbid")
+
+
 class InstrumentConfig(BaseModel):
     """Configuration for an astronomical instrument.
 
@@ -76,6 +97,9 @@ class InstrumentConfig(BaseModel):
     orientation: int | list[int] = 0
     transpose: bool = False
 
+    # Multi-amplifier readout (optional)
+    amplifiers: AmplifiersConfig | None = None
+
     # Detector dimensions
     naxis_x: str | int = "NAXIS1"
     naxis_y: str | int = "NAXIS2"