pyreduce-astro 0.6.0__cp312-cp312-macosx_11_0_arm64.whl

pyreduce/instruments/crires_plus.json

@@ -0,0 +1,63 @@
+{
+    "__comment__": "The upgraded CRIRES at ESO VLT, a cross-dispersed IR spectrograph for YJHKLM bands.",
+    "__instrument__": "CRIRES_PLUS",
+    "instrument": "INSTRUME",
+    "id_instrument": "CRIRES",
+    "telescope": "VLT",
+    "date": "DATE-OBS",
+    "date_format": "fits",
+    "id_mode": "ESO INS MODE",
+    "id_band": "ESO INS WLEN ID",
+    "id_decker": "ESO INS OPTI8 ID",
+    "id_lamp": "ESO INS1 LAMP? ID",
+    "modes": ["J1228"],
+    "deckers": ["OPEN", "pos1", "pos2"],
+    "bands": ["Y", "J", "H", "K", "L", "M"],
+    "settings": ["Y1029", "Y1028", "J1232", "J1228", "J1226", "H1582", "H1575", "H1567", "H1559", "K2217", "K2192", "K2166", "K2148", "L3426", "L3412", "L3377", "L3340", "L3302", "L3262", "L3244", "M4519", "M4504", "M4461", "M4416", "M4368", "M4318", "M4266", "M4211", "M4187"],
+    "chips": ["det1", "det2", "det3"],
+    "extension": "CHIP1.INT1",
+    "orientation": 0,
+    "transpose": false,
+    "prescan_x": 5,
+    "overscan_x": 5,
+    "prescan_y": 5,
+    "overscan_y": 5,
+    "naxis_x": "NAXIS1",
+    "naxis_y": "NAXIS2",
+    "gain": "HIERARCH ESO DET CHIP GAIN",
+    "readnoise": "HIERARCH ESO DET CHIP RON",
+    "dark": "HIERARCH ESO DET DIT",
+    "sky": 0,
+    "exposure_time": "EXPTIME",
+    "image_type": "OBJECT",
+    "category": "HIERARCH ESO DPR CATG",
+    "ra": "RA",
+    "dec": "DEC",
+    "jd": "MJD-OBS",
+    "longitude": "HIERARCH ESO TEL GEOLON",
+    "latitude": "HIERARCH ESO TEL GEOLAT",
+    "altitude": "HIERARCH ESO TEL GEOELEV",
+    "target": "OBJECT",
+    "observation_type": "ESO DPR TYPE",
+
+    "id_detcheck": "FLAT,LAMP,DETCHECK",
+    "id_lamp_wavecal" : "UNe_HCL",
+    "id_lamp_etalon": "Etalon_Halogen",
+
+    "kw_bias" : "ESO DPR TYPE",
+    "kw_flat" : "ESO DPR TYPE",
+    "kw_curvature": "ESO DPR TYPE",
+    "kw_scatter": "ESO DPR TYPE",
+    "kw_orders" : "ESO DPR TYPE",
+    "kw_wave": "ESO DPR TYPE",
+    "kw_comb": "ESO DPR TYPE",
+    "kw_spec": "ESO DPR TYPE",
+    "id_bias": "DARK",
+    "id_flat": "FLAT",
+    "id_orders": "FLAT",
+    "id_curvature": "WAVE,FPET",
+    "id_scatter": "FLAT",
+    "id_wave": "WAVE,UNE",
+    "id_comb": "WAVE,FPET",
+    "id_spec": "STAR,*,*"
+}

pyreduce/instruments/crires_plus.py

@@ -0,0 +1,103 @@
+"""
+Handles instrument specific info for the HARPS spectrograph
+
+Mostly reading data from the header
+"""
+
+import logging
+import os.path
+import re
+from itertools import product
+
+import numpy as np
+
+from .common import Instrument
+from .filters import Filter
+
+logger = logging.getLogger(__name__)
+
+
+class CRIRES_PLUS(Instrument):
+    def __init__(self):
+        super().__init__()
+        self.filters["lamp"] = Filter(self.info["id_lamp"])
+        self.filters["band"] = Filter(self.info["id_band"])
+        self.filters["decker"] = Filter(self.info["id_decker"])
+        self.shared += ["band", "decker"]
+
+    def add_header_info(self, header, mode, **kwargs):
+        """read data from header and add it as REDUCE keyword back to the header"""
+        # "Normal" stuff is handled by the general version, specific changes to values happen here
+        # alternatively you can implement all of it here, whatever works
+        band, decker, detector = self.parse_mode(mode)
+        header = super().add_header_info(header, band)
+        self.load_info()
+
+        return header
+
+    def get_supported_modes(self):
+        settings = self.info["settings"]
+        deckers = self.info["deckers"]
+        detectors = self.info["chips"]
+        modes = [
+            "_".join([s, d, c]) for s, d, c in product(settings, deckers, detectors)
+        ]
+        return modes
+
+    def parse_mode(self, mode):
+        pattern = r"([YJHKLM]\d{4})(_(Open|pos1|pos2))?_det(\d)"
+        match = re.match(pattern, mode, flags=re.IGNORECASE)
+        if not match:
+            logger.error("no mode match")
+        else:
+            band = match.group(1).upper()
+        if match.group(3) is not None:
+            decker = match.group(3).lower().capitalize()
+        else:
+            decker = "Open"
+        detector = match.group(4)
+        return band, decker, detector
+
+    def get_expected_values(self, target, night, mode):
+        expectations = super().get_expected_values(target, night)
+        band, decker, detector = self.parse_mode(mode)
+
+        for key in expectations.keys():
+            if key == "bias":
+                continue
+            expectations[key]["band"] = band
+            expectations[key]["decker"] = decker
+
+        return expectations
+
+    def get_extension(self, header, mode):
+        band, decker, detector = self.parse_mode(mode)
+        extension = int(detector)
+        return extension
+
+    def get_wavecal_filename(self, header, mode, **kwargs):
+        """Get the filename of the wavelength calibration config file"""
+        cwd = os.path.dirname(__file__)
+        fname = f"{self.name}_{mode}.npz"
+        fname = os.path.join(cwd, "..", "wavecal", fname)
+        return fname
+
+    def get_mask_filename(self, mode, **kwargs):
+        i = self.name.lower()
+        band, decker, detector = self.parse_mode(mode)
+
+        fname = f"mask_{i}_det{detector}.fits.gz"
+        cwd = os.path.dirname(__file__)
+        fname = os.path.join(cwd, "..", "masks", fname)
+        return fname
+
+    def get_wavelength_range(self, header, mode, **kwargs):
+        wmin = [header["ESO INS WLEN MIN%i" % i] for i in range(1, 11)]
+        wmax = [header["ESO INS WLEN MAX%i" % i] for i in range(1, 11)]
+
+        wavelength_range = np.array([wmin, wmax]).T
+        # Invert the order numbering
+        wavelength_range = wavelength_range[::-1]
+        # Convert from nm to Angstrom
+        wavelength_range *= 10
+        return wavelength_range

pyreduce/instruments/filters.py

@@ -0,0 +1,195 @@
+import logging
+import re
+from datetime import datetime
+from fnmatch import fnmatch
+
+import numpy as np
+from astropy import units as u
+from astropy.time import Time
+from dateutil import parser
+
+logger = logging.getLogger(__name__)
+
+
+class Filter:
+    def __init__(
+        self,
+        keyword,
+        dtype="U20",
+        wildcards=False,
+        regex=False,
+        flags=0,
+        unique=True,
+        ignorecase=True,
+    ):
+        self.keyword = keyword
+        self.dtype = dtype
+        self.wildcards = wildcards
+        self.regex = regex
+        self.flags = flags
+        self.data = []
+        self.unique = unique
+        self.ignorecase = ignorecase
+
+        if self.ignorecase and not self.flags & re.IGNORECASE:
+            self.flags += re.IGNORECASE
+
+    def _collect_value(self, header):
+        if self.keyword is None:
+            value = ""
+        elif "{" in self.keyword:
+            kws = re.findall(r"{([^{}]+)}", self.keyword)
+            values = {kw: header.get(kw, "") for kw in kws}
+            value = self.keyword.format(**values)
+        else:
+            value = header.get(self.keyword)
+        if value.__class__ == header.__class__:
+            if len(value) > 0:
+                value = value[0]
+            else:
+                value = ""
+        return value
+
+    def collect(self, header):
+        value = self._collect_value(header)
+        self.data.append(value)
+        return value
+
+    def match(self, value):
+        if self.keyword is None:
+            result = np.full(len(self.data), False)
+        else:
+            try:
+                if self.regex:
+                    regex = re.compile(f"^(?:{value})$", flags=self.flags)
+                elif self.wildcards:
+                    regex = re.compile(fnmatch.translate(value), flags=self.flags)
+                else:
+                    regex = re.compile(value, flags=self.flags)
+
+                result = [
+                    regex.match(f) is not None if f is not None else False
+                    for f in self.data
+                ]
+            except TypeError:
+                result = [f == value for f in self.data]
+        result = np.asarray(result, dtype=bool)
+        return result
+
+    def classify(self, value):
+        if self.unique:
+            if value is not None and value != "":
+                match = self.match(value)
+                data = np.asarray(self.data)
+                data = np.unique(data[match])
+            else:
+                data = set(self.data)
+            data = [(d, self.match(d)) for d in data]
+        else:
+            if value is not None and value != "":
+                match = self.match(value)
+            else:
+                match = np.full(len(self.data), True)
+            data = [(value, match)]
+        return data
+
+    def clear(self):
+        self.data = []
+
+
+class InstrumentFilter(Filter):
+    def __init__(self, keyword="INSTRUME", **kwargs):
+        kwargs["dtype"] = "U20"
+        kwargs["unique"] = False
+        super().__init__(keyword, **kwargs)
+
+
+class ObjectFilter(Filter):
+    def __init__(self, keyword="OBJECT", **kwargs):
+        kwargs["dtype"] = "U20"
+        kwargs["unique"] = False
+        super().__init__(keyword, **kwargs)
+
+
+class NightFilter(Filter):
+    def __init__(
+        self,
+        keyword="DATE-OBS",
+        timeformat="fits",
+        timezone="utc",
+        timezone_local=None,
+        **kwargs,
+    ):
+        super().__init__(keyword, dtype=datetime, **kwargs)
+        self.timeformat = timeformat
+        self.timezone = timezone
+        self.timezone_local = timezone_local
+
+    @staticmethod
+    def observation_date_to_night(observation_date):
+        """Convert an observation timestamp into the date of the observation night
+        Nights start at 12am and end at 12 am the next day
+        """
+        if observation_date.to_datetime().hour < 12:
+            observation_date -= 1 * u.day
+        return observation_date.to_datetime().date()
+
+    def collect(self, header):
+        value = super()._collect_value(header)
+        if value is not None:
+            try:
+                value = Time(value, format=self.timeformat, scale=self.timezone)
+                value = self.observation_date_to_night(value)
+            except ValueError:
+                logger.warning(
+                    "Could not determine the observation date of %s, skipping it",
+                    header,
+                )
+        else:
+            logger.warning(
+                "Could not determine the observation date of %s, skipping it", header
+            )
+        self.data.append(value)
+        return value
+
+    def match(self, value):
+        try:
+            value = parser.parse(value).date()
+        except Exception:
+            pass
+        match = super().match(value)
+        return match
+
+
+class ModeFilter(Filter):
+    def __init__(
+        self,
+        keyword,
+        dtype="U20",
+        wildcards=False,
+        regex=False,
+        flags=0,
+        unique=True,
+        ignorecase=True,
+        replacement=None,
+    ):
+        if replacement is None:
+            replacement = {}
+        super().__init__(
+            keyword,
+            dtype=dtype,
+            wildcards=wildcards,
+            regex=regex,
+            flags=flags,
+            unique=unique,
+            ignorecase=ignorecase,
+        )
+        self.replacement = replacement
+
+    def classify(self, value):
+        data = super().classify(value)
+        data = [
+            (self.replacement[d] if d in self.replacement.keys() else d, m)
+            for d, m in data
+        ]
+        return data

pyreduce/instruments/harpn.json

@@ -0,0 +1,136 @@
+{
+    "__comment__": "red and middle are in the same fits file, with different extensions, i.e. share the same mode identifier, but have different extensions",
+    "__instrument__": "HARPN",
+    "id_instrument": "HARPN",
+    "instrument": "INSTRUME",
+    "telescope": "TELESCOP",
+    "date": "DATE-OBS",
+    "date_format": "fits",
+    "modes": ["HARPN"],
+    "modes_id" : ["harpn"],
+    "extension": [  1  ],
+    "id": [
+        [
+            1,
+            2
+        ]
+    ],
+    "orientation": 2,
+    "transpose": true,
+    "prescan_x": "HIERARCH TNG DET OUT{id[0]} PRSCX",
+    "overscan_x": "HIERARCH TNG DET OUT{id[0]} OVSCX",
+    "prescan_y": 0,
+    "overscan_y": 0,
+    "naxis_x": "NAXIS1",
+    "naxis_y": "NAXIS2",
+    "gain": "HIERARCH TNG DET OUT{id[0]} GAIN",
+    "readnoise": "HIERARCH TNG DET OUT{id[0]} RON",
+    "dark": "HIERARCH TNG INS DET{id[1]} OFFDRK",
+    "sky": "HIERARCH TNG INS DET{id[1]} OFFSKY",
+    "exposure_time": "EXPTIME",
+    "image_type": "HIERARCH TNG OBS TARG NAME",
+    "category": "HIERARCH TNG DPR CATG",
+    "ra": "RA",
+    "dec": "DEC",
+    "longitude": "GEOLON",
+    "latitude": "GEOLAT",
+    "altitude": "GEOELEV",
+    "target": "OBJECT",
+    "instrument_mode": "HIERARCH TNG INS MODE",
+    "instrument_mode_alternative": "TNG TPL NAME",
+    "observation_type": "TNG DPR TYPE",
+    "id_fiber_a": "LAMP,DARK,TUN",
+    "id_fiber_b": "DARK,LAMP,TUN",
+    "kw_bias": "HIERARCH TNG DPR TYPE",
+    "kw_flat": "HIERARCH TNG DPR TYPE",
+    "kw_curvature": "HIERARCH TNG DPR TYPE",
+    "kw_scatter": "HIERARCH TNG DPR TYPE",
+    "kw_orders": "HIERARCH TNG DPR TYPE",
+    "kw_wave": "HIERARCH TNG DPR TYPE",
+    "kw_comb": "HIERARCH TNG DPR TYPE",
+    "kw_spec": "HIERARCH TNG DPR TYPE",
+    "id_bias": "BIAS,BIAS",
+    "id_flat": "LAMP,LAMP,TUN",
+    "id_orders": "LAMP,LAMP,TUN",
+    "id_curvature": "WAVE,WAVE,THAR2",
+    "id_scatter": "LAMP,LAMP,TUN",
+    "id_wave": "WAVE,WAVE,THAR2",
+    "id_comb": "WAVE,WAVE,COMB",
+    "id_spec": "STAR,*",
+    "wavelength_range": [[
+        [5245.4,     5304.3],
+        [5200.5,     5259.0],
+        [5156.5,     5214.4],
+        [5113.2,     5170.6],
+        [5070.6,     5127.6],
+        [5028.7,     5085.2],
+        [4987.5,     5043.5],
+        [4946.9,     5002.5],
+        [4907.0,     4962.2],
+        [4867.8,     4922.5],
+        [4829.2,     4883.4],
+        [4791.1,     4845.0],
+        [4753.7,     4807.1],
+        [4716.9,     4769.9],
+        [4680.6,     4733.2],
+        [4644.9,     4697.1],
+        [4609.7,     4661.5],
+        [4575.1,     4626.5],
+        [4540.9,     4591.9],
+        [4507.3,     4557.9],
+        [4474.2,     4524.4],
+        [4441.5,     4491.4],
+        [4409.3,     4458.9],
+        [4377.6,     4426.8],
+        [4346.4,     4395.2],
+        [4315.5,     4364.0],
+        [4285.2,     4333.3],
+        [4255.2,     4303.0],
+        [4225.7,     4273.1],
+        [4196.5,     4243.6],
+        [4167.8,     4214.6],
+        [4139.4,     4185.9],
+        [4111.5,     4157.6],
+        [4083.9,     4129.7],
+        [4056.7,     4102.2],
+        [4029.8,     4075.0],
+        [4003.3,     4048.2],
+        [3977.1,     4021.8],
+        [3951.3,     3995.7],
+        [3925.8,     3969.9],
+        [3900.7,     3944.5],
+        [3875.8,     3919.3],
+        [3851.3,     3894.5],
+        [3827.1,     3870.0],
+        [3803.2,     3845.9],
+        [3779.6,     3822.0]
+        ],[
+        [6835.9, 6913.0],
+        [6760.0, 6836.2],
+        [6685.7, 6761.1],
+        [6613.1, 6687.6],
+        [6542.0, 6615.7],
+        [6472.4, 6545.4],
+        [6404.3, 6476.5],
+        [6337.7, 6409.1],
+        [6272.3, 6343.0],
+        [6208.4, 6278.3],
+        [6145.7, 6214.9],
+        [6084.2, 6152.8],
+        [6024.0, 6091.9],
+        [5965.0, 6032.1],
+        [5907.1, 5973.6],
+        [5850.3, 5916.2],
+        [5794.6, 5859.8],
+        [5739.9, 5804.6],
+        [5686.3, 5750.3],
+        [5633.7, 5697.1],
+        [5582.0, 5644.8],
+        [5531.3, 5593.5],
+        [5481.5, 5543.2],
+        [5432.5, 5493.7],
+        [5384.5, 5445.1],
+        [5337.3, 5397.3]
+        ]
+    ]
+}

pyreduce/instruments/harpn.py

@@ -0,0 +1,201 @@
+"""
+Handles instrument specific info for the HARPN spectrograph
+
+Mostly reading data from the header
+"""
+
+import logging
+import re
+from os.path import dirname, join
+
+import numpy as np
+
+from .common import Instrument
+from .filters import Filter, InstrumentFilter, NightFilter, ObjectFilter
+
+logger = logging.getLogger(__name__)
+
+
+class TypeFilter(Filter):
+    def __init__(self, keyword="TNG DPR TYPE"):
+        super().__init__(keyword, regex=True)
+
+    def classify(self, value):
+        if value is not None:
+            match = self.match(value)
+            data = np.asarray(self.data)
+            data = np.unique(data[match])
+            try:
+                regex = re.compile(value)
+                keys = [regex.match(f) for f in data]
+                keys = [[g for g in d.groups() if g is not None][0] for d in keys]
+                unique = np.unique(keys)
+                assign = {
+                    u: [d for k, d in zip(keys, data, strict=False) if k == u]
+                    for u in unique
+                }
+                data = [(u, self.match("|".join(a))) for u, a in assign.items()]
+            except IndexError:
+                data = np.asarray(self.data)
+                data = np.unique(data[match])
+                data = [(d, self.match(d)) for d in data]
+        else:
+            data = np.unique(self.data)
+            data = [(d, self.match(d)) for d in data]
+        return data
+
+
+class HARPN(Instrument):
+    def __init__(self):
+        super().__init__()
+        self.filters = {
+            "instrument": InstrumentFilter(self.info["instrument"]),
+            "night": NightFilter(self.info["date"]),
+            # "branch": Filter(, regex=True),
+            "mode": Filter(
+                self.info["instrument_mode"], regex=True, flags=re.IGNORECASE
+            ),
+            "type": TypeFilter(self.info["observation_type"]),
+            "target": ObjectFilter(self.info["target"], regex=True),
+        }
+        self.night = "night"
+        self.science = "science"
+        self.shared = [
+            "instrument",
+            "night",
+            "mode",
+        ]
+        self.find_closest = [
+            "bias",
+            "flat",
+            "wavecal_master",
+            "freq_comb_master",
+            "orders",
+            "scatter",
+        ]
+
+    def get_expected_values(self, target, night, mode, fiber):
+        """Determine the default expected values in the headers for a given observation configuration
+
+        Any parameter may be None, to indicate that all values are allowed
+
+        Parameters
+        ----------
+        target : str
+            Name of the star / observation target
+        night : str
+            Observation night/nights
+        Returns
+        -------
+        expectations: dict
+            Dictionary of expected header values, with one entry per step.
+            The entries for each step refer to the filters defined in self.filters
+
+        Raises
+        ------
+        ValueError
+            Invalid combination of parameters
+        """
+        if target is not None:
+            target = target.replace(" ", r"(?:\s*|-)")
+        else:
+            target = ".*"
+
+        id_orddef = "LAMP,DARK,TUN"
+        id_spec = "STAR,WAVE"
+
+        expectations = {
+            "bias": {"instrument": "HARPN", "night": night, "type": r"BIAS,BIAS"},
+            "flat": {"instrument": "HARPN", "night": night, "type": r"LAMP,LAMP,TUN"},
+            "orders": {
+                "instrument": "HARPN",
+                "night": night,
+                "type": id_orddef,
+            },
+            "scatter": {
+                "instrument": "HARPN",
+                "night": night,
+                "type": id_orddef,  # Same as orders or same as flat?
+            },
+            "wavecal_master": {
+                "instrument": "HARPN",
+                "night": night,
+                "type": r"WAVE,WAVE,THAR2",
+            },
+            "freq_comb_master": {
+                "instrument": "HARPN",
+                "night": night,
+                "type": r"WAVE,WAVE,COMB",
+            },
+            "science": {
+                "instrument": "HARPN",
+                "night": night,
+                "mode": mode,
+                "type": id_spec,
+                "target": target,
+            },
+        }
+        return expectations
+
+    def get_extension(self, header, mode):
+        extension = super().get_extension(header, mode)
+
+        try:
+            if (
+                header["NAXIS"] == 2
+                and header["NAXIS1"] == 4296
+                and header["NAXIS2"] == 4096
+            ):
+                extension = 0
+        except KeyError:
+            pass
+
+        return extension
+
+    def add_header_info(self, header, mode, **kwargs):
+        """read data from header and add it as REDUCE keyword back to the header"""
+        # "Normal" stuff is handled by the general version, specific changes to values happen here
+        # alternatively you can implement all of it here, whatever works
+        header = super().add_header_info(header, mode)
+
+        try:
+            header["e_ra"] /= 15
+            header["e_jd"] += header["e_exptim"] / (7200 * 24) + 0.5
+
+        except:
+            pass
+
+        try:
+            if (
+                header["NAXIS"] == 2
+                and header["NAXIS1"] == 4296
+                and header["NAXIS2"] == 4096
+            ):
+                # both modes are in the same image
+                prescan_x = 50
+                overscan_x = 50
+                naxis_x = 2148
+                if mode == "BLUE":
+                    header["e_xlo"] = prescan_x
+                    header["e_xhi"] = naxis_x - overscan_x
+                elif mode == "RED":
+                    header["e_xlo"] = naxis_x + prescan_x
+                    header["e_xhi"] = 2 * naxis_x - overscan_x
+        except KeyError:
+            pass
+
+        return header
+
+    def get_wavecal_filename(self, header, mode, **kwargs):
+        """Get the filename of the wavelength calibration config file"""
+        cwd = dirname(__file__)
+        fname = f"harpn_{mode.lower()}_2D.npz"
+        fname = join(cwd, "..", "wavecal", fname)
+        return fname
+
+    def get_wavelength_range(self, header, mode, **kwargs):
+        wave_range = super().get_wavelength_range(header, mode, **kwargs)
+        # The wavelength orders are in inverse order in the .json file
+        # because I was to lazy to invert them in the file
+        wave_range = wave_range[::-1]
+        return wave_range