slide-lsst 0.1.0__py3-none-any.whl

slide_lsst/__init__.py

@@ -0,0 +1,41 @@
+"""
+SLIDE: Subtracting LSST Images with DECam Exposures
+
+This package provides tools for performing image subtraction on LSST images using DECam templates,
+including PSF modeling, reference image downloading, and image subtraction.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Yize Dong"
+
+from .lsst_utils import query_lsst_visits, lsst_visit_to_ccddata, lsst_visit_to_psf
+from .image_processing import (
+    read_with_datasec,
+    get_ccd_bbox,
+    make_psf,
+    refine_wcs,
+    assemble_reference
+)
+from .reference_download import (
+    download_des_reference,
+    download_decals_reference,
+    gaia3cat,
+)
+from .subtraction import perform_image_subtraction, lsst_decam_data_load, load_usesr_decam
+
+__all__ = [
+    'gaia3cat',
+    'query_lsst_visits',
+    'read_with_datasec',
+    'get_ccd_bbox',
+    'make_psf',
+    'refine_wcs',
+    'assemble_reference',
+    'download_des_reference',
+    'download_decals_reference',
+    'lsst_visit_to_ccddata',
+    'lsst_visit_to_psf',
+    'perform_image_subtraction',
+    'lsst_decam_data_load',
+    'load_usesr_decam'
+] 

slide_lsst/_version.py

@@ -0,0 +1,4 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+__version__ = version = '0.1.dev45+gfc69713'
+__version_tuple__ = version_tuple = (0, 1, 'dev45', 'gfc69713')

slide_lsst/image_processing.py

@@ -0,0 +1,344 @@
+"""
+Image processing utilities.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from reproject import reproject_interp, reproject_adaptive
+from astropy.io import fits
+from astropy.nddata import CCDData, NDData
+from astropy.wcs import WCS, _wcs
+from astropy.visualization import PercentileInterval, ImageNormalize
+from photutils.psf import EPSFBuilder, extract_stars
+from astropy.coordinates import SkyCoord
+from astropy.wcs.utils import skycoord_to_pixel
+import scipy.optimize
+import warnings
+from astropy.wcs.utils import fit_wcs_from_points
+import sep
+from .lsst_utils import astropy_world_to_pixel, lsst_world_to_pixel, lsst_pixel_to_world
+
+def read_with_datasec(filename, hdu=0):
+    """
+    Read FITS file with optional DATASEC handling.
+    
+    Parameters
+    ----------
+    filename : str
+        Path to FITS file
+    hdu : int, optional
+        HDU index to read (default: 0)
+        
+    Returns
+    -------
+    CCDData
+        Image data with WCS information
+    """
+    ccddata = CCDData.read(filename, format='fits', unit='adu', hdu=hdu)
+    if 'datasec' in ccddata.meta:
+        jmin, jmax, imin, imax = eval(ccddata.meta['datasec'].replace(':', ','))
+        ccddata = ccddata[imin-1:imax, jmin-1:jmax]
+    return ccddata
+
+
+def get_ccd_bbox(ccddata):
+    """
+    Get bounding box coordinates for a CCD image.
+    
+    Parameters
+    ----------
+    ccddata : CCDData
+        Image data with WCS
+        
+    Returns
+    -------
+    tuple
+        (ra_min, dec_min, ra_max, dec_max) in degrees
+    """
+    corners = [[0.], [0.5], [1.]] * np.array(ccddata.shape)[::-1]
+    (ra_min, dec_min), (ra_ctr, dec_ctr), (ra_max, dec_max) = ccddata.wcs.all_pix2world(corners, 0.)
+    if ra_min > ra_max:
+        ra_min, ra_max = ra_max, ra_min
+    if dec_min > dec_max:
+        dec_min, dec_max = dec_max, dec_min
+    max_size_dec = 0.199
+    if dec_max - dec_min > max_size_dec:
+        dec_min = dec_ctr - max_size_dec / 2.
+        dec_max = dec_ctr + max_size_dec / 2.
+    return ra_min, dec_min, ra_max, dec_max
+
+
+def make_psf(data, catalog, show=False, boxsize=25, oversampling=1, center_accuracy=0.001):
+    """
+    Create PSF model from catalog stars.
+    
+    Parameters
+    ----------
+    data : CCDData
+        Image data
+    catalog : astropy.table.Table
+        Star catalog with ra, dec columns
+    show : bool, optional
+        Show PSF visualization (default: False)
+    boxsize : int, optional
+        Size of star cutouts (default: 25)
+        
+    Returns
+    -------
+    tuple
+        (epsf, fitted_stars)
+    """
+    _catalog = catalog.copy()
+    coords = SkyCoord(_catalog['ra'], _catalog['dec'], unit='deg')
+    _catalog['x'], _catalog['y'] = skycoord_to_pixel(coords, data.wcs, origin=0)
+
+    good_mask = []
+    for x, y in zip(_catalog['x'], _catalog['y']):
+        x = int(np.round(x))
+        y = int(np.round(y))
+        # If any pixel in the cutout is masked, reject it
+        if data.mask is not None and np.any(data.mask[y-1:y+1,
+                                                      x-1:x+1]):
+            good_mask.append(False)
+        else:
+            good_mask.append(True)
+    _catalog = _catalog[good_mask]
+    
+    bkg = np.nanmedian(data.data)
+    nddata = NDData(data.data - bkg)
+
+    stars = extract_stars(nddata, _catalog, size=boxsize)
+    epsf_builder = EPSFBuilder(oversampling=oversampling, center_accuracy=center_accuracy)
+    epsf, fitted_stars = epsf_builder(stars)
+    
+    if show:
+        plt.figure()
+        plt.imshow(epsf.data)
+        plot_stars(fitted_stars)
+
+    return epsf, fitted_stars
+
+def find_catalog_stars(image, wcs, catalog):
+    try:
+        data = image.astype(np.float32)
+    except:
+        data = image.byteswap().newbyteorder()
+    bkg = sep.Background(data)
+    data_sub = data - bkg
+
+    # 2. Extract all sources
+    sources = sep.extract(data_sub, thresh=3, err=bkg.globalrms)
+    
+    known_x, known_y = astropy_world_to_pixel(catalog['ra'], catalog['dec'], wcs)
+
+    matched_sources = []
+    for x0, y0 in zip(known_x, known_y):
+        distances = np.hypot(sources['x'] - x0, sources['y'] - y0)
+        closest_idx = np.argmin(distances)
+        matched_sources.append(sources[closest_idx])
+
+    matched_sources = np.array(matched_sources)
+    return matched_sources
+
+def plot_stars(stars):
+    """
+    Plot extracted stars for visualization.
+    
+    Parameters
+    ----------
+    stars : list
+        List of star cutouts
+    """
+    nrows = int(np.ceil(len(stars) ** 0.5))
+    fig, axarr = plt.subplots(nrows, nrows, figsize=(20, 20), squeeze=True)
+    for ax, star in zip(axarr.ravel(), stars):
+        ax.imshow(star)
+        ax.plot(star.cutout_center[0], star.cutout_center[1], 'r+')
+
+
+def update_wcs(wcs, p):
+    """
+    Update WCS with transformation parameters.
+    
+    Parameters
+    ----------
+    wcs : WCS
+        WCS object to update
+    p : array-like
+        Transformation parameters [dx, dy, rotation, scale]
+    """
+    wcs.wcs.crval += p[:2]
+    c, s = np.cos(p[2]), np.sin(p[2])
+    if wcs.wcs.has_cd():
+        wcs.wcs.cd = wcs.wcs.cd @ np.array([[c, -s], [s, c]]) * p[3]
+    if wcs.wcs.has_pc():
+        wcs.wcs.pc = wcs.wcs.pc @ np.array([[c, -s], [s, c]]) * p[3]
+
+
+
+def wcs_offset(p, radec, xy, origwcs):
+    """
+    Calculate RMS offset between catalog and detected positions.
+    
+    Parameters
+    ----------
+    p : array-like
+        Transformation parameters
+    radec : array-like
+        Catalog coordinates
+    xy : array-like
+        Detected pixel coordinates
+    origwcs : WCS
+        Original WCS
+        
+    Returns
+    -------
+    float
+        RMS offset in pixels
+    """
+    wcs = origwcs.deepcopy()
+    update_wcs(wcs, p)
+    sky = SkyCoord(radec[:, 0], radec[:, 1], unit='deg')
+    test_xy = np.column_stack(skycoord_to_pixel(sky, wcs))
+    rms = (np.sum((test_xy - xy)**2) / len(radec))**0.5
+    return rms
+
+
+def refine_wcs(wcs, stars, catalog, use_sep=False):
+    """
+    Refine WCS using star positions.
+    
+    Parameters
+    ----------
+    wcs : WCS
+        WCS to refine
+    stars : object
+        Detected stars
+    catalog : astropy.table.Table
+        Reference catalog
+    use_sep : bool, optional
+        Use SEP detection format (default: False)
+    """
+    if use_sep:
+        xy = np.array([[star['x'], star['y']] for star in stars])
+        t_match = catalog[stars['i']]
+    else:
+        xy = np.array([star.center for star in stars.all_good_stars])
+        t_match = catalog[[star.id_label - 1 for star in stars.all_good_stars]]
+    radec = np.array([t_match['raMean'], t_match['decMean']]).T
+
+    res = scipy.optimize.minimize(wcs_offset, [0., 0., 0., 1.], args=(radec, xy, wcs),
+                                  bounds=[(-0.01, 0.01), (-0.01, 0.01), (-0.1, 0.1), (0.9, 1.1)])
+
+    orig_rms = wcs_offset([0., 0., 0., 1.], radec, xy, wcs)
+    print(' orig_fun: {}'.format(orig_rms))
+    print(res)
+    update_wcs(wcs, res.x)
+
+def refine_multiple_stars(image, wcs, catalog, box_size=25, fwhm=5.0, threshold=5):
+    from astropy.stats import sigma_clipped_stats
+    from astropy.nddata import Cutout2D
+    from photutils.detection import DAOStarFinder
+
+    known_x, known_y = astropy_world_to_pixel(catalog['ra'], catalog['dec'], wcs)
+    refined_xy = {}
+    refined_xy['x'] = []
+    refined_xy['y'] = []
+    
+
+    for (rough_x, rough_y) in zip(known_x, known_y):
+        try:
+            cutout = Cutout2D(image, (rough_x, rough_y), size=box_size)
+            mean, median, std = sigma_clipped_stats(cutout.data)
+            finder = DAOStarFinder(fwhm=fwhm, threshold=threshold*std)
+            sources = finder(cutout.data - median)
+
+            if sources is None or len(sources) == 0:
+                #refined_xy_list.append((np.nan, np.nan))
+                refined_xy['x'].append(np.nan)
+                refined_xy['y'].append(np.nan)
+                continue
+
+            # Choose nearest star to center
+            dx = sources['xcentroid'] - box_size/2
+            dy = sources['ycentroid'] - box_size/2
+            distances = np.hypot(dx, dy)
+            idx = np.argmin(distances)
+
+            x_refined = sources['xcentroid'][idx] + cutout.origin_original[0]
+            y_refined = sources['ycentroid'][idx] + cutout.origin_original[1]
+            #refined_xy_list.append((x_refined, y_refined))
+            refined_xy['x'].append(x_refined)
+            refined_xy['y'].append(y_refined)
+        except Exception as e:
+            print(f"Warning: failed to refine star at ({rough_x:.1f}, {rough_y:.1f}): {e}")
+            #refined_xy_list.append((np.nan, np.nan))
+            refined_xy['x'].append(np.nan)
+            refined_xy['y'].append(np.nan)
+
+    return refined_xy
+    
+def refine_wcs_astropy(image, wcs, catalog, fwhm=5.0, projection='TAN', fit_distortion=None):
+    #matched_sources = find_catalog_stars(image, wcs, catalog)
+    matched_sources = refine_multiple_stars(image, wcs, catalog, box_size=25, fwhm=fwhm)
+    
+    valid_mask = np.isfinite(matched_sources['x']) & np.isfinite(matched_sources['y'])
+    matched_x = np.array(matched_sources['x'])[valid_mask]
+    matched_y = np.array(matched_sources['y'])[valid_mask]
+    
+    catalog = catalog[valid_mask]
+    
+    sky_coords = SkyCoord(ra=catalog['ra'], dec=catalog['dec'], unit='deg')
+    # matched pixel positions and sky positions
+    new_wcs = fit_wcs_from_points(xy=(matched_x, matched_y), world_coords=sky_coords, projection=projection, sip_degree=fit_distortion)
+    return new_wcs, catalog
+    
+
+def assemble_reference(refdatas, wcs, shape, ref_global_bkg=0, order='bicubic'):
+    """
+    Reproject and stack reference images to match science image.
+    
+    Parameters
+    ----------
+    refdatas : list
+        List of reference CCDData objects
+    wcs : WCS
+        Target WCS
+    shape : tuple
+        Target image shape
+    ref_global_bkg : float, optional
+        Background value for masked pixels (default: 0)
+    order : str, optional
+        Interpolation order (default: 'bicubic')
+        
+    Returns
+    -------
+    CCDData
+        Assembled reference image
+    """
+    refdatas_reprojected = []
+    mask_stack = []
+    refdata_foot = np.zeros(shape, float)
+    for data in refdatas:
+        #reprojected, foot = reproject_interp((data.data, data.wcs), wcs, shape, order=order)
+        reprojected, foot = reproject_adaptive((data.data, data.wcs), wcs, shape, conserve_flux=True)
+        
+        refdatas_reprojected.append(reprojected)
+        refdata_foot += foot
+
+        if data.mask is not None:
+            # Use nearest-neighbor interpolation for boolean mask
+            mask_reproj, _ = reproject_interp((data.mask.astype(float), data.wcs), wcs, shape)
+            mask_stack.append(mask_reproj > 0.5)
+    # Combine masks if available
+    if mask_stack:
+        combined_mask = np.any(mask_stack, axis=0)
+    else:
+        combined_mask = np.zeros(shape, dtype=bool)
+    refdata_reproj = np.nanmedian(refdatas_reprojected, axis=0)
+    if np.all(np.isnan(refdata_reproj)):
+        raise ValueError("All reprojected reference data is NaN.")
+    refdata_reproj[np.isnan(refdata_reproj)] = ref_global_bkg
+    final_mask = (refdata_foot == 0.) | combined_mask
+    refdata = CCDData(refdata_reproj, wcs=wcs, mask=final_mask, unit='adu')
+    return refdata 

slide_lsst/lsst_utils.py

@@ -0,0 +1,312 @@
+from lsst.daf.butler import Butler, Timespan
+from lsst.rsp import get_tap_service
+import lsst.geom
+import lsst.afw.display as afwDisplay
+from astropy.time import Time
+import numpy as np
+import lsst.geom as geom
+from astroquery.gaia import Gaia
+from astropy.coordinates import SkyCoord
+from astropy.wcs.utils import skycoord_to_pixel, pixel_to_skycoord
+from astropy.nddata import CCDData
+from astropy.io import fits
+from astropy.wcs import WCS
+from photutils.aperture import SkyCircularAnnulus, SkyCircularAperture, ApertureStats
+from photutils.background import Background2D
+from photutils.psf import ImagePSF
+from astropy.table import QTable
+from photutils.psf import IterativePSFPhotometry
+from photutils.background import LocalBackground, MMMBackground
+from photutils.detection import DAOStarFinder
+from photutils.psf import PSFPhotometry
+from astropy.nddata import Cutout2D
+from astropy.wcs.utils import fit_wcs_from_points
+
+
+def query_lsst_visits(butler, ra, dec, band, time1, time2):
+    """
+    Query LSST Butler for visit images within a time range and sky region.
+    
+    Parameters
+    ----------
+    butler : lsst.daf.butler.Butler
+        Butler instance for data access
+    ra : float
+        Right ascension in degrees
+    dec : float
+        Declination in degrees
+    band : str
+        Filter band name
+    time1 : astropy.time.Time
+        Start time
+    time2 : astropy.time.Time
+        End time
+        
+    Returns
+    -------
+    list
+        Dataset references matching the criteria
+    """
+    #butler = Butler("dp1", collections="LSSTComCam/DP1")
+    time1 = Time(time1, format="isot", scale="tai")
+    time2 = Time(time2, format="isot", scale="tai")
+    timespan = Timespan(time1, time2)
+    
+    dataset_refs = butler.query_datasets("visit_image",
+                                         where="band.name = :band AND \
+                                         visit.timespan OVERLAPS :timespan AND \
+                                         visit_detector_region.region OVERLAPS POINT(:ra, :dec)",
+                                         bind={"band": band, "timespan": timespan,
+                                               "ra": ra, "dec": dec},
+                                         order_by=["visit.timespan.begin"])
+    return dataset_refs
+
+def lsst_bad_mask(visit_image, mask_type = ['']):
+    mask = visit_image.mask.array
+    if len(mask_type) == 0:
+        bitmask = visit_image.mask.getPlaneBitMask([
+                "BAD",          # detector bad pixel
+                "SAT",          # saturated pixel
+                "INTRP",        # interpolated pixel
+                "CR",           # cosmic ray
+                "EDGE",         # edge of the detector
+                #"DETECTED",     # source detected
+                #"DETECTED_NEGATIVE",  # negative source detected
+                "SUSPECT",      # suspicious pixel
+                "NO_DATA",      # no data available
+                "SENSOR_EDGE",  # sensor edge
+                "CLIPPED",      # pixel in clipped area
+                "CROSSTALK",    # crosstalk
+                #"NOT_DEBLENDED",# not deblended
+                "UNMASKEDNAN",  # unmasked NaN
+                #"VIGNETTED",    # vignetting
+                "STREAK",       # streak from satellite or airplane
+            ])
+    else:
+        bitmask = visit_image.mask.getPlaneBitMask(mask_type)
+    image_mask = (visit_image.mask.array & bitmask) != 0
+    return image_mask
+
+def lsst_visit_to_ccddata(visit_image, mask_type = ["BAD", "SAT", "INTRP", "CR", "EDGE", "SUSPECT", "NO_DATA", "SENSOR_EDGE", "CLIPPED", "CROSSTALK", "UNMASKEDNAN", "STREAK"], saveas=None):
+    data = visit_image.image.array
+    #header = fits.Header(visit_image.getWcs().getFitsMetadata().toDict())
+    #wcs = WCS(header)
+    wcs = lsst_refine_wcs_astropy(visit_image, n_points=10)
+    mask = lsst_bad_mask(visit_image, mask_type=mask_type)
+    
+    sat_mask = lsst_bad_mask(visit_image, mask_type = ['SAT'])
+    masked_values = data[sat_mask] 
+    finite_values = masked_values[np.isfinite(masked_values)]
+    SATURATE = np.nanmax(finite_values) if finite_values.size > 0 else 60000
+    
+    ccddata = CCDData(data, wcs=wcs, unit='adu')
+    ccddata.mask = mask
+    ccddata.meta['SATURATE'] = SATURATE
+    if saveas is not None:
+        visit_image.writeFits(saveas)
+    return ccddata
+
+def get_visit_fwhm(visit_image, ra, dec):
+    SIGMA_TO_FWHM = 2.0*np.sqrt(2.0*np.log(2.0))
+    x, y = lsst_world_to_pixel(ra, dec, visit_image)
+    
+    info_calexp = visit_image.getInfo()
+    psf_calexp = info_calexp.getPsf()
+    
+    point_image = lsst.geom.Point2D(x, y)
+    psf_shape = psf_calexp.computeShape(point_image)
+    psf_sigma = psf_shape.getDeterminantRadius()
+    psf_fwhm = psf_sigma * SIGMA_TO_FWHM
+    return psf_fwhm
+
+def lsst_visit_to_psf(visit_image, ra, dec):
+    x, y = lsst_world_to_pixel(ra, dec, visit_image)
+    psf = visit_image.getPsf()
+    xy = lsst.geom.Point2D(x, y)
+    psf_image = psf.computeImage(xy)
+    ccddata = CCDData(psf_image.array, unit='adu')
+    return ccddata
+
+
+def lsst_visit_to_psf_median(visit_image, ra, dec, cutout_size=(2000, 2000), sample_number=20):
+    if isinstance(cutout_size, (int, float)):
+        cutout_size = (int(cutout_size), int(cutout_size))
+    else:
+        cutout_size = (int(cutout_size[0]), int(cutout_size[1]))
+
+    data = visit_image.image.array
+    ny, nx = data.shape
+
+    # Get WCS and center in pixel coordinates
+    header = fits.Header(visit_image.getWcs().getFitsMetadata().toDict())
+    wcs = WCS(header)
+    xcen, ycen = astropy_world_to_pixel(ra, dec, wcs)
+
+    # Shift center inward if too close to edge
+    half_x, half_y = cutout_size[0] // 2, cutout_size[1] // 2
+    xcen = np.clip(xcen, half_x, nx - half_x)
+    ycen = np.clip(ycen, half_y, ny - half_y)
+
+    # Sample PSFs
+    psf = visit_image.getPsf()
+    psf_stars = []
+
+    for dx in np.linspace(-cutout_size[0] / 2, cutout_size[0] / 2, sample_number):
+        for dy in np.linspace(-cutout_size[1] / 2, cutout_size[1] / 2, sample_number):
+            x_sample, y_sample = xcen + dx, ycen + dy
+            xy = lsst.geom.Point2D(x_sample, y_sample)
+            psf_image = psf.computeImage(xy).getArray()
+            psf_stars.append(psf_image)
+
+    if len(psf_stars) == 0:
+        raise RuntimeError("No valid PSFs found in the region.")
+
+    # Stack and normalize
+    stacked = np.median(np.stack(psf_stars, axis=0), axis=0)
+    psf_final = stacked / np.sum(stacked)
+
+    ccddata = CCDData(psf_final, unit='adu')
+
+    return ccddata
+        
+
+
+def lsst_world_to_pixel(ra, dec, visit_image):
+    wcs = visit_image.wcs
+    if isinstance(ra, (int, float)):
+        spherePoint = lsst.geom.SpherePoint(ra*geom.degrees, dec*geom.degrees)
+        pixel_coord = wcs.skyToPixel(spherePoint)
+        x = pixel_coord.getX()
+        y = pixel_coord.getY()
+    else:
+        sphere_points = [geom.SpherePoint(_ra, _dec, geom.degrees) for _ra, _dec in zip(ra, dec)]
+        pixel_coords = [wcs.skyToPixel(sp) for sp in sphere_points]
+        x = [pt.getX() for pt in pixel_coords]
+        y = [pt.getY() for pt in pixel_coords]
+    return x, y
+
+def lsst_pixel_to_world(x, y, visit_image):
+    wcs = visit_image.wcs
+    if isinstance(x, (int, float)):
+        pixel = geom.Point2D(x, y)
+        sky_coord = wcs.pixelToSky(pixel)
+        ra = sky_coord.getRa().asDegrees()
+        dec = sky_coord.getDec().asDegrees()
+    else:
+        pixel_coords = [geom.Point2D(px, py) for px, py in zip(x, y)]
+        sky_coords = [wcs.pixelToSky(p) for p in pixel_coords]
+        ra = [c.getRa().asDegrees() for c in sky_coords]
+        dec = [c.getDec().asDegrees() for c in sky_coords]
+    return ra, dec
+
+def astropy_world_to_pixel(ra, dec, wcs, origin = 0):
+    coord = SkyCoord(ra, dec, unit='deg')
+    x, y = skycoord_to_pixel(coord, wcs, origin=origin)
+    return x, y
+
+def astropy_pixel_to_world(x, y, wcs, origin=0):
+    skycoord = pixel_to_skycoord(x, y, wcs, origin=origin)
+    return skycoord.ra.deg, skycoord.dec.deg
+
+def lsst_refine_wcs_astropy(visit_image, n_points=10, projection='TAN', fit_distortion=None):
+
+    ny, nx = visit_image.image.array.shape
+    # Sample pixel grid
+    x_vals = np.linspace(25, nx - 25, n_points)
+    y_vals = np.linspace(25, ny - 25, n_points)
+    xx, yy = np.meshgrid(x_vals, y_vals)
+    matched_x = xx.ravel()
+    matched_y = yy.ravel()
+
+    ra, dec = lsst_pixel_to_world(matched_x, matched_y, visit_image)
+    
+    sky_coords = SkyCoord(ra=ra, dec=dec, unit='deg')
+    #matched_x, matched_y = lsst_world_to_pixel(catalog['ra'], catalog['dec'], visit_image)
+    #matched_x = np.asarray(matched_x)
+    #matched_y = np.asarray(matched_y)
+    new_wcs = fit_wcs_from_points(xy=(matched_x, matched_y), world_coords=sky_coords, projection=projection, sip_degree=fit_distortion)
+    return new_wcs
+
+def safe_cutout2d(visit_image, ra, dec, cutout_size=(2000, 2000), mask_type = ["BAD", "SAT", "INTRP", "CR", "EDGE", "SUSPECT", "NO_DATA", "SENSOR_EDGE", "CLIPPED", "CROSSTALK", "UNMASKEDNAN", "STREAK"]):
+    """
+    Create a Cutout2D that contains the original RA/Dec, shifting inward if near the edge.
+
+    Parameters:
+        data (2D ndarray): Image array.
+        wcs (astropy.wcs.WCS): WCS for the image.
+        ra, dec (float): Center coordinates in degrees.
+        cutout_size (tuple): Desired cutout size in pixels.
+
+    Returns:
+        Cutout2D object.
+    """
+    if isinstance(cutout_size, (int, float)):
+        cutout_size = (int(cutout_size), int(cutout_size))
+    else:
+        cutout_size = (int(cutout_size[0]), int(cutout_size[1]))
+
+    data = visit_image.image.array
+    mask = lsst_bad_mask(visit_image, mask_type = mask_type)
+    sat_mask = lsst_bad_mask(visit_image, mask_type = ['SAT'])
+    masked_values = data[sat_mask] 
+    finite_values = masked_values[np.isfinite(masked_values)]
+    SATURATE = np.nanmax(finite_values) if finite_values.size > 0 else 60000
+    #SATURATE = np.max(data[sat_mask==True])
+    #header = fits.Header(visit_image.getWcs().getFitsMetadata().toDict())
+    #wcs = WCS(header)
+    wcs = lsst_refine_wcs_astropy(visit_image, n_points=10)
+        
+    xcen, ycen = astropy_world_to_pixel(ra, dec, wcs)
+
+    # Half size
+    half_x = cutout_size[0] // 2
+    half_y = cutout_size[1] // 2
+    ny, nx = data.shape
+
+    # Shift center inward if near edges
+    xcen = np.clip(xcen, half_x, nx - half_x)
+    ycen = np.clip(ycen, half_y, ny - half_y)
+
+    pixel_center = (xcen, ycen)
+    cutout = Cutout2D(data, position=pixel_center, size=cutout_size, wcs=wcs, mode='trim')
+    cutout_mask = Cutout2D(mask, position=pixel_center, size=cutout_size, wcs=wcs, mode='trim')
+    
+    ccddata = CCDData(cutout.data, wcs=cutout.wcs, unit='adu')
+    ccddata.mask = cutout_mask.data
+    ccddata.meta['SATURATE'] = SATURATE
+    return ccddata
+
+def lsst_cutout_to_ccddata(cutout, saveas=None):
+    ccddata = CCDData(cutout.data, wcs=cutout.wcs, unit='adu')
+    return ccddata
+
+def forced_phot(ra, dec, image, wcs, psf_data):
+    xx, yy = np.mgrid[:psf_data.shape[0], :psf_data.shape[1]]
+    psf_model = ImagePSF(psf_data/np.sum(psf_data), x_0=psf_data.shape[0]/2, y_0=psf_data.shape[1]/2, flux=1)
+    bkgstat = MMMBackground()
+    localbkg_estimator = LocalBackground(5, 10, bkgstat)
+    init_params = QTable()
+    _x, _y = astropy_world_to_pixel(ra, dec, wcs)
+    init_params['x'] = [_x]
+    init_params['y'] = [_y]
+    fit_shape = (5,5)
+    #bkgstat = MMMBackground()
+    #localbkg_estimator = LocalBackground(5, 10, bkgstat)
+    psfphot = PSFPhotometry(psf_model, fit_shape,
+                            aperture_radius=7,
+                            localbkg_estimator=None)
+    phot = psfphot(image.data, init_params=init_params)
+    if phot[0]['flux_fit'] / phot[0]['flux_err'] <= 3 or phot[0]['flux_err'] == 0:
+        psf_model.x_0.fixed = True
+        psf_model.y_0.fixed = True
+        psfphot = PSFPhotometry(psf_model, fit_shape,
+                            aperture_radius=7,
+                            localbkg_estimator=None)
+        phot = psfphot(image.data, init_params=init_params)
+    flux_njy = phot[0]['flux_fit']
+    flux_err = phot[0]['flux_err']
+    mag = -2.5 * np.log10(flux_njy / 3631e9)
+    magerr = (2.5 / np.log(10)) * (flux_err / flux_njy)
+    upper_limit = -2.5 * np.log10(flux_err * 5 / 3631e9)
+
+    return flux_njy, flux_err, mag, magerr, upper_limit