antares-devkit 0.6.3__tar.gz → 0.6.5__tar.gz

{antares_devkit-0.6.3 → antares_devkit-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: antares-devkit
-Version: 0.6.3
+Version: 0.6.5
 Summary: Provides tools and utility methods to write and debug ANTARES filters with Python.
 Keywords: antares,devkit,filter development
 Author-Email: NSF NOIRLab ANTARES Team <antares@noirlab.edu>

antares_devkit-0.6.5/antares_devkit/filters/lsst_transient_quality_scimma/__init__.py

@@ -0,0 +1,92 @@
+"""
+ANTARES filter for selecting high-quality LSST transient candidates
+for cross matching against Gaia and other catalogs using LSDB
+running in SCiMMA infrastructure. See https://scimma.org/
+
+This filter runs inside ANTARES infrastructure. It evaluates each incoming
+LSST alert against quality criteria and tags passing alerts for downstream
+crossmatching against catalogs.
+"""
+
+from antares_devkit.models import BaseFilter
+
+
+class LsstTransientQualityFilterScimma(BaseFilter):
+    """
+    This filter finds loci where the first alert has a SNR > 10 and the
+    image is not saturated, near an image edge, not classified as a dipole,
+    and excludes known solar system objects.
+    """
+
+    SLACK_CHANNEL = "#filter-scimma-lsst-quality"
+
+    TRIGGERING_SURVEY = "lsst"
+
+    REQUIRED_LOCUS_PROPERTIES = []
+
+    REQUIRED_ALERT_PROPERTIES = [
+        "lsst_diaSource_snr",
+        "lsst_diaSource_ssObjectId",
+        "lsst_diaSource_psfFlux_flag",
+        "lsst_diaSource_centroid_flag",
+        "lsst_diaSource_shape_flag",
+        "lsst_diaSource_isDipole",
+        "lsst_diaSource_pixelFlags_saturated",
+        "lsst_diaSource_pixelFlags_edge",
+        "lsst_diaSource_pixelFlags_cr",
+        "lsst_diaSource_pixelFlags_streak",
+    ]
+
+    REQUIRED_TAGS = []
+
+    REQUIRES_FILES = []
+
+    OUTPUT_TAG = "lsst_scimma_quality_transient"
+
+    OUTPUT_LOCUS_PROPERTIES = []
+
+    OUTPUT_LOCUS_TAGS = [
+        {
+            "name": OUTPUT_TAG,
+            "description": (
+                "LSST alert passes quality cuts for transient candidate "
+                "crossmatching by SCiMMA: SNR > 10, no quality flags, "
+                "not a known solar system object."
+            ),
+        },
+    ]
+
+    def setup(self):
+        pass
+
+    def _run(self, locus):
+        props = locus.alerts[-1].properties
+
+        # SNR must be strictly greater than 10.
+        if not props["lsst_diaSource_snr"] > 10:
+            return
+
+        # Exclude known solar system objects. The type of ssObjectId is
+        # not yet confirmed, so check for integer 0, None, and string "0".
+        if props["lsst_diaSource_ssObjectId"] not in (0, None, "0"):
+            return
+
+        # Quality flags must all be falsy.
+        if props["lsst_diaSource_psfFlux_flag"]:
+            return
+        if props["lsst_diaSource_centroid_flag"]:
+            return
+        if props["lsst_diaSource_shape_flag"]:
+            return
+        if props["lsst_diaSource_isDipole"]:
+            return
+        if props["lsst_diaSource_pixelFlags_saturated"]:
+            return
+        if props["lsst_diaSource_pixelFlags_edge"]:
+            return
+        if props["lsst_diaSource_pixelFlags_cr"]:
+            return
+        if props["lsst_diaSource_pixelFlags_streak"]:
+            return
+
+        locus.tag(self.OUTPUT_TAG)

antares_devkit-0.6.5/antares_devkit/filters/microlensing/__init__.py

@@ -0,0 +1,505 @@
+# Filter for microlensing events designed for the ANTARES broker 
+
+# Authors: Somayeh Khakpash, Natasha Abrams, Rachel Street, Atousa Kalantari
+
+import antares_devkit as dk
+from antares_devkit.models import DevKitLocus
+from antares_devkit.models import BaseFilter
+import warnings
+import math
+
+
+class microlensing(BaseFilter):
+    INPUT_LOCUS_PROPERTIES = [
+        'ant_object_id',
+    ]
+
+    REQUIRED_TAGS = ['lc_feature_extractor']
+
+    OUTPUT_TAGS = [
+        {
+            'name': 'microlensing_candidate',
+            'description': 'Locus - a transient candidate - exhibits a microlensing-like variability',
+        }
+    ]
+
+    np = None
+    curve_fit = None
+    skew = None
+    sigma_clip = None
+
+    # Define a Paczyński microlensing model
+    def paczynski(self, t, t0, u0, tE, F_s):
+        """
+        Paczyński microlensing light curve model
+        t0 : peak time
+        u0 : impact parameter
+        tE : Einstein crossing time
+        F_s : source flux
+        F_b : blended flux
+        """
+        u = self.np.sqrt(u0 ** 2 + ((t - t0) / tE) ** 2)
+        A = (u ** 2 + 2) / (u * self.np.sqrt(u ** 2 + 4))
+        return F_s * (A) + (1 - F_s)
+
+    def fit_paczynski(self, times, mags, flxs, flx_errs):
+        """
+        Fit the Paczyński microlensing model to flux data.
+        Returns best-fit parameters and chi-squared value.
+        """
+        if len(times) < 4:
+            return None, None  # Not enough data
+
+        # initial guesses
+        t0_guess = times[self.np.argmin(flxs)]
+        u0_guess = 1.0 / (self.np.max(flxs))
+
+        tE_guess = 20.0
+        F0_guess = 0.5
+
+        initial_guess = [t0_guess, u0_guess, tE_guess, F0_guess]
+
+        bounds = (
+            [times.min() - 50, 0, 1.0, 0.0],
+            [times.max() + 50, self.np.inf, 500.0, 1]
+        )
+
+        try:
+            popt, _ = self.curve_fit(
+                self.paczynski,
+                times, flxs,
+                p0=initial_guess,
+                sigma=flx_errs,
+                bounds=bounds,
+
+                maxfev=5000
+            )
+            chi2 = self.np.sum(((flxs - self.paczynski(times, *popt)) / flx_errs) ** 2) / len(times)
+            return popt, chi2
+        except Exception as e:
+            print(f"  Paczynski fitting error: {e}")
+            return None, None
+
+    def mag_to_flux(self, mag, F0=1.0):
+        """
+        Convert magnitude to flux.
+
+        Parameters:
+        - mag : magnitude (float or array)
+        - F0 : reference flux (zeropoint), default=1.0 for relative flux
+
+        Returns:
+        - flux : flux corresponding to the magnitude
+        """
+        flux = F0 * 10 ** (-0.4 * mag)
+        flux = flux / self.np.min(flux)
+        return flux
+
+    def magerr_to_fluxerr(self, mag, mag_err, F0=1.0):
+        """
+        Convert magnitude uncertainty to flux uncertainty.
+
+        Parameters:
+        - mag : magnitude value or array
+        - mag_err : magnitude uncertainty value or array
+        - F0 : zeropoint flux (default=1.0 for relative flux)
+
+        Returns:
+        - flux_err : flux uncertainty
+        """
+        flux = self.mag_to_flux(mag, F0)
+        flux_err = 0.4 * self.np.log(10) * flux * mag_err
+        return flux_err
+
+    # Chi squared functions for BAGLE model
+    def calc_chi2_mean(self, times, mag, mag_err, verbose=False):
+        """
+        Parameters
+        ----------
+        params : str or dict, optional
+            model_params = 'best' will load up the best solution and calculate
+            the chi^2 based on those values. Alternatively, pass in a dictionary
+            with the model parameters to use.
+        """
+        # Get likelihoods.
+        lnL_phot = self.log_likely_photometry(times, mag, mag_err)
+
+        # Lists to store lnL, chi2, and constants for each filter.
+        chi2_phot_filts = []
+        lnL_const_phot_filts = []
+
+        # Calculate the lnL for just a single filter.
+        lnL_phot_nn = self.log_likely_photometry(times, mag, mag_err)
+
+        # Calculate the chi2 and constants for just a single filter.
+        lnL_const_phot_nn = -0.5 * self.np.log(2.0 * math.pi * mag_err ** 2)
+        lnL_const_phot_nn = lnL_const_phot_nn.sum()
+
+        chi2_phot_nn = (lnL_phot_nn - lnL_const_phot_nn) / -0.5
+
+        # Save to our lists
+        chi2_phot_filts.append(chi2_phot_nn)
+        lnL_const_phot_filts.append(lnL_const_phot_nn)
+
+        lnL_const_phot = sum(lnL_const_phot_filts)
+
+        # Calculate chi2.
+        chi2 = (lnL_phot - lnL_const_phot) / -0.5
+
+        if verbose:
+            fmt = '{0:13s} = {1:f} '
+            ff = 0
+            print(fmt.format('chi2_phot' + str(ff + 1), chi2_phot_filts[ff]))
+
+            print(fmt.format('chi2', chi2))
+
+        return chi2
+
+    def log_likely_photometry(self, times, mag, mag_err, verbose=False):
+
+        lnL_phot = 0.0
+
+        # commenting out weight stuff for now
+        # weight = self.weights[i]
+        lnL_phot_unwgt = self.log_likely_photometry_each(times, mag, mag_err)
+        lnL_phot_i = lnL_phot_unwgt  # * weight
+        lnL_phot += lnL_phot_i
+
+        if verbose:
+            print(
+                f'lnL_phot: i = {i} L_unwgt = {lnL_phot_unwgt:15.1f}, L_wgt = {lnL_phot_i:15.1f}, weight = {weight:.1e}')
+
+        return lnL_phot
+
+    def log_likely_photometry_each(self, t_obs, mag_obs, mag_err_obs, filt_idx=0):
+        """
+        Get the natural log of the likelihood for the input photometric data in the
+        specified filter or data sets. Note, this function returns a list and it
+        is the full ln(likelihood), including the normalization constant.
+
+        Parameters
+        ----------
+        t_obs : array_like
+            List of times in MJD for the observations.
+        mag_obs : array_like
+            List of observed photometric measurements of the microlensing event in magnitudes.
+            Length must be the same as t_obs.
+        mag_obs_err : array_like
+            List of observed photometric uncertainties of the microlensing event in magnitudes.
+            Length must be the same as t_obs.
+        filt_idx : int, optional
+            Index of the photometric filter or data set.
+
+        Returns
+        -------
+        ln_L : array_like
+            List of ln(likelihood) for each photometric measurement.
+
+        """
+
+        chi2_m = self.get_chi2_photometry_mean(t_obs, mag_obs, mag_err_obs, filt_idx=filt_idx)
+
+        lnL_const_m = self.get_lnL_constant(mag_err_obs)
+
+        lnL = (-0.5 * chi2_m) + lnL_const_m
+
+        return lnL.sum()
+
+    def get_chi2_photometry_mean(self, t_obs, mag_obs, mag_err_obs, filt_idx=0):
+        """
+        Get chi^2 values for THE MEAN OF DATA and input photometric data in the
+        specified photometric filter or data set.
+
+        Parameters
+        ----------
+        t_obs : array_like
+            List of times in MJD for the observations.
+        mag_obs : array_like
+            List of observed photometric measurements of the microlensing event in magnitudes.
+            Length must be the same as t_obs.
+        mag_obs_err : array_like
+            List of observed photometric uncertainties of the microlensing event in magnitudes.
+            Length must be the same as t_obs.
+        filt_idx : int, optional
+            Index of the photometric filter or data set.
+
+        Returns
+        -------
+        chi2 : array_like
+            List of chi^2 values from the model and photometric data.
+
+        """
+        sigma_clip_mag = self.sigma_clip(mag_obs)
+        mag_model = self.np.mean(sigma_clip_mag)
+
+        chi2 = ((mag_obs - mag_model) / mag_err_obs) ** 2
+
+        return chi2
+
+    def get_lnL_constant(self, err_obs):
+        """
+        Get the natural log of the constant normalization terms of the likelihood.
+
+        .. math:: -0.5 * \ln{2 \pi \sigma_{obs}^2}
+
+        Parameters
+        ----------
+        err_obs : array_like
+            List of the uncertainties.
+
+        Returns
+        -------
+        List of ln(likelihood constants).
+
+        """
+        lnL_const = -0.5 * self.np.log(2.0 * math.pi * err_obs ** 2)
+
+        return lnL_const
+
+    def is_known_other_phenomenon(self, locus, locus_params):
+        """
+        Method to check the locus' pre-existing parameters indicated that it has
+        been identified or is likely to be a variable of a type other than microlensing
+
+        :param locus:
+        :param locus_params:
+        :return: boolean
+        """
+
+        # Default result is not a known variable
+        known_var = False
+
+        # Tunable detection thresholds.
+        # Ref: Sokolovsky et al. 2016: https://ui.adsabs.harvard.edu/abs/2017MNRAS.464..274S/abstract
+        period_peak_sn_threshold = 20.0  # Based on tests with ZTF alerts
+        stetson_k_threshold = 0.8  # The expected K-value for a constant lightcurve with Gaussian noise
+
+        # Check for periodicity
+        feature_period_s_to_n_0_magn_r_exists = 'feature_period_s_to_n_0_magn_r' in locus_params.keys()
+        if feature_period_s_to_n_0_magn_r_exists:
+            if locus_params['feature_period_s_to_n_0_magn_r'] >= period_peak_sn_threshold:
+                known_var = True
+
+        # Check Stetson-K index
+        feature_stetson_k_magn_r_exists = 'feature_stetson_k_magn_r' in locus_params.keys()
+        if feature_stetson_k_magn_r_exists:
+            if locus_params['feature_stetson_k_magn_r'] <= stetson_k_threshold:
+                known_var = True
+
+        # If the alert has parameters from JPL Horizons, then it is likely cause by
+        # a Solar System object
+        if 'horizons_targetname' in locus_params.keys():
+            known_var = True
+
+        # Check whether the ANTARES crossmatch against known galaxy catalogs threw up any matches
+        # The locus.catalog_objects attribute is a dictionary of lists of known objects for each
+        # catalogs.  If a match has been found, then the key for the corresponding catalog will be
+        # in the list of keys.  So we can use that to check for matches with galaxy catalogs.
+        # Of those available in the list the Gemini NIR survey of known quasars is the closest
+        if 'gnirs_dqs' in locus.catalog_objects.keys():
+            known_var = True
+
+        return known_var
+
+    def calculate_eta(self, mag):
+        """ Via puzle https://github.com/jluastro/puzle/blob/main/puzle/stats.py"""
+        delta = self.np.sum((self.np.diff(mag) * self.np.diff(mag)) / (len(mag) - 1))
+        variance = self.np.var(mag)
+        eta = delta / variance
+        return eta
+
+    def return_eta_residual_slope_offset(self):
+        """
+        Via puzle https://github.com/jluastro/puzle/blob/main/puzle/cands.py
+        TODO is 6 months and a year - calculate slope and intercept based on real Rubin data
+        """
+        slope = 3.8187919463087248
+        offset = -0.07718120805369133
+        return slope, offset
+
+    def make_bagle_data_dir(self, times, mags, errors):
+        data = {}
+        data['target'] = 'single_event'
+        data['phot_data'] = 'alert'
+        data['phot_files'] = ['locus']
+        data['ast_data'] = 'None'
+        data['ast_files'] = []
+
+        data['t_phot1'] = times
+        data['mag1'] = mags
+        data['mag_err1'] = errors
+
+        return data
+
+    def is_microlensing_candidate(self, locus, times, mags, errors, verbose):
+        """
+        Example of a set of Microlensing detection criteria
+        """
+        if len(times) < 10:  # Too few data points
+            if verbose == True:
+                print('Too Few Datapoints')
+            return False
+
+        # Extract the full parameter set from the locus and the alert
+        locus_params = locus.properties
+
+        # Use the pre-calculated properties of the locus to eliminate those
+        # which show signs of variability, e.g. in their periodicity signature or
+        # the Stetson-K index
+        known_var = self.is_known_other_phenomenon(locus, locus_params)
+        if known_var:
+            if verbose == True:
+                print('Other known phenomenon')
+            return False
+
+        # Sort data by time
+        sorted_idx = self.np.argsort(times)
+        times, mags, errors = times[sorted_idx], mags[sorted_idx], errors[sorted_idx]
+        npts = len(times)
+
+        # 1. Check for smoothness (low skewness means symmetric light curve)
+        # TODO: Check for threshold with parallax and maybe remove or lower threshold
+        if abs(self.skew(mags)) > 1:
+            if verbose == True:
+                print('Too skewed')
+            return False
+
+        # TODO is 6 months and a year - calculate this based on percentile of real data
+        eta_thresh = 1.255  # Avg from ZTF level 2 (low eta)
+        # Do check for existance since if there's only one band of data, only one will exist
+        eta_r_exists = 'feature_eta_e_magn_r' in locus_params.keys()
+        eta_g_exists = 'feature_eta_e_magn_g' in locus_params.keys()
+        if eta_r_exists:
+            eta_r = locus_params['feature_eta_e_magn_r']
+        if eta_g_exists:
+            eta_g = locus_params['feature_eta_e_magn_g']
+        if eta_r_exists and eta_g_exists:
+            if eta_r >= eta_thresh and eta_g >= eta_thresh:
+                if verbose == True:
+                    print('Failed von Neumann threshold')
+                return False
+        elif eta_r_exists:
+            if eta_r >= eta_thresh:
+                if verbose == True:
+                    print('Failed von Neumann threshold')
+                return False
+        elif eta_g_exists:
+            if eta_g >= eta_thresh:
+                if verbose == True:
+                    print('Failed von Neumann threshold')
+                return False
+
+        # 2. Check variability (microlensing should have a clear peak)
+        # Decrease threshold with longer baseline
+        # Q for broker - 365 days or full lightcurve?
+        if self.np.ptp(mags) < 0.5:  # Peak-to-peak magnitude difference
+            if verbose == True:
+                print('Too small magnitude change')
+            return False
+
+        flxs = self.mag_to_flux(mags)
+        flx_errs = self.magerr_to_fluxerr(mags, errors)
+
+        # 3. Perform a lightweight template fit (Paczyński model)
+
+        popt, chi2_paczynski = self.fit_paczynski(times, mags, flxs, flx_errs)
+        resid = flxs - self.paczynski(times, *popt)
+        chi2_val = self.np.sum((resid / flx_errs) ** 2) / npts
+
+        # 4. Apply a simple chi2 threshold
+        if chi2_val > 2:  # Poor-fit light curves fails
+            if verbose == True:
+                print('Failed simple fit chi^2 threshold', chi2_val)
+            return False
+        # except RuntimeError:
+        #     return False  # Fit failed
+
+        # 5. Check that the residual isn't correlated in all avaliable bands
+        eta_resid = self.calculate_eta(resid)
+        eta_slope, eta_offset = self.return_eta_residual_slope_offset()
+        if eta_r_exists and eta_g_exists:
+            if (eta_resid < eta_r * eta_slope + eta_offset) and (eta_resid < eta_g * eta_slope + eta_offset):
+                if verbose == True:
+                    print('Failed eta residual threshold')
+                return False
+        elif eta_r_exists:
+            if (eta_resid < eta_r * eta_slope + eta_offset):
+                if verbose == True:
+                    print('Failed eta residual threshold')
+                return False
+        elif eta_g_exists:
+            if (eta_resid < eta_g * eta_slope + eta_offset):
+                if verbose == True:
+                    print('Failed eta residual threshold')
+                return False
+        
+        # outbase = 'microlens_fit_'
+        # data = self.make_bagle_data_dir(times, mags, errors)
+        # fitter = model_fitter.PSPL_Solver(data,
+        #                                   model.PSPL_Phot_noPar_Param2,
+        #                                   importance_nested_sampling=False,
+        #                                   n_live_points=200,
+        #                                   outputfiles_basename=outbase)
+
+        # fitter.priors['tE'] = model_fitter.make_gen(1, 400)
+        # #1 year before start and 1 years after end of data
+        # fitter.priors['t0'] = model_fitter.make_gen(self.np.min(times) - 365.25, self.np.max(times) + 365.25)
+        # fitter.priors['b_sff1'] = model_fitter.make_gen(0.001, 1.25)
+
+        # fitter.solve()
+
+        # fit_vals = fitter.get_best_fit(def_best='map')
+        # chi2_red_bagle = fitter.calc_chi2(params=fit_vals) / (npts - len(fit_vals))
+        # chi2_red_flat = self.calc_chi2_mean(times, mags, errors)
+
+        # # Delta chi^2 threshold
+        # delta_chi2_threshold = 100
+        # if self.np.abs(chi2_red_bagle - chi2_red_flat) < delta_chi2_threshold:
+        #     if verbose == True:
+        #         print('Failed BAGLE fit chi^2 threshold', 'delta chi^2 = ', self.np.abs(chi2_red_bagle - chi2_red_flat))
+        #     return False
+
+        # fit_vals['b_sff'] = fit_vals.pop('b_sff1')
+        # fit_vals['mag_base'] = fit_vals.pop('mag_base1')
+        # for key in fit_vals.keys():
+        #     locus.set_property('feature_microlensing_' + key, fit_vals[key])
+        # locus.set_property('feature_microlensing_chi2_red', chi2_red_bagle)
+
+        return True
+
+    def _run(self, locus):
+        import numpy as np
+        import astropy
+        from scipy.optimize import curve_fit
+        from scipy.stats import skew
+        from astropy.stats import sigma_clip
+
+        self.np = np
+        self.curve_fit = curve_fit
+        self.skew = skew
+        self.sigma_clip = sigma_clip
+
+        
+        print('Processing Locus:', locus.locus_id)
+
+        with warnings.catch_warnings():
+            # The cast of locus.timeseries: astropy.table.Table to a pandas
+            # dataframe results in the conversion of some integer-valued
+            # columns to floating point represntation. This can result in a
+            # number of noisy warning so we will catch & ignore them for the
+            # next couple of lines.
+            warnings.simplefilter("ignore", astropy.table.TableReplaceWarning)
+            df = locus.timeseries().to_pandas()
+
+        data = df[['ant_mjd', 'ant_passband', 'ant_mag', 'ant_magerr']].dropna()
+
+        # Split into g-band and i-band
+        band_list = np.unique(data['ant_passband'])
+        for band in band_list:  # 1 = g-band, 2 = i-band
+            band_data = data[data['ant_passband'] == band]
+            times, mags, errors = band_data['ant_mjd'].values, band_data['ant_mag'].values, band_data[
+                'ant_magerr'].values
+
+            if self.is_microlensing_candidate(locus, times, mags, errors, verbose=False):
+                print(f'Locus {locus.locus_id} is a microlensing candidate in band {band}')
+                locus.tag('microlensing_candidate')

antares_devkit-0.6.5/antares_devkit/filters/shadow_virgo/__init__.py

@@ -0,0 +1,50 @@
+"""Description
+This filter finds locus located within a radius of 1.1 deg from the center of the Shadow Project's Virgo Pointings.
+"""
+from antares_devkit.models import BaseFilter
+
+class InShadowVirgo(BaseFilter):
+    NAME = 'in_shadow_virgo' #for this default filter, name is same as its tag
+
+    SLACK_CHANNEL = "#filter-in-shadow-virgo"
+
+    ## bare absolute minimum alert properties proving it's good to go
+    REQUIRED_ALERT_PROPERTIES = [
+        'ant_ra',
+        'ant_dec',
+        'ant_survey'
+    ]
+
+    OUTPUT_TAGS = [
+        {
+            'name': 'in_virgo_shadow',
+            'description': 'Locus is along the line of sight to the Virgo fields covered by the DECam Shadow Project',
+        }
+    ]
+
+    def _run(self, locus):
+        import numpy as np
+        from astropy import units as u
+        from astropy.coordinates import SkyCoord
+
+        if locus.alert.properties['ant_survey'] == 2: #be sure we don't work with upper limits
+            return
+
+        ra = locus.alert.properties['ant_ra']
+        dec = locus.alert.properties['ant_dec']
+        #https://github.com/lsstshadow/shadowpointings/tree/main
+        shadow_virgo_ra = np.array([187.7014, 186.0754, 187.9486, 189.4263, 189.1219, 187.4805, 
+                                    185.9601, 187.6007, 186.0131, 184.8111, 184.3502, 183.9883, 
+                                    184.4658, 186.3005, 191.0718, 190.5631, 189.1516, 188.7788, 
+                                    186.6354, 185.6507, 182.4151, 193.2665, 189.5427, 190.6638, 
+                                    193.4287, 188.2634, 185.2524, 188.0598, 193.0875, 191.0943])
+        shadow_virgo_dec = np.array([12.3963,  13.4965,  14.307,   13.3041,  11.295,   10.4477, 
+                                     11.6469,   8.4389,   7.1655,   5.7578,  12.8014,   7.6415,
+                                     14.6628,  15.364,   12.0456,  10.0351,   8.9448,   6.8992, 
+                                      5.3375,   8.9489,  13.7313,   8.2527,   4.8363,   2.8801, 
+                                      1.8786,   2.356,    3.7762,   0.1955,  -1.1488,  -0.0399])
+        field_centers = SkyCoord(ra=shadow_virgo_ra*u.deg, dec=shadow_virgo_dec*u.deg)
+        c = SkyCoord(ra*u.deg, dec*u.deg, frame='icrs')
+        sep = c.separation(field_centers)
+        if (sep.deg < 1.1).any(): #DECam FOV = 2.2 deg diameter
+            locus.tag('in_shadow_virgo')

{antares_devkit-0.6.3 → antares_devkit-0.6.5}/antares_devkit/filters/young_rubin_transients_soraisam/__init__.py

@@ -1,10 +1,8 @@
-## v2
+## production version
 from antares_devkit.models import BaseFilter
 
-
 class young_rubin_transients_soraisam(BaseFilter):
-    ## MS: this is mainly for the NOIRLab end-to-end demonstration
-    
+        
     TRIGGERING_SURVEY = "lsst"
 
     SLACK_CHANNEL = "#filter-young-rubin-transients"
@@ -76,15 +74,19 @@ class young_rubin_transients_soraisam(BaseFilter):
         if 'lsst' in locus.properties['survey'].keys():
             if len(locus.properties['survey']['lsst']['dia_object_id']) > 1:
                 C0 = True 
+        # print ("C0", C0)
         if C0:
             return
+
         
-        
-        C1 = (locus.alert.properties['lsst_diaSource_reliability'] < 0.9)
+        C1 = (locus.alert.properties['lsst_diaSource_reliability'] < 0.8)
+        # print ("C1", C1, locus.alert.properties['lsst_diaSource_reliability'])
         if C1:
             return
+        
 
         C2 = (locus.alert.properties['lsst_diaSource_ssObjectId'] != 0)
+        # print ("C2", C2)
         if C2:
             return
 
@@ -95,28 +97,30 @@ class young_rubin_transients_soraisam(BaseFilter):
         current_pb = locus.alert.properties['ant_passband']
         
         # ## confirm locus is extragalactic 
+        C3 = True
         astro_objects = locus.catalog_objects
-        # matching_catalog_names = astro_objects.keys()
-        # # Below is a battle-tested set of extended source catalogs (Antares-based names)
-        # xsc_cats = [
-        #     "2mass_xsc",
-        #     "ned",
-        #     "nyu_valueadded_gals",
-        #     "sdss_gals",
-        #     "veron_agn_qso",
-        #     "RC3",
-        # ]
-        # C3 = set(matching_catalog_names) & set(xsc_cats)
-        # if not C3:
-        # #     print ("No match with extragalactic catalog")
-        #     return
-        
+        matching_catalog_names = astro_objects.keys()
+        ps_cats = [
+            "bright_guide_star_cat", ##	Classification = 0 star
+            #"gaia_dr3_gaia_source", 
+            "sdss_stars", ## type = 6 star
+            "2mass_psc", 
+        ]
+        if "2mass_psc" in matching_catalog_names:
+            C3 = False
+        elif "bright_guide_star_cat" in matching_catalog_names and astro_objects['bright_guide_star_cat'][0]['classification']==0:
+            C3 = False
+        elif "sdss_stars" in matching_catalog_names and astro_objects['sdss_stars'][0]['type']==6:
+            C3 = False
+        # print ("C3", C3)
+        if not C3:
+            return   
 
         
-        TS_all = locus.timeseries('all')
         TS_lsst = locus.timeseries('lsst')
 
-        C4 = (len(TS_lsst) > 2) and (max(TS_lsst["ant_mjd"].data) - min(TS_lsst["ant_mjd"].data) < 30.0)
+        ## without upper limits info in alert packet, using a less strict time baseline
+        C4 = (len(TS_lsst) > 2) and (max(TS_lsst["ant_mjd"].data) - min(TS_lsst["ant_mjd"].data) < 15.0)
         if not C4:
             return
 

{antares_devkit-0.6.3 → antares_devkit-0.6.5}/antares_devkit/utils.py

@@ -23,11 +23,12 @@ def get_filters_path():
         "HighSNR": "antares_devkit.filters.highsnr",
         "IF_anomaly_detection": "antares_devkit.filters.if_anomaly_detection",  # ["numpy", "pandas", "sklearn", "astropy"]
         "IMBH": "antares_devkit.filters.imbh",
-        "In_LSSTDDF": "antares_devkit.filters.lsst_ddf", #["astropy", "numpy"]
+        "In_LSSTDDF": "antares_devkit.filters.lsst_ddf",  # ["astropy", "numpy"]
         "InM31": "antares_devkit.filters.inm31",
         "LAISS_RFC_AD_filter": "antares_devkit.filters.laiss_rfc_ad_filter",  # ["astropy", "timeout_decorator", "alerce", "numpy", "pandas", "matplotlib", "astro_ghost", "sklearn", "scipy"]
         "AnomalyTransientDmDt": "antares_devkit.filters.malanchev_anomaly_transient_dmdt",  # ["numpy", "astropy", "light_curve"]
         "Features": "antares_devkit.filters.malanchev_features_v1",  # ["numpy", "astropy", "light_curve"]
+        "microlensing": "antares_devkit.filters.microlensing",
         "NovTest": "antares_devkit.filters.novtest",
         "NuclearTransient": "antares_devkit.filters.nuclear_transient",
         "NUTTelA_TAO": "antares_devkit.filters.nuttela_tao",
@@ -36,6 +37,7 @@ def get_filters_path():
         "RecentReddening": "antares_devkit.filters.recent_reddening",
         "refitt_newsources_snrcut": "antares_devkit.filters.refitt_newsources_snrcut",
         "SampleFilter": "antares_devkit.filters.sample_filter",
+        "InShadowVirgo": "antares_devkit.filters.shadow_virgo",  # ["astropy", "numpy"]
         "siena_mag_coord_cut": "antares_devkit.filters.siena_mag_coord_cut",
         "SSOConfirmed": "antares_devkit.filters.sso",
         "sub_lum": "antares_devkit.filters.sub_lum",
@@ -48,6 +50,7 @@ def get_filters_path():
         "YoungExtragalacticCandidate": "antares_devkit.filters.young_extragalactic_candidate",
         "rubin_NovTest_soraisam": "antares_devkit.filters.rubin_NovTest_soraisam",
         "young_rubin_transients_soraisam": "antares_devkit.filters.young_rubin_transients_soraisam",
+        "LsstTransientQualityFilterScimma": "antares_devkit.filters.lsst_transient_quality_scimma",
     }
 
 

{antares_devkit-0.6.3 → antares_devkit-0.6.5}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "antares-devkit"
-version = "0.6.3"
+version = "0.6.5"
 description = "Provides tools and utility methods to write and debug ANTARES filters with Python."
 readme = "README.md"
 requires-python = ">=3.9"