pyreduce-astro 0.6.0__cp311-cp311-win_amd64.whl

pyreduce/instruments/neid.py

@@ -0,0 +1,154 @@
+"""
+Handles instrument specific info for the NEID spectrograph
+"""
+
+import logging
+import re
+from os.path import dirname, join
+
+from .common import Instrument
+from .filters import Filter, InstrumentFilter, NightFilter, ObjectFilter
+
+logger = logging.getLogger(__name__)
+
+
+class NEID(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": Filter(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 = {
+            "flat": {"instrument": "NEID", "night": night, "type": r"LAMP,LAMP,TUN"},
+            "orders": {
+                "instrument": "NEID",
+                "night": night,
+                "type": id_orddef,
+            },
+            "scatter": {
+                "instrument": "NEID",
+                "night": night,
+                "type": id_orddef,  # Same as orders or same as flat?
+            },
+            "wavecal_master": {
+                "instrument": "NEID",
+                "night": night,
+                "type": r"WAVE,WAVE,THAR2",
+            },
+            "freq_comb_master": {
+                "instrument": "NEID",
+                "night": night,
+                "type": r"WAVE,WAVE,COMB",
+            },
+            "science": {
+                "instrument": "NEID",
+                "night": night,
+                "mode": mode,
+                "type": id_spec,
+                "target": target,
+            },
+        }
+        return expectations
+
+    def get_extension(self, header, mode):
+        extension = super().get_extension(header, mode)
+
+        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"NEID_{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)
+        return wave_range

pyreduce/instruments/nirspec.json

@@ -0,0 +1,56 @@
+{
+    "__instrument__": "NIRSPEC",
+    "instrument": "CURRINST",
+    "id_instrument": "NIRSPEC",
+    "telescope": "Keck",
+    "date": "DATE-OBS",
+    "date_format": "fits",
+    "modes": ["NIRSPEC"],
+    "extension": 0,
+    "orientation": 0,
+    "transpose": false,
+    "prescan_x": 5,
+    "overscan_x": 5,
+    "prescan_y": 0,
+    "overscan_y": 0,
+    "naxis_x": "NAXIS1",
+    "naxis_y": "NAXIS2",
+    "gain": "DETGAIN",
+    "readnoise": "DETRN",
+    "bias": "DETBIAS",
+    "dark": 0,
+    "sky": 0,
+    "air": "AIRMASS",
+    "exposure_time": "ITIME",
+    "image_type": "OBJECT",
+    "ra": "HA",
+    "dec": "DEC",
+    "jd": "MJD-OBS",
+    "longitude": -155.4783333,
+    "latitude": 19.8283333,
+    "altitude": 4160,
+    "target": "OBJECT",
+
+    "id_neon": "NEON",
+    "id_argon": "ARGON",
+    "id_krypton": "KRYPTON",
+    "id_xenon": "XENON",
+    "id_etalon": "ETALON",
+
+    "kw_bias" : null,
+    "kw_flat" : null,
+    "kw_curvature": null,
+    "kw_scatter": null,
+    "kw_orders" : null,
+    "kw_wave": null,
+    "kw_comb": null,
+    "kw_spec": null,
+    "id_bias" : "BIAS",
+    "id_flat": "FLAT",
+    "id_orders": null,
+    "id_curvature": null,
+    "id_scatter": null,
+    "id_wave": null,
+    "id_comb": null,
+    "id_spec": null
+}

pyreduce/instruments/nirspec.py

@@ -0,0 +1,215 @@
+"""
+Handles instrument specific info for the UVES spectrograph
+
+Mostly reading data from the header
+"""
+
+import glob
+import logging
+import os.path
+from datetime import datetime
+
+import numpy as np
+from astropy.io import fits
+from dateutil import parser
+from tqdm import tqdm
+
+from .common import Instrument, observation_date_to_night
+
+logger = logging.getLogger(__name__)
+
+
+class NIRSPEC(Instrument):
+    @staticmethod
+    def get_mode(header):
+        # TODO figure out the parameters to use for this
+        try:
+            fil1pos = header["FIL1POS"]
+            fil2pos = header["FIL2POS"]
+            filter = header["FILNAME"]
+        except KeyError:
+            return ""
+
+        # TODO get other settings
+        if filter == "NIRSPEC-1":
+            raise ValueError
+        elif filter == "NIRSPEC-2":
+            raise ValueError
+        elif filter == "NIRSPEC-4":
+            raise ValueError
+        elif filter == "NIRSPEC-5":
+            raise ValueError
+        elif filter == "NIRSPEC-7":
+            if fil1pos == 11 and fil2pos == 18:
+                setting = "K2"
+            else:
+                raise ValueError
+        else:
+            raise ValueError
+
+        return setting
+
+    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)
+        # header["e_setting"] = NIRSPEC.get_mode(header)
+        header["EXPTIME"] = header.get("ITIME", 0) * header.get("COADDS", 0)
+        return header
+
+    def sort_files(self, input_dir, target, night, mode, calibration_dir, **kwargs):
+        """
+        Sort a set of fits files into different categories
+        types are: bias, flat, wavecal, orderdef, spec
+
+        Parameters
+        ----------
+        input_dir : str
+            input directory containing the files to sort
+        target : str
+            name of the target as in the fits headers
+        night : str
+            observation night, possibly with wildcards
+        mode : str
+            instrument mode
+        Returns
+        -------
+        files_per_night : list[dict{str:dict{str:list[str]}}]
+            a list of file sets, one entry per night, where each night consists of a dictionary with one entry per setting,
+            each fileset has five lists of filenames: "bias", "flat", "order", "wave", "spec", organised in another dict
+        nights_out : list[datetime]
+            a list of observation times, same order as files_per_night
+        """
+
+        # TODO allow several names for the target?
+
+        info = self.load_info()
+        target = target.casefold()
+        instrument = self.__class__.__name__
+
+        # Try matching with nights
+        try:
+            night = parser.parse(night).date()
+            individual_nights = [night]
+        except ValueError:
+            # if the input night can't be parsed, use all nights
+            # Usually the case if wildcards are involved
+            individual_nights = "all"
+
+        # find all fits files in the input dir(s)
+        input_dir = input_dir.format(
+            instrument=instrument.upper(), target=target, mode=mode, night=night
+        )
+        files = glob.glob(input_dir + "/*.fits")
+        files += glob.glob(input_dir + "/*.fits.gz")
+        files = np.array(files)
+
+        # Initialize arrays
+        # observed object
+        ob = np.zeros(len(files), dtype="U20")
+        # observed night, parsed into a datetime object
+        ni = np.zeros(len(files), dtype=datetime)
+        # instrument, used for observation
+        it = np.zeros(len(files), dtype="U20")
+
+        for i, f in enumerate(files):
+            with fits.open(f) as hdu:
+                h = hdu[0].header
+                ob[i] = h.get(info["target"], "")
+                ni_tmp = h.get(info["date"], "")
+                it[i] = h.get(info["instrument"], "")
+
+            # Sanitize input
+            ni[i] = observation_date_to_night(ni_tmp)
+            ob[i] = ob[i].replace("-", "").replace(" ", "").casefold()
+
+        if isinstance(individual_nights, str) and individual_nights == "all":
+            individual_nights = np.unique(ni)
+            logger.info(
+                "Can't parse night %s, use all %i individual nights instead",
+                night,
+                len(individual_nights),
+            )
+
+        files_per_observation = []
+        cache = {}
+
+        for ind_night in tqdm(individual_nights):
+            # Select files for this night, this instrument, this instrument mode
+            selection = (ni == ind_night) & (it == instrument) & (ob == target)
+
+            for file in files[selection]:
+                # Read caliblist
+                caliblist = file[:-8] + ".caliblist"
+                caliblist = np.genfromtxt(
+                    caliblist, skip_header=8, dtype=str, delimiter=" ", usecols=(0)
+                )
+                caliblist = np.array(
+                    [
+                        os.path.join(input_dir, calibration_dir, c) + ".gz"
+                        for c in caliblist
+                    ]
+                )
+
+                tp = np.zeros(len(caliblist), dtype="U20")
+                for i, c in enumerate(caliblist):
+                    try:
+                        tp[i] = cache[c]
+                    except KeyError:
+                        h = fits.open(c)[0].header
+                        if h[info["id_flat"]] == 1:
+                            tp[i] = "flat"
+                        elif (
+                            h[info["id_neon"]] == 1
+                            or h[info["id_argon"]] == 1
+                            or h[info["id_krypton"]] == 1
+                            or h[info["id_xenon"]] == 1
+                        ):
+                            tp[i] = "wavecal"
+                        elif h[info["id_etalon"]] == 1:
+                            tp[i] = "freq_comb"
+                        else:
+                            tp[i] = "bias"
+                        cache[c] = tp[i]
+                files_this_observation = {
+                    "bias": caliblist[tp == "bias"],
+                    "flat": caliblist[tp == "flat"],
+                    "orders": caliblist[tp == "flat"],
+                    "wavecal_master": caliblist[tp == "wavecal"],
+                    "freq_comb_master": caliblist[tp == "freq_comb"],
+                    "science": [file],
+                }
+                files_this_observation["curvature"] = (
+                    files_this_observation["freq_comb_master"]
+                    if len(files_this_observation["freq_comb_master"]) != 0
+                    else files_this_observation["wavecal_master"]
+                )
+                files_this_observation["scatter"] = files_this_observation["orders"]
+
+                files_per_observation.append(
+                    ({"night": ind_night, "target": target}, files_this_observation)
+                )
+
+        return files_per_observation
+
+    def get_wavecal_filename(self, header, mode, **kwargs):
+        """Get the filename of the wavelength calibration config file"""
+        info = self.load_info()
+        if header[info["id_neon"]] == 1:
+            pass
+        elif header[info["id_argon"]] == 1:
+            pass
+        elif header[info["id_krypton"]] == 1:
+            pass
+        elif header[info["id_xenon"]] == 1:
+            pass
+        else:
+            raise ValueError("Wavelength calibration element not recognised")
+
+        echelle_setting = "K2"
+
+        cwd = os.path.dirname(__file__)
+        fname = f"nirspec_{echelle_setting}.npz"
+        fname = os.path.join(cwd, "..", "wavecal", fname)
+        return fname

pyreduce/instruments/nte.json

@@ -0,0 +1,47 @@
+{
+    "__instrument__": "NTE",
+    "instrument": "INSTRUME",
+    "id_instrument": "NTE",
+    "telescope": "NOT",
+    "category": "IMAGECAT",
+    "target": "OBJECT",
+    "date": "DATE-OBS",
+    "date_format" : "fits",
+    "modes": ["VIS", "NIR"],
+    "extension": 0,
+    "orientation": 0,
+    "prescan_x": 0,
+    "overscan_x": 0,
+    "prescan_y": 0,
+    "overscan_y": 0,
+    "naxis_x": "NAXIS1",
+    "naxis_y": "NAXIS2",
+    "gain": "GAIN",
+    "readnoise": "RDNOISE",
+    "dark": "DARK",
+    "sky": 0,
+    "exposure_time": "EXPTIME",
+    "ra": "RA",
+    "dec": "DEC",
+    "longitude": "LONGITUD",
+    "latitude": "LATITUD",
+    "altitude": "ELEVAT",
+    "kw_bias": "IMAGETYP",
+    "kw_dark": "IMAGETYP",
+    "kw_flat": "IMAGETYP",
+    "kw_curvature": "IMAGETYP",
+    "kw_scatter": "IMAGETYP",
+    "kw_orders": "IMAGETYP",
+    "kw_wave": "IMAGETYP",
+    "kw_comb": "IMAGETYP",
+    "kw_spec": "IMAGETYP",
+    "id_bias": "BIAS",
+    "id_dark": "DARK",
+    "id_flat": "LAMP,FLAT",
+    "id_orders": "LAMP,ORDERDEF",
+    "id_curvature": "LAMP,FPE",
+    "id_scatter": "LAMP,FLAT",
+    "id_wave": "LAMP,WAVE",
+    "id_comb": "LAMP,FPE",
+    "id_spec": "OBJECT"
+}

pyreduce/instruments/nte.py

@@ -0,0 +1,42 @@
+"""
+Handles instrument specific info for the NTE spectrograph
+
+Mostly reading data from the header
+"""
+
+import logging
+import os.path
+
+from .common import Instrument
+
+logger = logging.getLogger(__name__)
+
+
+class NTE(Instrument):
+    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)
+
+        header["e_ra"] /= 15
+        if header["e_jd"] is not None:
+            header["e_jd"] += header["e_exptime"] / (7200 * 24) + 0.5
+
+        return header
+
+    def get_wavecal_filename(self, header, mode, **kwargs):
+        """Get the filename of the wavelength calibration config file"""
+        info = self.load_info()
+        specifier = int(header[info["wavecal_specifier"]])
+
+        cwd = os.path.dirname(__file__)
+        fname = "{instrument}_{mode}_{specifier}nm_2D.npz".format(
+            instrument="nte", mode=mode.lower(), specifier=specifier
+        )
+        fname = os.path.join(cwd, "..", "wavecal", fname)
+        return fname
+
+    def get_wavelength_range(self, header, mode):
+        wave = 7 * [7000, 20_000]
+        return wave

pyreduce/instruments/uves.json

@@ -0,0 +1,59 @@
+{
+    "__instrument__": "UVES",
+    "instrument": "INSTRUME",
+    "id_instrument": "UVES",
+    "telescope": "VLT",
+    "date": "DATE-OBS",
+    "date_format": "fits",
+    "modes": ["BLUE", "MIDDLE", "RED"],
+    "modes_id": ["blue", "red", "red"],
+    "extension": [0, 2, 1],
+    "id": [[1, 5], [1, 4], [1, 4]],
+    "orientation": [2, 1, 1],
+    "transpose" : false,
+    "prescan_x": "HIERARCH ESO DET OUT{id[0]} PRSCX",
+    "overscan_x": "HIERARCH ESO DET OUT{id[0]} OVSCX",
+    "prescan_y": 0,
+    "overscan_y": 0,
+    "naxis_x": "NAXIS1",
+    "naxis_y": "NAXIS2",
+    "gain": "HIERARCH ESO DET OUT{id[0]} CONAD",
+    "readnoise": "HIERARCH ESO DET OUT{id[0]} RON",
+    "dark": "HIERARCH ESO INS DET{id[1]} OFFDRK",
+    "sky": "HIERARCH ESO INS DET{id[1]} OFFSKY",
+    "exposure_time": "EXPTIME",
+    "ra": "RA",
+    "dec": "DEC",
+    "longitude": "HIERARCH ESO TEL GEOLON",
+    "latitude": "HIERARCH ESO TEL GEOLAT",
+    "altitude": "HIERARCH ESO TEL GEOELEV",
+
+    "target": "OBJECT",
+    "wavecal_element": "thar",
+
+    "wavecal_specifier": "ESO INS GRAT2 WLEN",
+    "category": "HIERARCH ESO DPR CATG",
+    "image_type": "OBJECT",
+
+    "observation_type": "ESO DPR TYPE",
+    "instrument_mode": "ESO INS MODE",
+    "instrument_mode_alternative": "ESO TPL NAME",
+
+
+    "kw_bias" : "ESO DPR TYPE",
+    "kw_flat" : "ESO DPR TYPE",
+    "kw_curvature": "OBJECT",
+    "kw_scatter": "ESO DPR TYPE",
+    "kw_orders" : "ESO DPR TYPE",
+    "kw_wave": "OBJECT",
+    "kw_comb": null,
+    "kw_spec": "ESO DPR TYPE",
+    "id_bias" : "BIAS",
+    "id_flat": "LAMP,FLAT",
+    "id_orders": "LAMP,ORDERDEF",
+    "id_curvature": "LAMP,WAVE",
+    "id_scatter": "LAMP,ORDERDEF",
+    "id_wave": "LAMP,WAVE",
+    "id_comb": null,
+    "id_spec": "OBJECT,POINT"
+}

pyreduce/instruments/uves.py

@@ -0,0 +1,46 @@
+"""
+Handles instrument specific info for the UVES spectrograph
+
+Mostly reading data from the header
+"""
+
+import logging
+import os.path
+
+from .common import Instrument
+
+logger = logging.getLogger(__name__)
+
+
+class UVES(Instrument):
+    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)
+
+        header["e_ra"] /= 15
+        if header["e_jd"] is not None:
+            header["e_jd"] += header["e_exptime"] / (7200 * 24) + 0.5
+
+        return header
+
+    def get_wavecal_filename(self, header, mode, **kwargs):
+        """Get the filename of the wavelength calibration config file"""
+        info = self.load_info()
+        specifier = int(header[info["wavecal_specifier"]])
+
+        cwd = os.path.dirname(__file__)
+        fname = "{instrument}_{mode}_{specifier}nm_2D.npz".format(
+            instrument="uves", mode=mode.lower(), specifier=specifier
+        )
+        fname = os.path.join(cwd, "..", "wavecal", fname)
+        return fname
+
+    def get_mask_filename(self, mode, **kwargs):
+        i = self.name.lower()
+        m = mode.lower()
+        fname = f"mask_{i}_{m}.fits.gz"
+        cwd = os.path.dirname(__file__)
+        fname = os.path.join(cwd, "..", "masks", fname)
+        return fname

pyreduce/instruments/xshooter.json

@@ -0,0 +1,66 @@
+{
+    "__instrument__": "XSHOOTER",
+    "instrument": "INSTRUME",
+    "id_instrument": "SHOOT|XSHOOTER",
+    "telescope": "VLT",
+    "date": "MJD-OBS",
+    "date_format": "mjd",
+    "modes": [
+        "UVB",
+        "VIS",
+        "NIR"
+    ],
+    "kw_modes": "ESO DET CHIP*NAME",
+    "id_modes": [
+        "E2V CC44-82",
+        "MIT/LL CCID-20",
+        "Hawaii2RG"
+    ],
+    "extension": 0,
+    "orientation": [
+        1,
+        0,
+        0
+    ],
+    "transpose": false,
+    "prescan_x": 0,
+    "overscan_x": 0,
+    "prescan_y": 0,
+    "overscan_y": 0,
+    "naxis_x": "NAXIS1",
+    "naxis_y": "NAXIS2",
+    "gain": "HIERARCH ESO DET OUT1 GAIN",
+    "readnoise": "HIERARCH ESO DET OUT1 RON",
+    "dark": 10,
+    "exposure_time": "EXPTIME",
+    "ra": "RA",
+    "dec": "DEC",
+    "jd": "MJD-OBS",
+    "longitude": "HIERARCH ESO TEL GEOLON",
+    "latitude": "HIERARCH ESO TEL GEOLAT",
+    "altitude": "HIERARCH ESO TEL GEOELEV",
+    "instrument_mode": "HIERARCH ESO SEQ ARM",
+    "observation_type": "HIERARCH ESO DPR TYPE",
+    "observation_category": "HIERARCH ESO DPR CATG",
+    "target": "HIERARCH ESO OBS TARG NAME",
+    "object": "OBJECT",
+    "id_dark": "DARK",
+    "id_format": "LAMP,FMTCHK",
+    "id_tell": "STD,TELLURIC",
+    "kw_bias": "HIERARCH ESO DPR TYPE",
+    "kw_flat": "HIERARCH ESO DPR TYPE",
+    "kw_curvature": "HIERARCH ESO DPR TYPE",
+    "kw_scatter": "HIERARCH ESO DPR TYPE",
+    "kw_orders": "HIERARCH ESO DPR TYPE",
+    "kw_wave": "HIERARCH ESO DPR TYPE",
+    "kw_comb": null,
+    "kw_spec": "HIERARCH ESO DPR TYPE",
+    "id_bias": "DARK",
+    "id_flat": "LAMP,FLAT",
+    "id_orders": "LAMP,ORDERDEF",
+    "id_curvature": "LAMP,WAVE",
+    "id_scatter": "LAMP,FLAT",
+    "id_wave": "LAMP,WAVE",
+    "id_comb": null,
+    "id_spec": "OBJECT"
+}