antares-devkit 0.6.4__tar.gz → 0.7.0__tar.gz

{antares_devkit-0.6.4 → antares_devkit-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: antares-devkit
-Version: 0.6.4
+Version: 0.7.0
 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.7.0/antares_devkit/filters/decam_shadow/__init__.py

@@ -0,0 +1,75 @@
+"""Description
+This filter finds locus located within a radius of 1.1 deg from the center of the Shadow Project's Virgo, Hydra, Fornax, Antlia, and Dorado Pointings.
+"""
+from antares_devkit.models import BaseFilter
+
+class InDecamShadow(BaseFilter):
+    NAME = 'in_decam_shadow' #for this default filter, name is same as its tag
+
+    SLACK_CHANNEL = "#filter-in-decam-shadow"
+
+    ## bare absolute minimum alert properties proving it's good to go
+    REQUIRED_ALERT_PROPERTIES = [
+        'ant_ra',
+        'ant_dec',
+        'ant_survey'
+    ]
+
+    OUTPUT_TAGS = [
+        {
+            'name': 'in_decam_shadow',
+            'description': 'Locus is along the line of sight to the Virgo, Antlia, Dorado, Fornax, Hydra, 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
+            #print('upper limit')
+            return
+            
+        if locus.alert.properties['ant_survey'] == 4:
+            #print(locus.alert.properties['lsst_diaSource_ssObjectId'], locus.alert.properties['lsst_diaSource_ssObjectId'] != 0, 'lsst_diaSource_ssObjectId')
+            if (locus.alert.properties['lsst_diaSource_ssObjectId'] != 0) is True:
+                return
+        elif locus.alert.properties['ant_survey'] == 1:
+            #print(locus.alert.properties['ztf_ssnamenr'], locus.alert.properties['ztf_ssnamenr'] !='null', 'ztf_ssnamenr')
+            if locus.alert.properties['ztf_ssnamenr'] != 'null':
+                return
+        
+        #    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.46,  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])
+        shadow_antlia_ra = np.array([ 157.3975])
+        shadow_antlia_dec = np.array([-35.3325])
+        shadow_dorado_ra = np.array([  71.4476,  66.7167,  63.6977,  65.9529,  62.6324])
+        shadow_dorado_dec = np.array([-59.2477, -55.0722, -55.6902, -57.0202, -57.7644])
+        shadow_fornax_ra = np.array([  54.5484,  54.1655,  52.4792,  52.8626,  54.9590, 56.6247, 
+                                       56.2302,  52.1175,  51.1123,  50.5994,  55.8479, 58.3521, 
+                                       53.6473, 51.4467, 63.1329])
+        shadow_fornax_dec = np.array([-35.5388, -33.7261, -34.8784, -36.6898, -37.3477, -36.1969, 
+                                      -34.3845, -33.0674, -37.8454, -35.8702, -32.5273, -34.962, 
+                                      -31.6796, -31.2712, -32.3313])
+        shadow_hydra_ra = np.array([ 159.2305, 159.2126, 157.6973])
+        shadow_hydra_dec = np.array([-27.5186, -25.3493, -29.1417])
+        shadow_all_ra = np.hstack((shadow_virgo_ra, shadow_antlia_ra, shadow_dorado_ra, shadow_fornax_ra, shadow_hydra_ra))
+        shadow_all_dec = np.hstack((shadow_virgo_dec, shadow_antlia_dec, shadow_dorado_dec, shadow_fornax_dec, shadow_hydra_dec))
+        field_centers = SkyCoord(ra=shadow_all_ra*u.deg, dec=shadow_all_dec*u.deg)
+        c = SkyCoord(ra*u.deg, dec*u.deg, frame='icrs')
+        sep = c.separation(field_centers)
+        #print(sep.min())
+        if (sep.deg < 1.1).any(): #DECam FOV = 2.2 deg diameter
+            locus.tag('in_decam_shadow')

antares_devkit-0.7.0/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.7.0/antares_devkit/filters/uniform_random_sample/__init__.py

@@ -0,0 +1,29 @@
+from antares_devkit.models import BaseFilter
+
+class UniformRandomSample(BaseFilter):
+    """
+    This filter aims to uniformly and randomly select 1% of all LSST alerts.
+    This is implemented by filtering for diaSourceId % 113 == 0, which roughly
+    selects everything 100th alert in chronological order. The 113 value is chosen
+    to be close to but arbitrarily different from 100, to avoid any potential
+    collisions with processing that might happen on every 100th alert.
+    """
+    SLACK_CHANNEL = "#filter-uniformrandomsample"
+    TRIGGERING_SURVEY = "lsst"
+
+    REQUIRED_ALERT_PROPERTIES = [
+       "lsst_diaSource_diaSourceId"
+    ]
+
+    OUTPUT_LOCUS_PROPERTIES = []
+    OUTPUT_LOCUS_TAGS = [{
+        'name': 'uniform_random_sample',
+        'description': '1% of all LSST Alerts uniformly and randomly sampled'
+    }]
+
+    def _run(self, locus):
+        """
+        If a LSST alert's diaSourceId % 113 == 0, tag with 'uniform_random_sample'
+        """
+        if locus.alert.properties['lsst_diaSource_diaSourceId'] % 113 == 0:
+            locus.tag("uniform_random_sample")

{antares_devkit-0.6.4 → antares_devkit-0.7.0}/antares_devkit/utils.py

@@ -24,10 +24,12 @@ def get_filters_path():
         "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"]
+        "InDecamShadow": "antares_devkit.filters.decam_shadow",  # ["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",
@@ -50,6 +52,7 @@ def get_filters_path():
         "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",
+        "UniformRandomSample": "antares_devkit.filters.uniform_random_sample",
     }
 
 

{antares_devkit-0.6.4 → antares_devkit-0.7.0}/pyproject.toml

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