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

{roman_snpit_snappl-0.3.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.3.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/18.feature.rst

@@ -0,0 +1 @@
+Add a few properties (sca, zeropoint, etc.) to Image ; add ou2024PSF.

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.3.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.3.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.3.0 → roman_snpit_snappl-0.5.0}/roman_snpit_snappl.egg-info/SOURCES.txt

@@ -29,6 +29,10 @@ changes/13.bugfix.rst
 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.3.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.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)

{roman_snpit_snappl-0.3.0 → roman_snpit_snappl-0.5.0}/snappl/image.py

@@ -1,10 +1,13 @@
 import types
+import pathlib
 
 import numpy as np
 from astropy.io import fits
 from astropy.nddata.utils import Cutout2D
 # from astropy.coordinates import SkyCoord
 
+import galsim.roman
+
 from snpit_utils.logger import SNLogger
 from snappl.wcs import AstropyWCS, GalsimWCS
 
@@ -63,11 +66,12 @@ class Image:
 
         """
         self.inputs = types.SimpleNamespace()
-        self.inputs.path = path
+        self.inputs.path = pathlib.Path( path )
         self.inputs.exposure = exposure
         self.inputs.sca = sca
         self._wcs = None      # a BaseWCS object (in wcs.py)
         self._is_cutout = False
+        self._zeropoint = None
 
     @property
     def data( self ):
@@ -101,6 +105,18 @@ class Image:
         """Tuple: (ny, nx) pixel size of image."""
         raise NotImplementedError( f"{self.__class__.__name__} needs to implement image_shape" )
 
+    @property
+    def sca( self ):
+        return self.inputs.sca
+
+    @property
+    def path( self ):
+        return self.inputs.path
+
+    @property
+    def name( self ):
+        return self.inputs.path.name
+
     @property
     def sky_level( self ):
         """Estimate of the sky level in ADU."""
@@ -116,6 +132,24 @@ class Image:
         """Band (str)"""
         raise NotImplementedError( f"{self.__class__.__name__} needs to implement band" )
 
+    @property
+    def zeropoint( self ):
+        """Image zeropoint for AB magnitudes.
+
+        The zeropoint zp is defined so that an object with total counts
+        c has magnitude m:
+
+           m = -2.5 * log(10) + zp
+
+        """
+        if self._zeropoint is None:
+            self._get_zeropoint()
+        return self._zeropoint
+
+    @zeropoint.setter
+    def zeropoint( self, val ):
+        self._zeropoint = val
+
     @property
     def mjd( self ):
         """MJD of the start of the image (defined how? TAI?)"""
@@ -192,7 +226,12 @@ class Image:
         """
         raise NotImplementedError( f"{self.__class__.__name__} needs to implement get_wcs" )
 
+    def _get_zeropoint( self ):
+        """Set self._zeropoint; see "zeropoint" property above."""
+        raise NotImplementedError( f"{self.__class__.__name__} needs to implement _get_zeropoint" )
+
     def get_cutout(self, ra, dec, size):
+
         """Make a cutout of the image at the given RA and DEC.
 
         Returns
@@ -504,3 +543,14 @@ class OpenUniverse2024FITSImage( FITSImage ):
         """The band the image is taken in (str)."""
         header = self._get_header()
         return header['FILTER'].strip()
+
+    @property
+    def mjd(self):
+        """The mjd of the image."""
+        header = self._get_header()
+        return float( header['MJD-OBS'] )
+
+    @property
+    def _get_zeropoint( self ):
+        header = self._get_header()
+        return galsim.roman.getBandpasses()[self.band].zeropoint + header['ZPTMAG']

roman_snpit_snappl-0.5.0/snappl/psf.py

@@ -0,0 +1,438 @@
+# IMPORTS Standard
+import base64
+import numpy as np
+import pathlib
+import yaml
+
+# 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
+
+
+class PSF:
+    # Thought required: how to deal with oversampling.
+
+    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.  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.  Same kind
+            of default as x.
+
+          flux: float, default 1.
+             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
+        -------
+          2d numpy array
+
+        """
+        raise NotImplementedError( f"{self.__class__.__name__} needs to implement get_stamp" )
+
+    @classmethod
+    def get_psf_object( cls, psfclass, **kwargs ):
+        """Return a PSF object whose type is specified by psfclass.
+
+        Parameters
+        ----------
+          psfclass : str
+             The name of the class of the PSF to instantiate.
+
+          **kwargs : further keyword arguments
+             TODO : we need to standardize on these so that things can
+             just call PSF.get_psf_object() without having to have their
+             own if statements on the type to figure out what kwargs to
+             pass!
+
+        """
+        if psfclass == "OversampledImagePSF":
+            return OversampledImagePSF.create( **kwargs )
+
+        if psfclass == "YamlSerialized_OversampledImagePSF":
+            return YamlSerialized_OversampledImagePSF( **kwargs )
+
+        if psfclass == "A25ePSF":
+            return A25ePSF( **kwargs )
+        
+        if psfclass == "ou24PSF":
+            return ou24PSF( **kwargs )
+
+        raise ValueError( f"Unknown PSF class {psfclass}" )
+
+
+class OversampledImagePSF( PSF ):
+    @classmethod
+    def create( cls, data=None, x=None, y=None, oversample_factor=1., enforce_odd=True, normalize=True, **kwargs ):
+
+        """Parameters
+        ----------
+          data: 2d numpy array
+            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.
+
+          enforce_odd: bool, default True
+            Enforce x_edges and y_edges having an odd width.
+
+          normalize: bool, default True
+            Make sure internally stored PSF sums to 1 ; you usually don't want to change this.
+
+        Returns
+        -------
+          object of type cls
+
+        """
+
+        if len(kwargs) > 0:
+            SNLogger.warning( f"Unused arguments to OversampledImagePSF.create: {[k for k in kwargs]}" )
+
+        # TODO : implement enforce_odd
+        # TODO : enforce square
+
+        if not isinstance( data, np.ndarray ) or ( len(data.shape) != 2 ):
+            raise TypeError( "data must be a 2d numpy array" )
+
+        x = float( x )
+        y = float( y )
+
+        psf = cls()
+        psf._data = data
+        if normalize:
+            psf._data /= psf._data.sum()
+        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
+
+    @property
+    def y0( self ):
+        return self._x0
+
+    @property
+    def oversample_factor( self ):
+        return self._oversamp
+
+    @property
+    def oversampled_data( self ):
+        return self._data
+
+    @property
+    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, 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
+        #   be as close to the center of the clip as possible.  In the
+        #   case where the fractional part of x is exactly 0.5, it's
+        #   ambiguous what that means-- there are four places you could
+        #   stick the PSF to statisfy that criterion.  By using
+        #   floor(x+0.5), we will consistently have the psf leaning down
+        #   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,
+        #   as the interpolation is more general than PSFEx:
+        #      https://en.wikipedia.org/wiki/Lanczos_resampling
+        #   ...though of course, the choice of a=4 comes from PSFEx.
+
+
+        psfwid = self._data.shape[0]
+        stampwid = self.clip_size
+
+        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.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 - 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 ]
+        clip = ( self._data[:, np.newaxis, :, np.newaxis ] * tenpro ).sum( axis=0 ).sum( axis=1 )
+
+        # Keeping the code below, because the code above is inpenetrable, and it's trying to
+        #   do the same thing as the code below.
+        # (I did emprically test it using the PSFs from the test_psf.py::test_psfex_rendering,
+        #  and it worked.  In particular, there is not a transposition error in the "tenpro=" line;
+        #  if you swap the order of yxincvals and xsincvals in the test, then the values of clip
+        #  do not match the code below very well.  As is, they match to within a few times 1e-17,
+        #  which is good enough as the minimum non-zero value in either one is of order 1e-12.)
+        # clip = np.empty( ( stampwid, stampwid ), dtype=dtype )
+        # for xi in range( xmin, xmax ):
+        #     for yi in range( ymin, ymax ):
+        #         xsincarg = psfdex1d - (xi-x) / psfsamp
+        #         xsincvals = np.sinc( xsincarg ) * np.sinc( xsincarg/4. )
+        #         xsincvals[ ( xsincarg > 4 ) | ( xsincarg < -4 ) ] = 0
+        #         ysincarg = psfdex1d - (yi-y) / psfsamp
+        #         ysincvals = np.sinc( ysincarg ) * np.sinc( ysincarg/4. )
+        #         ysincvals[ ( ysincarg > 4 ) | ( ysincarg < -4 ) ] = 0
+        #         clip[ yi-ymin, xi-xmin ] = ( xsincvals[np.newaxis, :]
+        #                                      * ysincvals[:, np.newaxis]
+        #                                      * psfbase ).sum()
+
+        clip *= flux / clip.sum()
+
+        return clip
+
+
+class YamlSerialized_OversampledImagePSF( OversampledImagePSF ):
+
+    def __init__( self, *args, **kwargs ):
+        super().__init__( *args, **kwargs )
+
+    def read( self, filepath ):
+        y = yaml.safe_load( open( filepath ) )
+        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._x ),
+                'y0': float( self._y ),
+                'oversamp': self._oversamp,
+                'shape0': self._data.shape[0],
+                'shape1': self._data.shape[1],
+                'dtype': str( self._data.dtype ),
+                # TODO : make this right, think about endian-ness, etc.
+                'data': base64.b64encode( self._data.tobytes() ).decode( 'utf-8' ) }
+        # 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
+    # TODO: support oversampling!
+
+    def __init__( self, pointing=None, sca=None, config_file=None, size=201, include_photonOps=True, **kwargs ):
+        if len(kwargs) > 0:
+            SNLogger.warning( f"Unused arguments to ou24PSF.__init__: {[k for k in kwargs]}" )
+
+        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
+        self.pointing = pointing
+        self.sca = sca
+        self.size = size
+        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.
+
+        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 (x, y) not in self._stamps:
+            rmutils = roman_utils( self.config_file, self.pointing, self.sca )
+            if seed is not None:
+                rmutils.rng = galsim.BaseDeviate( seed )
+            self._stamps[(x, y)] = rmutils.getPSF_Image( self.size, x, y,
+                                                         include_photonOps=self.include_photonOps ).array
+            self._stamps[(x, y)] *= flux / self._stamps[(x, y)].sum()
+        return self._stamps[(x, y)]

{roman_snpit_snappl-0.3.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 )

roman_snpit_snappl-0.3.0/snappl/psf.py

@@ -1,207 +0,0 @@
-import yaml
-import base64
-
-import numpy as np
-
-
-class PSF:
-    def __init__( self, *args, **kwargs ):
-        # Will define a PSF with a nominal position
-        pass
-
-    def get_stamp( self, x, y, flux=1. ):
-        """Return a 2d numpy image of the PSF at the image resolution.
-
-        Parameters
-        ----------
-          x: float
-            Position on the image of the center of the psf
-
-          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
-
-          flux: float, default 1.
-             Make the sum of the clip this
-
-        Returns
-        -------
-          2d numpy array
-
-        """
-        raise NotImplementedError( f"{self.__class__.__name__} needs to implement get_stamp" )
-
-
-
-class OversampledImagePSF( PSF ):
-    @classmethod
-    def create( cls, data, x0, y0, oversample_factor=1., enforce_odd=True, normalize=True ):
-        """Parameters
-        ----------
-          data: 2d numpy array
-
-          x0, y0: float
-            Position on the source image where this PSF is evaluated
-
-          oversample_factor: float, default 1.
-            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.
-
-          normalize: bool, default True
-            Make sure internally stored PSF sums to 1 ; you usually don't want to change this.
-
-        Returns
-        -------
-          object of type cls
-
-        """
-        # TODO : implement enforce_odd
-        # TODO : enforce square
-
-        psf = cls()
-        psf._data = data
-        if normalize:
-            psf._data /= psf._data.sum()
-        psf._x0 = x0
-        psf._y0 = y0
-        psf._oversamp = oversample_factor
-        return psf
-
-    @property
-    def x0( self ):
-        return self._x0
-
-    @property
-    def y0( self ):
-        return self._x0
-
-    @property
-    def oversample_factor( self ):
-        return self._oversamp
-
-    @property
-    def oversampled_data( self ):
-        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 __init__( self, *args, **kwargs ):
-        super().__init__( *args, **kwargs )
-        self._data = 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
-
-        # 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
-        #   be as close to the center of the clip as possible.  In the
-        #   case where the fractional part of x is exactly 0.5, it's
-        #   ambiguous what that means-- there are four places you could
-        #   stick the PSF to statisfy that criterion.  By using
-        #   floor(x+0.5), we will consistently have the psf leaning down
-        #   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 ) )
-
-        # 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,
-        #   as the interpolation is more general than PSFEx:
-        #      https://en.wikipedia.org/wiki/Lanczos_resampling
-        #   ...though of course, the choice of a=4 comes from PSFEx.
-
-
-        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 )
-
-        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
-        xsincvals = np.sinc( xsincarg ) * np.sinc( xsincarg/4. )
-        xsincvals[ ( xsincarg > 4 ) | ( xsincarg < -4 ) ] = 0.
-        ysincarg = psfdex1d[:, np.newaxis] - ( ys - 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 ]
-        clip = ( self._data[:, np.newaxis, :, np.newaxis ] * tenpro ).sum( axis=0 ).sum( axis=1 )
-
-        # Keeping the code below, because the code above is inpenetrable, and it's trying to
-        #   do the same thing as the code below.
-        # (I did emprically test it using the PSFs from the test_psf.py::test_psfex_rendering,
-        #  and it worked.  In particular, there is not a transposition error in the "tenpro=" line;
-        #  if you swap the order of yxincvals and xsincvals in the test, then the values of clip
-        #  do not match the code below very well.  As is, they match to within a few times 1e-17,
-        #  which is good enough as the minimum non-zero value in either one is of order 1e-12.)
-        # clip = np.empty( ( stampwid, stampwid ), dtype=dtype )
-        # for xi in range( xmin, xmax ):
-        #     for yi in range( ymin, ymax ):
-        #         xsincarg = psfdex1d - (xi-x) / psfsamp
-        #         xsincvals = np.sinc( xsincarg ) * np.sinc( xsincarg/4. )
-        #         xsincvals[ ( xsincarg > 4 ) | ( xsincarg < -4 ) ] = 0
-        #         ysincarg = psfdex1d - (yi-y) / psfsamp
-        #         ysincvals = np.sinc( ysincarg ) * np.sinc( ysincarg/4. )
-        #         ysincvals[ ( ysincarg > 4 ) | ( ysincarg < -4 ) ] = 0
-        #         clip[ yi-ymin, xi-xmin ] = ( xsincvals[np.newaxis, :]
-        #                                      * ysincvals[:, np.newaxis]
-        #                                      * psfbase ).sum()
-
-        if normalize:
-            clip /= clip.sum()
-
-        return clip
-
-
-class YamlSerialized_OversampledImagePSF( OversampledImagePSF ):
-
-    def __init__( self, *args, **kwargs ):
-        super().__init__( *args, **kwargs )
-
-    def read( self, filepath ):
-        y = yaml.safe_load( open( filepath ) )
-        self._x0 = y['x0']
-        self._y0 = 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 ),
-                'oversamp': self._oversamp,
-                'shape0': self._data.shape[0],
-                'shape1': self._data.shape[1],
-                'dtype': str( self._data.dtype ),
-                # TODO : make this right, think about endian-ness, etc.
-                'data': base64.b64encode( self._data.tobytes() ).decode( 'utf-8' ) }
-        # TODO : check overwriting etc.
-        yaml.dump( out, open( filepath, 'w' ) )
-
-
-class galsimPSF( PSF ):
-    pass