pz-rail-astro-tools 0.1.2__tar.gz → 0.1.3__tar.gz

{pz-rail-astro-tools-0.1.2 → pz_rail_astro_tools-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pz-rail-astro-tools
-Version: 0.1.2
+Version: 0.1.3
 Author-email: "LSST Dark Energy Science Collaboration (DESC)" <lsst-desc-rail-admin@slac.stanford.edu>
 License: MIT License
         

{pz-rail-astro-tools-0.1.2 → pz_rail_astro_tools-0.1.3}/src/pz_rail_astro_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pz-rail-astro-tools
-Version: 0.1.2
+Version: 0.1.3
 Author-email: "LSST Dark Energy Science Collaboration (DESC)" <lsst-desc-rail-admin@slac.stanford.edu>
 License: MIT License
         

{pz-rail-astro-tools-0.1.2 → pz_rail_astro_tools-0.1.3}/src/pz_rail_astro_tools.egg-info/SOURCES.txt

@@ -25,6 +25,8 @@ src/rail/astro_tools/_version.py
 src/rail/creation/degradation/grid_selection.py
 src/rail/creation/degradation/lsst_error_model.py
 src/rail/creation/degradation/observing_condition_degrader.py
+src/rail/creation/degradation/photerr_demo.ipynb
+src/rail/creation/degradation/photometric_errors.py
 src/rail/creation/degradation/spectroscopic_degraders.py
 src/rail/creation/degradation/spectroscopic_selections.py
 src/rail/creation/engines/gcr_engine.py

{pz-rail-astro-tools-0.1.2 → pz_rail_astro_tools-0.1.3}/src/rail/astro_tools/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.2'
-__version_tuple__ = version_tuple = (0, 1, 2)
+__version__ = version = '0.1.3'
+__version_tuple__ = version_tuple = (0, 1, 3)

{pz-rail-astro-tools-0.1.2 → pz_rail_astro_tools-0.1.3}/src/rail/creation/degradation/grid_selection.py

@@ -1,16 +1,16 @@
-"""Degraders that emulate spectroscopic effects on photometry"""
+"""Selector that emulate spectroscopic effects on photometry"""
 
 import os
 import numpy as np
 import pandas as pd
 import pickle
 import tables_io
-from rail.creation.degrader import Degrader
+from rail.creation.selector import Selector
 from rail.core.utils import find_rail_file
 from ceci.config import StageParameter as Param
 
 
-class GridSelection(Degrader):
+class GridSelection(Selector):
     """
     Uses the ratio of HSC spectroscpic galaxies to photometric galaxies to portion a sample
     into training and application samples. Option to implement a color-based redshift cut off in each pixel.
@@ -39,12 +39,14 @@ class GridSelection(Degrader):
     Second HSC Data Release, details of which can be found here:
     Aihara, H., AlSayyad, Y., Ando, M., et al. 2019, PASJ, 71, 114
     doi: 10.1093/pasj/psz103
+    
+    Update(Apr 16 2024): Now inherit from selector and implement the _select() instead of run()
     """
     def_ratio_file = find_rail_file("examples_data/creation_data/data/hsc_ratios_and_specz.hdf5")
     def_set_file = find_rail_file("examples_data/creation_data/data/HSC_grid_settings.pkl" )
 
     name = 'GridSelection'
-    config_options = Degrader.config_options.copy()
+    config_options = Selector.config_options.copy()
     config_options.update(color_redshift_cut=Param(bool, True, msg='using color-based redshift cut'),
                           percentile_cut=Param(float, 99.0, msg='percentile cut-off for each pixel in color-based redshift cut off'),
                           redshift_cut=Param(float, 100.0, msg="cut redshifts above this value"),
@@ -57,14 +59,14 @@ class GridSelection(Degrader):
 
     def __init__(self, args, comm=None):
 
-        Degrader.__init__(self, args, comm=comm)
+        Selector.__init__(self, args, comm=comm)
 
         if self.config.redshift_cut < 0:
             raise ValueError("redshift cut must be positive")
         if (self.config.percentile_cut < 0) | (self.config.percentile_cut > 100):
             raise ValueError('percentile cut off must be between 0 and 100')
 
-    def run(self):
+    def _select(self):
         """
         HSC galaxies were binned in color magnitude space with i-band mag from -2 to 6 and g-z color from 13 to 26
         200 bins in each direction. The ratio of of galaxies with spectroscopic redshifts (training galaxies) to
@@ -104,8 +106,9 @@ class GridSelection(Degrader):
             raise ValueError("x limits should have two elements!")
         if len(y_lims) != 2:  # pragma: no cover
             raise ValueError("y limits should have two elements!")
-        data_hsc_like = data[(data['x_vals'] >= x_lims[0]) & (data['x_vals'] <= x_lims[1]) & (data['y_vals'] >= y_lims[0]) & (data['y_vals'] <= y_lims[1])]
-
+        # data_hsc_like = data[(data['x_vals'] >= x_lims[0]) & (data['x_vals'] <= x_lims[1]) & (data['y_vals'] >= y_lims[0]) & (data['y_vals'] <= y_lims[1])]
+        
+        data_hsc_like = data
         x_vals = data_hsc_like['x_vals'].to_numpy()
         y_vals = data_hsc_like['y_vals'].to_numpy()
 
@@ -155,9 +158,15 @@ class GridSelection(Degrader):
 
         ratio_list = []
         max_specz_list = []
+                
         for pix_x, pix_y in zip(pixels_x, pixels_y):
-            ratio_list.append(ratios[pix_y][pix_x])
-            max_specz_list.append(max_specz[pix_y][pix_x])
+            # cover the galaxy outside the grid of ratio
+            if (pix_x in [-1,ratios.shape[0]]) or (pix_y in [-1, ratios.shape[1]]):
+                ratio_list.append(0.0)
+                max_specz_list.append(99.0)
+            else:
+                ratio_list.append(ratios[pix_y][pix_x])
+                max_specz_list.append(max_specz[pix_y][pix_x])
 
         data_hsc_like['ratios'] = ratio_list
         data_hsc_like['max_specz'] = max_specz_list
@@ -204,9 +213,13 @@ class GridSelection(Degrader):
             else:  # pragma: no cover
                 for j in range(int(number_to_keep) + 1):
                     keep_inds.append(indices_to_list[j])
-
-        training_data = data_hsc_like_redshift_cut.loc[keep_inds, :]
-        training_data = training_data[training_data['redshift'] > 0]
-        training_data = training_data.drop(['x_vals', 'y_vals', 'ratios'], axis=1)
-
-        self.add_data('output', training_data)
+        
+        finalcut = data_hsc_like_redshift_cut.loc[keep_inds, :]
+        finalcut = finalcut[finalcut['redshift'] > 0]
+        
+        final_keep_inds = np.array(finalcut.index)
+        
+        total_mask = np.zeros(len(data), dtype=bool)
+        total_mask[final_keep_inds] = True
+
+        return total_mask

{pz-rail-astro-tools-0.1.2 → pz_rail_astro_tools-0.1.3}/src/rail/creation/degradation/observing_condition_degrader.py

@@ -9,10 +9,10 @@ import pandas as pd
 from ceci.config import StageParameter as Param
 from photerr import LsstErrorModel, LsstErrorParams
 
-from rail.creation.degrader import Degrader
+from rail.creation.noisifier import Noisifier
 
 
-class ObsCondition(Degrader):
+class ObsCondition(Noisifier):
     """Photometric errors based on observation conditions
 
     This degrader calculates spatially-varying photometric errors
@@ -60,7 +60,7 @@ class ObsCondition(Degrader):
     """
 
     name = "ObsCondition"
-    config_options = Degrader.config_options.copy()
+    config_options = Noisifier.config_options.copy()
     config_options.update(
         nside=Param(
             int,
@@ -117,7 +117,7 @@ class ObsCondition(Degrader):
     
 
     def __init__(self, args, comm=None):
-        Degrader.__init__(self, args, comm=comm)
+        Noisifier.__init__(self, args, comm=comm)
 
         # store a list of keys relevant for
         # survey conditions;
@@ -407,10 +407,17 @@ class ObsCondition(Degrader):
 
         return pixel_cat
 
+    
+    def _initNoiseModel(self):
+        """
+        Initialise the error model: LSSTerrorModel
+        """
+        self.default_errorModel = LsstErrorModel()
 
-    def run(self):
+        
+    def _addNoise(self):
         """
-        Run the degrader.
+        Run the noisifier.
         """
         self.rng = np.random.default_rng(seed=self.config["random_seed"])
 
@@ -437,8 +444,8 @@ class ObsCondition(Degrader):
                 
                 # first, check if pixel is -99 - these objects have default obs_conditions:
                 if pixel==-99:
-                    # creating the error model for this pixel
-                    errorModel = LsstErrorModel()
+                    # use the default error model for this pixel
+                    errorModel = self.default_errorModel
                 
                 else:            
                     # get the observing conditions for this pixel

pz_rail_astro_tools-0.1.3/src/rail/creation/degradation/photerr_demo.ipynb

@@ -0,0 +1,238 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2610a0f0-0c71-4401-896f-734442bcd66d",
+   "metadata": {},
+   "source": [
+    "## Photometric error stage demo\n",
+    "\n",
+    "author: Tianqing Zhang, John-Franklin Crenshaw\n",
+    "\n",
+    "This notebook demonstrate the use of `rail.creation.degradation.photometric_errors`, which adds column for the  photometric noise to the catalog based on the package PhotErr developed by John-Franklin Crenshaw. The RAIL stage PhotoErrorModel inherit from the Noisifier base classes, and the LSST, Roman, Euclid child classes inherit from the PhotoErrorModel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f7a6adc3-68e8-4a1d-842f-bfb0960a1c4a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "from rail.creation.degradation.photometric_errors import LSSTErrorModel\n",
+    "from rail.creation.degradation.photometric_errors import RomanErrorModel\n",
+    "from rail.creation.degradation.photometric_errors import EuclidErrorModel\n",
+    "\n",
+    "from rail.core.data import PqHandle\n",
+    "from rail.core.stage import RailStage\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6912a740-31ea-4987-b06d-81ff17cd895a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "DS = RailStage.data_store\n",
+    "DS.__class__.allow_overwrite = True\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a282c2ed-141b-4507-8254-dc8fbc9864dc",
+   "metadata": {},
+   "source": [
+    "### Create a random catalog with ugrizy+YJHF bands as the the true input"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1078bc2a-fc54-41c3-bd30-6c447bb971d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = np.random.normal(23, 3, size = (1000,10))\n",
+    "\n",
+    "data_df = pd.DataFrame(data=data,    # values\n",
+    "            columns=['u', 'g', 'r', 'i', 'z', 'y', 'Y', 'J', 'H', 'F'])\n",
+    "data_truth = PqHandle('input')\n",
+    "data_truth.set_data(data_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1da27deb-d167-4f38-8c59-f270184d6ab3",
+   "metadata": {},
+   "source": [
+    "### The LSST error model adds noise to the optical bands"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e5f4862a-0621-46d4-8901-7e84b461c424",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "errorModel_lsst = LSSTErrorModel.make_stage(name=\"error_model\")\n",
+    "\n",
+    "samples_w_errs = errorModel_lsst(data_truth)\n",
+    "samples_w_errs()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6282c42e-1a6f-480a-aa2b-817bd30d372f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(5, 4), dpi=100)\n",
+    "\n",
+    "for band in \"ugrizy\":\n",
+    "    # pull out the magnitudes and errors\n",
+    "    mags = samples_w_errs.data[band].to_numpy()\n",
+    "    errs = samples_w_errs.data[band + \"_err\"].to_numpy()\n",
+    "\n",
+    "    # sort them by magnitude\n",
+    "    mags, errs = mags[mags.argsort()], errs[mags.argsort()]\n",
+    "\n",
+    "    # plot errs vs mags\n",
+    "    ax.plot(mags, errs, label=band)\n",
+    "\n",
+    "ax.legend()\n",
+    "ax.set(xlabel=\"Magnitude (AB)\", ylabel=\"Error (mags)\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50927ccb-4492-4bdd-a29b-0907704b2c59",
+   "metadata": {},
+   "source": [
+    "### The Roman error model adds noise to the infrared bands"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d484a34b-cf10-45bd-8571-b78dc1818180",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "errorModel_Roman = RomanErrorModel.make_stage(name=\"error_model\")\n",
+    "\n",
+    "samples_w_errs_roman = errorModel_Roman(data_truth)\n",
+    "samples_w_errs_roman()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a12362dc-0689-43f3-b990-edff734010bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(5, 4), dpi=100)\n",
+    "\n",
+    "for band in \"YJHF\":\n",
+    "    # pull out the magnitudes and errors\n",
+    "    mags = samples_w_errs_roman.data[band].to_numpy()\n",
+    "    errs = samples_w_errs_roman.data[band + \"_err\"].to_numpy()\n",
+    "\n",
+    "    # sort them by magnitude\n",
+    "    mags, errs = mags[mags.argsort()], errs[mags.argsort()]\n",
+    "\n",
+    "    # plot errs vs mags\n",
+    "    ax.plot(mags, errs, label=band)\n",
+    "\n",
+    "ax.legend()\n",
+    "ax.set(xlabel=\"Magnitude (AB)\", ylabel=\"Error (mags)\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "359de4ad-a47c-4dc5-8c81-53aeb92bdf42",
+   "metadata": {},
+   "source": [
+    "### The Euclid error model adds noise to YJH bands"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "775d0a23-7435-4b01-83db-2234c3d24f57",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "errorModel_Euclid = EuclidErrorModel.make_stage(name=\"error_model\")\n",
+    "\n",
+    "samples_w_errs_Euclid = errorModel_Euclid(data_truth)\n",
+    "samples_w_errs_Euclid()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7fcfe07a-5571-4dd3-8ad0-358964c1d493",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(5, 4), dpi=100)\n",
+    "\n",
+    "for band in \"YJH\":\n",
+    "    # pull out the magnitudes and errors\n",
+    "    mags = samples_w_errs_Euclid.data[band].to_numpy()\n",
+    "    errs = samples_w_errs_Euclid.data[band + \"_err\"].to_numpy()\n",
+    "\n",
+    "    # sort them by magnitude\n",
+    "    mags, errs = mags[mags.argsort()], errs[mags.argsort()]\n",
+    "\n",
+    "    # plot errs vs mags\n",
+    "    ax.plot(mags, errs, label=band)\n",
+    "\n",
+    "ax.legend()\n",
+    "ax.set(xlabel=\"Magnitude (AB)\", ylabel=\"Error (mags)\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "268b3d37-b7fd-4ac1-8457-2104a87c9e6d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rail_env",
+   "language": "python",
+   "name": "rail_env"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

pz_rail_astro_tools-0.1.3/src/rail/creation/degradation/photometric_errors.py

@@ -0,0 +1,136 @@
+"""
+The Photometric error Model LSST, Roman, and Euclid. Based on photometric 
+error models defined in the package photerr
+
+Author: John Franklin Crenshaw, Tianqing Zhang
+"""
+from dataclasses import MISSING
+
+from ceci.config import StageParameter as Param
+from photerr import LsstErrorModel as peLsstErrorModel
+from photerr import LsstErrorParams as peLsstErrorParams
+from photerr import RomanErrorModel as peRomanErrorModel
+from photerr import RomanErrorParams as peRomanErrorParams
+from photerr import EuclidErrorModel as peEuclidErrorModel
+from photerr import EuclidErrorParams as peEuclidErrorParams
+from rail.creation.noisifier import Noisifier
+
+class PhotoErrorModel(Noisifier):
+    """The Base Model for photometric errors.
+
+    This is a wrapper around the error model from PhotErr. The parameter
+    docstring below is dynamically added by the installed version of PhotErr:
+    
+    
+    """
+    
+    name = "PhotoErrorModel"
+    
+    def set_params(self, peparams):
+        """
+        Set the photometric error parameters from photerr to 
+        the ceci config
+        """
+        PhotErrErrorParams = peparams
+                
+        config_options = Noisifier.config_options.copy()
+
+        # Dynamically add all parameters from PhotErr
+        _photerr_params = PhotErrErrorParams.__dataclass_fields__
+        self._photerr_params = _photerr_params
+        for key, val in _photerr_params.items():
+            # Get the default value
+            if val.default is MISSING:
+                default = val.default_factory()
+            else:
+                default = val.default
+
+            # Add this param to config_options
+            self.config[key] = Param(
+                None,  # Let PhotErr handle type checking
+                default,  
+                msg="See the main docstring for details about this parameter.",
+                required=False,
+            )
+        
+    def __init__(self, args, comm=None):
+        """
+        Constructor
+
+        Does standard Degrader initialization and sets up the error model.
+        """
+        Noisifier.__init__(self, args, comm=comm)
+        
+    def _initNoiseModel(self):
+        """
+        Initialize the noise model by the peNoiseModel
+        """
+        self.noiseModel = self.peNoiseModel(
+            **{key: self.config[key] for key in self._photerr_params}
+        )
+        
+    def _addNoise(self):
+        
+        """
+        Add noise to the input catalog
+        """
+        
+        # Load the input catalog
+        data = self.get_data("input")
+
+        # Add photometric errors
+        obsData = self.noiseModel(data, random_state=self.config.seed)
+        
+        # Return the new catalog
+        self.add_data("output", obsData)
+ 
+        
+class LSSTErrorModel(PhotoErrorModel):
+
+    """
+    The LSST Error model, defined by peLsstErrorParams and peLsstErrorModel
+    """
+    
+    name = "LSSTErrorModel"
+    
+    def __init__(self, args, comm=None):
+
+        PhotoErrorModel.__init__(self, args, comm=comm)
+        
+        self.set_params(peLsstErrorParams)   
+        self.peNoiseModel = peLsstErrorModel
+        
+
+        
+        
+class RomanErrorModel(PhotoErrorModel):
+    
+    """
+    The Roman Error model, defined by peRomanErrorParams and peRomanErrorModel
+    """
+    
+    name = "RomanErrorModel"
+    
+    def __init__(self, args, comm=None):
+
+        PhotoErrorModel.__init__(self, args, comm=comm)
+        
+        self.set_params(peRomanErrorParams)    
+        self.peNoiseModel = peRomanErrorModel
+
+                
+        
+class EuclidErrorModel(PhotoErrorModel):
+    
+    """
+    The Roman Error model, defined by peRomanErrorParams and peRomanErrorModel
+    """
+    
+    name = "EuclidErrorModel"
+    
+    def __init__(self, args, comm=None):
+
+        PhotoErrorModel.__init__(self, args, comm=comm)
+        
+        self.set_params(peEuclidErrorParams)    
+        self.peNoiseModel = peEuclidErrorModel

{pz-rail-astro-tools-0.1.2 → pz_rail_astro_tools-0.1.3}/src/rail/creation/degradation/spectroscopic_degraders.py

@@ -2,10 +2,12 @@
 
 import numpy as np
 import pandas as pd
-from rail.creation.degrader import Degrader
+from rail.creation.selector import Selector
+from rail.creation.noisifier import Noisifier
 
 
-class LineConfusion(Degrader):
+
+class LineConfusion(Noisifier):
     """Degrader that simulates emission line confusion.
 
     .. code-block:: python
@@ -37,7 +39,7 @@ class LineConfusion(Degrader):
     """
 
     name = 'LineConfusion'
-    config_options = Degrader.config_options.copy()
+    config_options = Noisifier.config_options.copy()
     config_options.update(true_wavelen=float,
                           wrong_wavelen=float,
                           frac_wrong=float)
@@ -45,7 +47,7 @@ class LineConfusion(Degrader):
     def __init__(self, args, comm=None):
         """
         """
-        Degrader.__init__(self, args, comm=comm)
+        Noisifier.__init__(self, args, comm=comm)
         # validate parameters
         if self.config.true_wavelen < 0:
             raise ValueError("true_wavelen must be positive, not {self.config.true_wavelen}")
@@ -53,8 +55,12 @@ class LineConfusion(Degrader):
             raise ValueError("wrong_wavelen must be positive, not {self.config.wrong_wavelen}")
         if self.config.frac_wrong < 0 or self.config.frac_wrong > 1:
             raise ValueError("frac_wrong must be between 0 and 1., not {self.config.wrong_wavelen}")
+            
+            
+    def _initNoiseModel(self):
+        self.rng = np.random.default_rng(self.config.seed)
 
-    def run(self):
+    def _addNoise(self):
         """ Run method
 
         Applies line confusion
@@ -75,8 +81,7 @@ class LineConfusion(Degrader):
         zmin = self.config.wrong_wavelen / self.config.true_wavelen - 1
 
         # select the random fraction of galaxies whose lines are confused
-        rng = np.random.default_rng(self.config.seed)
-        idx = rng.choice(
+        idx = self.rng.choice(
             np.where(values[:, 0] > zmin)[0],
             size=int(self.config.frac_wrong * values.shape[0]),
             replace=False,
@@ -92,7 +97,7 @@ class LineConfusion(Degrader):
         self.add_data('output', outData)
 
 
-class InvRedshiftIncompleteness(Degrader):
+class InvRedshiftIncompleteness(Selector):
     """Degrader that simulates incompleteness with a selection function
     inversely proportional to redshift.
 
@@ -107,17 +112,17 @@ class InvRedshiftIncompleteness(Degrader):
     """
 
     name = 'InvRedshiftIncompleteness'
-    config_options = Degrader.config_options.copy()
+    config_options = Selector.config_options.copy()
     config_options.update(pivot_redshift=float)
 
     def __init__(self, args, comm=None):
         """
         """
-        Degrader.__init__(self, args, comm=comm)
+        Selector.__init__(self, args, comm=comm)
         if self.config.pivot_redshift < 0:
             raise ValueError("pivot redshift must be positive, not {self.config.pivot_redshift}")
 
-    def run(self):
+    def _select(self):
         """ Run method
 
         Applies incompleteness
@@ -136,4 +141,4 @@ class InvRedshiftIncompleteness(Degrader):
         rng = np.random.default_rng(self.config.seed)
         mask = rng.random(size=data.shape[0]) <= survival_prob
 
-        self.add_data('output', data[mask])
+        return mask