roman-snpit-snappl 0.4.0__tar.gz → 0.5.0__tar.gz

{roman_snpit_snappl-0.4.0/roman_snpit_snappl.egg-info → roman_snpit_snappl-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roman_snpit_snappl
-Version: 0.4.0
+Version: 0.5.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.5.0/changes/20.bugfix.rst

@@ -0,0 +1 @@
+Properly support creation of PSFs at non-integral pixel positions in OversampledImagePSF

roman_snpit_snappl-0.5.0/changes/23.snappl.rst

@@ -0,0 +1 @@
+AstropyWCS now automatically determines appropriate frame.

roman_snpit_snappl-0.5.0/changes/26.feature.rst

@@ -0,0 +1,3 @@
+Added A25ePSF class, made tests, updated yaml save format for YamlSerialized_OversampledImagePSF.
+Added clarifying variable names, blocked and alphabetized imports.
+Added comment about the gridsize int() conversion in A25ePSF.

{roman_snpit_snappl-0.4.0 → roman_snpit_snappl-0.5.0/roman_snpit_snappl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roman_snpit_snappl
-Version: 0.4.0
+Version: 0.5.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.4.0 → roman_snpit_snappl-0.5.0}/roman_snpit_snappl.egg-info/SOURCES.txt

@@ -30,6 +30,9 @@ changes/14.snappl.rst
 changes/15.feature.rst
 changes/16.feature.rst
 changes/18.feature.rst
+changes/20.bugfix.rst
+changes/23.snappl.rst
+changes/26.feature.rst
 changes/3.snappl.rst
 changes/5.snappl.rst
 changes/8.snappl.rst

{roman_snpit_snappl-0.4.0 → roman_snpit_snappl-0.5.0}/snappl/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)

{roman_snpit_snappl-0.4.0 → roman_snpit_snappl-0.5.0}/snappl/psf.py

@@ -1,11 +1,14 @@
-import yaml
+# IMPORTS Standard
 import base64
-
 import numpy as np
+import pathlib
+import yaml
 
-from roman_imsim.utils import roman_utils
+# IMPORTS Astro
 import galsim
 
+# IMPORTS Internal
+from roman_imsim.utils import roman_utils
 from snpit_utils.config import Config
 from snpit_utils.logger import SNLogger
 
@@ -16,24 +19,62 @@ class PSF:
     def __init__( self, *args, **kwargs ):
         pass
 
+    # This is here for backwards compatibility
+    @property
+    def clip_size( self ):
+        return self.stamp_size
+
+    @property
+    def stamp_size( self ):
+        """The size of the one side of a PSF image stamp at image resolution.  Is always odd."""
+        raise NotImplementedError( f"{self.__class__.__name__} needs to implement stamp_size." )
+
+
     def get_stamp( self, x, y, flux=1. ):
         """Return a 2d numpy image of the PSF at the image resolution.
 
+        The PSF will be centered as best possible on the stamp*.  So, if
+        x ends in 0.8, it will be left of center, and if x ends in 0.2,
+        it will be right of center.  If the fractional part of x or y is
+        exactly 0.5, there's an ambituity as to where on the image you
+        should place the stamp of the PSF.  The position of the PSF on
+        the returned stamp will always round *down* in this case.  (The
+        pixel on the image that corresponds to the center pixel on the
+        clip is at floor(x+0.5),floor(y+0.5), *not*
+        round(x+0.5),round(y+0.5).  Those two things are different, and
+        round is not consistent; see the comment in
+        OversampledImagePSF.get_stamp for more if you care.)
+
+        So, for example, assuming the PSF is intrinsically centered*,
+        if the stamp size is 5×5 and you ask for the PSF at x=1023,
+        y=1023, then you're going to want to put the stamp on to the
+        image at image[1021:1026,1021:1026].  However, if you ask for
+        the PSF at x=1023.5,y=1023., you'll want to put the stamp on the
+        image at image[1021:1026,1022:1027].  (Remember that default
+        numpy arrays of astronomy images are indexed [y,x].)
+
+        * "The PSF will be centered as best possible on the stamp": this
+          is only true if the PSF itself is intrinsically centered.  See
+          OversampledImagePSF.create for a discussion of
+          non-intrinsically-centered PSFs.
+
         Parameters
         ----------
           x: float
-            Position on the image of the center of the psf
+            Position on the image of the center of the psf.  If not
+            given, defaults to something sensible that was defined when
+            the object was constructed.  If you want to do sub-pixel
+            shifts, then the fractional part of x will (usually) not be
+            0.
 
           y: float
-            Position on the image of the center of the psf
-
-          x0: float or None
-            Image position of the center of the stamp; defaults to FIGURE THIS OUT
-
-          y0: float or None
+            Position on the image of the center of the psf.  Same kind
+            of default as x.
 
           flux: float, default 1.
-             Make the sum of the clip this
+             Make the sum of the clip this.  If None, just let the clip
+             be scaled however it's naturally scaled.  For some
+             subclasses, that may be what you actually want.
 
         Returns
         -------
@@ -64,6 +105,9 @@ class PSF:
         if psfclass == "YamlSerialized_OversampledImagePSF":
             return YamlSerialized_OversampledImagePSF( **kwargs )
 
+        if psfclass == "A25ePSF":
+            return A25ePSF( **kwargs )
+        
         if psfclass == "ou24PSF":
             return ou24PSF( **kwargs )
 
@@ -72,18 +116,42 @@ class PSF:
 
 class OversampledImagePSF( PSF ):
     @classmethod
-    def create( cls, data=None, x0=None, y0=None, oversample_factor=1., enforce_odd=True, normalize=True,
-                **kwargs ):
+    def create( cls, data=None, x=None, y=None, oversample_factor=1., enforce_odd=True, normalize=True, **kwargs ):
 
         """Parameters
         ----------
           data: 2d numpy array
-
-          x0, y0: float
-            Position on the source image where this PSF is evaluated
+            The image data of the oversampled PSF.  Required.
+
+          x, y: float
+            Position on the source image where this PSF is evaluated.
+            Required.  Most of the time, but not always, you probably
+            want x and y to be integer values.  (As in, not integer
+            typed, but floats that satisfy x-floor(x)=0.)  These are
+            also the defaults that get_stamp will use if x and y are not
+            passed to get_stamp.
+
+            If x and/or y have nonzero fractional parts, then the data
+            array must be consistent.  First consider non-oversampled
+            data.  Suppose you pass a 11×11 array with x=1022.5 and
+            y=1023.25.  In this case, the peak of a perfectly symmetric
+            PSF image on data would be at (4.5, 5.25).  (Not (5.5,
+            5.25)!  If something's at *exactly* .5, always round down
+            here regardless of wheter the integer part is even or odd.)
+            The center pixel and the one to the right of it should have
+            the same brightness, and the pixel just below center should
+            be dimmer than the pixel just above center.
+
+            For oversampled psfs, the data array must be properly
+            shifted to account for non-integral x and y.  The shift will
+            be as in non-oversampled data, only multiplied by the
+            oversampling factor.  So, in the same example, if you
+            specify a peak of (4.5, 5.25), and you have an oversampling
+            factor of 3, you should pass a 33×33 array with the peak of
+            the PSF (assuming a symmetric PSF) at (14.5, 16.75).
 
           oversample_factor: float, default 1.
-            There are this many pixels along one axis in data for one pixel in the original image
+            There are this many pixels along one axis in data for one pixel in the original image.
 
           enforce_odd: bool, default True
             Enforce x_edges and y_edges having an odd width.
@@ -106,18 +174,26 @@ class OversampledImagePSF( PSF ):
         if not isinstance( data, np.ndarray ) or ( len(data.shape) != 2 ):
             raise TypeError( "data must be a 2d numpy array" )
 
-        x0 = float( x0 )
-        y0 = float( y0 )
+        x = float( x )
+        y = float( y )
 
         psf = cls()
         psf._data = data
         if normalize:
             psf._data /= psf._data.sum()
-        psf._x0 = x0
-        psf._y0 = y0
+        psf._x = x
+        psf._y = y
         psf._oversamp = oversample_factor
         return psf
 
+    @property
+    def x( self ):
+        return self._x
+
+    @property
+    def y( self ):
+        return self._y
+
     @property
     def x0( self ):
         return self._x0
@@ -135,21 +211,29 @@ class OversampledImagePSF( PSF ):
         return self._data
 
     @property
-    def clip_size( self ):
-        """The size of the PSF image clip at image resolution."""
-        return int( np.floor( self._data.shape[0] / self._oversamp ) )
+    def stamp_size( self ):
+        """The size of the PSF image clip at image resolution.  Is always odd."""
+        sz = int( np.floor( self._data.shape[0] / self._oversamp ) )
+        sz += 1 if sz % 2 == 0 else 0
+        return sz
+
 
     def __init__( self, *args, **kwargs ):
         super().__init__( *args, **kwargs )
         self._data = None
+        self._x = None
+        self._y = None
         self._x0 = None
         self._y0 = None
         self._oversamp = None
 
-    def get_stamp( self, x=None, y=None, normalize=True ):
-        x = float(x) if x is not None else self._x0
-        y = float(y) if y is not None else self._y0
+    def get_stamp( self, x=None, y=None, flux=1. ):
+        # (x, y) is the position on the image for which we want to render the PSF.
+        x = float(x) if x is not None else self._x
+        y = float(y) if y is not None else self._y
 
+        # (xc, yc) is the closest pixel center to (x, y) on the image--
+        #
         # round() isn't the right thing to use here, because it will
         #   behave differently when x - round(x) = 0.5 based on whether
         #   floor(x) is even or odd.  What we *want* is for the psf to
@@ -161,10 +245,22 @@ class OversampledImagePSF( PSF ):
         #   and to the left when the fractional part of x (and y) is
         #   exactly 0.5, whereas using round would give different
         #   results based on the integer part of x (and y).
-
         xc = int( np.floor( x + 0.5 ) )
         yc = int( np.floor( y + 0.5 ) )
 
+        # (natx, naty) is the "natural position" on the image for the
+        # psf.  This is simply (int(x), int(y)) if the fractional part
+        # of x and y are zero.  Otherwise, it rounds to the closest
+        # pixel... unless the fractional part is exactly 0.5, in which
+        # case we do floor(x+0.5) instead of round(x) as described above.
+        natx = int( np.floor( self._x + 0.5 ) )
+        naty = int( np.floor( self._y + 0.5 ) )
+        # natxfrac and natyfrac kinda the negative of the fractional
+        #   part of natx and naty.  They will be in the range (-0.5,
+        #   0.5]
+        natxfrac = natx - self._x
+        natyfrac = naty - self._y
+
         # See Chapter 5, "How PSFEx Works", of the PSFEx manual
         #     https://psfex.readthedocs.io/en/latest/Working.html
         # We're using this method for both image and psfex PSFs,
@@ -175,22 +271,23 @@ class OversampledImagePSF( PSF ):
 
         psfwid = self._data.shape[0]
         stampwid = self.clip_size
-        stampwid += 1 if stampwid % 2 == 0 else 0
 
         psfdex1d = np.arange( -( psfwid//2), psfwid//2+1, dtype=int )
 
+        # If the returned clip is to be added to the image, it should
+        #   be added to image[ymin:ymax, xmin:xmax].
         xmin = xc - stampwid // 2
         xmax = xc + stampwid // 2 + 1
         ymin = yc - stampwid // 2
         ymax = yc + stampwid // 2 + 1
 
         psfsamp = 1. / self._oversamp
-        xs = np.array( range( xmin, xmax ) )
-        ys = np.array( range( ymin, ymax ) )
-        xsincarg = psfdex1d[:, np.newaxis] - ( xs - x ) / psfsamp
+        xs = np.arange( xmin, xmax )
+        ys = np.arange( ymin, ymax )
+        xsincarg = psfdex1d[:, np.newaxis] - ( xs - natxfrac - x ) / psfsamp
         xsincvals = np.sinc( xsincarg ) * np.sinc( xsincarg/4. )
         xsincvals[ ( xsincarg > 4 ) | ( xsincarg < -4 ) ] = 0.
-        ysincarg = psfdex1d[:, np.newaxis] - ( ys - y ) / psfsamp
+        ysincarg = psfdex1d[:, np.newaxis] - ( ys - natyfrac - y ) / psfsamp
         ysincvals = np.sinc( ysincarg ) * np.sinc( ysincarg/4. )
         ysincvals[ ( ysincarg > 4 ) | ( ysincarg < -4 ) ] = 0.
         tenpro = np.tensordot( ysincvals[:, :, np.newaxis], xsincvals[:, :, np.newaxis], axes=0 )[ :, :, 0, :, :, 0 ]
@@ -216,8 +313,7 @@ class OversampledImagePSF( PSF ):
         #                                      * ysincvals[:, np.newaxis]
         #                                      * psfbase ).sum()
 
-        if normalize:
-            clip /= clip.sum()
+        clip *= flux / clip.sum()
 
         return clip
 
@@ -229,15 +325,15 @@ class YamlSerialized_OversampledImagePSF( OversampledImagePSF ):
 
     def read( self, filepath ):
         y = yaml.safe_load( open( filepath ) )
-        self._x0 = y['x0']
-        self._y0 = y['y0']
+        self._x = y['x0']
+        self._y = y['y0']
         self._oversamp = y['oversamp']
         self._data = np.frombuffer( base64.b64decode( y['data'] ), dtype=y['dtype'] )
         self._data = self._data.reshape( ( y['shape0'], y['shape1'] ) )
 
     def write( self, filepath ):
-        out = { 'x0': float( self._x0 ),
-                'y0': float( self._y0 ),
+        out = { 'x0': float( self._x ),
+                'y0': float( self._y ),
                 'oversamp': self._oversamp,
                 'shape0': self._data.shape[0],
                 'shape1': self._data.shape[1],
@@ -247,6 +343,46 @@ class YamlSerialized_OversampledImagePSF( OversampledImagePSF ):
         # TODO : check overwriting etc.
         yaml.dump( out, open( filepath, 'w' ) )
 
+class A25ePSF( YamlSerialized_OversampledImagePSF ):
+
+    def __init__( self, band, sca, x, y, *args, **kwargs ):
+
+        super().__init__( *args, **kwargs )
+        
+        cfg = Config.get()
+        basepath = pathlib.Path( cfg.value( 'photometry.snappl.A25ePSF_path' ) )
+
+        """
+        The array size is the size of one image (nx, ny).
+        The grid size is the number of times we divide that image
+        into smaller parts for the purposes of assigning the
+        correct ePSF (8 x 8 = 64 ePSFs).
+        
+        4088 px/8 = 511 px. So, int(arr_size/gridsize) is just a type
+        conversion. In the future, we may have a class where these things
+        are variable, but for now, we are using only the 8 x 8 grid of
+        ePSFs from Aldoroty et al. 2025a. So, it's hardcoded. 
+
+        """
+        arr_size = 4088
+        gridsize = 8
+        cutoutsize = int(arr_size/gridsize)
+        grid_centers = np.linspace(0.5 * cutoutsize, arr_size - 0.5 * cutoutsize, gridsize)
+
+        dist_x = np.abs(grid_centers - x)
+        dist_y = np.abs(grid_centers - y)
+
+        x_idx = np.argmin(dist_x)
+        y_idx = np.argmin(dist_y)
+
+        x_cen = grid_centers[x_idx]
+        y_cen = grid_centers[y_idx]
+        
+        min_mag = 19.0
+        max_mag = 21.5
+        psfpath = basepath / band / str(sca) / f'{cutoutsize}_{x_cen:.1f}_{y_cen:.1f}_-_{min_mag}_{max_mag}_-_{band}_{sca}.psf'
+
+        self.read(psfpath)
 
 class ou24PSF( PSF ):
     # Currently, does not support any oversampling, because SFFT doesn't
@@ -258,6 +394,10 @@ class ou24PSF( PSF ):
 
         if ( pointing is None ) or ( sca is None ):
             raise ValueError( "Need a pointing and an sca to make an ou24PSF" )
+        if ( size % 2 == 0 ) or ( int(size) != size ):
+            raise ValueError( "Size must be an odd integer." )
+        size = int( size )
+
         if config_file is None:
             config_file = Config.get().value( 'ou24psf.config_file' )
         self.config_file = config_file
@@ -267,6 +407,12 @@ class ou24PSF( PSF ):
         self.include_photonOps = include_photonOps
         self._stamps = {}
 
+
+    @property
+    def stamp_size( self ):
+        return self.size
+
+
     def get_stamp( self, x, y, flux=1., seed=None ):
         """Return a 2d numpy image of the PSF at the image resolution.
 

{roman_snpit_snappl-0.4.0 → roman_snpit_snappl-0.5.0}/snappl/wcs.py

@@ -118,8 +118,9 @@ class AstropyWCS(BaseWCS):
             dec = float( dec )
         return ra, dec
 
-    def world_to_pixel( self, ra, dec ):
-        scs = SkyCoord( ra, dec, unit=(u.deg, u.deg) )
+    def world_to_pixel( self, ra, dec):
+        frame = self._wcs.wcs.radesys.lower()  # Needs to be lowercase for SkyCoord
+        scs = SkyCoord( ra, dec, unit=(u.deg, u.deg), frame = frame)
         x, y = self._wcs.world_to_pixel( scs )
         if not ( isinstance( ra, collections.abc.Sequence )
                  or ( isinstance( ra, np.ndarray ) and y.size > 1 )