roman-snpit-snappl 0.6.0__tar.gz → 0.7.0__tar.gz

{roman_snpit_snappl-0.6.0/roman_snpit_snappl.egg-info → roman_snpit_snappl-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roman_snpit_snappl
-Version: 0.6.0
+Version: 0.7.0
 Summary: Photometry utilities for the Roman SNPIT
 Author: Roman Supernove Project Infrastructure Team
 Maintainer-email: Roman SN PIT <raknop@lbl.gov>

roman_snpit_snappl-0.7.0/changes/35.snappl.rst

@@ -0,0 +1 @@
+photon ops now actually turns off 

roman_snpit_snappl-0.7.0/changes/36.snappl.rst

@@ -0,0 +1 @@
+created OU24 SED Collection object 

roman_snpit_snappl-0.7.0/changes/37.snappl.rst

@@ -0,0 +1 @@
+Added the non-slow ou24PSF class

roman_snpit_snappl-0.7.0/changes/40.snappl.rst

@@ -0,0 +1 @@
+Added manual fits image and test

{roman_snpit_snappl-0.6.0 → roman_snpit_snappl-0.7.0/roman_snpit_snappl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roman_snpit_snappl
-Version: 0.6.0
+Version: 0.7.0
 Summary: Photometry utilities for the Roman SNPIT
 Author: Roman Supernove Project Infrastructure Team
 Maintainer-email: Roman SN PIT <raknop@lbl.gov>

{roman_snpit_snappl-0.6.0 → roman_snpit_snappl-0.7.0}/roman_snpit_snappl.egg-info/SOURCES.txt

@@ -35,6 +35,10 @@ changes/23.snappl.rst
 changes/26.feature.rst
 changes/3.snappl.rst
 changes/31.feature.rst
+changes/35.snappl.rst
+changes/36.snappl.rst
+changes/37.snappl.rst
+changes/40.snappl.rst
 changes/5.snappl.rst
 changes/8.snappl.rst
 changes/9.snappl.rst
@@ -62,6 +66,7 @@ snappl/__init__.py
 snappl/_version.py
 snappl/image.py
 snappl/psf.py
+snappl/sed.py
 snappl/wcs.py
 snappl/_dev/__init__.py
 snappl/_dev/scm_version.py

{roman_snpit_snappl-0.6.0 → roman_snpit_snappl-0.7.0}/snappl/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.6.0'
-__version_tuple__ = version_tuple = (0, 6, 0)
+__version__ = version = '0.7.0'
+__version_tuple__ = version_tuple = (0, 7, 0)

{roman_snpit_snappl-0.6.0 → roman_snpit_snappl-0.7.0}/snappl/image.py

@@ -386,6 +386,42 @@ class FITSImage( Numpy2DImage ):
                 self._wcs = GalsimWCS.from_header( hdr )
         return self._wcs
 
+    def get_data(self, which="all"):
+        if self._is_cutout:
+            raise RuntimeError(
+                "get_data called on a cutout image, this will return the ORIGINAL UNCUT image. Currently not supported."
+            )
+        if which not in Image.data_array_list:
+            raise ValueError(f"Unknown which {which}, must be all, data, noise, or flags")
+
+        if (which == "all"):
+            if (self._data is not None) and (self._noise is not None) and (self._flags is not None):
+                return [self._data, self._noise, self._flags]
+            else:
+                raise RuntimeError(
+                    f"get_data called with which='all', but not all data arrays are set. "
+                    f"Data: {self._data is not None}, Noise: {self._noise is not None},"
+                    f" Flags: {self._flags is not None}"
+                )
+
+        if (which == "data"):
+            if (self._data is not None):
+                return [self._data]
+            else:
+                raise RuntimeError("get_data called with which='data', but data is not set.")
+
+        if (which == "noise"):
+            if (self._noise is not None):
+                return [self._noise]
+            else:
+                raise RuntimeError("get_data called with which='noise', but noise is not set.")
+
+        if (which == "flags"):
+            if (self._flags is not None):
+                return [self._flags]
+            else:
+                raise RuntimeError("get_data called with which='flags', but flags are not set.")
+
     def get_cutout(self, x, y, xsize, ysize=None):
         """Creates a new snappl image object that is a cutout of the original image, at a location in pixel-space.
 
@@ -554,3 +590,27 @@ class OpenUniverse2024FITSImage( FITSImage ):
     def _get_zeropoint( self ):
         header = self._get_header()
         return galsim.roman.getBandpasses()[self.band].zeropoint + header['ZPTMAG']
+
+
+class ManualFITSImage(FITSImage):
+    def __init__(self, header, data, noise=None, flags=None, path = None, exposure = None, sca = None, *args, **kwargs):
+
+        self._data = data
+        self._noise = noise
+        self._flags = flags
+        self._header = header
+        self._wcs = None
+        self._is_cutout = False
+        self._image_shape = None
+
+        self.inputs = types.SimpleNamespace()
+        self.inputs.path = None
+        self.inputs.exposure = None
+        self.inputs.sca = None
+
+    def _get_header(self):
+        """Get the header of the image."""
+        if self._header is None:
+            raise RuntimeError("Header is not set for ManualFITSImage.")
+        return self._header
+

{roman_snpit_snappl-0.6.0 → roman_snpit_snappl-0.7.0}/snappl/psf.py

@@ -1103,6 +1103,7 @@ class ou24PSF_slow( PSF ):
             raise ValueError( f"PSF would be rendered at ({stampx},{stampy}), which is too far off of the "
                               f"edge of a {self.stamp_size}-pixel stamp." )
 
+
         if (x, y, stampx, stampy) not in self._stamps:
             rmutils = roman_utils( self.config_file, self.pointing, self.sca )
             if seed is not None:
@@ -1113,7 +1114,6 @@ class ou24PSF_slow( PSF ):
             # TODO : does rmutils.getLocalWCS want 1-indexed or 0-indexed coordinates???
             wcs = rmutils.getLocalWCS( x+1, y+1 )
             stamp = galsim.Image( self.stamp_size, self.stamp_size, wcs=wcs )
-
             point = ( galsim.DeltaFunction() * self.sed ).withFlux( flux, rmutils.bpass )
             # TODO : make sure that rmutils.getPSF wants 1-indexed positions (which we assume here).
             # (This is not that big a deal, because the PSF is not going to vary significantly
@@ -1124,18 +1124,138 @@ class ou24PSF_slow( PSF ):
 
             # Note the +1s in galsim.PositionD below; galsim uses 1-indexed pixel positions,
             # whereas snappl uses 0-indexed pixel positions
-            point.drawImage( rmutils.bpass, method='phot', rng=rmutils.rng, photon_ops=photon_ops,
-                             n_photons=self.n_photons, maxN=self.n_photons, poisson_flux=False,
-                             center=galsim.PositionD(stampx+1, stampy+1), use_true_center=True, image=stamp )
-            self._stamps[(x, y, stampx, stampy)] = stamp.array
+            center = galsim.PositionD(stampx+1, stampy+1)
+            # Note: self.include_photonOps is a bool that states whether we are
+            #  shooting photons or not, photon_ops is the actual map (not sure
+            #  if that's the correct word) that describes where the photons
+            # should be shot, with some randomness.
+            if self.include_photonOps:
+                point.drawImage( rmutils.bpass, method='phot', rng=rmutils.rng, photon_ops=photon_ops,
+                              n_photons=self.n_photons, maxN=self.n_photons, poisson_flux=False,
+                              center=center, use_true_center=True, image=stamp )
+
+            else:
+                psf = galsim.Convolve(point, photon_ops[0])
+                psf.drawImage(rmutils.bpass, method="no_pixel", center=center,
+                              use_true_center=True, image=stamp, wcs=wcs)
 
+            self._stamps[(x, y, stampx, stampy)] = stamp.array
 
         return self._stamps[(x, y, stampx, stampy)]
 
 
 # TODO : make a ou24PSF that makes an image and caches... when things are working better
 class ou24PSF( ou24PSF_slow ):
-    pass
+    def __init__( self, *args, **kwargs ):
+        super().__init__(*args, **kwargs)
+        self._psf = None
+
+    def _init_psf_object( self, x0=None, y0=None, flux=1.):
+        """Create the galsim PSF object, WCS, and galsim.chromatic.SimpleChromaticTransformation
+           that can be reused for multiple calls to get_stamp.
+
+        Parameters are as in PSF.get_stamp, plus:
+
+        Parameters
+        ----------
+          seed : int
+            A random seed to pass to galsim.BaseDeviate for photonOps.
+            NOTE: this is not part of the base PSF interface (at least,
+            as of yet), so don't use it in production pipeline code.
+            However, it will be useful in tests for purposes of testing
+            reproducibility.
+
+
+        """
+        self._rmutils = roman_utils(self.config_file, self.pointing, self.sca)
+        self._psf = self._rmutils.getPSF(x0+1, y0+1, pupil_bin=8)
+        # TODO : does rmutils.getLocalWCS want 1-indexed or 0-indexed coordinates???
+        self._wcs = self._rmutils.getLocalWCS( x0+1, y0+1 )
+        self._stamp = galsim.Image( self.stamp_size, self.stamp_size, wcs=self._wcs )
+        self._point = ( galsim.DeltaFunction() * self.sed ).withFlux( flux, self._rmutils.bpass )
+        self._convolved_psf = galsim.Convolve(self._point, self._psf)
+        # This is only used to ensure the user isn't trying to move the PSF around
+        self._stored_x0 = x0
+        self._stored_y0 = y0
+
+    def get_stamp(self, x=None, y=None, x0=None, y0=None, flux=1.0, seed=None):
+        """Return a 2d numpy image of the PSF at the image resolution.
+        Parameters are as in PSF.get_stamp, plus:
+
+        Parameters
+        ----------
+          seed : int
+            A random seed to pass to galsim.BaseDeviate for photonOps.
+            NOTE: this is not part of the base PSF interface (at least,
+            as of yet), so don't use it in production pipeline code.
+            However, it will be useful in tests for purposes of testing
+            reproducibility.
+
+        """
+
+        # If a position is not given, assume the middle of the SCA
+        #   (within 1/2 pixel; by default, we want to make x and y
+        #   centered on a pixel).
+
+
+        x = x if x is not None else float( self.sca_size // 2 )
+        y = y if y is not None else float( self.sca_size // 2 )
+
+        xc = int( np.floor( x + 0.5 ) )
+        yc = int( np.floor( y + 0.5 ) )
+        x0 = xc if x0 is None else x0
+        y0 = yc if y0 is None else y0
+
+        if ( not isinstance( x0, numbers.Integral ) ) or ( not isinstance( y0, numbers.Integral ) ):
+            raise TypeError( f"x0 and y0 must be integers; got x0 as a {type(x0)} and y0 as a {type(y0)}" )
+
+        if self._psf is None:
+            SNLogger.debug( "Initializing ou24PSF galsim PSF object." )
+            # If we don't have a psf object, then we need to initialize it, we then re use it for multiple calls to
+            # get_stamp.
+            self._init_psf_object( x0=x0, y0=y0, flux=flux)
+        else:
+            if x0 != self._stored_x0 or y0 != self._stored_y0:
+                raise ValueError("ou24PSF.get_stamp called with x0 or y0 that does not match the x0 or y0 used"
+                                  "to initialize the PSF object. If you want to recreate the PSF object, use "
+                                  "ou24PSF_slow instead.")
+
+        stampx = self.stamp_size // 2 + ( x - x0 )
+        stampy = self.stamp_size // 2 + ( y - y0 )
+
+        if ( ( stampx < -self.stamp_size ) or ( stampx > 2.*self.stamp_size ) or
+             ( stampy < -self.stamp_size ) or ( stampy > 2.*self.stamp_size ) ):
+            raise ValueError( f"PSF would be rendered at ({stampx},{stampy}), which is too far off of the "
+                              f"edge of a {self.stamp_size}-pixel stamp." )
+
+        if (x, y, stampx, stampy) not in self._stamps:
+
+            if seed is not None:
+                self._rmutils.rng = galsim.BaseDeviate( seed )
+
+            photon_ops = [ self._psf ]
+            if self.include_photonOps:
+                photon_ops += self._rmutils.photon_ops
+
+            # Note the +1s in galsim.PositionD below; galsim uses 1-indexed pixel positions,
+            # whereas snappl uses 0-indexed pixel positions
+            center = galsim.PositionD(stampx+1, stampy+1)
+            # Note: self.include_photonOps is a bool that states whether we are
+            #  shooting photons or not, photon_ops is the actual map (not sure
+            #  if that's the correct word) that describes where the photons
+            # should be shot, with some randomness.
+            if self.include_photonOps:
+                self._point.drawImage(self._rmutils.bpass, method='phot', rng=self._rmutils.rng, photon_ops=photon_ops,
+                                      n_photons=self.n_photons, maxN=self.n_photons, poisson_flux=False,
+                                      center=center, use_true_center=True, image=self._stamp)
+
+            else:
+                self._convolved_psf.drawImage(self._rmutils.bpass, method="no_pixel", center=center,
+                                              use_true_center=True, image=self._stamp, wcs=self._wcs)
+
+            self._stamps[(x, y, stampx, stampy)] = self._stamp.array
+
+        return self._stamps[(x, y, stampx, stampy)]
 
 # class ou24PSF( OversampledImagePSF ):
 #     """An OversampledImagePSF that renders its internally stored image from a galsim roman_imsim PSF.

roman_snpit_snappl-0.7.0/snappl/sed.py

@@ -0,0 +1,168 @@
+# Put in necessary imports
+import numpy as np
+import os
+import h5py
+import galsim
+import pathlib
+import pandas as pd
+
+
+from snpit_utils.config import Config
+from snpit_utils.logger import SNLogger
+
+
+class SED_collection:
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def get_sed(self, filename=None, snid=None, mjd=None):
+        """Return a galsim SED."""
+        raise NotImplementedError( f"{self.__class__.__name__} needs to implement get_sed" )
+
+
+class Flat_SED( SED_collection ):
+    def __init__( self ):
+        self.sed = galsim.SED( galsim.LookupTable( [1000, 26000], [1, 1], interpolant='linear' ),
+                               wave_type='Angstrom', flux_type='fphotons' )
+
+    def get_sed( self, **kwargs):
+        return self.sed
+
+class Single_CSV_SED( SED_collection ):
+    def __init__( self, csv_file ):
+        # READ THE CSV FILE, make a galsim SED in self.sed
+        raise NotImplementedError( "Single_CSV_SED is not implemented yet.")
+
+    def get_sed( self, **kwargs ):
+        return self.sed
+
+
+class OU2024_Truth_SED(SED_collection):
+    def __init__(self, snid=None, isstar=False):
+        # if (snid is None) or (sn_path is None):
+        #     raise ValueError("Must specify all of snid, sn_path")
+
+        self.snid = snid
+        cfg = Config.get()
+        self.sn_path = cfg.value("ou24.sn_truth_dir")
+        self.isstar = isstar
+
+        if isstar:
+            self.lam_array, self.flambda_array = \
+                self._ou24_get_star_SED()
+        else:
+            self.lam_array, self.flambda_array, self.mjd_array = \
+                self._ou24_get_SN_SED()
+
+    def get_sed(self, snid=None, mjd=None):
+        """Return an SED for the given snid and mjd.
+        Inputs:
+        snid: the ID of the object
+        mjd: the MJD of the observation (only used if this is a SN)
+
+        Returns:
+        galsim.SED: the SED for the given snid and mjd, if a supernova, for the ID if a star.
+        """
+        assert snid == self.snid, "ID does not match the SED collection ID."
+
+        if not self.isstar:
+            # If this is a SN, we need to find the closest SED to the given MJD.
+            bestindex = np.argmin(np.abs(np.array(self.mjd_array) - mjd))
+            max_days_cutoff = 10
+            closest_days_away = np.min(np.abs(np.array(self.mjd_array) - mjd))
+
+            if closest_days_away > max_days_cutoff:
+                SNLogger.warning(f"WARNING: No SED data within {max_days_cutoff} days of "
+                                 + f"date. \n The closest SED is {closest_days_away} days away.")
+
+            return galsim.SED(
+                galsim.LookupTable(np.array(self.lam_array), (self.flambda_array[bestindex]), interpolant="linear"),
+                wave_type="Angstrom",
+                flux_type="fphotons",
+            )
+
+        else:
+            # If this is a star, we just return the SED
+            return galsim.SED(
+                galsim.LookupTable(np.array(self.lam_array), (self.flambda_array), interpolant="linear"),
+                wave_type="Angstrom",
+                flux_type="fphotons",
+            )
+
+    def _ou24_open_parquet(self, parq, obj_type="SN", engine="fastparquet"):
+        """Convenience function to open a parquet file given its number."""
+        path = self.sn_path
+        file_prefix = {"SN": "snana", "star": "pointsource"}
+        base_name = "{:s}_{}.parquet".format(file_prefix[obj_type], parq)
+        file_path = os.path.join(path, base_name)
+        df = pd.read_parquet(file_path, engine=engine)
+        return df
+
+    def _ou24_find_parquet(self, obj_type="SN"):
+        """Find the parquet file that contains a given supernova ID."""
+        path = self.sn_path
+        ID = self.snid
+        files = os.listdir(path)
+        SNLogger.debug(f"Looking for parquet files in {path} for {obj_type} with ID {ID}")
+        file_prefix = {"SN": "snana", "star": "pointsource"}
+        files = [f for f in files if file_prefix[obj_type] in f]
+        files = [f for f in files if ".parquet" in f]
+        files = [f for f in files if "flux" not in f]
+
+        for f in files:
+            pqfile = int(f.split("_")[1].split(".")[0])
+            df = self._ou24_open_parquet(pqfile, obj_type=obj_type)
+            if ID in df.id.values or str(ID) in df.id.values:
+                return pqfile
+
+    def _ou24_get_star_SED(self):
+        """Return the appropriate SED for the star.
+        Inputs:
+        SNID: the ID of the object
+        sn_path: the path to the supernova data
+
+        Returns:
+        lam: the wavelength of the SED in Angstrom (numpy  array of floats)
+        flambda: the flux of the SED units in erg/s/cm^2/Angstrom
+                (numpy array of floats)
+        """
+
+        filenum = self._ou24_find_parquet(obj_type="star")
+        pqfile = self._ou24_open_parquet(filenum, obj_type="star")
+        file_name = pqfile[pqfile["id"] == str(self.snid)]["sed_filepath"].values[0]
+        fullpath = pathlib.Path(Config.get().value("ou24.sims_sed_library")) / file_name
+        sed_table = pd.read_csv(fullpath,  compression="gzip", sep=r"\s+", comment="#")
+        lam = sed_table.iloc[:, 0]
+        flambda = sed_table.iloc[:, 1]
+        return np.array(lam), np.array(flambda)
+
+    def _ou24_get_SN_SED(self):
+        """Return the appropriate SED for the supernova on the given day.
+
+        Inputs:
+        SNID: the ID of the object
+        sn_path: the path to the supernova data
+
+        Returns:
+        lam: the wavelength of the SED in Angstrom
+        flambda: the flux of the SED units in erg/s/cm^2/Angstrom
+        """
+        filenum = self._ou24_find_parquet(obj_type="SN")
+        file_name = "snana" + "_" + str(filenum) + ".hdf5"
+        fullpath = os.path.join(self.sn_path, file_name)
+        # Setting locking=False on the next line becasue it seems that you can't
+        #   open an h5py file unless you have write access to... something.
+        #   Not sure what.  The directory where it exists?  We won't
+        #   always have that.  It's scary to set locking to false, because it
+        #   subverts all kinds of safety stuff that hdf5 does.  However,
+        #   because these files were created once in this case, it's not actually
+        #   scary, and we expect them to be static.  Locking only matters if you
+        #   think somebody else might change the file
+        #   while you're in the middle of reading bits of it.
+        sed_table = h5py.File(fullpath, "r", locking=False)
+        sed_table = sed_table[str(self.snid)]
+        flambda = sed_table["flambda"]
+        lam = sed_table["lambda"]
+        mjd = sed_table["mjd"]
+
+        return np.array(lam), np.array(flambda), np.array(mjd)